From bbcd7eac8e247c557be603020a5c7706af995a4e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 22 Nov 2019 12:56:33 -0700
Subject: [PATCH 001/456] editing

---
 README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/README.md b/README.md
index 82bac21..729fedc 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,12 @@ JNA libpython bindings to the tech ecosystem.
   REPL.
 
 
+#### Clojure Conj 2019
+
+* [slides](https://docs.google.com/presentation/d/1uegYhpS6P2AtEfhpg6PlgBmTSIPqCXvFTWcGYG_Qk2o/edit?usp=sharing)
+* video -- coming soon!!
+
+
 We have a [video](https://www.youtube.com/watch?v=ajDiGS73i2o) up of a scicloj community
 discussion with demos.
 

From 211b81cd274e1ebf469796f59b3410fcc6289939 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 22 Nov 2019 13:54:05 -0700
Subject: [PATCH 002/456] Adding nil test for ->jvm and as-jvm.  maps use
 getordefault for ifn overload now, and example of bridge.

---
 project.clj                         |  2 +-
 src/libpython_clj/python.clj        |  3 +-
 src/libpython_clj/python/bridge.clj |  4 +--
 src/libpython_clj/python/object.clj |  3 +-
 test/libpython_clj/python_test.clj  | 51 +++++++++++++++++++++++++++++
 testcode/__init__.py                |  4 +++
 6 files changed, 62 insertions(+), 5 deletions(-)

diff --git a/project.clj b/project.clj
index 16cb360..c067819 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.9"
+(defproject cnuernber/libpython-clj "1.10-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index dbfa5cd..634e53f 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -50,7 +50,8 @@
 
 
 (export-symbols libpython-clj.python.interop
-                libpython-clj-module-name)
+                libpython-clj-module-name
+                create-bridge-from-att-map)
 
 
 (export-symbols libpython-clj.python.bridge
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index 6117cfe..9be1ab4 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -292,7 +292,7 @@
 (defn- py-impl-call-raw
   [att-name att-map arglist]
   (if-let [py-fn (get att-map att-name)]
-    (-> (py-proto/do-call-fn py-fn (map as-python arglist) nil))
+    (py-proto/do-call-fn py-fn (map as-python arglist) nil)
     (throw (UnsupportedOperationException.
             (format "Python object has no attribute: %s"
                     att-name)))))
@@ -371,7 +371,7 @@
                               (MapEntry. k v))))))]
           (.iterator ^Iterable mapentry-seq)))
        IFn
-       (invoke [this arg] (.get this arg))
+       (invoke [this arg] (.getOrDefault this arg nil))
        (invoke [this k v] (.put this k v))
        (applyTo [this arglist]
                 (let [arglist (vec arglist)]
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 80a6c91..9d2303f 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -91,7 +91,8 @@
 (defn ->jvm
   "Copy an object into the jvm (if it wasn't there already.)"
   [item & [options]]
-  (py-proto/->jvm item options))
+  (when item
+    (py-proto/->jvm item options)))
 
 
 (def ^:dynamic *object-reference-logging* false)
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 20bfcfc..348dcd3 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -197,3 +197,54 @@
                (py/call-attr item "doit_noerr"))
       (is (= ["enter" "exit: None"]
              (py/->jvm fn-list))))))
+
+
+(deftest arrow-as-fns-with-nil
+  (py/initialize!)
+  (is (= nil (py/->jvm nil)))
+  (is (= nil (py/as-jvm nil))))
+
+
+(deftest pydict-nil-get
+  (py/initialize!)
+  (let [dict (py/->python {:a 1 :b {:a 1 :b 2}})
+        bridged (py/as-jvm dict)]
+    (is (= nil (bridged nil)))))
+
+
+(deftest custom-clojure-item
+  (let [att-map {"clojure_fn" (py/->python #(vector 1 2 3))}
+        my-python-item (py/create-bridge-from-att-map
+                        ;;First is the jvm object that this bridge stands for.  If this
+                        ;;gets garbage collected then the python side will be removed
+                        ;;also.
+                        att-map
+                        ;;second is the list of attributes.  In this case, since this
+                        ;;object isn't iterable or anything, this function will do.
+                        att-map
+                        )
+        py-mod (py/import-module "testcode")]
+    (is (= [1 2 3]
+           (py/call-attr py-mod "calling_custom_clojure_fn" my-python-item)))
+
+    ;;Now this case is harder.  Let's say we have something that is iterable and we
+    ;;want this to be reflected in python.  In that case we have to call 'as-python'
+    ;;on the iterator and that 'should' work.
+
+    (let [my-obj (reify
+                   Iterable
+                   (iterator [this] (.iterator [4 5 6])))
+          ;;Note that attributes themselves have to be python objects and wrapping
+          ;;this with as-python makes that function wrap whatever it returns in a
+          ;;bridging python object also.
+          att-map {"__iter__" (py/as-python #(.iterator my-obj))}
+          my-python-item (py/create-bridge-from-att-map
+                          my-obj
+                          ;;second is the list of attributes.  In this case, since this
+                          ;;object isn't iterable or anything, this function will do.
+                          att-map
+                          )]
+      (is (= [4 5 6]
+             (vec my-obj)))
+      (is (= [4 5 6]
+             (vec (py/call-attr py-mod "for_iter" my-python-item)))))))
diff --git a/testcode/__init__.py b/testcode/__init__.py
index c17ccd9..8e0922e 100644
--- a/testcode/__init__.py
+++ b/testcode/__init__.py
@@ -18,3 +18,7 @@ def for_iter(arg):
     for item in arg:
         retval.append(item)
     return retval
+
+
+def calling_custom_clojure_fn(arg):
+    return arg.clojure_fn()

From 1aacd27322f0a2ffe3047825d4084a8dfc44e0d9 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 22 Nov 2019 13:54:45 -0700
Subject: [PATCH 003/456] 1.10

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index c067819..1ba9374 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.10-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.10"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 41ce31bf7db990be64789065630725f29d71581e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 22 Nov 2019 13:54:53 -0700
Subject: [PATCH 004/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 1ba9374..fdb0679 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.10"
+(defproject cnuernber/libpython-clj "1.11-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 01840b2063b35996df25aebff9b8a4a80f2538fc Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 22 Nov 2019 16:50:20 -0700
Subject: [PATCH 005/456] edit

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 729fedc..ccf5ea6 100644
--- a/README.md
+++ b/README.md
@@ -16,8 +16,8 @@ JNA libpython bindings to the tech ecosystem.
 
 #### Clojure Conj 2019
 
+* [video](https://www.youtube.com/watch?v=vQPW16_jixs)
 * [slides](https://docs.google.com/presentation/d/1uegYhpS6P2AtEfhpg6PlgBmTSIPqCXvFTWcGYG_Qk2o/edit?usp=sharing)
-* video -- coming soon!!
 
 
 We have a [video](https://www.youtube.com/watch?v=ajDiGS73i2o) up of a scicloj community

From c9449c3c105cac8240afcb3ac8cd8b1515c9a534 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 24 Nov 2019 11:47:14 -0700
Subject: [PATCH 006/456] Fixing crash bug with iteration. Adding scoped
 execution.

---
 project.clj                              |   2 +-
 src/libpython_clj/jna/base.clj           |  27 +++-
 src/libpython_clj/jna/interpreter.clj    |  11 +-
 src/libpython_clj/python.clj             |  21 +++-
 src/libpython_clj/python/interop.clj     | 117 ++++++++---------
 src/libpython_clj/python/interpreter.clj |  20 +--
 src/libpython_clj/python/object.clj      | 152 +++++++++++++++--------
 test/libpython_clj/stress_test.clj       |  72 +++++++++++
 8 files changed, 295 insertions(+), 127 deletions(-)
 create mode 100644 test/libpython_clj/stress_test.clj

diff --git a/project.clj b/project.clj
index fdb0679..91645e1 100644
--- a/project.clj
+++ b/project.clj
@@ -4,7 +4,7 @@
   :license {:name "EPL-2.0"
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
-                 [techascent/tech.datatype "4.53"]
+                 [techascent/tech.datatype "4.54"]
                  [camel-snake-kebab "0.4.0"]]
   :repl-options {:init-ns user}
   :java-source-paths ["java"])
diff --git a/src/libpython_clj/jna/base.clj b/src/libpython_clj/jna/base.clj
index d4fad57..ed90fa7 100644
--- a/src/libpython_clj/jna/base.clj
+++ b/src/libpython_clj/jna/base.clj
@@ -46,11 +46,36 @@
   (ensure-pyobj item))
 
 
-(defmacro def-pylib-fn
+(def ^:dynamic *gil-captured* false)
+
+
+(defmacro def-no-gil-pylib-fn
+  "Define a pylib function where the gil doesn't need to be captured to call."
   [fn-name docstring & args]
   `(jna/def-jna-fn *python-library* ~fn-name ~docstring ~@args))
 
 
+(defmacro def-pylib-fn
+  [fn-name docstring rettype & argpairs]
+  `(defn ~fn-name
+     ~docstring
+     ~(mapv first argpairs)
+     (when-not *gil-captured*
+       (throw (Exception. "Failure to capture gil when calling into libpython")))
+     (let [~'tvm-fn (jna/find-function ~(str fn-name) *python-library*)
+           ~'fn-args (object-array
+                      ~(mapv (fn [[arg-symbol arg-coersion]]
+                               (when (= arg-symbol arg-coersion)
+                                 (throw (ex-info (format "Argument symbol (%s) cannot match coersion (%s)"
+                                                         arg-symbol arg-coersion)
+                                                 {})))
+                               `(~arg-coersion ~arg-symbol))
+                             argpairs))]
+       ~(if rettype
+          `(.invoke (jna-base/to-typed-fn ~'tvm-fn) ~rettype ~'fn-args)
+          `(.invoke (jna-base/to-typed-fn ~'tvm-fn) ~'fn-args)))))
+
+
 (def size-t-type (type (jna/size-t 0)))
 
 
diff --git a/src/libpython_clj/jna/interpreter.clj b/src/libpython_clj/jna/interpreter.clj
index 8db711c..07cdddb 100644
--- a/src/libpython_clj/jna/interpreter.clj
+++ b/src/libpython_clj/jna/interpreter.clj
@@ -1,6 +1,7 @@
 (ns libpython-clj.jna.interpreter
   (:require [libpython-clj.jna.base
              :refer [def-pylib-fn
+                     def-no-gil-pylib-fn
                      ensure-pyobj
                      ensure-pytuple
                      ensure-pydict
@@ -28,7 +29,7 @@
 ;; calls Py_Initialize() and Py_Finalize() more than once.
 
 
-(def-pylib-fn Py_InitializeEx
+(def-no-gil-pylib-fn Py_InitializeEx
   "This function works like Py_Initialize() if initsigs is 1. If initsigs is 0, it skips
   initialization registration of signal handlers, which might be useful when Python is
   embedded."
@@ -37,14 +38,14 @@
 
 
 
-(def-pylib-fn Py_IsInitialized
+(def-no-gil-pylib-fn Py_IsInitialized
   "Return true (nonzero) when the Python interpreter has been initialized, false (zero)
   if not. After Py_Finalize() is called, this returns false until Py_Initialize() is
   called again."
   Integer)
 
 
-(def-pylib-fn Py_FinalizeEx
+(def-no-gil-pylib-fn Py_FinalizeEx
   "Undo all initializations made by Py_Initialize() and subsequent use of Python/C API
   functions, and destroy all sub-interpreters (see Py_NewInterpreter() below) that were
   created and not yet destroyed since the last call to Py_Initialize(). Ideally, this
@@ -62,7 +63,7 @@
 
 ;; System Functionality
 
-(def-pylib-fn PySys_SetArgv
+(def-no-gil-pylib-fn PySys_SetArgv
   "This function works like PySys_SetArgvEx() with updatepath set to 1 unless the python
   interpreter was started with the -I.
 
@@ -226,7 +227,7 @@
 
 
 ;;Acquire the GIL of the given thread state
-(def-pylib-fn PyEval_RestoreThread
+(def-no-gil-pylib-fn PyEval_RestoreThread
   "Acquire the global interpreter lock (if it has been created and thread support is
   enabled) and set the thread state to tstate, which must not be NULL. If the lock has
   been created, the current thread must not have acquired it, otherwise deadlock ensues.
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 634e53f..65a077a 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -2,7 +2,7 @@
   (:require [tech.parallel.utils :refer [export-symbols]]
             [libpython-clj.python.interop :as pyinterop]
             [libpython-clj.python.interpreter :as pyinterp
-             :refer [with-gil with-interpreter]]
+             :refer [with-interpreter]]
             [libpython-clj.python.object :as pyobj]
             [libpython-clj.python.bridge]
             [libpython-clj.jna :as pyjna]
@@ -49,6 +49,25 @@
                 ->jvm)
 
 
+(defmacro stack-resource-context
+  "Create a stack-based resource context.  All python objects allocated within this
+  context will be released at the termination of this context.
+  !!This means that no python objects can escape from this context!!
+  You must use copy semantics (->jvm) for anything escaping this context."
+  [& body]
+  `(pyobj/stack-resource-context
+    ~@body))
+
+
+(defmacro with-gil
+  "Capture the gil for an extended amount of time.  This can greatly speed up
+  operations as the mutex is captured and held once as opposed to find grained
+  grabbing/releasing of the mutex."
+  [& body]
+  `(pyinterp/with-gil
+     ~@body))
+
+
 (export-symbols libpython-clj.python.interop
                 libpython-clj-module-name
                 create-bridge-from-att-map)
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
index dd7c7b3..cbd0809 100644
--- a/src/libpython_clj/python/interop.clj
+++ b/src/libpython_clj/python/interop.clj
@@ -23,6 +23,7 @@
             [tech.jna :as jna]
             ;;need memset
             [tech.v2.datatype.nio-buffer :as nio-buf]
+            [tech.resource :as resource]
             [libpython-clj.python.object
              :refer [wrap-pyobject incref-wrap-pyobject
                      incref
@@ -205,58 +206,62 @@
                   tp_iternext ;;may be nil
                   ]
            :as type-definition}]
-  (when (or (not type-name)
-            (= 0 (count type-name)))
-    (throw (ex-info "Cannot create unnamed type." {})))
-  (let [tp_new (or tp_new
-                   (reify CFunction$tp_new
-                     (pyinvoke [this self varargs kw_args]
-                       (libpy/PyType_GenericNew self varargs kw_args))))
-        module-name (get-attr module "__name__")
-        docstring-ptr (jna/string->ptr docstring)
-        type-name-ptr (jna/string->ptr (str module-name "." type-name))
-        tp_flags (long (or tp_flags
-                           (bit-or @libpy/Py_TPFLAGS_DEFAULT
-                                   @libpy/Py_TPFLAGS_BASETYPE)))
-        ;;We allocate our memory manually here else the system will gc the
-        ;;type object memory when the type goes out of scope.
-        new-mem (jna/malloc-untracked type-obj-size)
-        _ (nio-buf/memset new-mem 0 type-obj-size)
-        new-type (PyTypeObject. new-mem)]
-    (set! (.tp_name new-type) type-name-ptr)
-    (set! (.tp_doc new-type) docstring-ptr)
-    (set! (.tp_basicsize new-type) tp_basicsize)
-    (set! (.tp_flags new-type) tp_flags)
-    (set! (.tp_new new-type) tp_new)
-    (set! (.tp_dealloc new-type) tp_dealloc)
-    (set! (.tp_getattr new-type) tp_getattr)
-    (set! (.tp_setattr new-type) tp_setattr)
-    (set! (.tp_methods new-type) (method-def-data-seq->method-def-ref
-                                  method-definitions))
-    (when tp_iter
-      (set! (.tp_iter new-type) tp_iter))
-    (when tp_iternext
-      (set! (.tp_iternext new-type) tp_iternext))
-    (let [type-ready (libpy/PyType_Ready new-type)]
-      (if (>= 0 type-ready)
-        (do
-          (libpy/Py_IncRef new-type)
-          (.read new-type)
-          (libpy/PyModule_AddObject module (str type-name "_type") new-type)
-          ;;We are careful to keep track of the static data we give to python.
-          ;;the GC cannot now remove any of this stuff pretty much
-          ;;forever now.
-          (conj-forever! (assoc type-definition
-                                :tp_name type-name-ptr
-                                :tp_doc docstring-ptr
-                                :tp_new tp_new
-                                :tp_dealloc tp_dealloc
-                                :tp_getattr tp_getattr
-                                :tp_setattr tp_setattr))
-          (libpy/Py_IncRef new-type)
-          new-type)
-        (throw (ex-info (format "Type failed to register: %d" type-ready)
-                        {}))))))
+  (resource/stack-resource-context
+   (when (or (not type-name)
+             (= 0 (count type-name)))
+     (throw (ex-info "Cannot create unnamed type." {})))
+   (let [tp_new (or tp_new
+                    (reify CFunction$tp_new
+                      (pyinvoke [this self varargs kw_args]
+                        (libpy/PyType_GenericNew self varargs kw_args))))
+         module-name (get-attr module "__name__")
+         ;;These get leaked.  Really, types are global objects that cannot be released.
+         ;;Until we can destroy interpreters, it isn't worth the effort to track the
+         ;;type and memory related to the type.
+         docstring-ptr (jna/string->ptr-untracked docstring)
+         type-name-ptr (jna/string->ptr-untracked (str module-name "." type-name))
+         tp_flags (long (or tp_flags
+                            (bit-or @libpy/Py_TPFLAGS_DEFAULT
+                                    @libpy/Py_TPFLAGS_BASETYPE)))
+         ;;We allocate our memory manually here else the system will gc the
+         ;;type object memory when the type goes out of scope.
+         new-mem (jna/malloc-untracked type-obj-size)
+         _ (nio-buf/memset new-mem 0 type-obj-size)
+         new-type (PyTypeObject. new-mem)]
+     (set! (.tp_name new-type) type-name-ptr)
+     (set! (.tp_doc new-type) docstring-ptr)
+     (set! (.tp_basicsize new-type) tp_basicsize)
+     (set! (.tp_flags new-type) tp_flags)
+     (set! (.tp_new new-type) tp_new)
+     (set! (.tp_dealloc new-type) tp_dealloc)
+     (set! (.tp_getattr new-type) tp_getattr)
+     (set! (.tp_setattr new-type) tp_setattr)
+     (set! (.tp_methods new-type) (method-def-data-seq->method-def-ref
+                                   method-definitions))
+     (when tp_iter
+       (set! (.tp_iter new-type) tp_iter))
+     (when tp_iternext
+       (set! (.tp_iternext new-type) tp_iternext))
+     (let [type-ready (libpy/PyType_Ready new-type)]
+       (if (>= 0 type-ready)
+         (do
+           (libpy/Py_IncRef new-type)
+           (.read new-type)
+           (libpy/PyModule_AddObject module (str type-name "_type") new-type)
+           ;;We are careful to keep track of the static data we give to python.
+           ;;the GC cannot now remove any of this stuff pretty much
+           ;;forever now.
+           (conj-forever! (assoc type-definition
+                                 :tp_name type-name-ptr
+                                 :tp_doc docstring-ptr
+                                 :tp_new tp_new
+                                 :tp_dealloc tp_dealloc
+                                 :tp_getattr tp_getattr
+                                 :tp_setattr tp_setattr))
+           (libpy/Py_IncRef new-type)
+           new-type)
+         (throw (ex-info (format "Type failed to register: %d" type-ready)
+                         {})))))))
 
 (defn pybridge->bridge
   ^JVMBridge [^Pointer pybridge]
@@ -415,7 +420,7 @@
 
 (defn create-var-writer
   "Returns an unregistered bridge"
-  ^Pointer [writer-var]
+  ^Pointer [writer-var varname]
   (with-gil
     (create-bridge-from-att-map
      writer-var
@@ -428,17 +433,17 @@
 
 
 (defn get-or-create-var-writer
-  [writer-var]
+  [writer-var varname]
   (if-let [existing-writer (find-jvm-bridge-entry (get-object-handle writer-var)
                                                   (ensure-interpreter))]
     (:pyobject existing-writer)
-    (create-var-writer writer-var)))
+    (create-var-writer writer-var varname)))
 
 
 (defn setup-std-writer
   [writer-var sys-mod-attname]
   (with-gil
     (let [sys-module (import-module "sys")
-          std-out-writer (get-or-create-var-writer writer-var)]
+          std-out-writer (get-or-create-var-writer writer-var sys-mod-attname)]
       (py-proto/set-attr! sys-module sys-mod-attname std-out-writer)
       :ok)))
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index df9c4c5..df326d7 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -1,5 +1,6 @@
 (ns libpython-clj.python.interpreter
   (:require [libpython-clj.jna :as libpy]
+            [libpython-clj.jna.base :as libpy-base]
             [tech.resource :as resource]
             [libpython-clj.python.logging
              :refer [log-error log-warn log-info]]
@@ -196,12 +197,13 @@
        ;;No interpreters bound
        (not *current-thread-interpreter*)
        (locking interpreter
-         (try
-           (with-bindings {#'*current-thread-interpreter* interpreter}
-             (acquire-gil! interpreter)
-             (body-fn))
-           (finally
-             (release-gil! interpreter))))
+         (with-bindings {#'*current-thread-interpreter* interpreter}
+           (acquire-gil! interpreter)
+           (with-bindings {#'libpy-base/*gil-captured* true}
+             (try
+               (body-fn)
+               (finally
+                 (release-gil! interpreter))))))
        ;;Switch interpreters in the current thread...deadlock
        ;;is possible here.
        (not (identical? interpreter *current-thread-interpreter*))
@@ -244,8 +246,10 @@
       (resource/stack-resource-context
        (libpy/PySys_SetArgv 0 (-> program-name
                                   (jna/string->wide-ptr)))))
-    (let [type-symbols (libpy/lookup-type-symbols)]
-      (construct-main-interpreter! (libpy/PyEval_SaveThread) type-symbols))))
+    (let [type-symbols (libpy/lookup-type-symbols)
+          context (with-bindings {#'libpy-base/*gil-captured* true}
+                    (libpy/PyEval_SaveThread))]
+      (construct-main-interpreter! context type-symbols))))
 
 
 (def ^:dynamic *python-error-handler* nil)
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 9d2303f..cf165fe 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -44,6 +44,7 @@
             [tech.v2.datatype.casting :as casting]
             [tech.v2.tensor])
   (:import [com.sun.jna Pointer CallbackReference]
+           [com.sun.jna.ptr PointerByReference]
            [libpython_clj.jna
             PyObject
             CFunction$KeyWordFunction
@@ -98,6 +99,12 @@
 (def ^:dynamic *object-reference-logging* false)
 
 
+(def ^:dynamic *object-reference-tracker* nil)
+
+
+(def ^:dynamic *pyobject-tracking-flags* [:gc])
+
+
 (defn wrap-pyobject
   "Wrap object such that when it is no longer accessible via the program decref is
   called. Used for new references.  This is some of the meat of the issue, however,
@@ -106,7 +113,10 @@
   [pyobj & [skip-check-error?]]
   (when-not skip-check-error?
     (check-error-throw))
-  (when pyobj
+  ;;We don't wrap pynone
+  (when (and pyobj
+             (not= (Pointer/nativeValue (jna/as-ptr pyobj))
+                   (Pointer/nativeValue (jna/as-ptr (libpy/Py_None)))))
     (let [interpreter (ensure-bound-interpreter)
           pyobj-value (Pointer/nativeValue (jna/as-ptr pyobj))
           py-type-name (name (python-type pyobj))]
@@ -116,6 +126,9 @@
                             pyobj-value
                             (.ob_refcnt obj-data)
                             py-type-name))))
+      (when *object-reference-tracker*
+        (swap! *object-reference-tracker*
+               update pyobj-value #(inc (or % 0))))
       ;;We ask the garbage collector to track the python object and notify
       ;;us when it is released.  We then decref on that event.
       (resource/track pyobj
@@ -127,10 +140,21 @@
                                                 pyobj-value
                                                 (.ob_refcnt obj-data)
                                                 py-type-name))))
+                           (when *object-reference-tracker*
+                             (swap! *object-reference-tracker*
+                                    update pyobj-value (fn [arg]
+                                                         (dec (or arg 0)))))
                            (libpy/Py_DecRef (Pointer. pyobj-value))
                            (catch Throwable e
                              (log-error "Exception while releasing object: %s" e))))
-                      [:gc]))))
+                      *pyobject-tracking-flags*))))
+
+
+(defmacro stack-resource-context
+  [& body]
+  `(with-bindings {#'*pyobject-tracking-flags* [:stack :gc]}
+     (resource/stack-resource-context
+      ~@body)))
 
 
 (defn incref-wrap-pyobject
@@ -363,36 +387,37 @@
                                    doc
                                    function]
                             :as method-data}]
-  (let [callback (if (or (instance? CFunction$KeyWordFunction function)
-                         (instance? CFunction$TupleFunction function)
-                         (instance? CFunction$NoArgFunction function))
-                     function
-                     (wrap-clojure-fn function))
-        meth-flags (long (cond
-                           (instance? CFunction$NoArgFunction callback)
-                           @libpy/METH_NOARGS
-
-                           (instance? CFunction$TupleFunction callback)
-                           @libpy/METH_VARARGS
-
-                           (instance? CFunction$KeyWordFunction callback)
-                           (bit-or @libpy/METH_KEYWORDS @libpy/METH_VARARGS)
-                           :else
-                           (throw (ex-info (format "Failed due to type: %s"
-                                                   (type callback))))))
-        name-ptr (jna/string->ptr name)
-        doc-ptr (jna/string->ptr doc)]
-    (set! (.ml_name method-def) name-ptr)
-    (set! (.ml_meth method-def) (CallbackReference/getFunctionPointer callback))
-    (set! (.ml_flags method-def) (int meth-flags))
-    (set! (.ml_doc method-def) doc-ptr)
-    (.write method-def)
-    (pyinterp/conj-forever! (assoc method-data
-                                   :name-ptr name-ptr
-                                   :doc-ptr doc-ptr
-                                   :callback-object callback
-                                   :method-definition method-def))
-    method-def))
+  (resource/stack-resource-context
+   (let [callback (if (or (instance? CFunction$KeyWordFunction function)
+                          (instance? CFunction$TupleFunction function)
+                          (instance? CFunction$NoArgFunction function))
+                    function
+                    (wrap-clojure-fn function))
+         meth-flags (long (cond
+                            (instance? CFunction$NoArgFunction callback)
+                            @libpy/METH_NOARGS
+
+                            (instance? CFunction$TupleFunction callback)
+                            @libpy/METH_VARARGS
+
+                            (instance? CFunction$KeyWordFunction callback)
+                            (bit-or @libpy/METH_KEYWORDS @libpy/METH_VARARGS)
+                            :else
+                            (throw (ex-info (format "Failed due to type: %s"
+                                                    (type callback))))))
+         name-ptr (jna/string->ptr name)
+         doc-ptr (jna/string->ptr doc)]
+     (set! (.ml_name method-def) name-ptr)
+     (set! (.ml_meth method-def) (CallbackReference/getFunctionPointer callback))
+     (set! (.ml_flags method-def) (int meth-flags))
+     (set! (.ml_doc method-def) doc-ptr)
+     (.write method-def)
+     (pyinterp/conj-forever! (assoc method-data
+                                    :name-ptr name-ptr
+                                    :doc-ptr doc-ptr
+                                    :callback-object callback
+                                    :method-definition method-def))
+     method-def)))
 
 
 (defn method-def-data->method-def
@@ -691,29 +716,46 @@
   "This is a tough function to get right.  The iterator could return nil as in
   you could have a list of python none types or something so you have to iterate
   till you get a StopIteration error."
- [iter-fn item-conversion-fn]
- (with-gil nil
-   (let [interpreter (ensure-bound-interpreter)]
-     (let [py-iter (py-proto/call iter-fn)
-           next-fn (fn [last-item]
-                     (with-interpreter interpreter
-                       (try
-                         [(-> (py-proto/call-attr py-iter "__next__")
-                              item-conversion-fn)]
-                         (catch Throwable e
-                           nil))))
-           cur-item-store (atom (next-fn nil))]
-       (reify ObjectIter
-         jna/PToPtr
-         (is-jna-ptr-convertible? [item] true)
-         (->ptr-backing-store [item] py-iter)
-         (hasNext [obj-iter]
-           (not (nil? @cur-item-store)))
-         (next [obj-iter]
-           (-> (swap-vals! cur-item-store next-fn)
-               ffirst))
-         (current [obj-iter]
-           (first @cur-item-store)))))))
+  [iter-fn & [item-conversion-fn]]
+  (with-gil nil
+    (let [interpreter (ensure-bound-interpreter)]
+      (let [py-iter (py-proto/call iter-fn)
+            py-next-fn (when py-iter (py-proto/get-attr py-iter "__next__"))
+            next-fn (fn [last-item]
+                      (with-interpreter interpreter
+                        (let [retval (libpy/PyObject_CallObject py-next-fn nil)]
+                          (if (libpy/PyErr_Occurred)
+                            (let [ptype (PointerByReference.)
+                                  pvalue (PointerByReference.)
+                                  ptraceback (PointerByReference.)
+                                  _ (libpy/PyErr_Fetch ptype pvalue ptraceback)
+                                  ptype (jna/->ptr-backing-store ptype)
+                                  pvalue (jna/->ptr-backing-store pvalue)
+                                  ptraceback (jna/->ptr-backing-store ptraceback)]
+                              (if (= ptype
+                                     (libpy/PyExc_StopIteration))
+                                (do
+                                  (libpy/Py_DecRef ptype)
+                                  (when pvalue (libpy/Py_DecRef pvalue))
+                                  (when ptraceback (libpy/Py_DecRef ptraceback))
+                                  nil)
+                                (do (libpy/PyErr_Restore ptype pvalue ptraceback)
+                                    (check-error-throw))))
+                            [(cond-> (wrap-pyobject retval)
+                               item-conversion-fn
+                               item-conversion-fn)]))))
+            cur-item-store (atom (next-fn nil))]
+        (reify ObjectIter
+          jna/PToPtr
+          (is-jna-ptr-convertible? [item] true)
+          (->ptr-backing-store [item] py-iter)
+          (hasNext [obj-iter]
+            (not (nil? @cur-item-store)))
+          (next [obj-iter]
+            (-> (swap-vals! cur-item-store next-fn)
+                ffirst))
+          (current [obj-iter]
+            (first @cur-item-store)))))))
 
 
 (defn python->jvm-iterable
diff --git a/test/libpython_clj/stress_test.clj b/test/libpython_clj/stress_test.clj
new file mode 100644
index 0000000..94a2ab7
--- /dev/null
+++ b/test/libpython_clj/stress_test.clj
@@ -0,0 +1,72 @@
+(ns libpython-clj.stress-test
+  "A set of tests meant to crash the system or just run the system out of
+  memory if it isn't setup correctly."
+  (:require [libpython-clj.python :as py]))
+
+
+(defn get-data
+  []
+  (let [gd-fn
+        (->  (py/run-simple-string "
+def getdata():
+    while True:
+        yield {'a': 1, 'b': 2}
+")
+             :globals
+             (get "getdata"))]
+    (gd-fn)))
+
+;;If you want to see how the sausage is made...
+(alter-var-root #'libpython-clj.python.object/*object-reference-logging*
+                (constantly false))
+
+;;Ensure that failure to open resource context before tracking for stack
+;;related things causes immediate failure.
+(alter-var-root #'tech.resource.stack/*resource-context*
+                (constantly nil))
+
+(defn forever-test
+  []
+  (py/initialize! :no-io-redirect? false)
+  (doseq [items (partition 999 (get-data))]
+    ;;One way is to use the GC
+    (time
+     (do
+       (last
+        (eduction
+         (map py/->jvm)
+         (map (partial into {}))
+         items))
+       (System/gc)))
+    ;;A faster way is to grab the gil and use the resource system
+    ;;This also ensures that resources within that block do not escape
+    (time
+     (py/with-gil
+       (py/stack-resource-context
+        (last
+         (eduction
+          (map py/->jvm)
+          (map (partial into {}))
+          items)))))))
+
+
+(defn str-marshal-test
+  []
+  (py/initialize!)
+  (let [test-str (py/->python "a nice string to work with")]
+    (time
+     (py/with-gil
+       (py/stack-resource-context
+        (dotimes [iter 100000]
+          (py/->jvm test-str)))))))
+
+
+(defn dict-marshal-test
+  []
+  (py/initialize!)
+  (let [test-item (py/->python {:a 1 :b 2})]
+    (time
+     (py/with-gil
+       (py/stack-resource-context
+        (dotimes [iter 10000]
+          (py/->jvm test-item)))))))

From 8a3967d9a9b9ed2f0945b281048ea9acf1a2dee7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 24 Nov 2019 11:47:35 -0700
Subject: [PATCH 007/456] 1.11

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 91645e1..723cc84 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.11-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.11"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 2ff91403a27a71ecf54afacaa76b7138a98507d0 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 24 Nov 2019 11:47:48 -0700
Subject: [PATCH 008/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 723cc84..f05c0c2 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.11"
+(defproject cnuernber/libpython-clj "1.12-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 05a12ed634a85db1064ed14863806baf087a5982 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 25 Nov 2019 11:03:52 -0700
Subject: [PATCH 009/456] Lots of hardening and perf testing.  Found another
 crash bug in the way the None type was handled

---
 docs/scopes-and-gc.md                | 73 ++++++++++++++++++++
 src/libpython_clj/python.clj         | 19 +++++-
 src/libpython_clj/python/bridge.clj  |  6 +-
 src/libpython_clj/python/interop.clj |  5 +-
 src/libpython_clj/python/object.clj  | 35 ++++++----
 test/libpython_clj/python_test.clj   |  8 +++
 test/libpython_clj/stress_test.clj   | 99 +++++++++++++++++++++-------
 7 files changed, 203 insertions(+), 42 deletions(-)
 create mode 100644 docs/scopes-and-gc.md

diff --git a/docs/scopes-and-gc.md b/docs/scopes-and-gc.md
new file mode 100644
index 0000000..c76434f
--- /dev/null
+++ b/docs/scopes-and-gc.md
@@ -0,0 +1,73 @@
+# Scopes And Garbage Collection
+
+
+libpython-clj now supports stack-based scoping rules so you can guarantee all python
+objects created during a section of code will be released by a certain point.
+
+
+Using the stack-based scoping looks like:
+
+
+
+```clojure
+user> (require '[libpython-clj.python :as py])
+nil
+user> (py/initialize!)
+... (logging elided)
+:ok
+user> (py/stack-resource-context
+       (-> (py/->py-dict {:a 1 :b 2})
+           ;;Note - Without this call you guarantee a crash.
+           (py/->jvm)))
+{"a" 1, "b" 2}
+```
+
+
+You must either call ->jvm or return a keyword at the end of your scope.
+
+In the case where you are processing a batch of items (which we recommend for perf
+reasons), you can also grab the GIL at the top of your thing:
+
+```clojure
+user> (def dict-seq (py/as-jvm (py/->py-list (repeat 1000 (py/->py-dict {:a 1 :b 2})))))
+#'user/dict-seq
+
+
+user> (def ignored (time (mapv py/->jvm dict-seq)))
+"Elapsed time: 2200.556506 msecs"
+#'user/ignored
+user> (def ignored (time (py/with-gil (mapv py/->jvm dict-seq))))
+"Elapsed time: 2095.815518 msecs"
+#'user/ignored
+```
+
+
+The hidden thing above, regardless of if you grab the gil or not is that you are
+actually holding onto a lot of python objects that could be released.  Hence if you
+aren't disciplined about calling System/gc or if the jvm gc just decides not to run
+you could be allocating a lot of native-heap objects.  Plus what you don't see is
+that if you call System/gc the resource thread dedicated to releasing things will
+have a lot of work to do.
+
+For production use cases where you need a bit more assurance that things get released,
+please consider both grabbing the gil *and* opening a resource context:
+
+
+```clojure
+user> (def ignored (time (py/with-gil-stack-rc-context
+                           (->> (repeatedly 1000 #(py/->py-dict {:a 1 :b 2}))
+                                (py/->py-list)
+                                (py/as-jvm)
+                                (mapv py/->jvm)))))
+
+"Elapsed time: 3246.847595 msecs"
+#'user/ignored
+```
+
+This took a second longer!  But, you *know* that all python objects allocated within
+that scope are released.  Before, you would be in essence hoping that things would be
+released soon enough.
+
+Again, for production contexts we recommend batch processing objects *and* using
+the `with-gil-stack-rc-context` function call that correctly grabs the gil, opens
+a resource context and then releases anything allocated within that context.
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 65a077a..3c667ca 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -53,7 +53,10 @@
   "Create a stack-based resource context.  All python objects allocated within this
   context will be released at the termination of this context.
   !!This means that no python objects can escape from this context!!
-  You must use copy semantics (->jvm) for anything escaping this context."
+  You must use copy semantics (->jvm) for anything escaping this context.
+  Furthermore, if you are returning generic python objects you may need
+  to call (into {}) or something like that just to ensure that absolutely
+  everything is copied into the jvm."
   [& body]
   `(pyobj/stack-resource-context
     ~@body))
@@ -68,6 +71,20 @@
      ~@body))
 
 
+(defmacro with-gil-stack-rc-context
+  "Capture the gil, open a resource context.  The resource context is released
+  before the gil is leading to much faster resource collection.  See documentation
+  on `stack-resource-context` for multiple warnings; the most important one being
+  that if a python object escapes this context your program will eventually, at
+  some undefined point in the future crash.  That being said, this is the recommended
+  pathway to use in production contexts where you want defined behavior and timings
+  related to use of python."
+  [& body]
+  `(with-gil
+     (stack-resource-context
+      ~@body)))
+
+
 (export-symbols libpython-clj.python.interop
                 libpython-clj-module-name
                 create-bridge-from-att-map)
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index 9be1ab4..e791835 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -220,10 +220,12 @@
          (->python [item# options#] pyobj#)
          py-proto/PBridgeToPython
          (as-python [item# options#] pyobj#)
-         py-proto/PCopyToJVM
-         (->jvm [item# options#] item#)
          py-proto/PBridgeToJVM
          (as-jvm [item# options#] item#)
+         py-proto/PCopyToJVM
+         (->jvm [item# options#]
+           (with-interpreter interpreter#
+             (->jvm pyobj# options#)))
          py-proto/PPyObject
          (dir [item#]
            (with-interpreter interpreter#
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
index cbd0809..ea80a1b 100644
--- a/src/libpython_clj/python/interop.clj
+++ b/src/libpython_clj/python/interop.clj
@@ -383,7 +383,7 @@
             (getAttr [bridge att-name]
               (if-let [retval (get att-map att-name)]
                 (incref retval)
-                (libpy/Py_None)))
+                (incref (libpy/Py_None))))
             (setAttr [bridge att-name att-value]
               (throw (ex-info "Cannot set attributes" {})))
             (dir [bridge] dir-data)
@@ -425,7 +425,8 @@
     (create-bridge-from-att-map
      writer-var
      {"write" (->python (fn [& args]
-                          (.write ^Writer @writer-var (str (first args)))))
+                          (.write ^Writer @writer-var (str (first args)))
+                          ))
       "flush" (->python (fn [& args]))
       "isatty" (->python (fn [& args]
                            (libpy/Py_False)))
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index cf165fe..3b454e3 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -114,7 +114,7 @@
   (when-not skip-check-error?
     (check-error-throw))
   ;;We don't wrap pynone
-  (when (and pyobj
+  (if (and pyobj
              (not= (Pointer/nativeValue (jna/as-ptr pyobj))
                    (Pointer/nativeValue (jna/as-ptr (libpy/Py_None)))))
     (let [interpreter (ensure-bound-interpreter)
@@ -147,7 +147,11 @@
                            (libpy/Py_DecRef (Pointer. pyobj-value))
                            (catch Throwable e
                              (log-error "Exception while releasing object: %s" e))))
-                      *pyobject-tracking-flags*))))
+                      *pyobject-tracking-flags*))
+    (do
+      ;;Special handling for PyNone types
+      (libpy/Py_DecRef pyobj)
+      nil)))
 
 
 (defmacro stack-resource-context
@@ -175,6 +179,11 @@
     pyobj))
 
 
+(defn refcount
+  [pyobj]
+  (.ob_refcnt (PyObject. (jna/as-ptr pyobj))))
+
+
 (defn py-true
   []
   (libpy/Py_True))
@@ -371,7 +380,7 @@
         (let [retval
               (apply fn-obj (->jvm args))]
           (if (nil? retval)
-            (libpy/Py_None)
+            (incref (libpy/Py_None))
             (->python retval)))
         (catch Throwable e
           (log-error (format "%s:%s" e (with-out-str
@@ -661,7 +670,7 @@
 (extend-protocol py-proto/PyCall
   Pointer
   (do-call-fn [callable arglist kw-arg-map]
-    (with-gil nil
+    (with-gil
       (-> (cond
             (seq kw-arg-map)
             (libpy/PyObject_Call callable (->py-tuple arglist)
@@ -687,7 +696,7 @@
 
 (defn python->jvm-copy-hashmap
   [pyobj & [map-items]]
-  (with-gil nil
+  (with-gil
     (when-not (= 1 (libpy/PyMapping_Check pyobj))
       (throw (ex-info (format "Object does not implement the mapping protocol: %s"
                               (python-type pyobj)))))
@@ -700,7 +709,7 @@
 
 (defn python->jvm-copy-persistent-vector
   [pyobj]
-  (with-gil nil
+  (with-gil
     (when-not (= 1 (libpy/PySequence_Check pyobj))
       (throw (ex-info (format "Object does not implement sequence protocol: %s"
                               (python-type pyobj)))))
@@ -717,7 +726,7 @@
   you could have a list of python none types or something so you have to iterate
   till you get a StopIteration error."
   [iter-fn & [item-conversion-fn]]
-  (with-gil nil
+  (with-gil
     (let [interpreter (ensure-bound-interpreter)]
       (let [py-iter (py-proto/call iter-fn)
             py-next-fn (when py-iter (py-proto/get-attr py-iter "__next__"))
@@ -763,7 +772,7 @@
   maintains a reference to the python object, however, so this method isn't necessarily
   safe."
   [pyobj & [item-conversion-fn]]
-  (with-gil nil
+  (with-gil
     (when-not (has-attr? pyobj "__iter__")
       (throw (ex-info (format "object is not iterable: %s"
                               (python-type pyobj))
@@ -782,13 +791,13 @@
 
 (defmethod pyobject->jvm :int
   [pyobj]
-  (with-gil nil
+  (with-gil
     (libpy/PyLong_AsLongLong pyobj)))
 
 
 (defmethod pyobject->jvm :float
   [pyobj]
-  (with-gil nil
+  (with-gil
     (libpy/PyFloat_AsDouble pyobj)))
 
 
@@ -799,13 +808,13 @@
 
 (defmethod pyobject->jvm :str
   [pyobj]
-  (with-gil nil
+  (with-gil
     (py-string->string pyobj)))
 
 
 (defn pyobj-true?
   [pyobj]
-  (with-gil nil
+  (with-gil
     (= 1 (libpy/PyObject_IsTrue pyobj))))
 
 
@@ -839,7 +848,7 @@
 ;;numpy types
 (defn numpy-scalar->jvm
   [pyobj]
-  (with-gil nil
+  (with-gil
     (-> (py-proto/get-attr pyobj "data")
         (py-proto/get-item (->py-tuple []))
         ->jvm)))
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 348dcd3..493d817 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -248,3 +248,11 @@
              (vec my-obj)))
       (is (= [4 5 6]
              (vec (py/call-attr py-mod "for_iter" my-python-item)))))))
+
+
+(deftest bridged-dict-to-jvm
+  (py/initialize!)
+  (let [py-dict (py/->py-dict {:a 1 :b 2})
+        bridged (py/as-jvm py-dict)
+        copied-back (py/->jvm bridged)]
+    (is (instance? clojure.lang.PersistentArrayMap copied-back))))
diff --git a/test/libpython_clj/stress_test.clj b/test/libpython_clj/stress_test.clj
index 94a2ab7..88a5e32 100644
--- a/test/libpython_clj/stress_test.clj
+++ b/test/libpython_clj/stress_test.clj
@@ -1,33 +1,70 @@
 (ns libpython-clj.stress-test
   "A set of tests meant to crash the system or just run the system out of
   memory if it isn't setup correctly."
-  (:require [libpython-clj.python :as py]))
+  (:require [libpython-clj.python :as py]
+            [libpython-clj.jna :as libpy]
+            [libpython-clj.python.object :as pyobject]))
 
 
-(defn get-data
-  []
-  (let [gd-fn
-        (->  (py/run-simple-string "
+(def test-script
+  (memoize
+   (fn []
+     (->  (py/run-simple-string "
+import itertools
+
 def getdata():
     while True:
         yield {'a': 1, 'b': 2}
+
+def print_data():
+    print(\"hey\")
+
+def getmultidata():
+    a =  {'disableReason': 'None', 'generationNumber': 1186, 'leDomain': 0, 'protocol': 'FC', 'index': 197, 'authentication': 'None', 'physicalID': 4, 'cFlags': ['0x1'], 'wwn': '20:c5:00:05:1e:ba:a7:00', 'scn': 'Offline', 'health': 'OFFLINE', 'connectionSpeed': 'N8Gbps', 'shareIFID': None, 'id': '586a6086ce8d6e5d86a0a04b', 'flags': ['0x4001', 'PRESENT', 'LED'], 'portID': '01c500', 'storagecenterSnapshotType': 'live', 'transitionCount': 1, 'portType': 17.0, 'podPort': None, 'name': 'slot9 port21', 'deviceNumber': 267654, 'isPartOtherAD': False, 'creditRecovery': 'Inactive', 'distance': 'normal', 'storagecenterSnapshotTime': '2019-11-04T14:12:20.740000+00:00', 'scnID': 2, 'portIFID': '4392001d', 'fcFastwrite': False, 'state': 'Offline', 'wwnConnected': [], 'faa': 'Inactive', 'localSwcFlags': ['0x0'], 'stateID': 2, 'aoq': 'Inactive', 'physical': 'No_Light', 'peerBeacon': False}
+    b =   {'disableReason': 'None', 'generationNumber': 0, 'leDomain': 0, 'protocol': 'FC', 'index': 777, 'authentication': 'None', 'physicalID': 6, 'cFlags': ['0x1'], 'wwn': '50:00:53:32:3d:6f:73:09', 'scn': 'Online', 'health': 'HEALTHY', 'connectionSpeed': 'N8Gbps', 'shareIFID': None, 'id': '586a603560a298494d6a5e97', 'flags': ['0x24b03', 'PRESENT', 'ACTIVE', 'F_PORT', 'G_PORT', 'LOGICAL_ONLINE', 'LOGIN', 'NOELP', 'LED', 'ACCEPT'], 'portID': '3d8d80', 'storagecenterSnapshotType': 'deleted', 'transitionCount': 0, 'portType': 17.0, 'podPort': None, 'name': 'slot1 port57', 'deviceNumber': 365521, 'isPartOtherAD': None, 'creditRecovery': 'Inactive', 'distance': 'normal', 'storagecenterSnapshotTime': '2018-06-07T02:12:16.083000+00:00', 'scnID': 1, 'portIFID': '43120039', 'fcFastwrite': False, 'state': 'Online', 'wwnConnected': ['21:00:00:24:ff:f7:37:01'], 'faa': 'Inactive', 'localSwcFlags': ['0x0'], 'stateID': 1, 'aoq': 'Inactive', 'physical': 'In_Sync', 'peerBeacon': False}
+    c =  {'disableReason': 'None', 'generationNumber': 0, 'leDomain': 0, 'protocol': 'FC', 'index': 127, 'authentication': 'None', 'physicalID': 4, 'cFlags': ['0x1'], 'wwn': '20:7f:00:05:33:61:48:01', 'scn': 'Offline', 'health': 'OFFLINE', 'connectionSpeed': 'N8Gbps', 'shareIFID': None, 'id': '5c7d9d73c146f2bb9dd1a48c', 'flags': ['0x1', 'PRESENT'], 'portID': '42e000', 'storagecenterSnapshotType': 'live', 'transitionCount': 1, 'portType': 17.0, 'podPort': None, 'name': 'slot12 port15', 'deviceNumber': 382664, 'isPartOtherAD': None, 'creditRecovery': 'Inactive', 'distance': 'normal', 'storagecenterSnapshotTime': '2019-03-04T21:49:38.234000+00:00', 'scnID': 2, 'portIFID': '43c20037', 'fcFastwrite': False, 'state': 'Offline', 'wwnConnected': [], 'faa': None, 'localSwcFlags': ['0x0'], 'stateID': 2, 'aoq': None, 'physical': 'No_Light', 'peerBeacon': False}
+    d =  {'disableReason': 'None', 'generationNumber': 506, 'leDomain': 0, 'protocol': 'FC', 'index': 187, 'authentication': 'None', 'physicalID': 4, 'cFlags': ['0x1'], 'wwn': '20:bb:00:05:33:24:6a:01', 'scn': 'Offline', 'health': 'OFFLINE', 'connectionSpeed': 'N8Gbps', 'shareIFID': None, 'id': '586a604a1d2c89767dc345f1', 'flags': ['0x4001', 'PRESENT', 'LED'], 'portID': '3ed100', 'storagecenterSnapshotType': 'live', 'transitionCount': 1, 'portType': 17.0, 'podPort': None, 'name': 'slot4 port27 DISABLED server 640461 seg config', 'deviceNumber': 365522, 'isPartOtherAD': None, 'creditRecovery': 'Inactive', 'distance': 'normal', 'storagecenterSnapshotTime': '2019-10-18T13:10:24.968000+00:00', 'scnID': 2, 'portIFID': '4342100b', 'fcFastwrite': False, 'state': 'Offline', 'wwnConnected': [], 'faa': 'Inactive', 'localSwcFlags': ['0x0'], 'stateID': 2, 'aoq': 'Inactive', 'physical': 'No_Light', 'peerBeacon': False}
+    for x in itertools.cycle([a, b, c, d]):
+        yield x
 ")
-             :globals
-             (get "getdata"))]
+          :globals))))
+
+
+(defn get-data
+  []
+  (let [gd-fn (-> (test-script)
+                  (get "getdata"))]
+    (gd-fn)))
+
+
+(defn print-data
+  []
+  (let [pr-fn (-> (test-script)
+                  (get "print_data"))]
+    (pr-fn)))
+
+
+(defn get-multi-data
+  []
+  (let [gd-fn (-> (test-script)
+                  (get "getmultidata"))]
     (gd-fn)))
 
+
 ;;If you want to see how the sausage is made...
 (alter-var-root #'libpython-clj.python.object/*object-reference-logging*
                 (constantly false))
 
 ;;Ensure that failure to open resource context before tracking for stack
-;;related things causes immediate failure.
+;;related things causes immediate failure.  Unless you feel like being pedantic,
+;;this isn't necessary.  The python library automatically switches to normal gc-only
+;;mode if a resource context is open.
 (alter-var-root #'tech.resource.stack/*resource-context*
                 (constantly nil))
 
 (defn forever-test
   []
-  (py/initialize! :no-io-redirect? false)
+  (py/initialize!)
   (doseq [items (partition 999 (get-data))]
     ;;One way is to use the GC
     (time
@@ -41,13 +78,21 @@ def getdata():
     ;;A faster way is to grab the gil and use the resource system
     ;;This also ensures that resources within that block do not escape
     (time
-     (py/with-gil
-       (py/stack-resource-context
-        (last
-         (eduction
-          (map py/->jvm)
-          (map (partial into {}))
-          items)))))))
+     (py/with-gil-stack-rc-context
+       (last
+        (eduction
+         (map py/->jvm)
+         (map (partial into {}))
+         items))))))
+
+
+(defn multidata-test
+  []
+  (py/initialize!)
+  (doseq [items (partition 1000 (get-multi-data))]
+    (time (do (py/with-gil-stack-rc-context
+                (mapv py/->jvm items))
+              :ok))))
 
 
 (defn str-marshal-test
@@ -55,10 +100,9 @@ def getdata():
   (py/initialize!)
   (let [test-str (py/->python "a nice string to work with")]
     (time
-     (py/with-gil
-       (py/stack-resource-context
-        (dotimes [iter 100000]
-          (py/->jvm test-str)))))))
+     (py/with-gil-stack-rc-context
+       (dotimes [iter 100000]
+         (py/->jvm test-str))))))
 
 
 (defn dict-marshal-test
@@ -66,7 +110,14 @@ def getdata():
   (py/initialize!)
   (let [test-item (py/->python {:a 1 :b 2})]
     (time
-     (py/with-gil
-       (py/stack-resource-context
-        (dotimes [iter 10000]
-          (py/->jvm test-item)))))))
+     (py/with-gil-stack-rc-context
+       (dotimes [iter 10000]
+         (py/->jvm test-item))))))
+
+
+(defn print-stress-test
+  []
+  (py/initialize!)
+  (dotimes [iter 10000]
+    (with-out-str
+      (print-data))))

From 32dab03caefb64103a777c9ac709743a830b258d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 25 Nov 2019 11:04:21 -0700
Subject: [PATCH 010/456] 1.12

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index f05c0c2..3be2873 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.12-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.12"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 6ada8d863b8a341e02ef235e299dd8cb21118a93 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 25 Nov 2019 11:04:36 -0700
Subject: [PATCH 011/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 3be2873..6fcbaf4 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.12"
+(defproject cnuernber/libpython-clj "1.13-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 592c99b00aaa05842c19cb82c78950f48a2da374 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 25 Nov 2019 11:11:35 -0700
Subject: [PATCH 012/456] editing

---
 README.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ccf5ea6..04fb127 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,8 @@ JNA libpython bindings to the tech ecosystem.
 * Bridge between JVM objects and Python objects easily; use Python in your Java and
   use some Java in your Python.
 * Python objects are linked to the JVM GC such that when they are no longer reachable
-  from the JVM their references are released.
+  from the JVM their references are released.  Scope based resource contexts are 
+  [also available](https://github.com/cnuernber/libpython-clj/blob/master/docs/scopes-and-gc.md).
 * The exact same binary can run top of on multiple version of python reducing version
   dependency chain management issues.
 * Development of new functionality is faster because it can be done from purely from the
@@ -302,6 +303,7 @@ distance.
 ## Further Information
 
 * [design documentation](docs/design.md)
+* [scope and garbage collection docs](https://github.com/cnuernber/libpython-clj/blob/master/docs/scopes-and-gc.md)
 * [examples](example/README.md)
 * [docker setup](https://github.com/scicloj/docker-hub)
 * [pandas bindings (!!)](https://github.com/alanmarazzi/panthera)

From 529840fd543e2b49245728d3b64044f756648cbb Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 26 Nov 2019 06:57:02 -0700
Subject: [PATCH 013/456] editing

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 04fb127..c325cb4 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@ JNA libpython bindings to the tech ecosystem.
 * Bridge between JVM objects and Python objects easily; use Python in your Java and
   use some Java in your Python.
 * Python objects are linked to the JVM GC such that when they are no longer reachable
-  from the JVM their references are released.  Scope based resource contexts are 
+  from the JVM their references are released.  Scope based resource contexts are
   [also available](https://github.com/cnuernber/libpython-clj/blob/master/docs/scopes-and-gc.md).
 * The exact same binary can run top of on multiple version of python reducing version
   dependency chain management issues.
@@ -25,7 +25,7 @@ We have a [video](https://www.youtube.com/watch?v=ajDiGS73i2o) up of a scicloj c
 discussion with demos.
 
 
-TechAscent has a [blog post](http://www.techascent.com/blog/functions-across-languages.html) 
+TechAscent has a [blog post](http://www.techascent.com/blog/functions-across-languages.html)
 up about how the inter-language bindings actually work at a very low level.
 
 
@@ -115,7 +115,7 @@ there are java wrappers over the top of them.  For instance, `Object.toString` f
 its implementation to the python function `__str__`.
 
 ```clojure
-
+(def bridged (run-simple-string "print('hey')"))
 (instance? java.util.Map (:globals bridged))
 true
 user> (:globals bridged)

From c6be956dd2e4e51fa097732bcc97f308c8a291b3 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 26 Nov 2019 10:02:49 -0700
Subject: [PATCH 014/456] Syntax sugar and major perf upgrade copying dicts
 into jvm space.

---
 README.md                               | 23 +++++++
 src/libpython_clj/jna/concrete/dict.clj |  6 +-
 src/libpython_clj/python.clj            | 49 +++++++++++++++
 src/libpython_clj/python/bridge.clj     | 79 ++++++++++++++++++-------
 src/libpython_clj/python/object.clj     | 18 +++++-
 test/libpython_clj/python_test.clj      | 14 +++++
 6 files changed, 160 insertions(+), 29 deletions(-)

diff --git a/README.md b/README.md
index c325cb4..8d0cbcc 100644
--- a/README.md
+++ b/README.md
@@ -257,6 +257,29 @@ Execution error (ExceptionInfo) at libpython-clj.python.interpreter/check-error-
 SyntaxError: EOL while scanning string literal
 ```
 
+### Some Syntax Sugar
+```clojure
+user> (py/from-import numpy linspace)
+#'user/linspace
+user> (linspace 2 3 :num 10)
+[2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
+ 2.66666667 2.77777778 2.88888889 3.        ]
+user> (doc linspace)
+-------------------------
+user/linspace
+
+    Return evenly spaced numbers over a specified interval.
+
+    Returns `num` evenly spaced samples, calculated over the
+    interval [`start`, `stop`].
+
+```
+
+* `from-import` - sugar around python `from a import b`.  Takes multiple b's.
+* `import-as` - surgar around python `import a as b`.
+* `a$` - call an attribute using symbol att name.  Keywords map to kwargs
+* `c$` - call an object mapping keywords to fn-args
+
 ### Numpy
 
 Speaking of numpy, you can move data between numpy and java easily.
diff --git a/src/libpython_clj/jna/concrete/dict.clj b/src/libpython_clj/jna/concrete/dict.clj
index 2902568..93548a0 100644
--- a/src/libpython_clj/jna/concrete/dict.clj
+++ b/src/libpython_clj/jna/concrete/dict.clj
@@ -192,9 +192,9 @@
   structure, and since the structure is sparse, the offsets are not consecutive."
   Integer
   [p ensure-pyobj]
-  [ppos jna/as-ptr]
-  [pkey jna/as-ptr]
-  [pvalue jna/as-ptr])
+  [ppos (partial jna/ensure-type jna/size-t-ref-type)]
+  [pkey jna/ensure-ptr-ptr]
+  [pvalue jna/ensure-ptr-ptr])
 
 
 (def-pylib-fn PyDict_Merge
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 3c667ca..27f7667 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -91,6 +91,9 @@
 
 
 (export-symbols libpython-clj.python.bridge
+                args->pos-kw-args
+                cfn
+                afn
                 as-jvm
                 as-python
                 ->numpy
@@ -276,3 +279,49 @@
                retval#)
              (catch Throwable e#
                (with-exit-error-handler ~varname e#))))))))
+
+
+(defmacro a$
+  "Call an attribute of an object.  Similar calling conventions to afn except:
+  Keywords must be compile time constants.  So this won't work with 'apply'.  On the
+  other hand, building the positional and kw argmaps happens at compile time as
+  opposed to at runtime.  The attr name can be a symbol."
+  [item attr & args]
+  (let [attr-name (if (symbol? attr)
+                    (name attr)
+                    attr)
+        [pos-args kw-args] (args->pos-kw-args args)]
+    `(call-attr-kw ~item ~attr-name ~pos-args ~kw-args)))
+
+
+(defmacro c$
+  "Call an object.  Similar calling conventions to cfn except:
+  Keywords must be compile time constants.  So this won't work with 'apply'.  On the
+  other hand, building the positional and kw argmaps happens at compile time as
+  opposed to at runtime."
+  [item & args]
+  (let [[pos-args kw-args] (args->pos-kw-args args)]
+    `(call-kw ~item ~pos-args ~kw-args)))
+
+
+(defmacro import-as
+  "Import a module and assign it to a var.  Documentation is included."
+  [module-path varname]
+  `(let [~'mod-data (import-module ~(name module-path))]
+     (def ~varname (import-module ~(name module-path)))
+     (alter-meta! #'~varname assoc :doc (get-attr ~'mod-data "__doc__"))
+     #'~varname))
+
+
+(defmacro from-import
+  "Support for the from a import b,c style of importing modules and symbols in python.
+  Documentation is included."
+  [module-path item & args]
+  `(do
+     (let [~'mod-data (import-module ~(name module-path))]
+       ~@(map (fn [varname]
+                `(let [~'var-data (get-attr ~'mod-data ~(name varname))]
+                   (def ~varname ~'var-data)
+                   (alter-meta! #'~varname assoc :doc (get-attr ~'var-data "__doc__"))
+                   #'~varname))
+              (concat [item] args)))))
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index e791835..07a43fc 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -517,6 +517,55 @@
       (python->jvm-iterator iter-fn as-jvm))))
 
 
+(defn args->pos-kw-args
+  "Utility function that, given a list of arguments, separates them
+  into positional and keyword arguments.  Throws an exception if the
+  keyword argument is not followed by any more arguments."
+  [arglist]
+  (loop [args arglist
+         pos-args []
+         kw-args nil]
+    (if-not (seq args)
+      [pos-args kw-args]
+      (let [arg (first args)
+            [pos-args kw-args args]
+            (if (keyword? arg)
+              (if-not (seq (rest args))
+                (throw (Exception.
+                        (format "Keyword arguments must be followed by another arg: %s"
+                                (str arglist))))
+                [pos-args (assoc kw-args arg (first (rest args)))
+                 (drop 2 args)])
+              [(conj pos-args (first args))
+               kw-args
+               (rest args)])]
+        (recur args pos-args kw-args)))))
+
+
+(defn cfn
+  "Call an object.
+  Arguments are passed in positionally.  Any keyword
+  arguments are paired with the next arg, gathered, and passed into the
+  system as *kwargs.
+
+  Not having an argument after a keyword argument is an error."
+  [item & args]
+  (let [[pos-args kw-args] (args->pos-kw-args args)]
+    (py-proto/call-kw item pos-args kw-args)))
+
+
+(defn afn
+  "Call an attribute of an object.
+  Arguments are passed in positionally.  Any keyword
+  arguments are paired with the next arg, gathered, and passed into the
+  system as *kwargs.
+
+  Not having an argument after a keyword argument is an error."
+  [item attr & args]
+  (let [[pos-args kw-args] (args->pos-kw-args args)]
+    (py-proto/call-attr-kw item attr pos-args kw-args)))
+
+
 (defn generic-python-as-jvm
   "Given a generic pyobject, wrap it in a read-only map interface
   where the keys are the attributes."
@@ -542,48 +591,32 @@
            ;;uggh
            (invoke [this]
                    (with-interpreter interpreter
-                     (-> (libpy/PyObject_CallObject pyobj nil)
-                         wrap-pyobject
-                         as-jvm)))
+                     (cfn this)))
 
            (invoke [this arg0]
                    (with-interpreter interpreter
-                     (-> (libpy/PyObject_CallObject pyobj (as-tuple [arg0]))
-                         wrap-pyobject
-                         as-jvm)))
+                     (cfn this arg0)))
 
            (invoke [this arg0 arg1]
                    (with-interpreter interpreter
-                     (-> (libpy/PyObject_CallObject pyobj (as-tuple [arg0 arg1]))
-                         wrap-pyobject
-                         as-jvm)))
+                     (cfn this arg0 arg1)))
 
            (invoke [this arg0 arg1 arg2]
                    (with-interpreter interpreter
-                     (-> (libpy/PyObject_CallObject pyobj (as-tuple [arg0 arg1 arg2]))
-                         wrap-pyobject
-                         as-jvm)))
+                     (cfn this arg0 arg1 arg2)))
 
            (invoke [this arg0 arg1 arg2 arg3]
                    (with-interpreter interpreter
-                     (-> (libpy/PyObject_CallObject
-                          pyobj (as-tuple [arg0 arg1 arg2 arg3]))
-                         wrap-pyobject
-                         as-jvm)))
+                     (cfn this arg0 arg1 arg2 arg3)))
 
 
            (invoke [this arg0 arg1 arg2 arg3 arg4]
                    (with-interpreter interpreter
-                     (-> (libpy/PyObject_CallObject
-                          pyobj (as-tuple [arg0 arg1 arg2 arg3 arg4]))
-                         wrap-pyobject
-                         as-jvm)))
+                     (cfn this arg0 arg1 arg2 arg3 arg4)))
 
            (applyTo [this arglist]
                     (with-interpreter interpreter
-                      (-> (libpy/PyObject_CallObject pyobj (as-tuple arglist))
-                          wrap-pyobject
-                          as-jvm)))
+                      (apply cfn this arglist)))
            ;;Mark this as executable
            Fn
            PyFunction
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 3b454e3..f503e4c 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -92,7 +92,7 @@
 (defn ->jvm
   "Copy an object into the jvm (if it wasn't there already.)"
   [item & [options]]
-  (when item
+  (when-not (nil? item)
     (py-proto/->jvm item options)))
 
 
@@ -835,7 +835,19 @@
 
 (defmethod pyobject->jvm :dict
   [pyobj]
-  (python->jvm-copy-hashmap pyobj))
+  (with-gil
+    (let [ppos (jna/size-t-ref 0)
+          pkey (PointerByReference.)
+          pvalue (PointerByReference.)
+          retval (transient {})]
+      (loop [next-retval (libpy/PyDict_Next pyobj ppos pkey pvalue)]
+        (if (not= 0 next-retval)
+          (do
+            (assoc! retval
+                    (->jvm (jna/as-ptr pkey))
+                    (->jvm (jna/as-ptr pvalue)))
+            (recur (libpy/PyDict_Next pyobj ppos pkey pvalue)))
+          (persistent! retval))))))
 
 
 (defmethod pyobject->jvm :set
@@ -919,7 +931,7 @@
         (python->jvm-copy-persistent-vector pyobj)))
     ;;Sequences become persistent vectors
     (= 1 (libpy/PySequence_Check pyobj))
-    (python->jvm-copy-persistent-vector)
+    (python->jvm-copy-persistent-vector pyobj)
     :else
     {:type (python-type pyobj)
      :value (Pointer/nativeValue (jna/as-ptr pyobj))}))
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 493d817..793220f 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -1,6 +1,7 @@
 (ns libpython-clj.python-test
   (:require [libpython-clj.python :as py]
             [tech.v2.datatype :as dtype]
+            [tech.v2.datatype.functional :as dfn]
             [tech.v2.tensor :as dtt]
             [clojure.test :refer :all])
   (:import [java.io StringWriter]
@@ -256,3 +257,16 @@
         bridged (py/as-jvm py-dict)
         copied-back (py/->jvm bridged)]
     (is (instance? clojure.lang.PersistentArrayMap copied-back))))
+
+
+(deftest calling-conventions
+  (py/initialize!)
+  (let [np (py/import-module "numpy")
+        linspace (py/get-attr np "linspace")]
+
+    (is (dfn/equals [2.000 2.250 2.500 2.750 3.000]
+                    (py/as-tensor (linspace 2 3 :num 5))))
+    (is (dfn/equals [2.000 2.250 2.500 2.750 3.000]
+                    (py/as-tensor (py/c$ linspace 2 3 :num 5))))
+    (is (dfn/equals [2.000 2.250 2.500 2.750 3.000]
+                    (py/as-tensor (py/a$ np linspace 2 3 :num 5))))))

From 91c820eccdfae15810e421c37309be6f560d640a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 26 Nov 2019 10:03:16 -0700
Subject: [PATCH 015/456] 1.13

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 6fcbaf4..836b721 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.13-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.13"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 6cd5394ba4445f39d48809d8dbddc0c4559ea7a1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 26 Nov 2019 10:03:24 -0700
Subject: [PATCH 016/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 836b721..66a539c 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.13"
+(defproject cnuernber/libpython-clj "1.14-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 4cf7c965c39530a29a76971ff8e71cc8fd44a698 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 26 Nov 2019 10:42:41 -0700
Subject: [PATCH 017/456] Trying out auto-bridging some types for the top level
 API.

---
 src/libpython_clj/python.clj | 30 ++++++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)

diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 27f7667..71229cc 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -38,13 +38,9 @@
 
 
 (export-symbols libpython-clj.python.object
-                ->py-dict
                 ->py-float
-                ->py-list
                 ->py-long
                 ->py-string
-                ->py-tuple
-                ->py-fn
                 ->python
                 ->jvm)
 
@@ -100,6 +96,32 @@
                 as-numpy)
 
 
+(defn ->py-dict
+  "Create a python dictionary"
+  [item]
+  (-> (pyobj/->py-dict item)
+      (as-jvm)))
+
+
+(defn ->py-list
+  "Create a python list"
+  [item]
+  (-> (pyobj/->py-list item)
+      (as-jvm)))
+
+
+(defn ->py-tuple
+  [item]
+  (-> (pyobj/->py-tuple item)
+      (as-jvm)))
+
+
+(defn ->py-fn
+  [item]
+  (-> (pyobj/->py-fn item)
+      (as-jvm)))
+
+
 (defn run-simple-string
   "Run a string expression returning a map of
   {:globals :locals :result}.

From 17cf3428111c69ffc1b23940111dc84a496bd323 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 26 Nov 2019 10:43:59 -0700
Subject: [PATCH 018/456] editing

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 8d0cbcc..1f45a5e 100644
--- a/README.md
+++ b/README.md
@@ -278,7 +278,7 @@ user/linspace
 * `from-import` - sugar around python `from a import b`.  Takes multiple b's.
 * `import-as` - surgar around python `import a as b`.
 * `a$` - call an attribute using symbol att name.  Keywords map to kwargs
-* `c$` - call an object mapping keywords to fn-args
+* `c$` - call an object mapping keywords to kwargs
 
 ### Numpy
 

From e0e5619f1e511daeff68fab9a0e7f9f2e9773638 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 26 Nov 2019 13:20:54 -0700
Subject: [PATCH 019/456] editign

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 1f45a5e..4d0c12c 100644
--- a/README.md
+++ b/README.md
@@ -325,6 +325,7 @@ distance.
 
 ## Further Information
 
+* [development discussion forum](https://clojurians.zulipchat.com/#narrow/stream/215609-libpython-clj-dev)
 * [design documentation](docs/design.md)
 * [scope and garbage collection docs](https://github.com/cnuernber/libpython-clj/blob/master/docs/scopes-and-gc.md)
 * [examples](example/README.md)

From eb6ac5f4c671ce294c5483cd95f52335e6e6c59c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 27 Nov 2019 15:12:53 -0700
Subject: [PATCH 020/456] small datatype upgrade

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 66a539c..4f41a76 100644
--- a/project.clj
+++ b/project.clj
@@ -4,7 +4,7 @@
   :license {:name "EPL-2.0"
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
-                 [techascent/tech.datatype "4.54"]
+                 [techascent/tech.datatype "4.56"]
                  [camel-snake-kebab "0.4.0"]]
   :repl-options {:init-ns user}
   :java-source-paths ["java"])

From 45de248b0e93fb9c3a3a21ef5ea36781e209245b Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 29 Nov 2019 10:56:52 -0700
Subject: [PATCH 021/456] Attempted to make keras example as clojury as
 possible.

---
 example/project.clj          |  2 +-
 example/src/keras_simple.clj | 74 +++++++++++++++---------------------
 2 files changed, 32 insertions(+), 44 deletions(-)

diff --git a/example/project.clj b/example/project.clj
index 32a53ad..4063c45 100644
--- a/example/project.clj
+++ b/example/project.clj
@@ -4,4 +4,4 @@
   :license {:name "EPL-2.0"
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
-                 [cnuernber/libpython-clj "1.9"]])
+                 [cnuernber/libpython-clj "1.13"]])
diff --git a/example/src/keras_simple.clj b/example/src/keras_simple.clj
index 7986129..09c91e0 100644
--- a/example/src/keras_simple.clj
+++ b/example/src/keras_simple.clj
@@ -2,6 +2,10 @@
   "https://machinelearningmastery.com/tutorial-first-neural-network-python-keras/"
   (:require [libpython-clj.python
              :refer [import-module
+                     import-as
+                     from-import
+                     a$ ;;compile time call-attr
+                     afn ;;runtime call-attr
                      get-item
                      get-attr
                      python-type
@@ -22,83 +26,67 @@
 (py/initialize!)
 
 
-(defonce np (import-module "numpy"))
-(defonce builtins (import-module "builtins"))
-(defonce keras (import-module "keras"))
-(defonce keras-models (import-module "keras.models"))
-(defonce keras-layers (import-module "keras.layers"))
-(defonce c-types (import-module "ctypes"))
+(import-as numpy np)
+(import-as builtins builtins)
+(from-import builtins slice)
+(import-as keras keras)
+(import-as keras.models keras-models)
+(import-as keras.layers keras-layers)
+(import-as ctypes c-types)
 
-(defn slice
-  ([]
-   (call-attr builtins "slice" nil))
-  ([start]
-   (call-attr builtins "slice" start))
-  ([start stop]
-   (call-attr builtins "slice" start stop))
-  ([start stop incr]
-   (call-attr builtins "slice" start stop incr)))
 
+(defonce initial-data (a$ np loadtxt "pima-indians-diabetes.data.csv" :delimiter ","))
 
-(defonce initial-data (call-attr-kw np "loadtxt"
-                                    ["pima-indians-diabetes.data.csv"]
-                                    {"delimiter" ","}))
 
+(def features (get-item initial-data [(slice nil) (slice 0 8)]))
 
-(def features (get-item initial-data [(slice) (slice 0 8)]))
-
-(def labels (get-item initial-data [(slice) (slice 8 9)]))
+(def labels (get-item initial-data [(slice nil) (slice 8 9)]))
 
 (defn dense-layer
-  [output-size & {:as kwords}]
-  (call-attr-kw keras-layers "Dense" [output-size] kwords))
+  [output-size & args]
+  (apply py/afn keras-layers "Dense" output-size args))
 
 
 (defn sequential-model
   []
-  (call-attr keras-models "Sequential"))
+  (a$ keras-models Sequential))
 
 
 (defn add-layer!
   [model layer]
-  (call-attr model "add" layer)
+  (a$ model add layer)
   model)
 
 (defn compile-model!
-  [model & {:as kw-args}]
-  (call-attr-kw model "compile" []
-                kw-args)
+  [model & args]
+  (apply py/afn model "compile" args)
   model)
 
 
 (def model (-> (sequential-model)
-                   (add-layer! (dense-layer 12 "input_dim" 8 "activation" "relu"))
-                   (add-layer! (dense-layer 8 "activation" "relu"))
-                   (add-layer! (dense-layer 1 "activation" "sigmoid"))
-                   (compile-model! "loss" "binary_crossentropy"
-                                   "optimizer" "adam"
-                                   "metrics" (py/->py-list ["accuracy"]))))
-
-;;model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
+               (add-layer! (dense-layer 12 :input_dim 8 :activation :relu))
+               (add-layer! (dense-layer 8 :activation :relu))
+               (add-layer! (dense-layer 1 :activation :sigmoid))
+               (compile-model! :loss :binary_crossentropy
+                               :optimizer :adam
+                               :metrics (py/->py-list [:accuracy]))))
 
 (defn fit-model
-  [model features labels & {:as kw-args}]
-  (call-attr-kw model "fit"
-                [features labels]
-                kw-args)
+  [model features labels & args]
+  (apply py/afn model "fit" features labels args)
   model)
 
 
 (def fitted-model (fit-model model features labels
-                             "epochs" 150
-                             "batch_size" 10))
+                             :epochs 150
+                             :batch_size 10))
 
 
 (defn eval-model
   [model features lables]
   (let [model-names (->> (get-attr model "metrics_names")
                          (mapv keyword))]
-    (->> (call-attr model "evaluate" features labels)
+    (->> (a$ model evaluate features labels)
          (map vector model-names)
          (into {}))))
 

From 78a7c6becf6ca51bcb71e481e396efe79935e7ee Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 30 Nov 2019 08:11:57 -0700
Subject: [PATCH 022/456] Found link of persistent datastructures in python.

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 4d0c12c..12fd15b 100644
--- a/README.md
+++ b/README.md
@@ -334,6 +334,7 @@ distance.
 * [nextjournal notebook](https://nextjournal.com/chrisn/fun-with-matplotlib)
 * [scicloj video](https://www.youtube.com/watch?v=ajDiGS73i2o)
 * [Clojure/Python interop technical blog post](www.techascent.com/blogs/functions-across-languages.html)
+* [persistent datastructures in python](https://github.com/tobgu/pyrsistent)
 
 ## Resources
 

From 0a5eefa4228c864c001f5595d9d5dda643f3b128 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 30 Nov 2019 08:47:51 -0700
Subject: [PATCH 023/456] tiny update to keras-simple

---
 example/src/keras_simple.clj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/example/src/keras_simple.clj b/example/src/keras_simple.clj
index 09c91e0..52604b7 100644
--- a/example/src/keras_simple.clj
+++ b/example/src/keras_simple.clj
@@ -30,9 +30,9 @@
 (import-as builtins builtins)
 (from-import builtins slice)
 (import-as keras keras)
+(from-import keras.layers Dense)
 (import-as keras.models keras-models)
 (import-as keras.layers keras-layers)
-(import-as ctypes c-types)
 
 
 (defonce initial-data (a$ np loadtxt "pima-indians-diabetes.data.csv" :delimiter ","))
@@ -44,7 +44,7 @@
 
 (defn dense-layer
   [output-size & args]
-  (apply py/afn keras-layers "Dense" output-size args))
+  (apply py/cfn Dense output-size args))
 
 
 (defn sequential-model

From 50d848fd50fd890eefc655176cb4f0a8d1f3a7fd Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 2 Dec 2019 17:26:28 -0700
Subject: [PATCH 024/456] adding more libraries to be tried dynamically.

---
 CHANGELOG.md                             | 15 +++++++++++++++
 src/libpython_clj/jna/base.clj           |  7 +++++++
 src/libpython_clj/python.clj             |  5 +----
 src/libpython_clj/python/interpreter.clj | 21 +++++++++++++++++++--
 4 files changed, 42 insertions(+), 6 deletions(-)
 create mode 100644 CHANGELOG.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..7ccfda6
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,15 @@
+# Time for a ChangeLog!
+
+
+## 1.14
+
+libpython-clj now searches for several shared libraries instead of being hardcoded
+to just one of them.  Because of this, there is now:
+```clojure
+libpython-clj.jna.base/*python-library-names*
+```
+
+This is a sequence of library names that will be tried in order.
+
+You can also pass in the desired library name as part of the initialize! call and
+only this name will be tried.
diff --git a/src/libpython_clj/jna/base.clj b/src/libpython_clj/jna/base.clj
index ed90fa7..b179fd6 100644
--- a/src/libpython_clj/jna/base.clj
+++ b/src/libpython_clj/jna/base.clj
@@ -9,6 +9,13 @@
 
 (def ^:dynamic *python-library* "python3.6m")
 
+(def ^:dynamic *python-library-names* ["python3.7m" "python3.6m"])
+
+
+(defn library-names
+  []
+  *python-library-names*)
+
 
 (defprotocol PToPyObjectPtr
   (convertible-to-pyobject-ptr? [item])
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 71229cc..d59a1b7 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -194,11 +194,8 @@
   :no-io-redirect - there if you don't want python stdout and stderr redirection
      to *out* and *err*."
   [& {:keys [program-name no-io-redirect? library-path]}]
-  (when library-path
-    (alter-var-root #'libpython-clj.jna.base/*python-library*
-                    (constantly library-path)))
   (when-not @pyinterp/*main-interpreter*
-    (pyinterp/initialize! program-name)
+    (pyinterp/initialize! program-name library-path)
     ;;setup bridge mechansim and io redirection
     (pyinterop/register-bridge-type!)
     (when-not no-io-redirect?
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index df326d7..5c08b30 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -236,11 +236,28 @@
 (defonce ^:dynamic *program-name* "")
 
 
+(defn- try-load-python-library!
+  [libname]
+  (try
+    (jna/load-library libname)
+    (alter-var-root #'libpy-base/*python-library* (constantly libname))
+    (libpy/Py_InitializeEx 0)
+    libname
+    (catch Exception e)))
+
+
 (defn initialize!
-  [& [program-name]]
+  [& [program-name python-library-name]]
   (when-not @*main-interpreter*
     (log-info "executing python initialize!")
-    (libpy/Py_InitializeEx 0)
+    (let [user-names (when python-library-name
+                       [python-library-name])
+          library-names (or user-names (libpy-base/library-names))]
+      (when-not (->> library-names
+                     (filter try-load-python-library!)
+                     first)
+        (throw (Exception. (format "Failed to initialize python library.
+Attempted libraries %s" library-names)))))
     ;;Set program name
     (when-let [program-name (or program-name *program-name* "")]
       (resource/stack-resource-context

From ec8157d5fadfaee225b7b8e312df27ee4d454a3c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 2 Dec 2019 17:26:57 -0700
Subject: [PATCH 025/456] 1.14

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 4f41a76..14b91be 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.14-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.14"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 689bc330f0eacb2c80aeead61c6bc1a6cbb1dc03 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 2 Dec 2019 17:27:07 -0700
Subject: [PATCH 026/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 14b91be..8e2e91d 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.14"
+(defproject cnuernber/libpython-clj "1.15-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 9c2f4821e3e335c9d27ab79219b907da5961e7cd Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 2 Dec 2019 17:30:06 -0700
Subject: [PATCH 027/456] Changed location of python-library-name

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 12fd15b..b02628c 100644
--- a/README.md
+++ b/README.md
@@ -93,7 +93,7 @@ INFO: Reference thread starting
 
 This dynamically finds the python shared library and loads it.  If you desire a
 different shared library you can override
-[here](https://github.com/cnuernber/libpython-clj/blob/142c0dbc7056d0f5cd1969548a127a119f641c86/src/libpython_clj/jna/base.clj#L12).
+[here](https://github.com/cnuernber/libpython-clj/blob/master/src/libpython_clj/jna/base.clj#L12).
 
 
 ### Execute Some Python

From 04d8d1e8b1a48bb1eec31457c355f81ca4e46884 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 3 Dec 2019 16:20:30 -0700
Subject: [PATCH 028/456] Sytax sugar experimentation.

---
 CHANGELOG.md                       | 10 +++++++
 README.md                          | 16 +++++++++--
 src/libpython_clj/python.clj       | 45 ++++++++++++++++++++++++++++--
 test/libpython_clj/python_test.clj |  9 ++++++
 4 files changed, 76 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7ccfda6..c57b767 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,15 @@
 # Time for a ChangeLog!
 
+## 1.15-SNAPSHOT
+
+Moar syntax sugar --
+```clojure
+user> (py/$. numpy linspace)
+<function linspace at 0x7fa6642766a8>
+user> (py/$.. numpy random shuffle)
+<built-in method shuffle of numpy.random.mtrand.RandomState object at 0x7fa66410cca8>
+```
+
 
 ## 1.14
 
diff --git a/README.md b/README.md
index b02628c..633fde7 100644
--- a/README.md
+++ b/README.md
@@ -258,6 +258,7 @@ SyntaxError: EOL while scanning string literal
 ```
 
 ### Some Syntax Sugar
+
 ```clojure
 user> (py/from-import numpy linspace)
 #'user/linspace
@@ -277,8 +278,19 @@ user/linspace
 
 * `from-import` - sugar around python `from a import b`.  Takes multiple b's.
 * `import-as` - surgar around python `import a as b`.
-* `a$` - call an attribute using symbol att name.  Keywords map to kwargs
-* `c$` - call an object mapping keywords to kwargs
+* `$a` - call an attribute using symbol att name.  Keywords map to kwargs
+* `$c` - call an object mapping keywords to kwargs
+* `$.` - get an attribute.  Can pass in symbol, string, or keyword
+* `$..` - get an attribute.  If more args are present, get the attribute on that
+result.
+
+```clojure
+user> (py/$. numpy linspace)
+<function linspace at 0x7fa6642766a8>
+user> (py/$.. numpy random shuffle)
+<built-in method shuffle of numpy.random.mtrand.RandomState object at 0x7fa66410cca8>
+```
+
 
 ### Numpy
 
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index d59a1b7..9521431 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -299,12 +299,16 @@
              (catch Throwable e#
                (with-exit-error-handler ~varname e#))))))))
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 
 (defmacro a$
   "Call an attribute of an object.  Similar calling conventions to afn except:
   Keywords must be compile time constants.  So this won't work with 'apply'.  On the
   other hand, building the positional and kw argmaps happens at compile time as
-  opposed to at runtime.  The attr name can be a symbol."
+  opposed to at runtime.  The attr name can be a symbol.
+
+  DEPRECATION POSSIBLE - use $a."
   [item attr & args]
   (let [attr-name (if (symbol? attr)
                     (name attr)
@@ -317,12 +321,49 @@
   "Call an object.  Similar calling conventions to cfn except:
   Keywords must be compile time constants.  So this won't work with 'apply'.  On the
   other hand, building the positional and kw argmaps happens at compile time as
-  opposed to at runtime."
+  opposed to at runtime.
+
+  DEPRECATION POSSIBLE - use $c."
   [item & args]
   (let [[pos-args kw-args] (args->pos-kw-args args)]
     `(call-kw ~item ~pos-args ~kw-args)))
 
 
+
+(defmacro $a
+  "Call an attribute of an object.  Similar calling conventions to afn except:
+  Keywords must be compile time constants.  So this won't work with 'apply'.  On the
+  other hand, building the positional and kw argmaps happens at compile time as
+  opposed to at runtime.  The attr name can be a symbol."
+  [item attr & args]
+  `(a$ ~item ~attr ~@args))
+
+
+(defmacro $c
+  "Call an object.  Similar calling conventions to cfn except:
+  Keywords must be compile time constants.  So this won't work with 'apply'.  On the
+  other hand, building the positional and kw argmaps happens at compile time as
+  opposed to at runtime."
+  [item & args]
+  `(c$ ~item ~@args))
+
+
+(defmacro $.
+  "Get the attribute of an object."
+  [item attname]
+  `(get-attr ~item ~(name attname)))
+
+
+(defmacro $..
+  "Get the attribute of an object.  If there are extra args, apply successive
+  get-attribute calls to the arguments."
+  [item attname & args]
+  `(-> (get-attr ~item ~(name attname))
+       ~@(->> args
+              (map (fn [arg]
+                     `(get-attr ~(name arg)))))))
+
+
 (defmacro import-as
   "Import a module and assign it to a var.  Documentation is included."
   [module-path varname]
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 793220f..66c8b95 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -270,3 +270,12 @@
                     (py/as-tensor (py/c$ linspace 2 3 :num 5))))
     (is (dfn/equals [2.000 2.250 2.500 2.750 3.000]
                     (py/as-tensor (py/a$ np linspace 2 3 :num 5))))))
+
+(deftest syntax-sugar
+  (py/initialize!)
+  (let [np (py/import-module "numpy")]
+    (is (= (str (py/$. np linspace))
+           (str (py/get-attr np "linspace"))))
+    (is (= (str (py/$.. np random shuffle))
+           (str (-> (py/get-attr np "random")
+                    (py/get-attr "shuffle")))))))

From 0fa71d13d2cb0c3869bf8d2bee9602a04c798968 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 3 Dec 2019 16:23:43 -0700
Subject: [PATCH 029/456] Making experimental nature of sugar apparent.

---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index 633fde7..ac9b8f5 100644
--- a/README.md
+++ b/README.md
@@ -280,6 +280,10 @@ user/linspace
 * `import-as` - surgar around python `import a as b`.
 * `$a` - call an attribute using symbol att name.  Keywords map to kwargs
 * `$c` - call an object mapping keywords to kwargs
+
+
+#### Experimental Sugar (SNAPSHOT)
+
 * `$.` - get an attribute.  Can pass in symbol, string, or keyword
 * `$..` - get an attribute.  If more args are present, get the attribute on that
 result.

From 3df8b6a793fdc1e21caa624e27bf825b03838341 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 3 Dec 2019 16:24:57 -0700
Subject: [PATCH 030/456] 1.15

---
 CHANGELOG.md | 2 +-
 project.clj  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c57b767..2e735ec 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Time for a ChangeLog!
 
-## 1.15-SNAPSHOT
+## 1.15
 
 Moar syntax sugar --
 ```clojure
diff --git a/project.clj b/project.clj
index 8e2e91d..50939fc 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.15-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.15"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 3286631463271a16cde80809c5d1ad9cfa4c5b1d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 3 Dec 2019 16:27:12 -0700
Subject: [PATCH 031/456] editing

---
 CHANGELOG.md | 4 ++++
 README.md    | 5 ++++-
 project.clj  | 2 +-
 3 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2e735ec..d76ada8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Time for a ChangeLog!
 
+
+## 1.16-SNAPSHOT
+
+
 ## 1.15
 
 Moar syntax sugar --
diff --git a/README.md b/README.md
index ac9b8f5..e69b4de 100644
--- a/README.md
+++ b/README.md
@@ -282,7 +282,10 @@ user/linspace
 * `$c` - call an object mapping keywords to kwargs
 
 
-#### Experimental Sugar (SNAPSHOT)
+#### Experimental Sugar
+
+We are trying to find the best way to handle attributes in order to shorten
+generic python notebook-type usage.  The currently implemented direction is:
 
 * `$.` - get an attribute.  Can pass in symbol, string, or keyword
 * `$..` - get an attribute.  If more args are present, get the attribute on that
diff --git a/project.clj b/project.clj
index 50939fc..0e84e52 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.15"
+(defproject cnuernber/libpython-clj "1.16-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 66ef14ab5970c9eb14632dd60e509e8668101254 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 5 Dec 2019 07:26:09 -0700
Subject: [PATCH 032/456] small updates.

---
 example/project.clj          | 2 +-
 example/src/keras_simple.clj | 2 +-
 src/libpython_clj/python.clj | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/example/project.clj b/example/project.clj
index 4063c45..0464bad 100644
--- a/example/project.clj
+++ b/example/project.clj
@@ -4,4 +4,4 @@
   :license {:name "EPL-2.0"
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
-                 [cnuernber/libpython-clj "1.13"]])
+                 [cnuernber/libpython-clj "1.15"]])
diff --git a/example/src/keras_simple.clj b/example/src/keras_simple.clj
index 52604b7..44a2236 100644
--- a/example/src/keras_simple.clj
+++ b/example/src/keras_simple.clj
@@ -84,7 +84,7 @@
 
 (defn eval-model
   [model features lables]
-  (let [model-names (->> (get-attr model "metrics_names")
+  (let [model-names (->> ($. model metrics_names)
                          (mapv keyword))]
     (->> (a$ model evaluate features labels)
          (map vector model-names)
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 9521431..241605d 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -264,7 +264,7 @@
         (when (and ptype pvalue ptraceback
                    (not suppress-error?))
           (do
-            ;;MAnuall incref here because we cannot detach the object
+            ;;Manual incref here because we cannot detach the object
             ;;from our gc decref hook added during earlier pyerr-fetch handler.
             (pyjna/Py_IncRef ptype)
             (pyjna/Py_IncRef pvalue)

From 77687de777b640bf0d83b0bfb6d11328e47ac59c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 5 Dec 2019 13:56:13 -0700
Subject: [PATCH 033/456] Added test for nontrivial function definition.

---
 testcode/__init__.py | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/testcode/__init__.py b/testcode/__init__.py
index 8e0922e..d2fa00b 100644
--- a/testcode/__init__.py
+++ b/testcode/__init__.py
@@ -22,3 +22,17 @@ def for_iter(arg):
 
 def calling_custom_clojure_fn(arg):
     return arg.clojure_fn()
+
+
+
+def complex_fn(a, b, c: str=5, *args, d=10, **kwargs):
+    return {"a" : a,
+            "b" : b,
+            "c" : c,
+            "args" : args,            
+            "d": d,
+            "kwargs": kwargs}
+
+
+complex_fn_testcases = {"complex_fn(1, 2, c=10, d=10, e=10)":complex_fn(1, 2, c=10, d=10, e=10),
+                        "complex_fn(1, 2, 10, 11, 12, d=10, e=10)":complex_fn(1, 2, 10, 11, 12, d=10, e=10)}

From c3070c6f7096915d5f56c38a0d4b9c9072eb2d81 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 5 Dec 2019 14:13:57 -0700
Subject: [PATCH 034/456] generic testing of more complex fncall syntax.

---
 src/libpython_clj/python.clj        | 16 ++++++-------
 src/libpython_clj/python/bridge.clj | 35 ++++++++++++++++++++++-------
 test/libpython_clj/fncall_test.clj  | 29 ++++++++++++++++++++++++
 test/libpython_clj/python_test.clj  | 20 +++--------------
 4 files changed, 66 insertions(+), 34 deletions(-)
 create mode 100644 test/libpython_clj/fncall_test.clj

diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 241605d..4e97098 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -4,7 +4,7 @@
             [libpython-clj.python.interpreter :as pyinterp
              :refer [with-interpreter]]
             [libpython-clj.python.object :as pyobj]
-            [libpython-clj.python.bridge]
+            [libpython-clj.python.bridge :as pybridge]
             [libpython-clj.jna :as pyjna]
             [tech.jna :as jna])
   (:import [com.sun.jna Pointer]
@@ -310,11 +310,9 @@
 
   DEPRECATION POSSIBLE - use $a."
   [item attr & args]
-  (let [attr-name (if (symbol? attr)
-                    (name attr)
-                    attr)
-        [pos-args kw-args] (args->pos-kw-args args)]
-    `(call-attr-kw ~item ~attr-name ~pos-args ~kw-args)))
+  (let [[pos-args kw-args] (args->pos-kw-args args)]
+    `(call-attr-kw ~item ~(pybridge/key-sym-str->str attr)
+                   ~pos-args ~kw-args)))
 
 
 (defmacro c$
@@ -351,17 +349,17 @@
 (defmacro $.
   "Get the attribute of an object."
   [item attname]
-  `(get-attr ~item ~(name attname)))
+  `(get-attr ~item ~(pybridge/key-sym-str->str attname)))
 
 
 (defmacro $..
   "Get the attribute of an object.  If there are extra args, apply successive
   get-attribute calls to the arguments."
   [item attname & args]
-  `(-> (get-attr ~item ~(name attname))
+  `(-> (get-attr ~item ~(pybridge/key-sym-str->str attname))
        ~@(->> args
               (map (fn [arg]
-                     `(get-attr ~(name arg)))))))
+                     `(get-attr ~(pybridge/key-sym-str->str arg)))))))
 
 
 (defmacro import-as
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index 07a43fc..f7a531e 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -524,22 +524,27 @@
   [arglist]
   (loop [args arglist
          pos-args []
-         kw-args nil]
+         kw-args nil
+         found-kw? false]
     (if-not (seq args)
       [pos-args kw-args]
       (let [arg (first args)
-            [pos-args kw-args args]
+            [pos-args kw-args args found-kw?]
             (if (keyword? arg)
               (if-not (seq (rest args))
                 (throw (Exception.
                         (format "Keyword arguments must be followed by another arg: %s"
                                 (str arglist))))
                 [pos-args (assoc kw-args arg (first (rest args)))
-                 (drop 2 args)])
-              [(conj pos-args (first args))
-               kw-args
-               (rest args)])]
-        (recur args pos-args kw-args)))))
+                 (drop 2 args) true])
+              (if found-kw?
+                (throw (Exception.
+                        (format "Positional arguments are not allowed after keyword arguments: %s"
+                                arglist)))
+                [(conj pos-args (first args))
+                 kw-args
+                 (rest args) found-kw?]))]
+        (recur args pos-args kw-args found-kw?)))))
 
 
 (defn cfn
@@ -554,6 +559,19 @@
     (py-proto/call-kw item pos-args kw-args)))
 
 
+(defn key-sym-str->str
+  [attr-name]
+  (cond
+    (or (keyword? attr-name)
+        (symbol? attr-name))
+    (name attr-name)
+    (string? attr-name)
+    attr-name
+    :else
+    (throw (Exception.
+            "Only keywords, symbols, or strings can be used to access attributes."))))
+
+
 (defn afn
   "Call an attribute of an object.
   Arguments are passed in positionally.  Any keyword
@@ -563,7 +581,8 @@
   Not having an argument after a keyword argument is an error."
   [item attr & args]
   (let [[pos-args kw-args] (args->pos-kw-args args)]
-    (py-proto/call-attr-kw item attr pos-args kw-args)))
+    (py-proto/call-attr-kw item (key-sym-str->str attr)
+                           pos-args kw-args)))
 
 
 (defn generic-python-as-jvm
diff --git a/test/libpython_clj/fncall_test.clj b/test/libpython_clj/fncall_test.clj
new file mode 100644
index 0000000..c2dbacc
--- /dev/null
+++ b/test/libpython_clj/fncall_test.clj
@@ -0,0 +1,29 @@
+(ns libpython-clj.fncall-test
+  (:require [libpython-clj.python :as py]
+            [clojure.test :refer :all]))
+
+
+(py/initialize!)
+
+
+
+(deftest complex-fn-test
+  (let [testmod (py/import-module "testcode")
+        testcases (py/$. testmod complex_fn_testcases)]
+    (is (= (-> (get testcases "complex_fn(1, 2, c=10, d=10, e=10)")
+               (py/->jvm))
+           (-> (py/$a testmod complex_fn 1 2 :c 10 :d 10 :e 10)
+               (py/->jvm))))
+    (is (= (-> (get testcases "complex_fn(1, 2, 10, 11, 12, d=10, e=10)")
+               (py/->jvm))
+           (-> (py/$a testmod complex_fn 1 2 10 11 12 :d 10 :e 10)
+               (py/->jvm))))
+
+    (is (= (-> (get testcases "complex_fn(1, 2, c=10, d=10, e=10)")
+               (py/->jvm))
+           (-> (apply py/afn testmod "complex_fn" [1 2 :c 10 :d 10 :e 10])
+               (py/->jvm))))
+    (is (= (-> (get testcases "complex_fn(1, 2, 10, 11, 12, d=10, e=10)")
+               (py/->jvm))
+           (-> (apply py/afn testmod "complex_fn" [1 2 10 11 12 :d 10 :e 10])
+               (py/->jvm))))))
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 66c8b95..e150733 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -7,9 +7,10 @@
   (:import [java.io StringWriter]
            [java.util Map List]))
 
+  (py/initialize!)
+
 
 (deftest stdout-and-stderr
-  (py/initialize!)
   (is (= "hey\n" (with-out-str
                    (py/run-simple-string "print('hey')"))))
   (is (= "hey\n" (let [custom-writer (StringWriter.)]
@@ -21,7 +22,6 @@
 
 
 (deftest dicts
-  (py/initialize!)
   (let [py-dict (py/->python {:a 1 :b 2})]
     (is (= :dict (py/python-type py-dict)))
     (is (= 2 (-> (py/call-attr py-dict "__len__")
@@ -40,7 +40,6 @@
 
 
 (deftest lists
-  (py/initialize!)
   (let [py-list (py/->py-list [4 3 2 1])]
     (is (= :list (py/python-type py-list)))
     (is (= 4 (-> (py/call-attr py-list "__len__")
@@ -58,7 +57,6 @@
 
 
 (deftest global-dict
-  (py/initialize!)
   (let [main-module (py/add-module "__main__")
         ^Map globals (-> (py/module-dict main-module)
                     (py/as-jvm))]
@@ -72,7 +70,6 @@
 
 
 (deftest numpy-and-back
-  (py/initialize!)
   (let [jvm-tens (dtt/->tensor (->> (range 9)
                                     (partition 3)))]
     ;;zero-copy can't work on jvm datastructures with current JNA tech.
@@ -109,7 +106,6 @@
                    dtt/->jvm)))))))
 
 (deftest numpy-scalars
-  (py/initialize!)
   (let [np (py/import-module "numpy")
         scalar-constructors (concat ["float64"
                                      "float32"]
@@ -123,7 +119,6 @@
 
 
 (deftest dict-with-complex-key
-  (py/initialize!)
   (let [py-dict (py/->python {["a" "b"] 1
                               ["c" "d"] 2})
         bridged (py/as-jvm py-dict)]
@@ -136,20 +131,17 @@
 
 
 (deftest simple-print-crashed
-  (py/initialize!)
   (let [numpy (py/import-module "numpy")]
     (println (py/as-tensor (py/call-attr numpy "ones" [3 3])))))
 
 
 (deftest true-false-list
-  (py/initialize!)
   (is (= [false true]
          (-> '(false true)
              py/->py-list
              py/->jvm))))
 
 (deftest true-false-true-numpy
-  (py/initialize!)
   (let [numpy (py/import-module "numpy")]
     (is (= [true false true]
            (->> (for [a (py/call-attr numpy "array" [true false true])]
@@ -158,7 +150,6 @@
 
 
 (deftest aspy-iter
-  (py/initialize!)
   (let [testcode-module (py/import-module "testcode")]
     (is (= [1 2 3 4 5]
            (-> (py/call-attr testcode-module
@@ -171,7 +162,6 @@
 
 
 (deftest basic-with-test
-  (py/initialize!)
   (let [testcode-module (py/import-module "testcode")]
     (let [fn-list (py/->py-list [])]
       (is (nil?
@@ -201,13 +191,11 @@
 
 
 (deftest arrow-as-fns-with-nil
-  (py/initialize!)
   (is (= nil (py/->jvm nil)))
   (is (= nil (py/as-jvm nil))))
 
 
 (deftest pydict-nil-get
-  (py/initialize!)
   (let [dict (py/->python {:a 1 :b {:a 1 :b 2}})
         bridged (py/as-jvm dict)]
     (is (= nil (bridged nil)))))
@@ -252,7 +240,6 @@
 
 
 (deftest bridged-dict-to-jvm
-  (py/initialize!)
   (let [py-dict (py/->py-dict {:a 1 :b 2})
         bridged (py/as-jvm py-dict)
         copied-back (py/->jvm bridged)]
@@ -260,9 +247,8 @@
 
 
 (deftest calling-conventions
-  (py/initialize!)
   (let [np (py/import-module "numpy")
-        linspace (py/get-attr np "linspace")]
+        linspace (py/$. np linspace)]
 
     (is (dfn/equals [2.000 2.250 2.500 2.750 3.000]
                     (py/as-tensor (linspace 2 3 :num 5))))

From 9407189bc3c31ff41db19a62f9dd736af37a9500 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 6 Dec 2019 09:38:23 -0700
Subject: [PATCH 035/456] 1.16

---
 project.clj                              | 2 +-
 src/libpython_clj/python/interpreter.clj | 9 ++++-----
 test/libpython_clj/fncall_test.clj       | 2 ++
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/project.clj b/project.clj
index 0e84e52..785453e 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.16-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.16"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 5c08b30..e446b29 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -253,11 +253,10 @@
     (let [user-names (when python-library-name
                        [python-library-name])
           library-names (or user-names (libpy-base/library-names))]
-      (when-not (->> library-names
-                     (filter try-load-python-library!)
-                     first)
-        (throw (Exception. (format "Failed to initialize python library.
-Attempted libraries %s" library-names)))))
+      (loop [[library-name & library-names] library-names]
+        (if (and library-name
+                 (not (try-load-python-library! library-name)))
+          (recur library-names))))
     ;;Set program name
     (when-let [program-name (or program-name *program-name* "")]
       (resource/stack-resource-context
diff --git a/test/libpython_clj/fncall_test.clj b/test/libpython_clj/fncall_test.clj
index c2dbacc..aa43dfd 100644
--- a/test/libpython_clj/fncall_test.clj
+++ b/test/libpython_clj/fncall_test.clj
@@ -6,6 +6,8 @@
 (py/initialize!)
 
 
+(py/import-as testcode testmod)
+(py/from-import inspect getfullargspec)
 
 (deftest complex-fn-test
   (let [testmod (py/import-module "testcode")

From dd4fa650e7998c005d64ed1f51ff503fbcedccb4 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 6 Dec 2019 09:40:37 -0700
Subject: [PATCH 036/456] Updating changelog.

---
 CHANGELOG.md | 10 +++++++++-
 project.clj  |  2 +-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d76ada8..25e9561 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,15 @@
 # Time for a ChangeLog!
 
 
-## 1.16-SNAPSHOT
+## 1.16
+
+Fixed a bug where the system would load multiple python libraries, not stopping
+after the first valid library loaded.  There are two ways to control the system's
+python library loading mechanism:
+
+1. Pass in a library name in initialize!
+2. alter-var-root the list of libraries in libpython-clj.jna.base before
+   calling initialize!.
 
 
 ## 1.15
diff --git a/project.clj b/project.clj
index 785453e..b106221 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.16"
+(defproject cnuernber/libpython-clj "1.17-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 4f264eb9055a03778b2e88918a32952f245ac613 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 7 Dec 2019 17:07:29 -0700
Subject: [PATCH 037/456] First crack at creating custom classes.

---
 src/libpython_clj/jna.clj                    |  3 +-
 src/libpython_clj/jna/concrete/cfunction.clj | 17 +++++++
 src/libpython_clj/jna/concrete/type.clj      |  4 +-
 src/libpython_clj/python.clj                 | 52 +++++++++++++++++++-
 src/libpython_clj/python/interop.clj         | 14 ++++--
 src/libpython_clj/python/protocols.clj       |  3 ++
 test/libpython_clj/classes_test.clj          | 41 +++++++++++++++
 test/libpython_clj/stress_test.clj           | 46 ++++++++++++++---
 8 files changed, 167 insertions(+), 13 deletions(-)
 create mode 100644 test/libpython_clj/classes_test.clj

diff --git a/src/libpython_clj/jna.clj b/src/libpython_clj/jna.clj
index 906de77..a1f4bde 100644
--- a/src/libpython_clj/jna.clj
+++ b/src/libpython_clj/jna.clj
@@ -272,7 +272,8 @@
                 METH_O
                 METH_STATIC
                 METH_VARARGS
-                PyCFunction_New)
+                PyCFunction_New
+                PyInstanceMethod_New)
 
 
 (export-symbols libpython-clj.jna.concrete.import
diff --git a/src/libpython_clj/jna/concrete/cfunction.clj b/src/libpython_clj/jna/concrete/cfunction.clj
index 38e534f..d078a9e 100644
--- a/src/libpython_clj/jna/concrete/cfunction.clj
+++ b/src/libpython_clj/jna/concrete/cfunction.clj
@@ -55,3 +55,20 @@
   Pointer
   [method-def (partial jna/ensure-type PyMethodDef)]
   [self jna/as-ptr])
+
+
+(def-pylib-fn PyInstanceMethod_New
+  "Return value: New reference.
+
+  Return a new instance method object, with func being any callable object func is the
+  function that will be called when the instance method is called."
+  Pointer
+  [func ensure-pyobj])
+
+
+(def-pylib-fn PyInstanceMethod_Function
+  "Return value: Borrowed reference.
+
+  Return the function object associated with the instance method im."
+  Pointer
+  [im ensure-pyobj])
diff --git a/src/libpython_clj/jna/concrete/type.clj b/src/libpython_clj/jna/concrete/type.clj
index d043859..323a906 100644
--- a/src/libpython_clj/jna/concrete/type.clj
+++ b/src/libpython_clj/jna/concrete/type.clj
@@ -110,8 +110,8 @@
    type’s tp_alloc slot."
   Pointer
   [type (partial jna/ensure-type PyTypeObject)]
-  [args ensure-pyobj]
-  [kwds ensure-pyobj])
+  [args #(when % (ensure-pyobj %))]
+  [kwds #(when % (ensure-pyobj %))])
 
 
 (def-pylib-fn PyType_Ready
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 4e97098..3ff0970 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -10,7 +10,10 @@
   (:import [com.sun.jna Pointer]
            [com.sun.jna.ptr PointerByReference]
            [java.io Writer]
-           [libpython_clj.jna PyObject]))
+           [libpython_clj.jna PyObject
+            CFunction$KeyWordFunction
+            CFunction$TupleFunction
+            CFunction$NoArgFunction]))
 
 
 (set! *warn-on-reflection* true)
@@ -111,17 +114,64 @@
 
 
 (defn ->py-tuple
+  "Create a python tuple"
   [item]
   (-> (pyobj/->py-tuple item)
       (as-jvm)))
 
 
 (defn ->py-fn
+  "Make a python function.  If clojure function is passed in the arguments are
+  marshalled from python to clojure, the function called, and the return value will be
+  marshalled back."
   [item]
   (-> (pyobj/->py-fn item)
       (as-jvm)))
 
 
+(defn make-tuple-fn
+  "Reify the appropriate interface for tuple functions and return a new python cfunction
+  object.  Args are exposed as a python tuple to the embedded code.  This is a low level
+  function and you may never need it."
+  [clj-fn & [options]]
+  (-> (reify CFunction$TupleFunction
+        (pyinvoke [_ self args]
+          (let [retval
+                (apply clj-fn (as-jvm args))]
+            (pyobj/incref (->python retval)))))
+      (pyobj/->py-fn options)))
+
+(declare import-module)
+
+
+(def ^:private builtins (delay (import-module "builtins")))
+
+
+(defn create-class
+  "Create a new class object.  Any callable values in the cls-hashmap
+  will be presented as instance methods.
+  Things in the cls hashmap had better be either atoms or already converted
+  python objects.  You may get surprised otherwise; you have been warned.
+  See the classes-test file in test/libpython-clj"
+  [name bases cls-hashmap]
+  (with-gil
+    (let [cls-hashmap (->> cls-hashmap
+                           (map (fn [[k v]]
+                                  [k (if (callable? v)
+                                       (-> (pyjna/PyInstanceMethod_New v)
+                                           (pyobj/wrap-pyobject))
+                                       v)])))
+          cls-dict (reduce (fn [cls-dict [k v]]
+                             (set-item! cls-dict k (->python v))
+                             cls-dict)
+                           (->py-dict {})
+                           cls-hashmap)
+          bases (->py-tuple bases)
+          builtins @builtins
+          new-cls (call-attr builtins "type" name bases cls-dict)]
+      new-cls)))
+
+
 (defn run-simple-string
   "Run a string expression returning a map of
   {:globals :locals :result}.
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
index ea80a1b..221d5ce 100644
--- a/src/libpython_clj/python/interop.clj
+++ b/src/libpython_clj/python/interop.clj
@@ -198,6 +198,7 @@
                   method-definitions
                   tp_flags ;;may be nil
                   tp_basicsize ;;size of binary type
+                  tp_init ;;init fn, may be nil
                   tp_new ;;may be nil, will use generic
                   tp_dealloc ;;may be nil, will use generic
                   tp_getattr ;;may *not* be nil
@@ -213,12 +214,15 @@
    (let [tp_new (or tp_new
                     (reify CFunction$tp_new
                       (pyinvoke [this self varargs kw_args]
-                        (libpy/PyType_GenericNew self varargs kw_args))))
+                        (let [retval (libpy/PyType_GenericNew self varargs kw_args)]
+                          (println retval)
+                          retval)
+                        )))
          module-name (get-attr module "__name__")
          ;;These get leaked.  Really, types are global objects that cannot be released.
          ;;Until we can destroy interpreters, it isn't worth the effort to track the
          ;;type and memory related to the type.
-         docstring-ptr (jna/string->ptr-untracked docstring)
+         docstring-ptr (when docstring (jna/string->ptr-untracked docstring))
          type-name-ptr (jna/string->ptr-untracked (str module-name "." type-name))
          tp_flags (long (or tp_flags
                             (bit-or @libpy/Py_TPFLAGS_DEFAULT
@@ -229,6 +233,7 @@
          _ (nio-buf/memset new-mem 0 type-obj-size)
          new-type (PyTypeObject. new-mem)]
      (set! (.tp_name new-type) type-name-ptr)
+     (set! (.tp_init new-type) tp_init)
      (set! (.tp_doc new-type) docstring-ptr)
      (set! (.tp_basicsize new-type) tp_basicsize)
      (set! (.tp_flags new-type) tp_flags)
@@ -255,9 +260,12 @@
                                  :tp_name type-name-ptr
                                  :tp_doc docstring-ptr
                                  :tp_new tp_new
+                                 :tp_init tp_init
                                  :tp_dealloc tp_dealloc
                                  :tp_getattr tp_getattr
-                                 :tp_setattr tp_setattr))
+                                 :tp_setattr tp_setattr
+                                 :tp_iter tp_iter
+                                 :tp_iternext tp_iternext))
            (libpy/Py_IncRef new-type)
            new-type)
          (throw (ex-info (format "Type failed to register: %d" type-ready)
diff --git a/src/libpython_clj/python/protocols.clj b/src/libpython_clj/python/protocols.clj
index 415f515..b4b72ab 100644
--- a/src/libpython_clj/python/protocols.clj
+++ b/src/libpython_clj/python/protocols.clj
@@ -88,6 +88,9 @@ are converted into a {:type :pyobject-address} pairs."))
 
 
 (extend-type Object
+  PPyObject
+  (callable? [_] false)
+  (has-attr? [_ _] false)
   PPyAttMap
   (att-type-map [item]
     (->> (dir item)
diff --git a/test/libpython_clj/classes_test.clj b/test/libpython_clj/classes_test.clj
new file mode 100644
index 0000000..d80fb5f
--- /dev/null
+++ b/test/libpython_clj/classes_test.clj
@@ -0,0 +1,41 @@
+(ns libpython-clj.classes-test
+  (:require [libpython-clj.python :as py]
+            [libpython-clj.jna :as pylib]
+            [clojure.test :refer :all]
+            [clojure.pprint :as pp]
+            [clojure.edn :as edn]))
+
+
+
+(py/initialize!)
+
+(deftest new-cls-test
+  (let [cls-obj (py/create-class
+                 "Stock" nil
+                 ;;Using as-py-fn instead of ->py-fn to avoid any marshalling.
+                 ;;What happens is the self object gets marshalled to a
+                 ;;persistent map.  This isn't what we want.
+                 {"__init__" (py/make-tuple-fn
+                              (fn [self name shares price]
+                                (py/set-attr! self "name" name)
+                                (py/set-attr! self "shares" shares)
+                                (py/set-attr! self "price" price)
+                                nil))
+                  "cost" (py/make-tuple-fn
+                          (fn [self]
+                            (* (py/$. self shares)
+                               (py/$. self price))))
+                  "__str__" (py/make-tuple-fn
+                             (fn [self]
+                               ;;Self is just a dict so it converts to a hashmap
+                               (pr-str {"name" (py/$. self name)
+                                        "shares" (py/$. self shares)
+                                        "price" (py/$. self price)})))
+                  "clsattr" 55})
+        new-instance (cls-obj "ACME" 50 90)]
+    (is (= 4500
+           (py/$a new-instance cost)))
+    (is (= 55 (py/$. new-instance clsattr)))
+
+    (is (= {"name" "ACME", "shares" 50, "price" 90}
+           (edn/read-string (.toString new-instance))))))
diff --git a/test/libpython_clj/stress_test.clj b/test/libpython_clj/stress_test.clj
index 88a5e32..939d2d0 100644
--- a/test/libpython_clj/stress_test.clj
+++ b/test/libpython_clj/stress_test.clj
@@ -3,7 +3,12 @@
   memory if it isn't setup correctly."
   (:require [libpython-clj.python :as py]
             [libpython-clj.jna :as libpy]
-            [libpython-clj.python.object :as pyobject]))
+            [libpython-clj.python.object :as pyobject]
+            [clojure.test :refer :all]
+            [clojure.edn :as edn]))
+
+
+(py/initialize!)
 
 
 (def test-script
@@ -64,7 +69,6 @@ def getmultidata():
 
 (defn forever-test
   []
-  (py/initialize!)
   (doseq [items (partition 999 (get-data))]
     ;;One way is to use the GC
     (time
@@ -88,7 +92,6 @@ def getmultidata():
 
 (defn multidata-test
   []
-  (py/initialize!)
   (doseq [items (partition 1000 (get-multi-data))]
     (time (do (py/with-gil-stack-rc-context
                 (mapv py/->jvm items))
@@ -97,7 +100,6 @@ def getmultidata():
 
 (defn str-marshal-test
   []
-  (py/initialize!)
   (let [test-str (py/->python "a nice string to work with")]
     (time
      (py/with-gil-stack-rc-context
@@ -107,7 +109,6 @@ def getmultidata():
 
 (defn dict-marshal-test
   []
-  (py/initialize!)
   (let [test-item (py/->python {:a 1 :b 2})]
     (time
      (py/with-gil-stack-rc-context
@@ -117,7 +118,40 @@ def getmultidata():
 
 (defn print-stress-test
   []
-  (py/initialize!)
   (dotimes [iter 10000]
     (with-out-str
       (print-data))))
+
+
+(defn new-cls-stress-test
+  []
+  (dotimes [iter 1000]
+    (py/with-gil-stack-rc-context
+      (let [test-cls (py/create-class "testcls" nil
+                                      {"__init__" (py/make-tuple-fn
+                                                   (fn [self name shares price]
+                                                     (py/set-attr! self "name" name)
+                                                     (py/set-attr! self "shares" shares)
+                                                     (py/set-attr! self "price" price)
+                                                     nil))
+                                       "cost" (py/make-tuple-fn
+                                               (fn [self]
+                                                 (* (py/$. self shares)
+                                                    (py/$. self price))))
+                                       "__str__" (py/make-tuple-fn
+                                                  (fn [self]
+                                                    ;;Self is just a dict so it converts to a hashmap
+                                                    (pr-str {"name" (py/$. self name)
+                                                             "shares" (py/$. self shares)
+                                                             "price" (py/$. self price)})))
+                                       "testvar" 55}
+                                      )
+            new-inst (test-cls "ACME" 50 90)]
+        (is (= 4500
+               (py/$a new-inst cost)))
+        (is (= 55 (py/$. new-inst testvar)))
+
+        (is (= {"name" "ACME", "shares" 50, "price" 90}
+               (edn/read-string (.toString new-inst))))
+
+        ))))

From da33cc4123af3cbc75a6beee12585970c32e9928 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 8 Dec 2019 09:14:10 -0700
Subject: [PATCH 038/456] Refactored pathway for generating classes
 dynamically.

---
 src/libpython_clj/jna.clj           |  19 ++-
 src/libpython_clj/python.clj        |  68 ++++-----
 src/libpython_clj/python/object.clj | 215 +++++++++++++++++++++-------
 test/libpython_clj/classes_test.clj |  45 +++---
 4 files changed, 236 insertions(+), 111 deletions(-)

diff --git a/src/libpython_clj/jna.clj b/src/libpython_clj/jna.clj
index a1f4bde..04b42ec 100644
--- a/src/libpython_clj/jna.clj
+++ b/src/libpython_clj/jna.clj
@@ -7,9 +7,10 @@
             [tech.parallel.utils :refer [export-symbols]]
             [libpython-clj.jna.base
              :refer [def-pylib-fn
-                     ensure-pyobj]]
+                     ensure-pyobj]
+             :as libpy-base]
             [libpython-clj.jna.base]
-            [libpython-clj.jna.interpreter]
+            [libpython-clj.jna.interpreter :as jnainterp]
             [libpython-clj.jna.protocols.object]
             [libpython-clj.jna.protocols.iterator]
             [libpython-clj.jna.protocols.sequence]
@@ -55,6 +56,20 @@
                 PyRun_StringFlags)
 
 
+(defmacro ^:private export-type-symbols
+  []
+  `(do
+     ~@(->> (vals jnainterp/type-symbol-table)
+            (map (fn [sym-name]
+                   `(defn ~(symbol sym-name)
+                      ~(format "%s type object" sym-name)
+                      []
+                      (libpy-base/find-pylib-symbol ~sym-name)))))))
+
+
+(export-type-symbols)
+
+
 (export-symbols libpython-clj.jna.protocols.object
                 Py_DecRef
                 Py_IncRef
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 3ff0970..a3a6864 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -45,7 +45,10 @@
                 ->py-long
                 ->py-string
                 ->python
-                ->jvm)
+                ->jvm
+                make-tuple-fn
+                make-tuple-instance-fn
+                create-class)
 
 
 (defmacro stack-resource-context
@@ -84,6 +87,26 @@
       ~@body)))
 
 
+(defn set-attrs!
+  "Set a sequence of [name value] attributes.
+  Returns item"
+  [item att-seq]
+  (with-gil
+    (doseq [[k v] att-seq]
+      (set-attr! item k v)))
+  item)
+
+
+(defn set-items!
+  "Set a sequence of [name value].
+  Returns item"
+  [item item-seq]
+  (with-gil
+    (doseq [[k v] item-seq]
+      (set-item! item k v)))
+  item)
+
+
 (export-symbols libpython-clj.python.interop
                 libpython-clj-module-name
                 create-bridge-from-att-map)
@@ -129,49 +152,6 @@
       (as-jvm)))
 
 
-(defn make-tuple-fn
-  "Reify the appropriate interface for tuple functions and return a new python cfunction
-  object.  Args are exposed as a python tuple to the embedded code.  This is a low level
-  function and you may never need it."
-  [clj-fn & [options]]
-  (-> (reify CFunction$TupleFunction
-        (pyinvoke [_ self args]
-          (let [retval
-                (apply clj-fn (as-jvm args))]
-            (pyobj/incref (->python retval)))))
-      (pyobj/->py-fn options)))
-
-(declare import-module)
-
-
-(def ^:private builtins (delay (import-module "builtins")))
-
-
-(defn create-class
-  "Create a new class object.  Any callable values in the cls-hashmap
-  will be presented as instance methods.
-  Things in the cls hashmap had better be either atoms or already converted
-  python objects.  You may get surprised otherwise; you have been warned.
-  See the classes-test file in test/libpython-clj"
-  [name bases cls-hashmap]
-  (with-gil
-    (let [cls-hashmap (->> cls-hashmap
-                           (map (fn [[k v]]
-                                  [k (if (callable? v)
-                                       (-> (pyjna/PyInstanceMethod_New v)
-                                           (pyobj/wrap-pyobject))
-                                       v)])))
-          cls-dict (reduce (fn [cls-dict [k v]]
-                             (set-item! cls-dict k (->python v))
-                             cls-dict)
-                           (->py-dict {})
-                           cls-hashmap)
-          bases (->py-tuple bases)
-          builtins @builtins
-          new-cls (call-attr builtins "type" name bases cls-dict)]
-      new-cls)))
-
-
 (defn run-simple-string
   "Run a string expression returning a map of
   {:globals :locals :result}.
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index f503e4c..c15f465 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -32,8 +32,6 @@
              :refer [pyobject->jvm
                      python-type]
              :as py-proto]
-            [libpython-clj.python.logging
-             :refer [log-error log-warn log-info]]
             [libpython-clj.jna.base :as libpy-base]
             [libpython-clj.jna :as libpy]
             [clojure.stacktrace :as st]
@@ -42,7 +40,8 @@
             [tech.v2.datatype :as dtype]
             [tech.v2.datatype.protocols :as dtype-proto]
             [tech.v2.datatype.casting :as casting]
-            [tech.v2.tensor])
+            [tech.v2.tensor]
+            [clojure.tools.logging :as log])
   (:import [com.sun.jna Pointer CallbackReference]
            [com.sun.jna.ptr PointerByReference]
            [libpython_clj.jna
@@ -52,7 +51,7 @@
             CFunction$NoArgFunction
             PyMethodDef]
            [java.nio.charset StandardCharsets]
-           [tech.v2.datatype ObjectIter]
+           [tech.v2.datatype ObjectIter ObjectReader]
            [tech.v2.datatype.typed_buffer TypedBuffer]
            [tech.v2.tensor.protocols PTensor]
            [java.util RandomAccess Map Set Map$Entry]
@@ -146,7 +145,7 @@
                                                          (dec (or arg 0)))))
                            (libpy/Py_DecRef (Pointer. pyobj-value))
                            (catch Throwable e
-                             (log-error "Exception while releasing object: %s" e))))
+                             (log/error e "Exception while releasing object"))))
                       *pyobject-tracking-flags*))
     (do
       ;;Special handling for PyNone types
@@ -370,25 +369,11 @@
 (def ^:dynamic *item-tuple-cutoff* 8)
 
 
-(defn wrap-clojure-fn
-  [fn-obj]
-  (when-not (fn? fn-obj)
-    (throw (ex-info "This is not a function." {})))
-  (reify CFunction$TupleFunction
-    (pyinvoke [this self args]
-      (try
-        (let [retval
-              (apply fn-obj (->jvm args))]
-          (if (nil? retval)
-            (incref (libpy/Py_None))
-            (->python retval)))
-        (catch Throwable e
-          (log-error (format "%s:%s" e (with-out-str
-                                         (st/print-stack-trace e))))
-          (libpy/PyErr_SetString (libpy/PyExc_Exception)
-                                 (format "%s:%s" e (with-out-str
-                                                     (st/print-stack-trace e))))
-          nil)))))
+(defn- cfunc-instance?
+  [function]
+  (or (instance? CFunction$KeyWordFunction function)
+      (instance? CFunction$TupleFunction function)
+      (instance? CFunction$NoArgFunction function)))
 
 
 (defn apply-method-def-data!
@@ -397,34 +382,34 @@
                                    function]
                             :as method-data}]
   (resource/stack-resource-context
-   (let [callback (if (or (instance? CFunction$KeyWordFunction function)
-                          (instance? CFunction$TupleFunction function)
-                          (instance? CFunction$NoArgFunction function))
-                    function
-                    (wrap-clojure-fn function))
-         meth-flags (long (cond
-                            (instance? CFunction$NoArgFunction callback)
+   (when-not (cfunc-instance? function)
+     (throw (Exception.
+             (format "Callbacks must implement one of the CFunction interfaces:
+%s" (type function)))))
+   (let [meth-flags (long (cond
+                            (instance? CFunction$NoArgFunction function)
                             @libpy/METH_NOARGS
 
-                            (instance? CFunction$TupleFunction callback)
+                            (instance? CFunction$TupleFunction function)
                             @libpy/METH_VARARGS
 
-                            (instance? CFunction$KeyWordFunction callback)
+                            (instance? CFunction$KeyWordFunction function)
                             (bit-or @libpy/METH_KEYWORDS @libpy/METH_VARARGS)
                             :else
                             (throw (ex-info (format "Failed due to type: %s"
-                                                    (type callback))))))
+                                                    (type function))
+                                            {}))))
          name-ptr (jna/string->ptr name)
          doc-ptr (jna/string->ptr doc)]
      (set! (.ml_name method-def) name-ptr)
-     (set! (.ml_meth method-def) (CallbackReference/getFunctionPointer callback))
+     (set! (.ml_meth method-def) (CallbackReference/getFunctionPointer function))
      (set! (.ml_flags method-def) (int meth-flags))
      (set! (.ml_doc method-def) doc-ptr)
      (.write method-def)
      (pyinterp/conj-forever! (assoc method-data
                                     :name-ptr name-ptr
                                     :doc-ptr doc-ptr
-                                    :callback-object callback
+                                    :callback-object function
                                     :method-definition method-def))
      method-def)))
 
@@ -434,29 +419,161 @@
   (apply-method-def-data! (PyMethodDef.) method-data))
 
 
+
+(defn- cfunc-impl->pyobject
+  [cfunc {:keys [method-name
+                 documentation
+                 py-self]
+          :or {method-name "unnamed_function"
+               documentation "not documented"}}]
+  (with-gil
+    (let [py-self (or py-self (->python {}))]
+      (-> (libpy/PyCFunction_New (method-def-data->method-def
+                                  {:name method-name
+                                   :doc documentation
+                                   :function cfunc})
+                                 ;;This is a nice little tidbit, cfunction_new
+                                 ;;steals the reference.
+                                 (libpy/Py_IncRef py-self))
+          (wrap-pyobject)))))
+
+
+(defn py-tuple->borrowed-reference-reader
+  "Given a python tuple, return an object reader that iterates
+  through the items.  If you hold onto one of these items you need
+  to add to it's reference count.  If unsure of what you are doing
+  don't use this method, use ->jvm."
+  [tuple]
+  (with-gil
+    (let [interpreter (ensure-bound-interpreter)
+          n-items (long (libpy/PyObject_Length tuple))]
+      (reify ObjectReader
+        (lsize [_] n-items)
+        (read [_ idx]
+          (with-interpreter interpreter
+            (libpy/PyTuple_GetItem tuple idx)))))))
+
+
+(defn ->python-incref
+  "Convert to python and add a reference.  This is necessary for return values from
+  functions as the ->python pathway adds a reference but it also tracks it and
+  releases it when it is not in use any more.  Thus python ends up holding onto
+  something with fewer refcounts than it should have.  If you are just messing
+  around in the repl you only need ->python.  There is an expectation that the
+  return value of a function call is a new reference and not a borrowed reference
+  hence this pathway."
+  [item]
+  (-> (->python item)
+      (incref)))
+
+
+
+(defn make-tuple-fn
+  "Given a clojure function, create a python tuple function.
+  arg-convert is applied to arguments before the clojure function
+  gets them and result-converter is applied to the outbound result.
+  Exceptions are caught, logged, and propagated to python.
+
+  arg-converter: A function to be called on arguments before they get to
+    clojure.  Defaults to ->jvm.
+  result-converter: A function to be called on the return value before it
+    makes it back to python.  Defaults to ->python-incref.
+  method-name: Name of function exposed to python.
+  documentation: Documentation of function exposed to python."
+  [fn-obj & {:keys [arg-converter
+                    result-converter]
+             :or {arg-converter ->jvm
+                  result-converter ->python-incref}
+             :as options}]
+  (with-gil
+    (-> (reify CFunction$TupleFunction
+          (pyinvoke [this self args]
+            (try
+              (let [argseq (cond->> (py-tuple->borrowed-reference-reader args)
+                             arg-converter
+                             (map arg-converter))]
+                (cond-> (apply fn-obj argseq)
+                  result-converter
+                  (result-converter)))
+              (catch Throwable e
+                (log/error e "Error executing clojure function.")
+                (libpy/PyErr_SetString (libpy/PyExc_Exception)
+                                       (format "%s:%s" e (with-out-str
+                                                           (st/print-stack-trace e))))
+                nil))))
+        (cfunc-impl->pyobject options))))
+
+
 (defn ->py-fn
   "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."
-  ([fn-obj {:keys [method-name documentation py-self]
-             :or {method-name "unnamed_function"
-                  documentation "not documented"}}]
-   (with-gil
-     (let [py-self (or py-self (->python {}))]
-       (wrap-pyobject (libpy/PyCFunction_New (method-def-data->method-def
-                                              {:name method-name
-                                               :doc documentation
-                                               :function fn-obj})
-                                             ;;This is a nice little tidbit, cfunction_new
-                                             ;;steals the reference.
-                                             (libpy/Py_IncRef py-self))))))
+  indicator.
+  Options are
+  method-name: Name of function exposed to python.
+  documentation: Documentation of function exposed to python.
+  py-self: The 'self' object to be used for the function."
+  ([fn-obj {:keys []
+            :as options}]
+   (cond
+     (instance? clojure.lang.IFn fn-obj)
+     (apply make-tuple-fn fn-obj (apply concat options))
+     (cfunc-instance? fn-obj)
+     (cfunc-impl->pyobject fn-obj options)
+     :else
+     (throw (Exception. "fn-obj is neither a CFunction nor clojure callable."))))
   ([fn-obj]
    (->py-fn fn-obj {})))
 
 
+(defn py-fn->instance-fn
+  "Given a python callable, return an instance function meant to be used
+  in class definitions."
+  [py-fn]
+  (with-gil
+    (-> (libpy/PyInstanceMethod_New py-fn)
+        (wrap-pyobject))))
+
+
+(defn make-tuple-instance-fn
+  "Make an instance function.  In this case the default behavior is to
+  pass raw python object ptr args  to the clojure function without marshalling
+  as that can add confusion and unnecessary overhead.  Self will be the first argument.
+  Callers can change this behavior by setting the 'arg-converter' option as in
+  'make-tuple-fn'.
+  Options are the same as make-tuple-fn."
+  [clj-fn & {:keys [arg-converter]
+             :as options}]
+  (with-gil
+    (-> (apply make-tuple-fn
+               clj-fn
+               ;;Explicity set arg-convert to override make-tuple-fn's default
+               ;;->jvm arg-converter.
+               (->> (assoc options :arg-converter arg-converter)
+                    (apply concat)))
+        ;;Mark this as an instance function.
+        (py-fn->instance-fn))))
+
+
+(defn create-class
+  "Create a new class object.  Any callable values in the cls-hashmap
+  will be presented as instance methods.
+  Things in the cls hashmap had better be either atoms or already converted
+  python objects.  You may get surprised otherwise; you have been warned.
+  See the classes-test file in test/libpython-clj"
+  [name bases cls-hashmap]
+  (with-gil
+    (let [cls-dict (reduce (fn [cls-dict [k v]]
+                             (py-proto/set-item! cls-dict k (->python v))
+                             cls-dict)
+                           (->py-dict {})
+                           cls-hashmap)
+          bases (->py-tuple bases)
+          new-cls (py-proto/call (libpy/PyType_Type) name bases cls-dict)]
+      (py-proto/as-jvm new-cls nil))))
+
 
 (extend-protocol py-proto/PCopyToPython
   Number
diff --git a/test/libpython_clj/classes_test.clj b/test/libpython_clj/classes_test.clj
index d80fb5f..e68d7cc 100644
--- a/test/libpython_clj/classes_test.clj
+++ b/test/libpython_clj/classes_test.clj
@@ -6,36 +6,49 @@
             [clojure.edn :as edn]))
 
 
-
 (py/initialize!)
 
+
 (deftest new-cls-test
+  ;;The crux of this is making instance functions.  The make-tuple-instance-fn pathway
+  ;;is pretty close to the metal and as such it does no marshalling of parameters by
+  ;;default.  You can turn on marshalling of all parameters adding `arg-converter`
+  ;;optional argument (this may make your life easier) or you can marshal just the
+  ;;parameter you have to (self in the examples below).
   (let [cls-obj (py/create-class
                  "Stock" nil
-                 ;;Using as-py-fn instead of ->py-fn to avoid any marshalling.
-                 ;;What happens is the self object gets marshalled to a
-                 ;;persistent map.  This isn't what we want.
-                 {"__init__" (py/make-tuple-fn
+                 {"__init__" (py/make-tuple-instance-fn
                               (fn [self name shares price]
-                                (py/set-attr! self "name" name)
-                                (py/set-attr! self "shares" shares)
-                                (py/set-attr! self "price" price)
+                                ;;Because we did not use an arg-converter, all the
+                                ;;arguments above are raw jna Pointers - borrowed
+                                ;;references.
+                                (py/set-attrs! self {"name" name
+                                                     "shares" shares
+                                                     "price" price})
+                                ;;If you don't return nil from __init__ that is an
+                                ;;error.
                                 nil))
-                  "cost" (py/make-tuple-fn
+                  "cost" (py/make-tuple-instance-fn
                           (fn [self]
                             (* (py/$. self shares)
-                               (py/$. self price))))
-                  "__str__" (py/make-tuple-fn
+                               (py/$. self price)))
+
+                          ;;Convert self to something that auto-marshals things.
+                          ;;This pathway will autoconvert all arguments to the function.
+                          :arg-converter py/as-jvm
+                          :method-name "cost")
+                  "__str__" (py/make-tuple-instance-fn
                              (fn [self]
-                               ;;Self is just a dict so it converts to a hashmap
-                               (pr-str {"name" (py/$. self name)
-                                        "shares" (py/$. self shares)
-                                        "price" (py/$. self price)})))
+                               ;;Alternative to using arg-converter.  This way you can
+                               ;;explicitly control which arguments are converted.
+                               (let [self (py/as-jvm self)]
+                                 (pr-str {"name" (py/$. self name)
+                                          "shares" (py/$. self shares)
+                                          "price" (py/$. self price)}))))
                   "clsattr" 55})
         new-instance (cls-obj "ACME" 50 90)]
     (is (= 4500
            (py/$a new-instance cost)))
     (is (= 55 (py/$. new-instance clsattr)))
-
     (is (= {"name" "ACME", "shares" 50, "price" 90}
            (edn/read-string (.toString new-instance))))))

From 72043c8c9c1fa90a570b24095f61dae52e0aaf92 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sun, 8 Dec 2019 11:21:56 -0500
Subject: [PATCH 039/456] Add alpha framework for require-python feature (#12)

* Add alpha framework for require-python feature

* more docstring

* less docstring

* less docstring

* remove trace statements

* remove unused code; formatting

* spacing

* relevant examples

* add developer note

* typos

* note formatting

* fix documentation typo

* fix load-py-fn invocation in load-python-lib
---
 src/libpython_clj/require.clj | 253 ++++++++++++++++++++++++++++++++++
 1 file changed, 253 insertions(+)
 create mode 100644 src/libpython_clj/require.clj

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
new file mode 100644
index 0000000..6d46246
--- /dev/null
+++ b/src/libpython_clj/require.clj
@@ -0,0 +1,253 @@
+(ns libpython-clj.require
+  (:refer-clojure :exclude [fn? doc])
+  (:require [libpython-clj.python :as py]))
+
+(def ^:private builtins (py/import-module "builtins"))
+
+(def ^:private inspect (py/import-module "inspect"))
+
+(def ^:private argspec (py/get-attr inspect "getfullargspec"))
+
+(def ^:private py-source (py/get-attr inspect "getsource"))
+
+(def ^:private types (py/import-module "types"))
+
+(def ^:private fn-type (py/get-attr types "FunctionType"))
+
+(def ^:private method-type (py/get-attr types "MethodType"))
+
+(def ^:private isinstance? (py/get-attr builtins "isinstance"))
+
+(def ^:private fn? #(isinstance? % fn-type))
+
+(def ^:private method? #(isinstance? % method-type))
+
+(def ^:private doc #(try
+                      (py/get-attr % "__doc__")
+                      (catch Exception e
+                        nil)))
+
+(def ^:private importlib (py/import-module "importlib"))
+
+(def ^:private reload-module (py/get-attr importlib "reload"))
+
+(def ^:priviate import-module (py/get-attr importlib "import_module"))
+
+(def ^{:private false :public true}
+  get-pydoc doc)
+
+(def ^:private vars (py/get-attr builtins "vars"))
+
+(defn ^:private py-fn-argspec [f]
+  (let [spec (argspec f)]
+    {:args           (py/->jvm (py/get-attr spec "args"))
+     :varargs        (py/->jvm (py/get-attr spec "varargs"))
+     :varkw          (py/->jvm (py/get-attr spec "varkw"))
+     :defaults       (py/->jvm (py/get-attr spec "defaults"))
+     :kwonlyargs     (py/->jvm  (py/get-attr spec "kwonlyargs"))
+     :kwonlydefaults (py/->jvm  (py/get-attr spec "kwonlydefaults"))
+     :annotations    (py/->jvm  (py/get-attr spec "annotations"))}))
+
+(defn ^:private py-class-argspec [class]
+  (let [constructor (py/get-attr class "__init__")]
+    (py-fn-argspec constructor)))
+
+(defn pyargspec [x]
+  (cond
+    (fn? x) (py-fn-argspec x)
+    (method? x) (py-fn-argspec x)
+    :else (py-class-argspec x)))
+
+(defn ^:private load-py-fn [f fn-name fn-module-name-or-ns]
+  (let [fn-argspec (pyargspec f)
+        fn-docstr  (get-pydoc f)
+        fn-ns      (symbol (str fn-module-name-or-ns))
+        fn-sym     (symbol fn-name)]
+    (intern fn-ns fn-sym
+            (with-meta f
+              (merge
+               fn-argspec
+               {:doc  fn-docstr
+                :name fn-name})))))
+
+(defn ^:private load-python-lib [req]
+  (let [supported-flags     #{:reload}
+        [module-name & etc] req
+        flags               (into #{}
+                                  (filter supported-flags)
+                                  etc)
+        etc                 (into {}
+                                  (comp
+                                   (remove supported-flags)
+                                   (partition-all 2)
+                                   (map vec))
+                                  etc)
+        reload?             (:reload flags)
+        this-module         (import-module (str module-name))
+        module-name-or-ns   (:as etc module-name)
+        exclude             (into #{} (:exclude etc))
+        refer          (cond
+                         (= :all (:refer etc)) #{:all}
+                         (= :* (:refer etc))   #{:*}
+                         :else                 (into
+                                                #{}
+                                                (:refer etc)))
+        current-ns     *ns*
+        current-ns-sym (symbol (str current-ns))]
+
+
+    ;; if the current namespace is already loaded, unless
+    ;; the :reload flag is specified, this will be a no-op
+    (when (not (and (find-ns module-name-or-ns)
+                    (not reload?)));; :reload behavior
+
+      ;; TODO: should we track things referred into the existing
+      ;;   ..: *ns* with an atom and clear them on :reload?
+
+      (when reload? 
+        (remove-ns module-name)
+        (reload-module this-module))
+
+      ;; bind the python module to its symbolic name
+      ;; in the current namespace
+      (intern current-ns-sym module-name-or-ns this-module)
+
+      ;; create namespace for module and bind python
+      ;; values to namespace symbols
+      (doseq [[k pyfn?] (seq (py/as-jvm (vars  this-module)))]
+        (try
+          (load-py-fn pyfn? (symbol k) module-name-or-ns)
+          (catch Exception e
+            (try
+              (let [ns     module-name-or-ns
+                    symbol (symbol k)]
+                (in-ns ns)
+                (intern ns symbol pyfn?))
+              (finally
+                (in-ns current-ns-sym))))))
+
+      ;; behavior for [.. :refer :all], [.. :refer [...]], and
+      ;; [.. :refer :*]
+      ;; TODO: code is a bit repetitive maybe
+      (cond
+        ;; include everything into the current namespace,
+        ;; ignore __all__ directive
+        (refer :all)
+        (doseq
+            [[k pyfn?]
+             (seq (py/as-jvm (vars  this-module)))
+             :when (not (exclude (symbol k)))]
+          (try
+            (load-py-fn pyfn? (symbol k) current-ns-sym)
+            (catch Exception e
+              (let [symbol (symbol k)]
+                (intern *ns* symbol pyfn?)))))
+        ;; only include that specfied by __all__ attribute
+        ;; of python module if specified, else same as :all
+        (refer :*)
+        (let [hasattr (py/get-attr builtins "hasattr")
+              getattr (py/get-attr builtins "getattr")]
+          (if (hasattr this-module "__all__")
+            (doseq
+                [[k pyfn?]
+                 (for [item-name (getattr this-module "__all__")]
+                   [(symbol item-name)
+                    (getattr this-module item-name)])
+                 :when (not (exclude (symbol k)))]
+              (try
+                (load-py-fn pyfn? (symbol k) current-ns-sym)
+                (catch Exception e
+                  (let [symbol (symbol k)]
+                    (intern *ns* symbol pyfn?)))))
+            (doseq
+                [[k pyfn?]
+                 (seq (py/as-jvm (vars  this-module)))
+                 :when (not (exclude (symbol k)))]
+              (try
+                (load-py-fn pyfn? (symbol k) current-ns-sym)
+                (catch Exception e
+                  (let [symbol (symbol k)]
+                    (intern *ns* symbol pyfn?)))))))
+        
+        ;; [.. :refer [..]] behavior
+        :else
+        (doseq [r    refer
+                :let [pyfn? (py/get-attr this-module (str r))]]
+          (if (or (fn? pyfn?) (method? pyfn?))
+            (load-py-fn pyfn?)
+            (intern current-ns-sym r pyfn?)))))))
+
+(defn require-python [reqs]
+  "## Basic usage ##
+   
+   (require-python 'math)
+   (math/sin 1.0) ;;=> 0.8414709848078965
+
+   (require-python '[math :as maaaath])
+
+   (maaaath/sin 1.0) ;;=> 0.8414709848078965
+
+   (require-python '(math csv))
+   (require-python '([math :as pymath] csv))
+   (require-python '([math :as pymath] [csv :as py-csv])
+   (require-python 'concurrent.futures)
+   (require-python '[concurrent.futures :as fs])
+
+   (require-python '[requests :refer [get post]])
+
+   (requests/get \"https//www.google.com\") ;;=>  <Response [200]>
+   (get \"https//www.google.com\") ;;=>  <Response [200]>
+
+
+   ## Use with custom modules ##
+
+   For use with a custom namespace foo.py while developing, you can
+   use:
+
+   (require-python '[foo :reload])
+
+   NOTE: unless you specify the :reload flag,
+     ..: the module will NOT reload.  If the :reload flag is set,
+     ..: the behavior mimics importlib.reload
+
+   ## Setting up classpath for custom modules ##
+
+   Note: you may need to setup your PYTHONPATH correctly. 
+   One technique to do this is, if your foo.py lives at 
+   /path/to/foodir/foo.py:
+
+   (require-python 'sys)
+   (py/call-attr (py/get-attr sys \"path\") 
+                 \"append\" 
+                 \"/path/to/foodir\")
+
+   Another option is 
+
+   (require-python 'os)
+   (os/chdir \"/path/to/foodir\")
+
+
+   ## For library developers ##
+
+   If you want to intern all symbols to your current namespace,
+   you can do the following -- 
+
+   (require-python '[math :refer :all])
+
+   However, if you only want to use 
+   those things designated by the module under the __all__ attribute,
+   you can do
+
+   (require-python '[operators :refer :*])"
+
+  (cond
+    (list? reqs)
+    (doseq [req (vec reqs)] (require-python req))
+    (symbol? reqs)
+    (load-python-lib (vector reqs))
+    (vector? reqs)
+    (load-python-lib reqs)))
+
+(comment
+  (require-python '([clojure :refer [parenthesis]] __future__))
+  (py/set-attr! __future__ "braces" parenthesis))

From 5c09e99df953e5a060b953db90a694678fad9e75 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 8 Dec 2019 09:54:49 -0700
Subject: [PATCH 040/456] Metadata is now applied to symbol.

---
 src/libpython_clj/py_modules/numpy.clj |  5 ++-
 src/libpython_clj/require.clj          | 44 ++++++++++++++------------
 2 files changed, 26 insertions(+), 23 deletions(-)

diff --git a/src/libpython_clj/py_modules/numpy.clj b/src/libpython_clj/py_modules/numpy.clj
index afda395..81bbf46 100644
--- a/src/libpython_clj/py_modules/numpy.clj
+++ b/src/libpython_clj/py_modules/numpy.clj
@@ -1,13 +1,12 @@
 (ns libpython-clj.py-modules.numpy
   (:require [libpython-clj.python :as py]
-            [libpython-clj.export-module-symbols
-             :refer [export-module-symbols]])
+            [libpython-clj.require :refer [require-python]])
   (:refer-clojure :exclude [test take str sort short require repeat partition
                             mod min max long load int identity float empty double
                             conj char cast byte]))
 
 
-(export-module-symbols "numpy")
+(require-python '[numpy :refer :* :reload])
 
 
 (comment
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 6d46246..c7f5cc9 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -2,6 +2,8 @@
   (:refer-clojure :exclude [fn? doc])
   (:require [libpython-clj.python :as py]))
 
+(py/initialize!)
+
 (def ^:private builtins (py/import-module "builtins"))
 
 (def ^:private inspect (py/import-module "inspect"))
@@ -58,17 +60,18 @@
     (method? x) (py-fn-argspec x)
     :else (py-class-argspec x)))
 
+(defn pymetadata [fn-name x]
+  (let [fn-argspec (pyargspec x)
+        fn-docstr  (get-pydoc x)]
+    (merge
+     fn-argspec
+     {:doc  fn-docstr
+      :name fn-name})))
+
 (defn ^:private load-py-fn [f fn-name fn-module-name-or-ns]
-  (let [fn-argspec (pyargspec f)
-        fn-docstr  (get-pydoc f)
-        fn-ns      (symbol (str fn-module-name-or-ns))
+  (let [fn-ns      (symbol (str fn-module-name-or-ns))
         fn-sym     (symbol fn-name)]
-    (intern fn-ns fn-sym
-            (with-meta f
-              (merge
-               fn-argspec
-               {:doc  fn-docstr
-                :name fn-name})))))
+    (intern fn-ns (with-meta fn-sym (metadata fn-name f)) f)))
 
 (defn ^:private load-python-lib [req]
   (let [supported-flags     #{:reload}
@@ -104,7 +107,7 @@
       ;; TODO: should we track things referred into the existing
       ;;   ..: *ns* with an atom and clear them on :reload?
 
-      (when reload? 
+      (when reload?
         (remove-ns module-name)
         (reload-module this-module))
 
@@ -168,7 +171,7 @@
                 (catch Exception e
                   (let [symbol (symbol k)]
                     (intern *ns* symbol pyfn?)))))))
-        
+
         ;; [.. :refer [..]] behavior
         :else
         (doseq [r    refer
@@ -177,9 +180,9 @@
             (load-py-fn pyfn?)
             (intern current-ns-sym r pyfn?)))))))
 
-(defn require-python [reqs]
+(defn require-python
   "## Basic usage ##
-   
+
    (require-python 'math)
    (math/sin 1.0) ;;=> 0.8414709848078965
 
@@ -212,16 +215,16 @@
 
    ## Setting up classpath for custom modules ##
 
-   Note: you may need to setup your PYTHONPATH correctly. 
-   One technique to do this is, if your foo.py lives at 
+   Note: you may need to setup your PYTHONPATH correctly.
+   One technique to do this is, if your foo.py lives at
    /path/to/foodir/foo.py:
 
    (require-python 'sys)
-   (py/call-attr (py/get-attr sys \"path\") 
-                 \"append\" 
+   (py/call-attr (py/get-attr sys \"path\")
+                 \"append\"
                  \"/path/to/foodir\")
 
-   Another option is 
+   Another option is
 
    (require-python 'os)
    (os/chdir \"/path/to/foodir\")
@@ -230,15 +233,16 @@
    ## For library developers ##
 
    If you want to intern all symbols to your current namespace,
-   you can do the following -- 
+   you can do the following --
 
    (require-python '[math :refer :all])
 
-   However, if you only want to use 
+   However, if you only want to use
    those things designated by the module under the __all__ attribute,
    you can do
 
    (require-python '[operators :refer :*])"
+  [reqs]
 
   (cond
     (list? reqs)

From 4a0747011a4a1bbaf58a952b598218c6ed37be03 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 8 Dec 2019 09:58:15 -0700
Subject: [PATCH 041/456] Deprecating export macro.

---
 src/libpython_clj/export_module_symbols.clj | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/libpython_clj/export_module_symbols.clj b/src/libpython_clj/export_module_symbols.clj
index 30aac0c..b6e48c4 100644
--- a/src/libpython_clj/export_module_symbols.clj
+++ b/src/libpython_clj/export_module_symbols.clj
@@ -1,6 +1,8 @@
 (ns libpython-clj.export-module-symbols
   "A macro that will export all the symbols from a python module and make
-  them functions in the current clojure namespace."
+  them functions in the current clojure namespace.
+
+  DEPRECATED - please use 'libpython-clj.require/require-python"
   (:require [libpython-clj.python :as py]))
 
 
@@ -8,6 +10,7 @@
 
 
 (defmacro export-module-symbols
+  "DEPRECATED - please use 'libpython-clj.require/require-python"
   [py-mod-name]
   (py/initialize!)
   (let [mod-data (py/import-module py-mod-name)]

From 245e76b81294499ec5132d333eaa1dc9c62c4ab9 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 8 Dec 2019 10:41:59 -0700
Subject: [PATCH 042/456] Preparing for next release.

---
 CHANGELOG.md | 36 ++++++++++++++++++++++++++++++++++++
 project.clj  |  2 +-
 2 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 25e9561..abd6c10 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,41 @@
 # Time for a ChangeLog!
 
+## 1.20-SNAPSHOT
+
+With two many huge things we had to skip a few versions!
+
+#### require-python
+
+`require-python` works like require but it works on python modules.
+`require-python` dynamically loads the module and exports it's symbols into
+a clojure namespace.  There are many options available for this pathway.
+
+
+This implements a big step towards embedding python in Clojure in a simple,
+clear, and easy to use way.  One important thing to consider is the require
+has a `:reload:` option to allow you to actively develop a python module and
+test it via clojure.
+
+
+This excellent work was done by [James Tolton](https://github.com/jjtolton).
+
+
+#### Clojure-defined Python classes
+
+You can now extend a tuple of python classes (or implement a new one).  This system
+allows, among many things, us to use frameworks that use derivation as part of their
+public API.  Please see [classes-test](test/libpython-clj.classes-test) for a documented
+example of a simple pathway through the new API.  Note that if you use vanilla
+`->py-fn` functions as part of the class definition you won't get access to the `self`
+object.
+
+
+#### Bugfixes
+
+A general stability bugfix was made that was involved in the interoperation of
+Clojure functions within Python.  Clojure functions weren't currently adding
+a refcount to their return values.
+
 
 ## 1.16
 
diff --git a/project.clj b/project.clj
index b106221..ec008c2 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.17-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.20-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 87bdc05b86cd20885f0a0071da1ebe249db0d016 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 8 Dec 2019 10:54:23 -0700
Subject: [PATCH 043/456] editing

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index abd6c10..f09152e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -24,7 +24,7 @@ This excellent work was done by [James Tolton](https://github.com/jjtolton).
 
 You can now extend a tuple of python classes (or implement a new one).  This system
 allows, among many things, us to use frameworks that use derivation as part of their
-public API.  Please see [classes-test](test/libpython-clj.classes-test) for a documented
+public API.  Please see [classes-test](test/libpython_clj.classes-test) for a documented
 example of a simple pathway through the new API.  Note that if you use vanilla
 `->py-fn` functions as part of the class definition you won't get access to the `self`
 object.

From d9f5e3fe8f029deaaf815ecfd4343cb38165626d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 8 Dec 2019 10:54:58 -0700
Subject: [PATCH 044/456] editing

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f09152e..c684f37 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -24,7 +24,7 @@ This excellent work was done by [James Tolton](https://github.com/jjtolton).
 
 You can now extend a tuple of python classes (or implement a new one).  This system
 allows, among many things, us to use frameworks that use derivation as part of their
-public API.  Please see [classes-test](test/libpython_clj.classes-test) for a documented
+public API.  Please see [classes-test](test/libpython_clj/classes_test.clj) for a documented
 example of a simple pathway through the new API.  Note that if you use vanilla
 `->py-fn` functions as part of the class definition you won't get access to the `self`
 object.

From bdfcb5da637d1ad6b710f5580a58284474bc8a2d Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sun, 8 Dec 2019 13:20:22 -0500
Subject: [PATCH 045/456] convert python argspec to clojure arglists; properly
 assign metadata for discoverability (#14)

---
 src/libpython_clj/require.clj | 105 ++++++++++++++++++++++++++++++----
 1 file changed, 94 insertions(+), 11 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index c7f5cc9..8a8ff39 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -2,8 +2,6 @@
   (:refer-clojure :exclude [fn? doc])
   (:require [libpython-clj.python :as py]))
 
-(py/initialize!)
-
 (def ^:private builtins (py/import-module "builtins"))
 
 (def ^:private inspect (py/import-module "inspect"))
@@ -60,18 +58,106 @@
     (method? x) (py-fn-argspec x)
     :else (py-class-argspec x)))
 
+(defn pyarglists
+  ([argspec] (pyarglists argspec
+                         (if-let [defaults
+                                  (not-empty (:defaults argspec))]
+                           defaults
+                           [])))
+  ([argspec defaults] (pyarglists argspec defaults []))
+  ([{:as            argspec
+     args           :args
+     varkw          :varkw
+     varargs        :varargs
+     kwonlydefaults :kwonlydefaults
+     kwonlyargs     :kwonlyargs}
+    defaults res]
+   (println argspec)
+   (println defaults)
+   (let [n-args          (count args)
+         n-defaults      (count defaults)
+         n-pos-args      (- n-args n-defaults)
+         pos-args        (transduce
+                          (comp
+                           (take n-pos-args)
+                           (map symbol))
+                          (completing conj)
+                          []
+                          args)
+         kw-default-args (transduce
+                          (comp
+                           (drop n-pos-args)
+                           (map symbol))
+                          (completing conj)
+                          []
+                          args)
+         or-map          (transduce
+                          (comp
+                           (partition-all 2)
+                           (map vec)
+                           (map (fn [[k v]] [(symbol k) v])))
+                          (completing (partial apply assoc))
+                          {}
+                          (concat
+                           (interleave kw-default-args defaults)
+                           (flatten (seq kwonlydefaults))))
+         as-varkw    (when (not (nil? varkw))
+                       {:as (symbol varkw)})
+         default-map (transduce
+                      (comp
+                       (partition-all 2)
+                       (map vec)
+                       (map (fn [[k v]] [(symbol k) (keyword k)])))
+                      (completing (partial apply assoc))
+                      {}
+                      (concat
+                       (interleave kw-default-args defaults)
+                       (flatten (seq kwonlydefaults))))
+         kwargs-map (merge default-map
+                           (when (not-empty or-map)
+                             {:or or-map})
+                           (when (not-empty as-varkw)
+                             as-varkw))
+         opt-args
+         (cond
+           (and (empty? kwargs-map)
+                (nil? varargs)) '()
+           (empty? kwargs-map)  (list '& [(symbol varargs)])
+           (nil? varargs)       (list '& [or-map])
+           :else                (list '& [(symbol varargs)
+                                          kwargs-map]))
+
+         arglist (concat (list* pos-args) opt-args)]
+     (let [arglists  (conj res arglist)
+           defaults' (if (not-empty defaults) (pop defaults) [])
+           argspec'  (update argspec :args
+                             (fn [args]
+                               (if (not-empty args)
+                                 (pop args)
+                                 args)))]
+
+       (if (and (empty? defaults) (empty? defaults'))
+         arglists
+         (recur argspec defaults' arglists))))))
+
+
 (defn pymetadata [fn-name x]
-  (let [fn-argspec (pyargspec x)
-        fn-docstr  (get-pydoc x)]
+  (let [fn-argspec  (pyargspec x)
+        fn-docstr   (get-pydoc x)
+        fn-arglists (pyarglists fn-argspec)]
     (merge
      fn-argspec
-     {:doc  fn-docstr
-      :name fn-name})))
+     {:doc      fn-docstr
+      :arglists fn-arglists
+      :name     fn-name})))
+
+
 
 (defn ^:private load-py-fn [f fn-name fn-module-name-or-ns]
   (let [fn-ns      (symbol (str fn-module-name-or-ns))
         fn-sym     (symbol fn-name)]
-    (intern fn-ns (with-meta fn-sym (metadata fn-name f)) f)))
+    (intern fn-ns (with-meta fn-sym (pymetadata fn-name f)) f)))
+
 
 (defn ^:private load-python-lib [req]
   (let [supported-flags     #{:reload}
@@ -96,10 +182,7 @@
                                                 #{}
                                                 (:refer etc)))
         current-ns     *ns*
-        current-ns-sym (symbol (str current-ns))]
-
-
-    ;; if the current namespace is already loaded, unless
+        current-ns-sym (symbol (str current-ns))];; if the current namespace is already loaded, unless
     ;; the :reload flag is specified, this will be a no-op
     (when (not (and (find-ns module-name-or-ns)
                     (not reload?)));; :reload behavior

From 70db576c401fcf185eaf31b4d0f20630033bb738 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 8 Dec 2019 12:52:42 -0700
Subject: [PATCH 046/456] testing require-python

---
 src/libpython_clj/require.clj              | 252 ++++++++++++++-------
 test/libpython_clj/require_python_test.clj |  21 ++
 2 files changed, 192 insertions(+), 81 deletions(-)
 create mode 100644 test/libpython_clj/require_python_test.clj

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index c7f5cc9..83ca6ed 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -1,6 +1,7 @@
 (ns libpython-clj.require
   (:refer-clojure :exclude [fn? doc])
-  (:require [libpython-clj.python :as py]))
+  (:require [libpython-clj.python :as py]
+            [clojure.tools.logging :as log]))
 
 (py/initialize!)
 
@@ -27,7 +28,7 @@
 (def ^:private doc #(try
                       (py/get-attr % "__doc__")
                       (catch Exception e
-                        nil)))
+                        "")))
 
 (def ^:private importlib (py/import-module "importlib"))
 
@@ -58,20 +59,123 @@
   (cond
     (fn? x) (py-fn-argspec x)
     (method? x) (py-fn-argspec x)
+    (string? x) ""
+    (number? x) ""
     :else (py-class-argspec x)))
 
-(defn pymetadata [fn-name x]
+
+(defn pyarglists
+  ([argspec] (pyarglists argspec
+                         (if-let [defaults
+                                  (not-empty (:defaults argspec))]
+                           defaults
+                           [])))
+  ([argspec defaults] (pyarglists argspec defaults []))
+  ([{:as            argspec
+     args           :args
+     varkw          :varkw
+     varargs        :varargs
+     kwonlydefaults :kwonlydefaults
+     kwonlyargs     :kwonlyargs}
+    defaults res]
+   (let [n-args          (count args)
+         n-defaults      (count defaults)
+         n-pos-args      (- n-args n-defaults)
+         pos-args        (transduce
+                          (comp
+                           (take n-pos-args)
+                           (map symbol))
+                          (completing conj)
+                          []
+                          args)
+         kw-default-args (transduce
+                          (comp
+                           (drop n-pos-args)
+                           (map symbol))
+                          (completing conj)
+                          []
+                          args)
+         or-map          (transduce
+                          (comp
+                           (partition-all 2)
+                           (map vec)
+                           (map (fn [[k v]] [(symbol k) v])))
+                          (completing (partial apply assoc))
+                          {}
+                          (concat
+                           (interleave kw-default-args defaults)
+                           (flatten (seq kwonlydefaults))))
+
+         as-varkw    (when (not (nil? varkw))
+                       {:as (symbol varkw)})
+         default-map (transduce
+                      (comp
+                       (partition-all 2)
+                       (map vec)
+                       (map (fn [[k v]] [(symbol k) (keyword k)])))
+                      (completing (partial apply assoc))
+                      {}
+                      (concat
+                       (interleave kw-default-args defaults)
+                       (flatten (seq kwonlydefaults))))
+
+         kwargs-map (merge default-map
+                           (when (not-empty or-map)
+                             {:or or-map})
+                           (when (not-empty as-varkw)
+                             as-varkw))
+
+
+
+
+         opt-args
+         (cond
+           (and (empty? kwargs-map)
+                (nil? varargs)) '()
+           (empty? kwargs-map)  (list '& [(symbol varargs)])
+           (nil? varargs)       (list '& [or-map])
+           :else                (list '& [(symbol varargs)
+                                          kwargs-map]))
+
+         arglist (concat (list* pos-args) opt-args)]
+     (let [arglists  (conj res arglist)
+           defaults' (if (not-empty defaults) (pop defaults) [])
+           argspec'  (update argspec :args
+                             (fn [args]
+                               (if (not-empty args)
+                                 (pop args)
+                                 args)))]
+
+       (if (and (empty? defaults) (empty? defaults'))
+         arglists
+         (recur argspec' defaults' arglists))))))
+
+
+(defn py-fn-metadata [fn-name x]
   (let [fn-argspec (pyargspec x)
         fn-docstr  (get-pydoc x)]
     (merge
      fn-argspec
      {:doc  fn-docstr
-      :name fn-name})))
+      :name fn-name}
+     ;;TODO --
+     ;;We need to figure out a syntax that allows the actual functions
+     ;;to be called.  The arglists, while they look good the compiler parses
+     ;;them and then errors out.
+
+      ;; (when (py/callable? x)
+      ;;  (try
+      ;;    {:arglists (pyarglists fn-argspec)}
+      ;;    (catch Throwable e
+      ;;      nil)))
+     )))
+
 
 (defn ^:private load-py-fn [f fn-name fn-module-name-or-ns]
   (let [fn-ns      (symbol (str fn-module-name-or-ns))
         fn-sym     (symbol fn-name)]
-    (intern fn-ns (with-meta fn-sym (metadata fn-name f)) f)))
+    (intern fn-ns (with-meta fn-sym (py-fn-metadata fn-name f)) f)))
+
 
 (defn ^:private load-python-lib [req]
   (let [supported-flags     #{:reload}
@@ -86,7 +190,6 @@
                                    (map vec))
                                   etc)
         reload?             (:reload flags)
-        this-module         (import-module (str module-name))
         module-name-or-ns   (:as etc module-name)
         exclude             (into #{} (:exclude etc))
         refer          (cond
@@ -96,89 +199,76 @@
                                                 #{}
                                                 (:refer etc)))
         current-ns     *ns*
-        current-ns-sym (symbol (str current-ns))]
+        current-ns-sym (symbol (str current-ns))
+        python-namespace (find-ns module-name-or-ns)
+        this-module (import-module (str module-name))]
 
-
-    ;; if the current namespace is already loaded, unless
-    ;; the :reload flag is specified, this will be a no-op
-    (when (not (and (find-ns module-name-or-ns)
-                    (not reload?)));; :reload behavior
-
-      ;; TODO: should we track things referred into the existing
-      ;;   ..: *ns* with an atom and clear them on :reload?
-
-      (when reload?
-        (remove-ns module-name)
-        (reload-module this-module))
+    (when reload?
+      (remove-ns module-name)
+      (reload-module this-module))
+    (create-ns module-name-or-ns)
 
       ;; bind the python module to its symbolic name
       ;; in the current namespace
-      (intern current-ns-sym module-name-or-ns this-module)
+
 
       ;; create namespace for module and bind python
       ;; values to namespace symbols
-      (doseq [[k pyfn?] (seq (py/as-jvm (vars  this-module)))]
-        (try
-          (load-py-fn pyfn? (symbol k) module-name-or-ns)
-          (catch Exception e
-            (try
-              (let [ns     module-name-or-ns
-                    symbol (symbol k)]
-                (in-ns ns)
-                (intern ns symbol pyfn?))
-              (finally
-                (in-ns current-ns-sym))))))
-
-      ;; behavior for [.. :refer :all], [.. :refer [...]], and
-      ;; [.. :refer :*]
-      ;; TODO: code is a bit repetitive maybe
-      (cond
-        ;; include everything into the current namespace,
-        ;; ignore __all__ directive
-        (refer :all)
-        (doseq
-            [[k pyfn?]
-             (seq (py/as-jvm (vars  this-module)))
-             :when (not (exclude (symbol k)))]
+    (when (or reload?
+              (not python-namespace))
+      ;;Mutably define the root namespace.
+      (doseq [att-name (py/dir this-module)]
+        (let [v (py/get-attr this-module att-name)]
           (try
-            (load-py-fn pyfn? (symbol k) current-ns-sym)
-            (catch Exception e
-              (let [symbol (symbol k)]
-                (intern *ns* symbol pyfn?)))))
-        ;; only include that specfied by __all__ attribute
-        ;; of python module if specified, else same as :all
-        (refer :*)
-        (let [hasattr (py/get-attr builtins "hasattr")
-              getattr (py/get-attr builtins "getattr")]
-          (if (hasattr this-module "__all__")
-            (doseq
-                [[k pyfn?]
-                 (for [item-name (getattr this-module "__all__")]
-                   [(symbol item-name)
-                    (getattr this-module item-name)])
-                 :when (not (exclude (symbol k)))]
-              (try
-                (load-py-fn pyfn? (symbol k) current-ns-sym)
-                (catch Exception e
-                  (let [symbol (symbol k)]
-                    (intern *ns* symbol pyfn?)))))
-            (doseq
-                [[k pyfn?]
-                 (seq (py/as-jvm (vars  this-module)))
-                 :when (not (exclude (symbol k)))]
-              (try
-                (load-py-fn pyfn? (symbol k) current-ns-sym)
-                (catch Exception e
-                  (let [symbol (symbol k)]
-                    (intern *ns* symbol pyfn?)))))))
-
-        ;; [.. :refer [..]] behavior
-        :else
-        (doseq [r    refer
-                :let [pyfn? (py/get-attr this-module (str r))]]
-          (if (or (fn? pyfn?) (method? pyfn?))
-            (load-py-fn pyfn?)
-            (intern current-ns-sym r pyfn?)))))))
+            (when v
+              (if (py/callable? v)
+                (load-py-fn v (symbol att-name) module-name-or-ns)
+                (intern module-name-or-ns (symbol att-name) v)))
+            (catch Throwable e
+              (log/warnf e "Failed to require symbol %s" att-name))))))
+
+
+    (let [python-namespace (find-ns module-name-or-ns)
+          ;;ns-publics is a map of symbol to var.  Var's have metadata on them.
+          public-data (->> (ns-publics python-namespace)
+                           (remove #(exclude (first %)))
+                           (into {}))]
+
+      ;;Always make the loaded namespace available to the current namespace.
+      (intern current-ns-sym (with-meta module-name-or-ns
+                               {:doc (doc this-module)}))
+      (let [refer-symbols
+            (cond
+              ;; include everything into the current namespace,
+              ;; ignore __all__ directive
+              (or (refer :all)
+                  (and (not (py/has-attr? this-module "__all__"))
+                       (refer :*)))
+              (keys public-data)
+              ;; only include that specfied by __all__ attribute
+              ;; of python module if specified, else same as :all
+              (refer :*)
+              (->> (py/get-attr this-module "__all__")
+                   (map (fn [item-name]
+                          (let [item-sym (symbol item-name)]
+                            (when (contains? public-data item-sym)
+                              item-sym))))
+                   (remove nil?))
+
+              ;; [.. :refer [..]] behavior
+              :else
+              (do
+                (when-let [missing (->> refer
+                                        (remove (partial contains? public-data))
+                                        seq)]
+                  (throw (Exception.
+                          (format "'refer' symbols not found: %s"
+                                  (vec missing)))))
+                refer))]
+        (doseq [[s v] (select-keys public-data refer-symbols)]
+          (intern current-ns-sym
+                  (with-meta s (meta v))
+                  (deref v)))))))
 
 (defn require-python
   "## Basic usage ##
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
new file mode 100644
index 0000000..76b127d
--- /dev/null
+++ b/test/libpython_clj/require_python_test.clj
@@ -0,0 +1,21 @@
+(ns libpython-clj.require-python-test
+  (:require [libpython-clj.require :refer [require-python]]
+            [clojure.test :refer :all]))
+
+
+;;Since this test mutates the global environment we have to accept that
+;;it may not always work.
+
+(require-python '[math
+                  :refer :*
+                  :exclude [sin cos]
+                  ])
+
+
+(deftest base-require-test
+  (let [publics (ns-publics (find-ns 'libpython-clj.require-python-test))]
+    (is (contains? publics 'acos))
+    (is (contains? publics 'floor))
+    (is (not (contains? publics 'sin)))
+    (is (= 10.0 (double (floor 10.1))))
+    (is (thrown? Throwable (require-python '[math :refer [blah]])))))

From 894162cdc849e5cce726dc6f18e7d5813638bf46 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 8 Dec 2019 13:03:01 -0700
Subject: [PATCH 047/456] oof, bad merge!

---
 src/libpython_clj/require.clj | 53 ++---------------------------------
 1 file changed, 2 insertions(+), 51 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index a6e0fed..83ca6ed 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -3,6 +3,8 @@
   (:require [libpython-clj.python :as py]
             [clojure.tools.logging :as log]))
 
+(py/initialize!)
+
 (def ^:private builtins (py/import-module "builtins"))
 
 (def ^:private inspect (py/import-module "inspect"))
@@ -61,10 +63,7 @@
     (number? x) ""
     :else (py-class-argspec x)))
 
-<<<<<<< HEAD
 
-=======
->>>>>>> bdfcb5da637d1ad6b710f5580a58284474bc8a2d
 (defn pyarglists
   ([argspec] (pyarglists argspec
                          (if-let [defaults
@@ -79,11 +78,6 @@
      kwonlydefaults :kwonlydefaults
      kwonlyargs     :kwonlyargs}
     defaults res]
-<<<<<<< HEAD
-=======
-   (println argspec)
-   (println defaults)
->>>>>>> bdfcb5da637d1ad6b710f5580a58284474bc8a2d
    (let [n-args          (count args)
          n-defaults      (count defaults)
          n-pos-args      (- n-args n-defaults)
@@ -111,10 +105,7 @@
                           (concat
                            (interleave kw-default-args defaults)
                            (flatten (seq kwonlydefaults))))
-<<<<<<< HEAD
 
-=======
->>>>>>> bdfcb5da637d1ad6b710f5580a58284474bc8a2d
          as-varkw    (when (not (nil? varkw))
                        {:as (symbol varkw)})
          default-map (transduce
@@ -127,22 +118,16 @@
                       (concat
                        (interleave kw-default-args defaults)
                        (flatten (seq kwonlydefaults))))
-<<<<<<< HEAD
 
-=======
->>>>>>> bdfcb5da637d1ad6b710f5580a58284474bc8a2d
          kwargs-map (merge default-map
                            (when (not-empty or-map)
                              {:or or-map})
                            (when (not-empty as-varkw)
                              as-varkw))
-<<<<<<< HEAD
 
 
 
 
-=======
->>>>>>> bdfcb5da637d1ad6b710f5580a58284474bc8a2d
          opt-args
          (cond
            (and (empty? kwargs-map)
@@ -163,7 +148,6 @@
 
        (if (and (empty? defaults) (empty? defaults'))
          arglists
-<<<<<<< HEAD
          (recur argspec' defaults' arglists))))))
 
 
@@ -185,31 +169,12 @@
       ;;    (catch Throwable e
       ;;      nil)))
      )))
-=======
-         (recur argspec defaults' arglists))))))
-
-
-(defn pymetadata [fn-name x]
-  (let [fn-argspec  (pyargspec x)
-        fn-docstr   (get-pydoc x)
-        fn-arglists (pyarglists fn-argspec)]
-    (merge
-     fn-argspec
-     {:doc      fn-docstr
-      :arglists fn-arglists
-      :name     fn-name})))
-
->>>>>>> bdfcb5da637d1ad6b710f5580a58284474bc8a2d
 
 
 (defn ^:private load-py-fn [f fn-name fn-module-name-or-ns]
   (let [fn-ns      (symbol (str fn-module-name-or-ns))
         fn-sym     (symbol fn-name)]
-<<<<<<< HEAD
     (intern fn-ns (with-meta fn-sym (py-fn-metadata fn-name f)) f)))
-=======
-    (intern fn-ns (with-meta fn-sym (pymetadata fn-name f)) f)))
->>>>>>> bdfcb5da637d1ad6b710f5580a58284474bc8a2d
 
 
 (defn ^:private load-python-lib [req]
@@ -234,7 +199,6 @@
                                                 #{}
                                                 (:refer etc)))
         current-ns     *ns*
-<<<<<<< HEAD
         current-ns-sym (symbol (str current-ns))
         python-namespace (find-ns module-name-or-ns)
         this-module (import-module (str module-name))]
@@ -243,19 +207,6 @@
       (remove-ns module-name)
       (reload-module this-module))
     (create-ns module-name-or-ns)
-=======
-        current-ns-sym (symbol (str current-ns))];; if the current namespace is already loaded, unless
-    ;; the :reload flag is specified, this will be a no-op
-    (when (not (and (find-ns module-name-or-ns)
-                    (not reload?)));; :reload behavior
-
-      ;; TODO: should we track things referred into the existing
-      ;;   ..: *ns* with an atom and clear them on :reload?
-
-      (when reload?
-        (remove-ns module-name)
-        (reload-module this-module))
->>>>>>> bdfcb5da637d1ad6b710f5580a58284474bc8a2d
 
       ;; bind the python module to its symbolic name
       ;; in the current namespace

From 0576b6d965a078583218a48418b12ff52322e36d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 8 Dec 2019 13:27:45 -0700
Subject: [PATCH 048/456] editing

---
 CHANGELOG.md                  |  5 ++++-
 src/libpython_clj/require.clj | 17 ++++++++---------
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c684f37..376bece 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,7 +17,10 @@ has a `:reload:` option to allow you to actively develop a python module and
 test it via clojure.
 
 
-This excellent work was done by [James Tolton](https://github.com/jjtolton).
+This excellent work was in large part done by [James Tolton](https://github.com/jjtolton).
+
+
+* [require-python-test](test/libpython_clj/require_python_test.clj)
 
 
 #### Clojure-defined Python classes
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 83ca6ed..7c71e64 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -217,15 +217,14 @@
     (when (or reload?
               (not python-namespace))
       ;;Mutably define the root namespace.
-      (doseq [att-name (py/dir this-module)]
-        (let [v (py/get-attr this-module att-name)]
-          (try
-            (when v
-              (if (py/callable? v)
-                (load-py-fn v (symbol att-name) module-name-or-ns)
-                (intern module-name-or-ns (symbol att-name) v)))
-            (catch Throwable e
-              (log/warnf e "Failed to require symbol %s" att-name))))))
+      (doseq [[att-name v] (vars this-module)]
+        (try
+          (when v
+            (if (py/callable? v)
+              (load-py-fn v (symbol att-name) module-name-or-ns)
+              (intern module-name-or-ns (symbol att-name) v)))
+          (catch Throwable e
+            (log/warnf e "Failed to require symbol %s" att-name)))))
 
 
     (let [python-namespace (find-ns module-name-or-ns)

From 310b3b021295db2f7aa600fd10c99441a656f676 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Mon, 9 Dec 2019 12:07:50 -0500
Subject: [PATCH 049/456] fix for arglists not compiling bug (#16)

* fix for arglists not compiling bug

* or-map -> kwarg-map

* remove TODO
---
 src/libpython_clj/require.clj | 35 +++++++++++++----------------------
 1 file changed, 13 insertions(+), 22 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 7c71e64..8729454 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -133,11 +133,11 @@
            (and (empty? kwargs-map)
                 (nil? varargs)) '()
            (empty? kwargs-map)  (list '& [(symbol varargs)])
-           (nil? varargs)       (list '& [or-map])
+           (nil? varargs)       (list '& [kwargs-map])
            :else                (list '& [(symbol varargs)
                                           kwargs-map]))
-
-         arglist (concat (list* pos-args) opt-args)]
+         
+         arglist  ((comp vec concat) (list* pos-args) opt-args)]
      (let [arglists  (conj res arglist)
            defaults' (if (not-empty defaults) (pop defaults) [])
            argspec'  (update argspec :args
@@ -157,18 +157,12 @@
     (merge
      fn-argspec
      {:doc  fn-docstr
-      :name fn-name}
-     ;;TODO --
-     ;;We need to figure out a syntax that allows the actual functions
-     ;;to be called.  The arglists, while they look good the compiler parses
-     ;;them and then errors out.
-
-      ;; (when (py/callable? x)
-      ;;  (try
-      ;;    {:arglists (pyarglists fn-argspec)}
-      ;;    (catch Throwable e
-      ;;      nil)))
-     )))
+      :name fn-name}     
+     (when (py/callable? x)
+       (try
+         {:arglists (pyarglists fn-argspec)}
+         (catch Throwable e
+           nil))))))
 
 
 (defn ^:private load-py-fn [f fn-name fn-module-name-or-ns]
@@ -208,12 +202,12 @@
       (reload-module this-module))
     (create-ns module-name-or-ns)
 
-      ;; bind the python module to its symbolic name
-      ;; in the current namespace
+    ;; bind the python module to its symbolic name
+    ;; in the current namespace
 
 
-      ;; create namespace for module and bind python
-      ;; values to namespace symbols
+    ;; create namespace for module and bind python
+    ;; values to namespace symbols
     (when (or reload?
               (not python-namespace))
       ;;Mutably define the root namespace.
@@ -341,6 +335,3 @@
     (vector? reqs)
     (load-python-lib reqs)))
 
-(comment
-  (require-python '([clojure :refer [parenthesis]] __future__))
-  (py/set-attr! __future__ "braces" parenthesis))

From 64fcb4bed8eb3af070dbb2209abbd32d18bfba50 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 9 Dec 2019 10:21:18 -0700
Subject: [PATCH 050/456] Adding one more flag and testing it.

---
 src/libpython_clj/require.clj              | 29 +++++++++++++++-------
 test/libpython_clj/require_python_test.clj |  3 +--
 2 files changed, 21 insertions(+), 11 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 8729454..fa4cfae 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -136,7 +136,7 @@
            (nil? varargs)       (list '& [kwargs-map])
            :else                (list '& [(symbol varargs)
                                           kwargs-map]))
-         
+
          arglist  ((comp vec concat) (list* pos-args) opt-args)]
      (let [arglists  (conj res arglist)
            defaults' (if (not-empty defaults) (pop defaults) [])
@@ -151,28 +151,31 @@
          (recur argspec' defaults' arglists))))))
 
 
-(defn py-fn-metadata [fn-name x]
+(defn py-fn-metadata [fn-name x {:keys [no-arglists?]}]
   (let [fn-argspec (pyargspec x)
         fn-docstr  (get-pydoc x)]
     (merge
      fn-argspec
      {:doc  fn-docstr
-      :name fn-name}     
-     (when (py/callable? x)
+      :name fn-name}
+     (when (and (py/callable? x)
+                (not no-arglists?))
        (try
          {:arglists (pyarglists fn-argspec)}
          (catch Throwable e
            nil))))))
 
 
-(defn ^:private load-py-fn [f fn-name fn-module-name-or-ns]
+(defn ^:private load-py-fn [f fn-name fn-module-name-or-ns
+                            options]
   (let [fn-ns      (symbol (str fn-module-name-or-ns))
         fn-sym     (symbol fn-name)]
-    (intern fn-ns (with-meta fn-sym (py-fn-metadata fn-name f)) f)))
+    (intern fn-ns (with-meta fn-sym (py-fn-metadata fn-name f
+                                                    options)) f)))
 
 
 (defn ^:private load-python-lib [req]
-  (let [supported-flags     #{:reload}
+  (let [supported-flags     #{:reload :no-arglists}
         [module-name & etc] req
         flags               (into #{}
                                   (filter supported-flags)
@@ -184,6 +187,7 @@
                                    (map vec))
                                   etc)
         reload?             (:reload flags)
+        no-arglists?        (:no-arglists flags)
         module-name-or-ns   (:as etc module-name)
         exclude             (into #{} (:exclude etc))
         refer          (cond
@@ -215,7 +219,9 @@
         (try
           (when v
             (if (py/callable? v)
-              (load-py-fn v (symbol att-name) module-name-or-ns)
+              (load-py-fn v (symbol att-name) module-name-or-ns
+                          {:no-arglists?
+                           no-arglists?})
               (intern module-name-or-ns (symbol att-name) v)))
           (catch Throwable e
             (log/warnf e "Failed to require symbol %s" att-name)))))
@@ -284,6 +290,12 @@
    (requests/get \"https//www.google.com\") ;;=>  <Response [200]>
    (get \"https//www.google.com\") ;;=>  <Response [200]>
 
+   In some cases we may generate invalid arglists metadata for the clojure compiler.
+   In those cases we have a flag, :no-arglists that will disable adding arglists to
+   the generated metadata for the vars.  Use the reload flag below if you need to
+   force reload a namespace where invalid arglists have been generated.
+
+   (require-python '[numpy :refer [linspace] :no-arglists :as np])
 
    ## Use with custom modules ##
 
@@ -334,4 +346,3 @@
     (load-python-lib (vector reqs))
     (vector? reqs)
     (load-python-lib reqs)))
-
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index 76b127d..4eb3508 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -8,8 +8,7 @@
 
 (require-python '[math
                   :refer :*
-                  :exclude [sin cos]
-                  ])
+                  :exclude [sin cos]])
 
 
 (deftest base-require-test

From d9dbba254a2667a3e50e18a86fc500495e40886f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 9 Dec 2019 10:22:17 -0700
Subject: [PATCH 051/456] 1.20

---
 CHANGELOG.md | 2 +-
 project.clj  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 376bece..c8f0075 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Time for a ChangeLog!
 
-## 1.20-SNAPSHOT
+## 1.20
 
 With two many huge things we had to skip a few versions!
 
diff --git a/project.clj b/project.clj
index ec008c2..2d1d578 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.20-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.20"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 0c73ad8f90cb9759662e9f6ebe9c2475814b0b4f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 9 Dec 2019 10:22:24 -0700
Subject: [PATCH 052/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 2d1d578..850ae23 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.20"
+(defproject cnuernber/libpython-clj "1.21-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From dbc5ad1da11e7f8f6668499fd3a75b01a61028fd Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Tue, 10 Dec 2019 11:05:51 -0500
Subject: [PATCH 053/456] fix for arglists on some functions (#17)

---
 src/libpython_clj/require.clj | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index fa4cfae..1a05ae7 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -15,9 +15,15 @@
 
 (def ^:private types (py/import-module "types"))
 
-(def ^:private fn-type (py/get-attr types "FunctionType"))
+(def ^:private fn-type
+  (py/call-attr builtins "tuple"
+                [(py/get-attr types "FunctionType")
+                 (py/get-attr types "BuiltinFunctionType")]))
 
-(def ^:private method-type (py/get-attr types "MethodType"))
+(def ^:private method-type
+  (py/call-attr builtins "tuple"
+                [(py/get-attr types "MethodType")
+                 (py/get-attr types "BuiltinMethodType")]))
 
 (def ^:private isinstance? (py/get-attr builtins "isinstance"))
 
@@ -42,23 +48,35 @@
 (def ^:private vars (py/get-attr builtins "vars"))
 
 (defn ^:private py-fn-argspec [f]
-  (let [spec (argspec f)]
+  (if-let [spec (try (argspec f) (catch Throwable e nil))]
     {:args           (py/->jvm (py/get-attr spec "args"))
      :varargs        (py/->jvm (py/get-attr spec "varargs"))
      :varkw          (py/->jvm (py/get-attr spec "varkw"))
      :defaults       (py/->jvm (py/get-attr spec "defaults"))
      :kwonlyargs     (py/->jvm  (py/get-attr spec "kwonlyargs"))
      :kwonlydefaults (py/->jvm  (py/get-attr spec "kwonlydefaults"))
-     :annotations    (py/->jvm  (py/get-attr spec "annotations"))}))
+     :annotations    (py/->jvm  (py/get-attr spec "annotations"))}
+    (py-fn-argspec (py/get-attr f "__init__"))))
 
 (defn ^:private py-class-argspec [class]
   (let [constructor (py/get-attr class "__init__")]
     (py-fn-argspec constructor)))
 
 (defn pyargspec [x]
+  ;; TODO: certain builtin functions have
+  ;;   ..: signatures that are found in the first line
+  ;;   ..: of their docstring, aka, print.
+  ;;   ..: These seem to be uniform enough that
+  ;;   ..: most IDEs have a way of creating stubs
+  ;;   ..: for the signature.  If there is a uniform way
+  ;;   ..: to do this that doesn't simply involve an
+  ;;   ..: army of devs doing transcription I'd like to
+  ;;   ..: pull that in here
   (cond
     (fn? x) (py-fn-argspec x)
     (method? x) (py-fn-argspec x)
+    ;; (builtin-function? x) (py-builtin-fn-argspec x)
+    ;; (builtin-method? x) (py-builtin-method-argspec x)
     (string? x) ""
     (number? x) ""
     :else (py-class-argspec x)))

From 5f3035215f5acecf45ab75e237a57475e782ebf7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 10 Dec 2019 09:22:54 -0700
Subject: [PATCH 054/456] added test for inifinite sequence.

---
 test/libpython_clj/python_test.clj | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index e150733..4404c9f 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -1,5 +1,6 @@
 (ns libpython-clj.python-test
   (:require [libpython-clj.python :as py]
+            [libpython-clj.require :refer [require-python]]
             [tech.v2.datatype :as dtype]
             [tech.v2.datatype.functional :as dfn]
             [tech.v2.tensor :as dtt]
@@ -7,7 +8,7 @@
   (:import [java.io StringWriter]
            [java.util Map List]))
 
-  (py/initialize!)
+(py/initialize!)
 
 
 (deftest stdout-and-stderr
@@ -265,3 +266,15 @@
     (is (= (str (py/$.. np random shuffle))
            (str (-> (py/get-attr np "random")
                     (py/get-attr "shuffle")))))))
+
+
+(deftest infinite-seq
+  (let [islice (-> (py/import-module "itertools")
+                   (py/get-attr "islice"))]
+
+    (is (= (vec (range 10))
+           ;;Range is an infinite sequence
+           (-> (range)
+               (py/as-python)
+               (islice 0 10)
+               (vec))))))

From e5613eb7d99abb7f81e36d22e15a30a30ca9ca5d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 10 Dec 2019 11:13:29 -0700
Subject: [PATCH 055/456] Checking in what I have to move to bigger monitor.

---
 src/libpython_clj/python/bridge.clj      |  6 +++++-
 src/libpython_clj/python/interop.clj     |  7 ++++++-
 src/libpython_clj/python/interpreter.clj | 13 +++++++++++--
 src/libpython_clj/python/object.clj      |  2 +-
 test/libpython_clj/python_test.clj       | 10 ++++++++--
 5 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index f7a531e..114ba6c 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -260,7 +260,11 @@
              (py-proto/att-type-map pyobj#)))
          py-proto/PyCall
          (do-call-fn [callable# arglist# kw-arg-map#]
-           (-> (py-proto/do-call-fn pyobj# arglist# kw-arg-map#)
+           (-> (py-proto/do-call-fn pyobj# (mapv as-python arglist#)
+                                    (->> kw-arg-map#
+                                         (map (fn [[k# v#]]
+                                                [k# (as-python v#)]))
+                                         (into {})))
                (as-jvm)))
          Object
          (toString [this#]
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
index 221d5ce..999326c 100644
--- a/src/libpython_clj/python/interop.clj
+++ b/src/libpython_clj/python/interop.clj
@@ -368,7 +368,12 @@
               (throw (ex-info "Failed to find bridge type" {})))
           bridge-type (PyTypeObject. bridge-type-ptr)
           ^Pointer new-py-obj (libpy/_PyObject_New bridge-type)
-          pybridge (JVMBridgeType. new-py-obj)]
+          pybridge (JVMBridgeType. new-py-obj)
+          ]
+      (println (format "Creating bridge: 0x%x -> %s:%s"
+                       (Pointer/nativeValue new-py-obj)
+                       (get-object-handle (.interpreter bridge))
+                       (get-object-handle (.wrappedObject bridge))))
       (set! (.jvm_interpreter_handle pybridge) (get-object-handle
                                                 (.interpreter bridge)))
       (set! (.jvm_handle pybridge) (get-object-handle (.wrappedObject bridge)))
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index e446b29..96e4d74 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -80,18 +80,26 @@
   ^JVMBridge [handle interpreter]
   (if-let [bridge-obj (find-jvm-bridge-entry handle interpreter)]
     (:jvm-bridge bridge-obj)
-    (throw (ex-info "Unable to find bridge for interpreter %s and handle %s"
-                    interpreter handle))))
+    (throw (Exception.
+            (format "Unable to find bridge for interpreter %s and handle %s"
+                    interpreter handle)))))
 
 
 (defn register-bridge!
   [^JVMBridge bridge ^PyObject bridge-pyobject]
   (let [interpreter (.interpreter bridge)
         bridge-handle (get-object-handle (.wrappedObject bridge))]
+    (when (contains? (get-in @(:interpreter-state* interpreter)
+                           [:bridge-objects])
+                     bridge-handle)
+      (throw (Exception. (format "Bridge already exists!! - %s" bridge-handle))))
     (swap! (:interpreter-state* interpreter) assoc-in
            [:bridge-objects bridge-handle]
            {:jvm-bridge bridge
             :pyobject bridge-pyobject})
+    (println "ADDING-BRIDGE" bridge-handle
+             (keys (get-in @(:interpreter-state* interpreter)
+                           [:bridge-objects])))
     :ok))
 
 
@@ -99,6 +107,7 @@
   [^JVMBridge bridge]
   (let [interpreter (.interpreter bridge)
         bridge-handle (get-object-handle (.wrappedObject bridge))]
+    (println "REMOVING-BRIDGE:" bridge-handle)
     (swap! (:interpreter-state* interpreter)
            update :bridge-objects dissoc bridge-handle)
     :ok))
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index c15f465..4c230d4 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -95,7 +95,7 @@
     (py-proto/->jvm item options)))
 
 
-(def ^:dynamic *object-reference-logging* false)
+(def ^:dynamic *object-reference-logging* true)
 
 
 (def ^:dynamic *object-reference-tracker* nil)
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 4404c9f..08d0307 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -1,6 +1,5 @@
 (ns libpython-clj.python-test
   (:require [libpython-clj.python :as py]
-            [libpython-clj.require :refer [require-python]]
             [tech.v2.datatype :as dtype]
             [tech.v2.datatype.functional :as dfn]
             [tech.v2.tensor :as dtt]
@@ -11,6 +10,14 @@
 (py/initialize!)
 
 
+(defn crashit
+  []
+  (let [test-data (py/->python (py/as-python [1 2]))
+        test-py-data (py/->py-tuple [test-data test-data])
+        _ :ignored]
+    :ok))
+
+
 (deftest stdout-and-stderr
   (is (= "hey\n" (with-out-str
                    (py/run-simple-string "print('hey')"))))
@@ -275,6 +282,5 @@
     (is (= (vec (range 10))
            ;;Range is an infinite sequence
            (-> (range)
-               (py/as-python)
                (islice 0 10)
                (vec))))))

From 164ce13ddc63ca5c5bc0c2d8d956658118f1a6b0 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 10 Dec 2019 15:04:58 -0700
Subject: [PATCH 056/456] Fixing really tough bridging errors.

---
 java/libpython_clj/jna/JVMBridge.java    |   2 -
 src/libpython_clj/python.clj             |   3 +
 src/libpython_clj/python/bridge.clj      | 108 +++++++++++++----------
 src/libpython_clj/python/interop.clj     |  52 ++++-------
 src/libpython_clj/python/interpreter.clj |  16 ++--
 src/libpython_clj/python/object.clj      |  10 +--
 6 files changed, 96 insertions(+), 95 deletions(-)

diff --git a/java/libpython_clj/jna/JVMBridge.java b/java/libpython_clj/jna/JVMBridge.java
index f63ee0a..5906057 100644
--- a/java/libpython_clj/jna/JVMBridge.java
+++ b/java/libpython_clj/jna/JVMBridge.java
@@ -9,8 +9,6 @@ public interface JVMBridge extends AutoCloseable
   public Pointer getAttr(String name);
   public void setAttr(String name, Pointer val);
   public String[] dir();
-  // Next has to have special treatment; in this case it is more manually wrapped.
-  public Object nextFn ();
   public Object interpreter();
   public Object wrappedObject();
   // Called from python when the python mirror is deleted.
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index a3a6864..d902be1 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -45,6 +45,8 @@
                 ->py-long
                 ->py-string
                 ->python
+                ;;Used when you are returning a value from a function.
+                ->python-incref
                 ->jvm
                 make-tuple-fn
                 make-tuple-instance-fn
@@ -118,6 +120,7 @@
                 afn
                 as-jvm
                 as-python
+                as-python-incref ;; Used when returning a value from a function to python.
                 ->numpy
                 as-numpy)
 
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index 114ba6c..8df49d1 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -34,7 +34,8 @@
               ->py-tuple
               ->py-dict
               ->py-string
-              ->py-fn]]
+              ->py-fn]
+             :as pyobj]
             [libpython-clj.python.interop :as pyinterop
              :refer
              [expose-bridge-to-python!
@@ -200,6 +201,24 @@
   (->jvm pyobj))
 
 
+(defn- mostly-copy-arg
+  "This is the dirty boundary between the languages.  Copying as often faster
+  for simple things but we have to be careful not to attempt a copy of things that
+  are only iterable (and not random access)."
+  [arg]
+  (cond
+    (jna/as-ptr arg)
+    (jna/as-ptr arg)
+    (instance? RandomAccess arg)
+    (->python arg)
+    (instance? Map arg)
+    (->python arg)
+    (instance? Iterable arg)
+    (as-python arg)
+    :else
+    (->python arg)))
+
+
 (defmacro bridge-pyobject
   [pyobj interpreter & body]
   `(let [pyobj# ~pyobj
@@ -260,12 +279,14 @@
              (py-proto/att-type-map pyobj#)))
          py-proto/PyCall
          (do-call-fn [callable# arglist# kw-arg-map#]
-           (-> (py-proto/do-call-fn pyobj# (mapv as-python arglist#)
-                                    (->> kw-arg-map#
-                                         (map (fn [[k# v#]]
-                                                [k# (as-python v#)]))
-                                         (into {})))
-               (as-jvm)))
+           (with-interpreter interpreter#
+             (let [arglist# (mapv mostly-copy-arg arglist#)
+                   kw-arg-map# (->> kw-arg-map#
+                                    (map (fn [[k# v#]]
+                                           [k# (mostly-copy-arg v#)]))
+                                    (into {}))]
+               (-> (py-proto/do-call-fn pyobj# arglist# kw-arg-map#)
+                   (as-jvm)))))
          Object
          (toString [this#]
            (->jvm (py-proto/call-attr pyobj# "__str__")))
@@ -507,7 +528,8 @@
           long-addr (get-attr ctypes "data")
           hash-ary {:ctypes-map ctypes}
           ptr-val (-> (Pointer. long-addr)
-                      (resource/track #(get hash-ary :ctypes-map) [:gc]))]
+                      (resource/track #(get hash-ary :ctypes-map)
+                                      pyobj/*pyobject-tracking-flags*))]
       {:ptr ptr-val
        :datatype np-dtype
        :shape shape
@@ -682,47 +704,43 @@
                 (with-out-str
                   (st/print-stack-trace e#)))))))
 
-(defmacro impl-tuple-function
-  [& body]
-  `(reify CFunction$TupleFunction
-     (pyinvoke [this# ~'self ~'args]
-       (wrap-jvm-context
-        (-> (let [~'args (as-jvm ~'args)]
-              ~@body)
-            ;;as-python can create a bridge object or just a ptr
-            as-python
-            ;;convert any bridge objects to actual jna ptrs to match
-            ;;interface definitions
-            jna/->ptr-backing-store)))))
-
-
-(defn jvm-fn->iface
-  [jvm-fn]
-  (impl-tuple-function
-   (apply jvm-fn args)))
-
-
-(defn as-py-fn
-  [jvm-fn]
-  (-> (jvm-fn->iface jvm-fn)
-      ->py-fn))
-
 
 (defn jvm-iterator-as-python
   ^Pointer [^Iterator item]
   (with-gil nil
     (let [next-fn #(if (.hasNext item)
                      (-> (.next item)
+                         ;;As python tracks the object in a jvm context
                          (as-python)
-                         (jna/->ptr-backing-store))
+                         (jna/->ptr-backing-store)
+                         ;;But we are handing the object back to python which is expecting
+                         ;;a new reference.
+                         (pyobj/incref))
                      (do
                        (libpy/PyErr_SetNone
                         (err/PyExc_StopIteration))
                        nil))
           att-map
-          {"__next__" (->py-fn next-fn)}]
-      (create-bridge-from-att-map item att-map
-                                  :next-fn next-fn))))
+          {"__next__" (pyobj/make-tuple-fn next-fn
+                                           :arg-converter nil
+                                           :result-converter nil)}]
+      (create-bridge-from-att-map item att-map))))
+
+
+(defn as-python-incref
+  "Convert to python and add a reference.  Necessary for return values from
+  functions as python expects a new reference and the as-python pathway
+  ensures the jvm garbage collector also sees the reference."
+  [item]
+  (-> (as-python item)
+      (pyobj/incref)))
+
+
+(defn- as-py-fn
+  ^Pointer [obj-fn]
+  (pyobj/make-tuple-fn obj-fn
+                       :arg-converter as-jvm
+                       :result-converter as-python-incref))
 
 
 (defn jvm-map-as-python
@@ -763,13 +781,13 @@
            "append" (as-py-fn #(.add jvm-data %))
            "insert" (as-py-fn #(.add jvm-data (int %1) %2))
            "pop" (as-py-fn (fn [& args]
-                                   (let [index (int (if (first args)
-                                                      (first args)
-                                                      -1))
-                                         index (if (< index 0)
-                                                 (- (.size jvm-data) index)
-                                                 index)]
-                                     #(.remove jvm-data index))))}]
+                             (let [index (int (if (first args)
+                                                (first args)
+                                                -1))
+                                   index (if (< index 0)
+                                           (- (.size jvm-data) index)
+                                           index)]
+                               #(.remove jvm-data index))))}]
       (create-bridge-from-att-map jvm-data att-map))))
 
 
@@ -869,7 +887,7 @@
                             initial-buffer
                             (->py-tuple shape)
                             (->py-tuple strides))]
-      (resource/track retval #(get buffer-desc :ptr) [:gc]))))
+      (resource/track retval #(get buffer-desc :ptr) pyobj/*pyobject-tracking-flags*))))
 
 
 (extend-type Object
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
index 999326c..7aceb6d 100644
--- a/src/libpython_clj/python/interop.clj
+++ b/src/libpython_clj/python/interop.clj
@@ -215,7 +215,6 @@
                     (reify CFunction$tp_new
                       (pyinvoke [this self varargs kw_args]
                         (let [retval (libpy/PyType_GenericNew self varargs kw_args)]
-                          (println retval)
                           retval)
                         )))
          module-name (get-attr module "__name__")
@@ -274,7 +273,7 @@
 (defn pybridge->bridge
   ^JVMBridge [^Pointer pybridge]
   (let [bridge-type (JVMBridgeType. pybridge)]
-    (get-jvm-bridge (.jvm_handle bridge-type)
+    (get-jvm-bridge (Pointer/nativeValue pybridge)
                     (.jvm_interpreter_handle bridge-type))))
 
 
@@ -311,7 +310,7 @@
                                                e
                                                (with-out-str
                                                  (st/print-stack-trace e))))))
-                            (unregister-bridge! bridge))
+                            (unregister-bridge! bridge self))
                           (catch Throwable e
                             (log-error e)))
                         (try
@@ -343,17 +342,20 @@
                             0))))
         :tp_iter (reify CFunction$NoArgFunction
                    (pyinvoke [this self]
-                     (let [attr
-                           (-> (pybridge->bridge self)
-                               (.getAttr "__iter__"))]
-                       (py-proto/call attr))))
-
+                     (if-let [attr (-> (pybridge->bridge self)
+                                         (.getAttr "__iter__"))]
+                       (libpy/PyObject_CallObject (jna/as-ptr attr) nil)
+                       (do
+                         (libpy/PyErr_SetNone (libpy/PyExc_Exception))
+                         nil))))
         :tp_iternext (reify CFunction$NoArgFunction
                        (pyinvoke [this self]
-                         (when-let [next
-                                    (-> (pybridge->bridge self)
-                                        (.nextFn))]
-                           (next))))}))))
+                         (if-let [next (-> (pybridge->bridge self)
+                                           (.getAttr "__next__"))]
+                           (libpy/PyObject_CallObject (jna/as-ptr next) nil)
+                           (do
+                             (libpy/PyErr_SetNone (libpy/PyExc_Exception))
+                             nil))))}))))
 
 
 (defn expose-bridge-to-python!
@@ -368,23 +370,17 @@
               (throw (ex-info "Failed to find bridge type" {})))
           bridge-type (PyTypeObject. bridge-type-ptr)
           ^Pointer new-py-obj (libpy/_PyObject_New bridge-type)
-          pybridge (JVMBridgeType. new-py-obj)
-          ]
-      (println (format "Creating bridge: 0x%x -> %s:%s"
-                       (Pointer/nativeValue new-py-obj)
-                       (get-object-handle (.interpreter bridge))
-                       (get-object-handle (.wrappedObject bridge))))
+          pybridge (JVMBridgeType. new-py-obj)]
       (set! (.jvm_interpreter_handle pybridge) (get-object-handle
                                                 (.interpreter bridge)))
       (set! (.jvm_handle pybridge) (get-object-handle (.wrappedObject bridge)))
       (.write pybridge)
-      (register-bridge! bridge pybridge)
-      (-> (.getPointer pybridge)
-          wrap-pyobject))))
+      (register-bridge! bridge new-py-obj)
+      (wrap-pyobject new-py-obj))))
 
 
 (defn create-bridge-from-att-map
-  [src-item att-map & {:keys [next-fn]}]
+  [src-item att-map]
   (with-gil
     (let [interpreter (ensure-bound-interpreter)
           dir-data (->> (keys att-map)
@@ -402,21 +398,11 @@
             (dir [bridge] dir-data)
             (interpreter [bridge] interpreter)
             (wrappedObject [bridge] src-item)
-            (nextFn [bridge] next-fn)
-            libpy-base/PToPyObjectPtr
-            (->py-object-ptr [item]
-              (with-gil
-                (if-let [existing-bridge (find-jvm-bridge-entry
-                                          (get-object-handle src-item)
-                                          (ensure-bound-interpreter))]
-                  (:pyobject existing-bridge)
-                  (expose-bridge-to-python! item))))
             py-proto/PCopyToJVM
             (->jvm [item options] src-item)
             py-proto/PBridgeToJVM
             (as-jvm [item options] src-item))]
-      (expose-bridge-to-python! bridge)
-      (libpy-base/->py-object-ptr bridge))))
+      (expose-bridge-to-python! bridge))))
 
 
 (defmethod py-proto/pyobject->jvm :jvm-bridge
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 96e4d74..45bf054 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -86,28 +86,24 @@
 
 
 (defn register-bridge!
-  [^JVMBridge bridge ^PyObject bridge-pyobject]
+  [^JVMBridge bridge ^Pointer bridge-pyobject]
   (let [interpreter (.interpreter bridge)
-        bridge-handle (get-object-handle (.wrappedObject bridge))]
+        bridge-handle (Pointer/nativeValue bridge-pyobject)]
     (when (contains? (get-in @(:interpreter-state* interpreter)
                            [:bridge-objects])
                      bridge-handle)
-      (throw (Exception. (format "Bridge already exists!! - %s" bridge-handle))))
+      (throw (Exception. (format "Bridge already exists!! - 0x%x" bridge-handle))))
     (swap! (:interpreter-state* interpreter) assoc-in
            [:bridge-objects bridge-handle]
            {:jvm-bridge bridge
-            :pyobject bridge-pyobject})
-    (println "ADDING-BRIDGE" bridge-handle
-             (keys (get-in @(:interpreter-state* interpreter)
-                           [:bridge-objects])))
+            :pyobject bridge-handle})
     :ok))
 
 
 (defn unregister-bridge!
-  [^JVMBridge bridge]
+  [^JVMBridge bridge ^Pointer bridge-pyobject]
   (let [interpreter (.interpreter bridge)
-        bridge-handle (get-object-handle (.wrappedObject bridge))]
-    (println "REMOVING-BRIDGE:" bridge-handle)
+        bridge-handle (Pointer/nativeValue bridge-pyobject)]
     (swap! (:interpreter-state* interpreter)
            update :bridge-objects dissoc bridge-handle)
     :ok))
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 4c230d4..b2c3456 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -95,7 +95,7 @@
     (py-proto/->jvm item options)))
 
 
-(def ^:dynamic *object-reference-logging* true)
+(def ^:dynamic *object-reference-logging* false)
 
 
 (def ^:dynamic *object-reference-tracker* nil)
@@ -427,14 +427,14 @@
           :or {method-name "unnamed_function"
                documentation "not documented"}}]
   (with-gil
-    (let [py-self (or py-self (->python {}))]
+    ;;This is a nice little tidbit, cfunction_new
+    ;;steals the reference.
+    (let [py-self (when py-self (incref (->python py-self)))]
       (-> (libpy/PyCFunction_New (method-def-data->method-def
                                   {:name method-name
                                    :doc documentation
                                    :function cfunc})
-                                 ;;This is a nice little tidbit, cfunction_new
-                                 ;;steals the reference.
-                                 (libpy/Py_IncRef py-self))
+                                 py-self)
           (wrap-pyobject)))))
 
 

From 620966bca9b8ed662cd4589b730c5cb6c4e21b9d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 11 Dec 2019 09:40:18 -0700
Subject: [PATCH 057/456] 1.21

---
 CHANGELOG.md                        | 11 +++++++++++
 project.clj                         |  2 +-
 src/libpython_clj/python/bridge.clj |  2 +-
 test/libpython_clj/python_test.clj  | 10 ++++++++++
 4 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c8f0075..9f2a799 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,16 @@
 # Time for a ChangeLog!
 
+## 1.21
+
+Bugfix release.  Passing infinite sequences to python functions was
+causing a hang as libpython-clj attempted to copy the sequence.  The
+current calling convention does a shallow copy of things that are list-like
+or map-like, while bridging things that are iterable or don't fall into
+the above categories.
+
+This exposed a bug that caused reference counting to be subtly wrong when
+python iterated through a bridged object.  And that was my life for a day.
+
 ## 1.20
 
 With two many huge things we had to skip a few versions!
diff --git a/project.clj b/project.clj
index 850ae23..cc2287a 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.21-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.21"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index 8df49d1..e8b1993 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -216,7 +216,7 @@
     (instance? Iterable arg)
     (as-python arg)
     :else
-    (->python arg)))
+    (as-python arg)))
 
 
 (defmacro bridge-pyobject
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 08d0307..a3f8401 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -284,3 +284,13 @@
            (-> (range)
                (islice 0 10)
                (vec))))))
+
+
+(deftest persistent-vector-nparray
+  (testing "Create numpy array from nested persistent vectors"
+    (let [ary-data (-> (py/import-module "numpy")
+                       (py/$a array [[1 2 3]
+                                     [4 5 6]]))]
+      (is (dfn/equals (dtt/->tensor [[1 2 3]
+                                     [4 5 6]])
+                      (py/as-tensor ary-data))))))

From da45409906ada252521968193bb0c9a2b705fd09 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 11 Dec 2019 09:40:34 -0700
Subject: [PATCH 058/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index cc2287a..609e296 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.21"
+(defproject cnuernber/libpython-clj "1.22-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 711a15bd1df54ff01150c059768dc20842ef262a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 11 Dec 2019 11:07:40 -0700
Subject: [PATCH 059/456] editing

---
 README.md | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e69b4de..3cde429 100644
--- a/README.md
+++ b/README.md
@@ -54,13 +54,22 @@ This is important to realize in that the code below doesn't look like python bec
 referencing the item and attribute systems by name and not via '.' or '[]'.
 
 
+### Installation
+
+#### Ubuntu
+
 ```console
-sudo apt install libpython3.6-dev
+sudo apt install libpython3.6
 # numpy and pandas are required for unit tests.  Numpy is required for
 # zero copy support.
 python3.6 -m pip install numpy pandas --user
 ```
 
+#### MacOSX
+
+Python installation instructions [here](https://docs.python-guide.org/starting/install3/osx/).
+
+
 
 ### Initialize python
 

From 12e07fe94047260710561912a54a2a610122dc4b Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 11 Dec 2019 16:20:49 -0700
Subject: [PATCH 060/456] Some conda exploration.

---
 dockerfiles/Dockerfile | 34 ++++++++++++++++++++++++++++++++++
 scripts/build-docker   |  7 +++++++
 scripts/docker-repl    | 10 ++++++++++
 3 files changed, 51 insertions(+)
 create mode 100644 dockerfiles/Dockerfile
 create mode 100755 scripts/build-docker
 create mode 100755 scripts/docker-repl

diff --git a/dockerfiles/Dockerfile b/dockerfiles/Dockerfile
new file mode 100644
index 0000000..e7a3411
--- /dev/null
+++ b/dockerfiles/Dockerfile
@@ -0,0 +1,34 @@
+# We will use Ubuntu for our image
+FROM ubuntu:latest
+
+# Updating Ubuntu packages
+
+
+RUN apt-get -qq update && apt-get -qq -y install curl wget bzip2 openjdk-8-jdk-headless \
+    && curl -sSL https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -o /tmp/miniconda.sh \
+    && bash /tmp/miniconda.sh -bfp /usr/local \
+    && rm -rf /tmp/miniconda.sh \
+    && conda install -y python=3 \
+    && conda update conda \
+    && curl -O https://download.clojure.org/install/linux-install-1.10.1.492.sh \
+    && chmod +x linux-install-1.10.1.492.sh \
+    && ./linux-install-1.10.1.492.sh && rm linux-install-1.10.1.492.sh \
+    && wget https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein \
+    && chmod a+x lein \
+    && mv lein /usr/bin \
+    && apt-get -qq -y autoremove \
+    && apt-get autoclean \
+    && rm -rf /var/lib/apt/lists/* /var/log/dpkg.log \
+    && conda clean --all --yes
+
+
+ENV PATH /opt/conda/bin:$PATH
+
+
+ARG USERID
+ARG GROUPID
+ARG USERNAME
+
+RUN groupadd -g $GROUPID $USERNAME
+RUN useradd -u $USERID -g $GROUPID $USERNAME
+RUN mkdir /home/$USERNAME && chown $USERNAME:$USERNAME /home/$USERNAME
\ No newline at end of file
diff --git a/scripts/build-docker b/scripts/build-docker
new file mode 100755
index 0000000..5a1da08
--- /dev/null
+++ b/scripts/build-docker
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -e
+
+pushd dockerfiles
+docker build -t docker-conda -f Dockerfile --build-arg USERID=$(id -u) --build-arg GROUPID=$(id -u) --build-arg USERNAME=$USER .
+popd
diff --git a/scripts/docker-repl b/scripts/docker-repl
new file mode 100755
index 0000000..508fde7
--- /dev/null
+++ b/scripts/docker-repl
@@ -0,0 +1,10 @@
+#!/bin/bash
+
+
+docker run --rm -it -u $(id -u):$(id -g) \
+  -e LEIN_REPL_HOST="0.0.0.0" \
+  -v /$HOME/.m2:/home/$USER/.m2 \
+  -v /$HOME/.lein:/home/$USER/.lein \
+  -v $(pwd)/:/libpython-clj \
+  --net=host -w /libpython-clj \
+  docker-conda $@

From 12b23f24b96f1d5ebf98cc316e57e6164b90877c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 11 Dec 2019 16:48:41 -0700
Subject: [PATCH 061/456] Small updates.

---
 scripts/docker-repl | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/scripts/docker-repl b/scripts/docker-repl
index 508fde7..c41dddb 100755
--- a/scripts/docker-repl
+++ b/scripts/docker-repl
@@ -1,5 +1,8 @@
 #!/bin/bash
 
+## This is incomplete, you still have to mess around with pythonpath and such.  The
+## goal at this stage is to get this docker container to launch a repl that allows
+## initialize! to work out of the box.
 
 docker run --rm -it -u $(id -u):$(id -g) \
   -e LEIN_REPL_HOST="0.0.0.0" \
@@ -8,3 +11,7 @@ docker run --rm -it -u $(id -u):$(id -g) \
   -v $(pwd)/:/libpython-clj \
   --net=host -w /libpython-clj \
   docker-conda $@
+
+  # docker-conda lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
+  # -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
+  # -- repl :headless :host localhost

From 6df574d4c925e2ec9708ee253b9fafcc534f8a96 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 12 Dec 2019 08:17:36 -0700
Subject: [PATCH 062/456] Checking on a dockerfile that builds conda and
 libpython-clj.

---
 dockerfiles/{Dockerfile => CondaDockerfile} | 0
 scripts/build-conda-docker                  | 7 +++++++
 scripts/build-docker                        | 7 -------
 scripts/{docker-repl => run-conda-docker}   | 2 +-
 4 files changed, 8 insertions(+), 8 deletions(-)
 rename dockerfiles/{Dockerfile => CondaDockerfile} (100%)
 create mode 100755 scripts/build-conda-docker
 delete mode 100755 scripts/build-docker
 rename scripts/{docker-repl => run-conda-docker} (96%)

diff --git a/dockerfiles/Dockerfile b/dockerfiles/CondaDockerfile
similarity index 100%
rename from dockerfiles/Dockerfile
rename to dockerfiles/CondaDockerfile
diff --git a/scripts/build-conda-docker b/scripts/build-conda-docker
new file mode 100755
index 0000000..d323d22
--- /dev/null
+++ b/scripts/build-conda-docker
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -e
+
+pushd dockerfiles
+docker build -t docker-conda -f CondaDockerfile --build-arg USERID=$(id -u) --build-arg GROUPID=$(id -u) --build-arg USERNAME=$USER .
+popd
diff --git a/scripts/build-docker b/scripts/build-docker
deleted file mode 100755
index 5a1da08..0000000
--- a/scripts/build-docker
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/bash
-
-set -e
-
-pushd dockerfiles
-docker build -t docker-conda -f Dockerfile --build-arg USERID=$(id -u) --build-arg GROUPID=$(id -u) --build-arg USERNAME=$USER .
-popd
diff --git a/scripts/docker-repl b/scripts/run-conda-docker
similarity index 96%
rename from scripts/docker-repl
rename to scripts/run-conda-docker
index c41dddb..848f691 100755
--- a/scripts/docker-repl
+++ b/scripts/run-conda-docker
@@ -10,7 +10,7 @@ docker run --rm -it -u $(id -u):$(id -g) \
   -v /$HOME/.lein:/home/$USER/.lein \
   -v $(pwd)/:/libpython-clj \
   --net=host -w /libpython-clj \
-  docker-conda $@
+  docker-conda /bin/bash
 
   # docker-conda lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
   # -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\

From cf14225817d62303bdf6d4e43d1bf0bf94e49db6 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 12 Dec 2019 10:08:32 -0700
Subject: [PATCH 063/456] Working through new knowledge and new apis

---
 dockerfiles/CondaDockerfile              |  4 +-
 src/libpython_clj/jna.clj                |  4 +-
 src/libpython_clj/jna/interpreter.clj    | 32 ++++++++++++
 src/libpython_clj/python/interpreter.clj | 62 ++++++++++++++++++++++--
 4 files changed, 95 insertions(+), 7 deletions(-)

diff --git a/dockerfiles/CondaDockerfile b/dockerfiles/CondaDockerfile
index e7a3411..8f976e9 100644
--- a/dockerfiles/CondaDockerfile
+++ b/dockerfiles/CondaDockerfile
@@ -31,4 +31,6 @@ ARG USERNAME
 
 RUN groupadd -g $GROUPID $USERNAME
 RUN useradd -u $USERID -g $GROUPID $USERNAME
-RUN mkdir /home/$USERNAME && chown $USERNAME:$USERNAME /home/$USERNAME
\ No newline at end of file
+RUN mkdir /home/$USERNAME && chown $USERNAME:$USERNAME /home/$USERNAME
+USER $USERNAME
+RUN conda create -n pyclj python=3.6 && echo "source activate pyclj" > /home/$USERNAME/.bashrc
\ No newline at end of file
diff --git a/src/libpython_clj/jna.clj b/src/libpython_clj/jna.clj
index 04b42ec..0a5df41 100644
--- a/src/libpython_clj/jna.clj
+++ b/src/libpython_clj/jna.clj
@@ -38,11 +38,13 @@
 
 
 (export-symbols libpython-clj.jna.interpreter
+                PySys_SetArgv
+                Py_SetProgramName
+                Py_SetPythonHome
                 Py_InitializeEx
                 Py_IsInitialized
                 Py_FinalizeEx
                 PyRun_SimpleString
-                PySys_SetArgv
                 get-type-name
                 lookup-type-symbols
                 Py_None
diff --git a/src/libpython_clj/jna/interpreter.clj b/src/libpython_clj/jna/interpreter.clj
index 07cdddb..9a6bacc 100644
--- a/src/libpython_clj/jna/interpreter.clj
+++ b/src/libpython_clj/jna/interpreter.clj
@@ -18,6 +18,38 @@
            [libpython_clj.jna PyObject]))
 
 
+
+(def-no-gil-pylib-fn Py_SetProgramName
+  "This function should be called before Py_Initialize() is called for the first time,
+  if it is called at all. It tells the interpreter the value of the argv[0] argument to
+  the main() function of the program (converted to wide characters). This is used by
+  Py_GetPath() and some other functions below to find the Python run-time libraries
+  relative to the interpreter executable. The default value is 'python'. The argument
+  should point to a zero-terminated wide character string in static storage whose
+  contents will not change for the duration of the program’s execution. No code in the
+  Python interpreter will change the contents of this storage.
+
+  Use Py_DecodeLocale() to decode a bytes string to get a wchar_* string."
+  nil
+  [name jna/ensure-ptr])
+
+
+
+
+(def-no-gil-pylib-fn Py_SetPythonHome
+  "Set the default “home” directory, that is, the location of the standard Python
+  libraries. See PYTHONHOME for the meaning of the argument string.
+
+  The argument should point to a zero-terminated character string in static storage
+  whose contents will not change for the duration of the program’s execution. No code
+  in the Python interpreter will change the contents of this storage.
+
+  Use Py_DecodeLocale() to decode a bytes string to get a wchar_* string."
+  nil
+  [home jna/ensure-ptr])
+
+
+
 ;; Bugs and caveats: The destruction of modules and objects in modules is done in random
 ;; order; this may cause destructors (__del__() methods) to fail when they depend on
 ;; other objects (even functions) or modules. Dynamically loaded extension modules
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 45bf054..cee8926 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -4,7 +4,9 @@
             [tech.resource :as resource]
             [libpython-clj.python.logging
              :refer [log-error log-warn log-info]]
-            [tech.jna :as jna])
+            [tech.jna :as jna]
+            [clojure.java.shell :as sh]
+            [clojure.string :as s])
   (:import [libpython_clj.jna
             JVMBridge
             PyObject]
@@ -241,6 +243,9 @@
 (defonce ^:dynamic *program-name* "")
 
 
+
+
+
 (defn- try-load-python-library!
   [libname]
   (try
@@ -251,13 +256,60 @@
     (catch Exception e)))
 
 
+(defn- ignore-shell-errors
+  [& args]
+  (try
+    (apply sh/sh args)
+    (catch Throwable e nil)))
+
+
+(defn- find-python-home
+  [& [python-home]]
+  (cond
+    python-home
+    python-home
+    (seq (System/getenv "PYTHONHOME"))
+    (System/getenv "PYTHONHOME")
+    :else
+    (let [{:keys [out err exit]} (ignore-shell-errors "python3-config" "--prefix")]
+      (when (= 0 exit)
+        (s/trimr out)))))
+
+
+(defn- find-python-lib-version
+  []
+  (let [{:keys [out err exit]} (ignore-shell-errors "python3" "--version")]
+    (when (= 0 exit)
+      (when-let [parts (->> (s/split out #"\.")
+                            (take 2)
+                            seq)]
+        (let [^String first-part (first parts)
+              first-part (if (.startsWith first-part "Python ")
+                           (.substring first-part (count "Python "))
+                           first-part)]
+          (s/join "." (concat [first-part] (rest parts))))))))
+
+
+(defn set-java-library-path!
+  [python-home]
+  )
+
+
 (defn initialize!
-  [& [program-name python-library-name]]
+  [& {:keys [program-name
+             python-library-name
+             python-home]}]
   (when-not @*main-interpreter*
     (log-info "executing python initialize!")
-    (let [user-names (when python-library-name
-                       [python-library-name])
-          library-names (or user-names (libpy-base/library-names))]
+    (let [python-home (find-python-home python-home)
+          lib-version (find-python-lib-version)
+          library-names (if python-library-name
+                          [python-library-name]
+                          (concat
+                           [(str "python" lib-version "m")]
+                           (libpy-base/library-names)))]
+      (when python-home
+        (set-java-library-path! python-home))
       (loop [[library-name & library-names] library-names]
         (if (and library-name
                  (not (try-load-python-library! library-name)))

From 2b90f9f0fbf6efc41a2c90f2049ff1531f021273 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 12 Dec 2019 11:48:32 -0700
Subject: [PATCH 064/456] Upgrades to enable python to run more reliably.

---
 dockerfiles/CondaDockerfile              |   3 +-
 scripts/run-conda-docker                 |   7 +-
 src/libpython_clj/python.clj             |   9 +-
 src/libpython_clj/python/interpreter.clj | 109 +++++++++++++++--------
 4 files changed, 86 insertions(+), 42 deletions(-)

diff --git a/dockerfiles/CondaDockerfile b/dockerfiles/CondaDockerfile
index 8f976e9..038c986 100644
--- a/dockerfiles/CondaDockerfile
+++ b/dockerfiles/CondaDockerfile
@@ -33,4 +33,5 @@ RUN groupadd -g $GROUPID $USERNAME
 RUN useradd -u $USERID -g $GROUPID $USERNAME
 RUN mkdir /home/$USERNAME && chown $USERNAME:$USERNAME /home/$USERNAME
 USER $USERNAME
-RUN conda create -n pyclj python=3.6 && echo "source activate pyclj" > /home/$USERNAME/.bashrc
\ No newline at end of file
+RUN conda create -n pyclj python=3.6 && conda install -n pyclj numpy mxnet\
+    && echo "source activate pyclj" > /home/$USERNAME/.bashrc
\ No newline at end of file
diff --git a/scripts/run-conda-docker b/scripts/run-conda-docker
index 848f691..d193f96 100755
--- a/scripts/run-conda-docker
+++ b/scripts/run-conda-docker
@@ -11,7 +11,6 @@ docker run --rm -it -u $(id -u):$(id -g) \
   -v $(pwd)/:/libpython-clj \
   --net=host -w /libpython-clj \
   docker-conda /bin/bash
-
-  # docker-conda lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
-  # -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
-  # -- repl :headless :host localhost
+     # lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
+     #   -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
+     #   -- repl :headless :host localhost
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index d902be1..35a6d0d 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -226,9 +226,14 @@
   :program-name - optional but will show up in error messages from python.
   :no-io-redirect - there if you don't want python stdout and stderr redirection
      to *out* and *err*."
-  [& {:keys [program-name no-io-redirect? library-path]}]
+  [& {:keys [program-name
+             library-path
+             python-home
+             no-io-redirect?]}]
   (when-not @pyinterp/*main-interpreter*
-    (pyinterp/initialize! program-name library-path)
+    (pyinterp/initialize! :program-name program-name
+                          :library-path library-path
+                          :python-home python-home)
     ;;setup bridge mechansim and io redirection
     (pyinterop/register-bridge-type!)
     (when-not no-io-redirect?
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index cee8926..ba4d386 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -6,13 +6,15 @@
              :refer [log-error log-warn log-info]]
             [tech.jna :as jna]
             [clojure.java.shell :as sh]
-            [clojure.string :as s])
+            [clojure.string :as s]
+            [clojure.tools.logging :as log])
   (:import [libpython_clj.jna
             JVMBridge
             PyObject]
            [com.sun.jna Pointer]
            [com.sun.jna.ptr PointerByReference]
-           [java.io StringWriter]))
+           [java.io StringWriter]
+           [java.nio.file Paths Path]))
 
 
 (set! *warn-on-reflection* true)
@@ -245,17 +247,6 @@
 
 
 
-
-(defn- try-load-python-library!
-  [libname]
-  (try
-    (jna/load-library libname)
-    (alter-var-root #'libpy-base/*python-library* (constantly libname))
-    (libpy/Py_InitializeEx 0)
-    libname
-    (catch Exception e)))
-
-
 (defn- ignore-shell-errors
   [& args]
   (try
@@ -280,39 +271,87 @@
   []
   (let [{:keys [out err exit]} (ignore-shell-errors "python3" "--version")]
     (when (= 0 exit)
-      (when-let [parts (->> (s/split out #"\.")
-                            (take 2)
-                            seq)]
-        (let [^String first-part (first parts)
-              first-part (if (.startsWith first-part "Python ")
-                           (.substring first-part (count "Python "))
-                           first-part)]
-          (s/join "." (concat [first-part] (rest parts))))))))
+      ;;Anaconda prints version info only to the error stream.
+      (when-let [version-info (first (filter seq [out err]))]
+        (log/infof "Python detected: %s" version-info)
+        (let [version-data (re-find #"\d+\.\d+\.\d+" version-info)
+              parts (->> (s/split version-data #"\.")
+                         (take 2)
+                         seq)]
+          (s/join "." parts))))))
+
+
+(defn append-java-library-path!
+  [new-search-path]
+  (let [existing-paths (-> (System/getProperty "java.library.path")
+                           (s/split #":"))]
+    (when-not (contains? (set existing-paths) new-search-path)
+      (let [new-path-str (s/join ":" (concat [new-search-path]
+                                             existing-paths))]
+        (log/infof "Setting java library path: %s" new-path-str)
+        (System/setProperty "java.library.path" new-path-str)))))
+
+
+(defonce ^:private python-home-wide-ptr* (atom nil))
+
+
+(defn- try-load-python-library!
+  [libname python-home-wide-ptr]
+  (try
+    (jna/load-library libname)
+    (alter-var-root #'libpy-base/*python-library* (constantly libname))
+    (when python-home-wide-ptr
+      (libpy/Py_SetPythonHome python-home-wide-ptr))
+    (libpy/Py_InitializeEx 0)
+    libname
+    (catch Exception e)))
 
 
-(defn set-java-library-path!
-  [python-home]
-  )
+(defn- detect-startup-info
+  [{:keys [library-path python-home]}]
+  (let [python-home (find-python-home python-home)
+        java-library-path-addendum
+        (when python-home
+          (-> (Paths/get python-home (into-array String ["lib"]))
+              (.toString)))
+        lib-version (find-python-lib-version)
+        libname (when (seq lib-version)
+                  (str "python" lib-version "m"))
+        retval
+        {:python-home python-home
+         :lib-version lib-version
+         :libname libname
+         :java-library-path-addendum java-library-path-addendum}]
+    (log/infof "Startup info detected: %s" retval)
+    retval))
 
 
 (defn initialize!
   [& {:keys [program-name
-             python-library-name
-             python-home]}]
+             library-path
+             python-home]
+      :as options}]
   (when-not @*main-interpreter*
-    (log-info "executing python initialize!")
-    (let [python-home (find-python-home python-home)
-          lib-version (find-python-lib-version)
-          library-names (if python-library-name
-                          [python-library-name]
+    (log-info "Executing python initialize!")
+    (let [{:keys [python-home libname java-library-path-addendum] :as startup-info}
+          (detect-startup-info options)
+          library-names (cond
+                          library-path
+                          [library-path]
+                          libname
                           (concat
-                           [(str "python" lib-version "m")]
-                           (libpy-base/library-names)))]
+                           [libname]
+                           (libpy-base/library-names))
+                          :else
+                          (libpy-base/library-names))]
+      (reset! python-home-wide-ptr* nil)
       (when python-home
-        (set-java-library-path! python-home))
+        (append-java-library-path! java-library-path-addendum)
+        ;;This can never be released if load-library succeeeds
+        (reset! python-home-wide-ptr* (jna/string->wide-ptr python-home)))
       (loop [[library-name & library-names] library-names]
         (if (and library-name
-                 (not (try-load-python-library! library-name)))
+                 (not (try-load-python-library! library-name @python-home-wide-ptr*)))
           (recur library-names))))
     ;;Set program name
     (when-let [program-name (or program-name *program-name* "")]

From 03787e789c8fb9b8d4a2e3f1dc3936a4be41dedf Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 12 Dec 2019 11:53:13 -0700
Subject: [PATCH 065/456] 1.22

---
 CHANGELOG.md                             | 9 +++++++++
 project.clj                              | 2 +-
 src/libpython_clj/python/interpreter.clj | 2 +-
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9f2a799..528b96a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,14 @@
 # Time for a ChangeLog!
 
+## 1.22
+
+Working to make more python environments work out of the box.  Currently have a
+testcase for conda working in a clean install of a docker container.  There is now a
+new method: `libpython-clj.python.interpreter/detect-startup-info` that attempts
+call python3-config and python3 --version in order to automagically configure the
+python library.
+
+
 ## 1.21
 
 Bugfix release.  Passing infinite sequences to python functions was
diff --git a/project.clj b/project.clj
index 609e296..dba79b2 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.22-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.22"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index ba4d386..484da8b 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -307,7 +307,7 @@
     (catch Exception e)))
 
 
-(defn- detect-startup-info
+(defn detect-startup-info
   [{:keys [library-path python-home]}]
   (let [python-home (find-python-home python-home)
         java-library-path-addendum

From 94dbef6bd61c4bb48ea2d9c83603a9c1f6c8e88d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 12 Dec 2019 11:53:23 -0700
Subject: [PATCH 066/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index dba79b2..ca4dfbf 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.22"
+(defproject cnuernber/libpython-clj "1.23-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 015af9c24f1a7ed0b4de6fdda809828ef47a5e72 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 12 Dec 2019 14:37:40 -0700
Subject: [PATCH 067/456] Equality/hash/better tostring for types.

---
 CHANGELOG.md                               | 46 +++++++++++++++++++++-
 src/libpython_clj/jna.clj                  |  1 +
 src/libpython_clj/jna/protocols/object.clj | 28 ++++++++++++-
 src/libpython_clj/python.clj               |  5 ++-
 src/libpython_clj/python/bridge.clj        | 11 +++++-
 src/libpython_clj/python/interop.clj       |  4 --
 src/libpython_clj/python/object.clj        | 25 ++++++++++++
 test/libpython_clj/python_test.clj         | 20 ++++++----
 8 files changed, 123 insertions(+), 17 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 528b96a..0700fb4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,12 +1,54 @@
 # Time for a ChangeLog!
 
+
+## 1.23-SNAPSHOT
+
+
+Equals, hashcode, nice default .toString of python types:
+
+```clojure
+user> (require '[libpython-clj.python :as py])
+nil
+user> (def test-tuple (py/->py-tuple [1 2]))
+#'user/test-tuple
+user> (require '[libpython-clj.require :refer [require-python]])
+nil
+user> (require-python '[builtins :as bt])
+nil
+user> (bt/type test-tuple)
+builtins.tuple
+user> test-tuple
+(1, 2)
+user> (def new-tuple (py/->py-tuple [3 4]))
+#'user/new-tuple
+user> (= test-tuple new-tuple)
+false
+user> (= test-tuple (py/->py-tuple [1 2]))
+true
+user> (.hashCode test-tuple)
+2130570162
+user> (.hashCode (py/->py-tuple [1 2]))
+2130570162
+user> (require-python '[numpy :as np])
+nil
+user> (def np-ary (np/array [1 2 3]))
+#'user/np-ary
+user> np-ary
+[1 2 3]
+user> (bt/type np-ary)
+numpy.ndarray
+user> (py/python-type *1)
+:type
+```
+
+
 ## 1.22
 
 Working to make more python environments work out of the box.  Currently have a
 testcase for conda working in a clean install of a docker container.  There is now a
 new method: `libpython-clj.python.interpreter/detect-startup-info` that attempts
-call python3-config and python3 --version in order to automagically configure the
-python library.
+call `python3-config --prefix` and `python3 --version` in order to automagically
+configure the python library.
 
 
 ## 1.21
diff --git a/src/libpython_clj/jna.clj b/src/libpython_clj/jna.clj
index 0a5df41..2121f5d 100644
--- a/src/libpython_clj/jna.clj
+++ b/src/libpython_clj/jna.clj
@@ -96,6 +96,7 @@
                 PyObject_Call
                 PyObject_CallObject
                 PyObject_Hash
+                PyObject_IsInstance
                 PyObject_IsTrue
                 PyObject_Not
                 PyObject_Length
diff --git a/src/libpython_clj/jna/protocols/object.clj b/src/libpython_clj/jna/protocols/object.clj
index d83d8b2..e2f9691 100644
--- a/src/libpython_clj/jna/protocols/object.clj
+++ b/src/libpython_clj/jna/protocols/object.clj
@@ -42,6 +42,7 @@
                    keyword)
                v]))
        (into {})))
+(def bool-fn-value-set (set (vals bool-fn-table)))
 
 
 (defn bool-fn-constant
@@ -51,7 +52,7 @@
                 (long item)
                 (keyword? item)
                 (get bool-fn-table item))
-        value-set (set (vals bool-fn-table))]
+        value-set bool-fn-value-set]
     (when-not (contains? value-set value)
       (throw (ex-info (format "Unrecognized bool fn %s" item) {})))
     (int value)))
@@ -309,10 +310,33 @@
 
    Changed in version 3.2: The return type is now Py_hash_t. This is a signed integer
    the same size as Py_ssize_t."
-  (size-t-type)
+  size-t-type
   [o ensure-pyobj])
 
 
+(def-pylib-fn PyObject_IsInstance
+  "Return 1 if inst is an instance of the class cls or a subclass of cls, or 0 if
+   not. On error, returns -1 and sets an exception.
+
+   If cls is a tuple, the check will be done against every entry in cls. The result
+   will be 1 when at least one of the checks returns 1, otherwise it will be 0.
+
+   If cls has a __instancecheck__() method, it will be called to determine the
+   subclass status as described in PEP 3119. Otherwise, inst is an instance of cls
+   if its class is a subclass of cls.
+
+   An instance inst can override what is considered its class by having a __class__
+   attribute.
+
+   An object cls can override if it is considered a class, and what its base
+   classes are, by having a __bases__ attribute (which must be a tuple of base
+   classes)."
+  Integer
+  [inst ensure-pyobj]
+  [cls ensure-pyobj])
+
+
+
 (def-pylib-fn PyObject_IsTrue
   "Returns 1 if the object o is considered to be true, and 0 otherwise. This is
   equivalent to the Python expression not not o. On failure, return -1."
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 35a6d0d..e33c5d7 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -50,7 +50,10 @@
                 ->jvm
                 make-tuple-fn
                 make-tuple-instance-fn
-                create-class)
+                create-class
+                is-instance?
+                hash-code
+                equals?)
 
 
 (defmacro stack-resource-context
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index e8b1993..afa532c 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -289,7 +289,16 @@
                    (as-jvm)))))
          Object
          (toString [this#]
-           (->jvm (py-proto/call-attr pyobj# "__str__")))
+           (with-interpreter interpreter#
+             (if (= 1 (libpy/PyObject_IsInstance pyobj# (libpy/PyType_Type)))
+               (format "%s.%s"
+                       (->jvm (py-proto/get-attr pyobj# "__module__"))
+                       (->jvm (py-proto/get-attr pyobj# "__name__")))
+               (->jvm (py-proto/call-attr pyobj# "__str__")))))
+         (equals [this# other#]
+           (pyobj/equals? this# other#))
+         (hashCode [this#]
+           (.hashCode ^Object (pyobj/hash-code this#)))
          ~@body)
        {:type :pyobject})))
 
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
index 7aceb6d..935eed6 100644
--- a/src/libpython_clj/python/interop.clj
+++ b/src/libpython_clj/python/interop.clj
@@ -166,10 +166,6 @@
            (into-array Object [(str fieldname)])))
 
 
-(defn create-python-type
-  [type-name module-name method-def-data])
-
-
 (defn method-def-data-seq->method-def-ref
   ^PyMethodDef$ByReference [method-def-data-seq]
   (when (seq method-def-data-seq)
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index b2c3456..ecf7e42 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -1052,3 +1052,28 @@
     :else
     {:type (python-type pyobj)
      :value (Pointer/nativeValue (jna/as-ptr pyobj))}))
+
+
+(defn is-instance?
+  "Returns true if inst is an instance of type.
+  False otherwise."
+  [py-inst py-type]
+  (with-gil
+    (= 1 (libpy/PyObject_IsInstance (->python py-inst)
+                                    ;;The type has to be a python type already.
+                                    py-type))))
+
+
+(defn hash-code
+  ^long [py-inst]
+  (with-gil
+    (long (libpy/PyObject_Hash (->python py-inst)))))
+
+
+(defn equals?
+  "Returns true of the python equals operator returns 1."
+  [lhs rhs]
+  (with-gil
+    (= 1 (libpy/PyObject_RichCompareBool (->python lhs)
+                                         (->python rhs)
+                                         :py-eq))))
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index a3f8401..28259ee 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -10,13 +10,6 @@
 (py/initialize!)
 
 
-(defn crashit
-  []
-  (let [test-data (py/->python (py/as-python [1 2]))
-        test-py-data (py/->py-tuple [test-data test-data])
-        _ :ignored]
-    :ok))
-
 
 (deftest stdout-and-stderr
   (is (= "hey\n" (with-out-str
@@ -294,3 +287,16 @@
       (is (dfn/equals (dtt/->tensor [[1 2 3]
                                      [4 5 6]])
                       (py/as-tensor ary-data))))))
+
+
+(deftest python-tuple-equals
+  (testing "Python tuples have nice equal semantics."
+    (let [lhs (py/->py-tuple [1 2])
+          same (py/->py-tuple [1 2])
+          not-same (py/->py-tuple [3 4])]
+      (is (= lhs same))
+      (is (not= lhs not-same))
+      (is (= (.hashCode lhs)
+             (.hashCode same)))
+      (is (not= (.hashCode lhs)
+                (.hashCode not-same))))))

From b9941fb571d975fa20e153429834dd5236d025e1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 12 Dec 2019 14:38:38 -0700
Subject: [PATCH 068/456] 1.23

---
 CHANGELOG.md | 2 +-
 project.clj  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0700fb4..f897c68 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,7 @@
 # Time for a ChangeLog!
 
 
-## 1.23-SNAPSHOT
+## 1.23
 
 
 Equals, hashcode, nice default .toString of python types:
diff --git a/project.clj b/project.clj
index ca4dfbf..24f3e3e 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.23-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.23"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 669ecca619e8b38a3d0a3a36a739ed0474bdbf8b Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 12 Dec 2019 14:38:45 -0700
Subject: [PATCH 069/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 24f3e3e..2df8bf0 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.23"
+(defproject cnuernber/libpython-clj "1.24-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From a2ec5110b1c798b891815a77c98c5bb5e10cdbf9 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 13 Dec 2019 08:57:20 -0700
Subject: [PATCH 070/456] 1.24

---
 project.clj                         | 4 ++--
 src/libpython_clj/python/bridge.clj | 2 +-
 test/libpython_clj/python_test.clj  | 7 +++++++
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/project.clj b/project.clj
index 2df8bf0..f5b7371 100644
--- a/project.clj
+++ b/project.clj
@@ -1,10 +1,10 @@
-(defproject cnuernber/libpython-clj "1.24-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.24"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
-                 [techascent/tech.datatype "4.56"]
+                 [techascent/tech.datatype "4.61"]
                  [camel-snake-kebab "0.4.0"]]
   :repl-options {:init-ns user}
   :java-source-paths ["java"])
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index afa532c..9dd4e82 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -209,7 +209,7 @@
   (cond
     (jna/as-ptr arg)
     (jna/as-ptr arg)
-    (instance? RandomAccess arg)
+    (dtype/reader? arg)
     (->python arg)
     (instance? Map arg)
     (->python arg)
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 28259ee..306e1cb 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -300,3 +300,10 @@
              (.hashCode same)))
       (is (not= (.hashCode lhs)
                 (.hashCode not-same))))))
+
+
+(deftest range-nparray
+  (let [ary-data (-> (py/import-module "numpy")
+                     (py/$a array (range 10)))]
+    (is (dfn/equals (dtt/->tensor (range 10))
+                    (py/as-tensor ary-data)))))

From 5a936943a6be54488a66b7607db04dcb5b2948b8 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 13 Dec 2019 08:57:27 -0700
Subject: [PATCH 071/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index f5b7371..6b3f82a 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.24"
+(defproject cnuernber/libpython-clj "1.25-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 3bf1ec9d819dc7bf59799c67a78a11e35e09d79e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 13 Dec 2019 08:59:33 -0700
Subject: [PATCH 072/456] changelog update.

---
 CHANGELOG.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f897c68..716d0f9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,14 @@
 # Time for a ChangeLog!
 
 
+## 1.24
+
+
+Clojure's range is now respected in two different ways:
+* `(range)` - bridges to a python iterable
+* `(range 5)` - copies to a python list
+
+
 ## 1.23
 
 

From a16fb2dad8f71f7d9eee8aa6c407c3abc6e598ab Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Fri, 13 Dec 2019 16:34:38 -0500
Subject: [PATCH 073/456] Tools for finding system library paths (#22)

* * tools for finding python library paths

* Update project.clj
---
 project.clj                              |   3 +-
 src/libpython_clj/python/interpreter.clj | 108 ++++++++++++++++++++++-
 2 files changed, 109 insertions(+), 2 deletions(-)

diff --git a/project.clj b/project.clj
index 6b3f82a..66c867b 100644
--- a/project.clj
+++ b/project.clj
@@ -4,7 +4,8 @@
   :license {:name "EPL-2.0"
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
+                 [camel-snake-kebab "0.4.0"]
                  [techascent/tech.datatype "4.61"]
-                 [camel-snake-kebab "0.4.0"]]
+                 [cheshire "5.9.0"]]
   :repl-options {:init-ns user}
   :java-source-paths ["java"])
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 484da8b..d3c44ca 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -6,8 +6,10 @@
              :refer [log-error log-warn log-info]]
             [tech.jna :as jna]
             [clojure.java.shell :as sh]
+            [clojure.java.io :as io]
             [clojure.string :as s]
-            [clojure.tools.logging :as log])
+            [clojure.tools.logging :as log]
+            [cheshire.core :as json])
   (:import [libpython_clj.jna
             JVMBridge
             PyObject]
@@ -25,6 +27,110 @@
   (System/identityHashCode obj))
 
 
+(defn py-system-attribute [executable attr]
+  (let [{out :out err :err}
+        (sh executable
+            "-c"
+            (format "import sys,json; print(getattr(sys, '%s'))" attr))]
+    (clojure.string/trim out)))
+
+(defn py-system-version [executable]
+  (let [{out :out err :err}
+        (sh executable "-c"
+            (format "import sys, json; print(list(getattr(sys, 'version_info')[:3]))"))]
+    (json/parse-string out)))
+
+
+(defn python-system-info
+  "An information map about the Python system information provided
+  by a Python executable (string).
+
+  :platform (operating system information)
+  :prefix
+  A string giving the site-specific directory prefix where the platform independent Python files are installed; by default, this is the string '/usr/local'. This can be set at build time with the --prefix argument to the configure script. The main collection of Python library modules is installed in the directory prefix/lib/pythonX.Y while the platform independent header files (all except pyconfig.h) are stored in prefix/include/pythonX.Y, where X.Y is the version number of Python, for example 3.2.
+  Note If a virtual environment is in effect, this value will be changed in site.py to point to the virtual environment. The value for the Python installation will still be available, via base_prefix.
+
+  :base-prefix
+  Set during Python startup, before site.py is run, to the same value as prefix. If not running in a virtual environment, the values will stay the same; if site.py finds that a virtual environment is in use, the values of prefix and exec_prefix will be changed to point to the virtual environment, whereas base_prefix and base_exec_prefix will remain pointing to the base Python installation (the one which the virtual environment was created from).
+
+  :executable
+  A string giving the absolute path of the executable binary for the Python interpreter, on systems where this makes sense. If Python is unable to retrieve the real path to its executable, sys.executable will be an empty string or None.
+
+  :exec-prefix
+  A string giving the site-specific directory prefix where the platform-dependent Python files are installed; by default, this is also '/usr/local'. This can be set at build time with the --exec-prefix argument to the configure script. Specifically, all configuration files (e.g. the pyconfig.h header file) are installed in the directory exec_prefix/lib/pythonX.Y/config, and shared library modules are installed in exec_prefix/lib/pythonX.Y/lib-dynload, where X.Y is the version number of Python, for example 3.2.
+  Note If a virtual environment is in effect, this value will be changed in site.py to point to the virtual environment. The value for the Python installation will still be available, via base_exec_prefix.
+
+  :base-exec-prefix
+  Set during Python startup, before site.py is run, to the same value as exec_prefix. If not running in a virtual environment, the values will stay the same; if site.py finds that a virtual environment is in use, the values of prefix and exec_prefix will be changed to point to the virtual environment, whereas base_prefix and base_exec_prefix will remain pointing to the base Python installation (the one which the virtual environment was created from).
+
+  :version
+  (list python-major python-minor python-micro)"
+  [executable]
+  (letfn [(system-attribte [x]
+            (py-system-attribute executable x))]
+
+    {:platform         (system-attribte "platform")
+     :prefix           (system-attribte "prefix")
+     :base-prefix      (system-attribte "base_prefix")
+     :executable       (system-attribte "executable")
+     :exec-prefix      (system-attribte "exec_prefix")
+     :base-exec-prefix (system-attribte "base_exec_prefix")
+     :version          (py-system-version executable)}))
+
+(defn python-library-regex [system-info]
+  (let [{version  :version
+         platform :platform} system-info
+        [major minor micro]  (vec version)]
+    (re-pattern
+     (format
+      (condp (partial =) (keyword platform)
+        ;; TODO: not sure what the strings returned by
+        ;;   ..: mac and windows are for sys.platform
+        :linux   "libpython%s.%sm.so$"
+        :mac     "libpython%s.%sm.dylib$"
+        :windows "python%s.%sm.dll$")
+      major minor))))
+
+(defn python-library-paths
+  "Returns vector of matching python libraries in order of:
+  - virtual-env (library)
+  - installation prefix (library)
+  - default installation location
+  - virtual-env (executable)
+  - installation prefix (executable)
+  - default executable location"
+  [system-info python-regex]
+  (transduce
+   (comp
+    (map io/file)
+    (map file-seq)
+    cat
+    (map str)
+    (filter #(re-find python-regex %)))
+   (fn
+     ([[seen results]] results)
+     ([[seen? results] input]
+      (if (not (seen? input))
+        [(conj seen? input) (conj results input)]
+        [seen? results])))
+   ;; [seen? results]
+   [#{} []]
+   ((comp
+     vec
+     (juxt :base-prefix :prefix :base-exec-prefix :exec-prefix))
+    system-info)))
+
+(comment
+  ;; library paths workflow
+
+  (let [executable "python3.7"
+        system-info (python-system-info executable)
+        pyregex (python-library-regex system-info)]
+    (python-library-paths system-info pyregex))
+  ;;=> ["/usr/lib/x86_64-linux-gnu/libpython3.7m.so" "/usr/lib/python3.7/config-3.7m-x86_64-linux-gnu/libpython3.7m.so"]
+  )
+
+
 ;;All interpreters share the same type symbol table as types are uniform
 ;;across initializations.  So given an unknown item, we can in constant time
 ;;get the type of that item if we have seen it before.

From 8ec9452ff40179efbf02b9e0204311fb6b2087f1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 13 Dec 2019 15:20:56 -0700
Subject: [PATCH 074/456] Now have mxnet importing correctly into the docker
 container.

---
 dockerfiles/CondaDockerfile              |  1 +
 scripts/conda-repl                       |  9 +++++++++
 scripts/run-conda-docker                 |  2 +-
 src/libpython_clj/python/interpreter.clj | 19 ++++++++++++++-----
 4 files changed, 25 insertions(+), 6 deletions(-)
 create mode 100755 scripts/conda-repl

diff --git a/dockerfiles/CondaDockerfile b/dockerfiles/CondaDockerfile
index 038c986..1320a77 100644
--- a/dockerfiles/CondaDockerfile
+++ b/dockerfiles/CondaDockerfile
@@ -10,6 +10,7 @@ RUN apt-get -qq update && apt-get -qq -y install curl wget bzip2 openjdk-8-jdk-h
     && rm -rf /tmp/miniconda.sh \
     && conda install -y python=3 \
     && conda update conda \
+    && conda install -y mxnet numpy \
     && curl -O https://download.clojure.org/install/linux-install-1.10.1.492.sh \
     && chmod +x linux-install-1.10.1.492.sh \
     && ./linux-install-1.10.1.492.sh && rm linux-install-1.10.1.492.sh \
diff --git a/scripts/conda-repl b/scripts/conda-repl
new file mode 100755
index 0000000..45f6921
--- /dev/null
+++ b/scripts/conda-repl
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+source activate pyclj
+
+export LD_LIBRARY_PATH="/home/chrisn/.conda/envs/pyclj/lib"
+
+lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
+     -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
+     -- repl :headless :host localhost
diff --git a/scripts/run-conda-docker b/scripts/run-conda-docker
index d193f96..0e1688c 100755
--- a/scripts/run-conda-docker
+++ b/scripts/run-conda-docker
@@ -10,7 +10,7 @@ docker run --rm -it -u $(id -u):$(id -g) \
   -v /$HOME/.lein:/home/$USER/.lein \
   -v $(pwd)/:/libpython-clj \
   --net=host -w /libpython-clj \
-  docker-conda /bin/bash
+  docker-conda scripts/conda-repl
      # lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
      #   -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
      #   -- repl :headless :host localhost
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index d3c44ca..66b7906 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -5,7 +5,7 @@
             [libpython-clj.python.logging
              :refer [log-error log-warn log-info]]
             [tech.jna :as jna]
-            [clojure.java.shell :as sh]
+            [clojure.java.shell :refer [sh]]
             [clojure.java.io :as io]
             [clojure.string :as s]
             [clojure.tools.logging :as log]
@@ -356,7 +356,7 @@
 (defn- ignore-shell-errors
   [& args]
   (try
-    (apply sh/sh args)
+    (apply sh args)
     (catch Throwable e nil)))
 
 
@@ -399,15 +399,18 @@
 
 
 (defonce ^:private python-home-wide-ptr* (atom nil))
+(defonce ^:private python-path-wide-ptr* (atom nil))
 
 
 (defn- try-load-python-library!
-  [libname python-home-wide-ptr]
+  [libname python-home-wide-ptr python-path-wide-ptr]
   (try
     (jna/load-library libname)
     (alter-var-root #'libpy-base/*python-library* (constantly libname))
     (when python-home-wide-ptr
       (libpy/Py_SetPythonHome python-home-wide-ptr))
+    (when python-path-wide-ptr
+      (libpy/Py_SetProgramName python-path-wide-ptr))
     (libpy/Py_InitializeEx 0)
     libname
     (catch Exception e)))
@@ -451,13 +454,19 @@
                           :else
                           (libpy-base/library-names))]
       (reset! python-home-wide-ptr* nil)
+      (reset! python-path-wide-ptr* nil)
       (when python-home
         (append-java-library-path! java-library-path-addendum)
         ;;This can never be released if load-library succeeeds
-        (reset! python-home-wide-ptr* (jna/string->wide-ptr python-home)))
+        (reset! python-home-wide-ptr* (jna/string->wide-ptr python-home))
+        (reset! python-path-wide-ptr* (jna/string->wide-ptr
+                                       (format "%s/bin/python3"
+                                               python-home))))
       (loop [[library-name & library-names] library-names]
         (if (and library-name
-                 (not (try-load-python-library! library-name @python-home-wide-ptr*)))
+                 (not (try-load-python-library! library-name
+                                                @python-home-wide-ptr*
+                                                @python-path-wide-ptr*)))
           (recur library-names))))
     ;;Set program name
     (when-let [program-name (or program-name *program-name* "")]

From 2cafb93cb69ea61a66b374196d1244c4567a33ab Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 13 Dec 2019 21:14:46 -0700
Subject: [PATCH 075/456] correct ld config export

---
 scripts/conda-repl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/conda-repl b/scripts/conda-repl
index 45f6921..c39c4b3 100755
--- a/scripts/conda-repl
+++ b/scripts/conda-repl
@@ -2,7 +2,7 @@
 
 source activate pyclj
 
-export LD_LIBRARY_PATH="/home/chrisn/.conda/envs/pyclj/lib"
+export LD_LIBRARY_PATH="$(python3-config --prefix)/lib"
 
 lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
      -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\

From 4a9ae56c2de5f8143def337d61371471b44d8927 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 14 Dec 2019 13:41:25 -0700
Subject: [PATCH 076/456] Python-require issue.

---
 CHANGELOG.md                               |  6 ++++++
 src/libpython_clj/require.clj              | 17 +++++++++++------
 test/libpython_clj/require_python_test.clj |  5 ++++-
 3 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 716d0f9..ed2f42b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,12 @@
 # Time for a ChangeLog!
 
 
+## 1.25
+
+
+Fixed (with tests) major issue with require-python.
+
+
 ## 1.24
 
 
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 1a05ae7..2c19c48 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -219,10 +219,13 @@
         python-namespace (find-ns module-name-or-ns)
         this-module (import-module (str module-name))]
 
-    (when reload?
-      (remove-ns module-name)
-      (reload-module this-module))
-    (create-ns module-name-or-ns)
+    (cond
+      reload?
+      (do
+        (remove-ns module-name)
+        (reload-module this-module))
+      (not python-namespace)
+      (create-ns module-name-or-ns))
 
     ;; bind the python module to its symbolic name
     ;; in the current namespace
@@ -252,8 +255,10 @@
                            (into {}))]
 
       ;;Always make the loaded namespace available to the current namespace.
-      (intern current-ns-sym (with-meta module-name-or-ns
-                               {:doc (doc this-module)}))
+      (intern current-ns-sym
+              (with-meta module-name-or-ns
+                {:doc (doc this-module)})
+              this-module)
       (let [refer-symbols
             (cond
               ;; include everything into the current namespace,
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index 4eb3508..a0b16c5 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -1,5 +1,6 @@
 (ns libpython-clj.require-python-test
   (:require [libpython-clj.require :refer [require-python]]
+            [libpython-clj.python :as py]
             [clojure.test :refer :all]))
 
 
@@ -8,7 +9,8 @@
 
 (require-python '[math
                   :refer :*
-                  :exclude [sin cos]])
+                  :exclude [sin cos]
+                  :as pymath])
 
 
 (deftest base-require-test
@@ -17,4 +19,5 @@
     (is (contains? publics 'floor))
     (is (not (contains? publics 'sin)))
     (is (= 10.0 (double (floor 10.1))))
+    (is (= pymath (py/import-module "math")))
     (is (thrown? Throwable (require-python '[math :refer [blah]])))))

From edb80cd9c610c3b55b2b769cbbb317452e5d7d00 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 14 Dec 2019 13:41:57 -0700
Subject: [PATCH 077/456] 1.25

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 66c867b..985cefa 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.25-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.25"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From e7ef6ed3e40d4538672f3ff2beababf5db550ebc Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 14 Dec 2019 13:42:38 -0700
Subject: [PATCH 078/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 985cefa..d9103d4 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.25"
+(defproject cnuernber/libpython-clj "1.26-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 16da3d885f29bde59ea219c9438b9d3654387971 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sat, 14 Dec 2019 16:19:36 -0500
Subject: [PATCH 079/456] Multiple system calls -> single system call in python
 library path finding (#23)

* * tools for finding python library paths

* * change to single system call

* refactor symbol names

* refactor symbol names

* Update interpreter.clj

spacing
---
 src/libpython_clj/python/interpreter.clj | 50 +++++++++++++-----------
 1 file changed, 28 insertions(+), 22 deletions(-)

diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 66b7906..bee7435 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -27,19 +27,19 @@
   (System/identityHashCode obj))
 
 
-(defn py-system-attribute [executable attr]
+(defn python-system-data [executable]
   (let [{out :out err :err}
-        (sh executable
-            "-c"
-            (format "import sys,json; print(getattr(sys, '%s'))" attr))]
-    (clojure.string/trim out)))
-
-(defn py-system-version [executable]
-  (let [{out :out err :err}
-        (sh executable "-c"
-            (format "import sys, json; print(list(getattr(sys, 'version_info')[:3]))"))]
-    (json/parse-string out)))
-
+        (sh executable "-c" "import sys, json;
+print(json.dumps(
+{\"platform\":          sys.platform,
+  \"prefix\":           sys.prefix,
+  \"base_prefix\":      sys.base_prefix,
+  \"executable\":       sys.executable,
+  \"base_exec_prefix\": sys.base_exec_prefix,
+  \"exec_prefix\":      sys.exec_prefix,
+  \"version\":          list(sys.version_info)[:3]}))")]
+    (when (clojure.string/blank? err)
+      (json/parse-string out true))))
 
 (defn python-system-info
   "An information map about the Python system information provided
@@ -66,16 +66,22 @@
   :version
   (list python-major python-minor python-micro)"
   [executable]
-  (letfn [(system-attribte [x]
-            (py-system-attribute executable x))]
-
-    {:platform         (system-attribte "platform")
-     :prefix           (system-attribte "prefix")
-     :base-prefix      (system-attribte "base_prefix")
-     :executable       (system-attribte "executable")
-     :exec-prefix      (system-attribte "exec_prefix")
-     :base-exec-prefix (system-attribte "base_exec_prefix")
-     :version          (py-system-version executable)}))
+  (let [{platform         :platform
+         prefix           :prefix
+         base-prefix      :base_prefix
+         executable       :executable
+         exec-prefix      :exec_prefix
+         base-exec-prefix :base_exec_prefix
+         version          :version}
+        (python-system-data executable)]
+    {:platform         platform
+     :prefix           prefix
+     :base-prefix      base-prefix
+     :executable       executable
+     :exec-prefix      exec-prefix
+     :base-exec-prefix base-exec-prefix
+     :version          version}))
+
 
 (defn python-library-regex [system-info]
   (let [{version  :version

From e6718c1c08ac02c83a09616c703bb73de7b12abd Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sat, 14 Dec 2019 16:20:56 -0500
Subject: [PATCH 080/456] Issue 26 (Python generators in Clojure transducer
 context) (#27)

* add transducing converter

* add tests

* add sugar

* add sugar

* revert require.clj
---
 src/libpython_clj/sugar.clj       | 48 +++++++++++++++++++
 test/libpython_clj/sugar_test.clj | 79 +++++++++++++++++++++++++++++++
 2 files changed, 127 insertions(+)
 create mode 100644 src/libpython_clj/sugar.clj
 create mode 100644 test/libpython_clj/sugar_test.clj

diff --git a/src/libpython_clj/sugar.clj b/src/libpython_clj/sugar.clj
new file mode 100644
index 0000000..5972ca5
--- /dev/null
+++ b/src/libpython_clj/sugar.clj
@@ -0,0 +1,48 @@
+(ns libpython-clj.sugar
+  (:require [libpython-clj.python :as py]))
+
+
+(let [{{:strs [pyxfn]} :globals}
+      (py/run-simple-string "
+import collections
+
+
+class Deque:
+
+    def __init__(self):
+        self.q = collections.deque()
+
+    def __iter__(self):
+        while True:
+            yield next(self)
+
+    def __next__(self):
+        return self.q.popleft()
+
+
+    def append(self, x):
+        self.q.appendleft(x)
+
+    def pop(self):
+        self.q.popleft()
+
+
+def pyxfn(g, *args, **kwargs):
+    q = Deque()
+    gx = g(q, *args, **kwargs)
+    return q, gx
+")]
+  (def ^:private -pyxfn pyxfn))
+
+(let [builtins (py/import-module "builtins")
+      pynext   (py/get-attr builtins "next")]
+  (defn pyxfn
+    [g & args]
+    (fn [rf]
+      (let [[q gx] (apply -pyxfn g args)]
+        (fn
+          ([] (rf))
+          ([result] (rf result))
+          ([result input]
+           (py/$a q append input)
+           (rf result (pynext gx))))))))
diff --git a/test/libpython_clj/sugar_test.clj b/test/libpython_clj/sugar_test.clj
new file mode 100644
index 0000000..00adf24
--- /dev/null
+++ b/test/libpython_clj/sugar_test.clj
@@ -0,0 +1,79 @@
+(ns libpython-clj.sugar-test
+  (:require [libpython-clj.sugar :as pysug :reload true]
+            [clojure.test :refer :all]
+            [libpython-clj.python :as py]))
+
+(deftest test-pyxfn
+  (let [{{:strs [addem addx addxkwargs stringify addbang]} :globals}
+        (py/run-simple-string
+         "
+def addem(nums):
+    for num in nums:
+        yield num + num
+
+
+def addx(nums, x):
+    for num in nums:
+        yield num + x
+
+
+def addxkwargs(nums, *, x=None):
+    if x is None:
+        raise Exception('x should not be None')
+    for num in nums:
+        yield num + x
+
+
+def stringify(xs):
+    for x in xs:
+        yield str(x)
+
+
+def addbang(xs):
+    for x in xs:
+        yield '{}!'.format(x)
+")]
+    (is (= [0 2 4 6 8 10 12 14 16 18]
+           (into [] (pysug/pyxfn addem) (range 10))))
+
+    (is (= [1 2 3 4 5]
+           (into [] (pysug/pyxfn addx 1) (range 5))))
+
+    (is (= [1 2 3 4 5]
+           (into [] (pysug/pyxfn addxkwargs :x 1) (range 5))))
+
+    (is (= ["00!" "11!" "22!" "33!"]
+           (transduce
+            (comp
+             (pysug/pyxfn stringify)
+             (pysug/pyxfn addem)
+             (pysug/pyxfn addbang))
+            (completing conj)
+            []
+            (range 4)))) (is (= ["33!" "22!" "11!" "00!"]
+                                (transduce
+                                 (comp
+                                  (pysug/pyxfn stringify)
+                                  (pysug/pyxfn addem)
+                                  (pysug/pyxfn addbang))
+                                 (fn
+                                   ([result] ((comp vec reverse) result))
+                                   ([result input]
+                                    (conj result input)))
+                                 []
+                                 (range 4))))
+
+    (is (= [["22!" "33!"] ["00!" "11!"]]
+           (transduce
+            (comp
+             (pysug/pyxfn stringify)
+             (pysug/pyxfn addem)
+             (pysug/pyxfn addbang)
+             (partition-all 2))
+            (fn
+              ([result] ((comp vec reverse) result))
+              ([result input]
+               (conj result input)))
+            []
+            (range 4))))))
+

From 985ac7e6cba0840b03e83f0b8683de74f420673c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 14 Dec 2019 14:24:37 -0700
Subject: [PATCH 081/456] updating changelog

---
 CHANGELOG.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ed2f42b..f05e9a7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,15 @@
 # Time for a ChangeLog!
 
 
+## 1.26-SNAPSHOT
+
+
+
+* [python startup work](https://github.com/cnuernber/libpython-clj/commit/16da3d885f29bde59ea219c9438b9d3654387971)
+* [python generates & clojure transducers](https://github.com/cnuernber/libpython-clj/pull/27) 
+
+
+
 ## 1.25
 
 

From 170dc9a783fd8a9956baf7654b72c0528ee1938e Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sat, 14 Dec 2019 17:17:37 -0500
Subject: [PATCH 082/456] Issue 20 (require reload syntax) (#24)

* conform require-python to unary or binary flags

* refactor to parse-flags route

* remove spacing deltas

* remove spacing

* remove spacing

* readability

* fix tests

* fix tests

* merge master
---
 src/libpython_clj/require.clj              | 100 +++++++++++++++++----
 test/libpython_clj/require_python_test.clj |  31 ++++++-
 2 files changed, 114 insertions(+), 17 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 2c19c48..b2f88d2 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -191,16 +191,84 @@
     (intern fn-ns (with-meta fn-sym (py-fn-metadata fn-name f
                                                     options)) f)))
 
+(defn- parse-flags
+  "FSM style parser for flags.  Designed to support both
+  unary style flags aka '[foo :reload] and
+  boolean flags '[foo :reload true] to support Clojure
+  style 'require syntax.  Possibly overengineered."
+  [supported-flags reqs]
+  
+  (letfn [(supported-flag-item
+            ;; scanned a supported tag token
+            [supported-flags flag results item items]
+            (cond
+              ;; add flag, continue scanning
+              (true? item) (next-flag-item
+                            supported-flags
+                            (conj results flag)
+                            (first items)
+                            (rest items))
+
+              ;; don't add flag, continue scanning
+              (false? item) (next-flag-item
+                             supported-flags
+                             results
+                             (first items)
+                             (rest items))
+
+              
+              :else
+              ;; unary flag -- add flag but scan current item/s
+              (next-flag-item
+               supported-flags
+               (conj  results flag)
+               item
+               items)))
+
+
+          ;; scan flags
+          (next-flag-item [supported-flags results item items]
+            (cond
+              ;; supported flag scanned, begin FSM parse
+              (get supported-flags item)
+              (let [flag            (get supported-flags item)
+                    remaining-flags (clojure.set/difference
+                                     supported-flags #{flag})]
+                (supported-flag-item
+                 remaining-flags
+                 flag
+                 results
+                 (first items)
+                 (rest items)))
+
+              ;; FSM complete
+              (nil? item) (into #{} results)
+
+              ;; no flag scanned, continue scanning
+              :else (recur
+                     supported-flags
+                     results
+                     (first items)
+                     (rest items))))
+
+          ;; entrypoint
+          (get-flags [supported-flags reqs]
+            (next-flag-item supported-flags
+                            []
+                            (first reqs)
+                            (rest reqs)))]
+    (trampoline get-flags supported-flags reqs)))
+
+
 
 (defn ^:private load-python-lib [req]
   (let [supported-flags     #{:reload :no-arglists}
         [module-name & etc] req
-        flags               (into #{}
-                                  (filter supported-flags)
-                                  etc)
+        flags               (flags* supported-flags etc)
         etc                 (into {}
                                   (comp
                                    (remove supported-flags)
+                                   (remove boolean?)
                                    (partition-all 2)
                                    (map vec))
                                   etc)
@@ -208,16 +276,16 @@
         no-arglists?        (:no-arglists flags)
         module-name-or-ns   (:as etc module-name)
         exclude             (into #{} (:exclude etc))
-        refer          (cond
-                         (= :all (:refer etc)) #{:all}
-                         (= :* (:refer etc))   #{:*}
-                         :else                 (into
-                                                #{}
-                                                (:refer etc)))
-        current-ns     *ns*
-        current-ns-sym (symbol (str current-ns))
-        python-namespace (find-ns module-name-or-ns)
-        this-module (import-module (str module-name))]
+        refer               (cond
+                              (= :all (:refer etc)) #{:all}
+                              (= :* (:refer etc))   #{:*}
+                              :else                 (into
+                                                     #{}
+                                                     (:refer etc)))
+        current-ns          *ns*
+        current-ns-sym      (symbol (str current-ns))
+        python-namespace    (find-ns module-name-or-ns)
+        this-module         (import-module (str module-name))]
 
     (cond
       reload?
@@ -250,9 +318,9 @@
 
     (let [python-namespace (find-ns module-name-or-ns)
           ;;ns-publics is a map of symbol to var.  Var's have metadata on them.
-          public-data (->> (ns-publics python-namespace)
-                           (remove #(exclude (first %)))
-                           (into {}))]
+          public-data      (->> (ns-publics python-namespace)
+                                (remove #(exclude (first %)))
+                                (into {}))]
 
       ;;Always make the loaded namespace available to the current namespace.
       (intern current-ns-sym
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index a0b16c5..6ff616e 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -1,5 +1,5 @@
 (ns libpython-clj.require-python-test
-  (:require [libpython-clj.require :refer [require-python]]
+  (:require [libpython-clj.require :as req :refer [require-python]]
             [libpython-clj.python :as py]
             [clojure.test :refer :all]))
 
@@ -21,3 +21,32 @@
     (is (= 10.0 (double (floor 10.1))))
     (is (= pymath (py/import-module "math")))
     (is (thrown? Throwable (require-python '[math :refer [blah]])))))
+
+
+(deftest parse-flags-test
+  ;; sanity check
+  (is (= #{:reload :foo}
+         #{:foo :reload}))
+  (let [parse-flags #'req/parse-flags]
+    (is (= #{:reload} (parse-flags
+                       #{:reload}
+                       '[:reload foo])))
+    (is (= #{} (parse-flags #{} '[:reload foo])))
+    (is (= #{:reload} (parse-flags #{:reload} '[:reload true])))
+    (is (= #{:reload} (parse-flags #{:reload} '[:reload :as foo])))
+    (is (= #{:reload} (parse-flags #{:reload} '[:reload foo :as])))
+    (is (= #{:reload} (parse-flags #{:reload} '[foo :reload :as bar])))
+    (is (= #{} (parse-flags #{:reload} '[:reload false])))
+    (is (= #{} (parse-flags #{:reload} '[:reload false :reload])))
+    (is (= #{} (parse-flags #{:reload} '[:reload false :reload true])))
+    (is (= #{:reload} (parse-flags  #{:reload} '[:reload :reload false])))
+    (is (= #{:reload} (parse-flags #{:reload} '[:reload true :reload false])))
+    (is (= #{:a :b}) (parse-flags #{:a :b} '[:a true :b]))
+    (is (= #{:a :b}) (parse-flags #{:a :b} '[:a :b]))
+    (is (= #{:a :b} (parse-flags #{:a :b} '[:a true :b])))
+    (is (= #{:a :b} (parse-flags #{:a :b} '[:a  :b true])))
+    (is (= #{:a :b} (parse-flags #{:a :b} '[:a  true :b true])))
+    (is (= #{:b} (parse-flags #{:a :b} '[:a  false :b true])))
+    (is (= #{:b} (parse-flags #{:a :b} '[:b true :a false])))
+    (is (= #{:b} (parse-flags #{:a :b} '[:b :a false])))
+    (is (= #{:b} (parse-flags #{:a :b} '[:b :a false :a true])))))

From 3bc16d343ee4bf7e9a70d8d14a595fbfeaf8a889 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 14 Dec 2019 15:31:11 -0700
Subject: [PATCH 083/456] small merge issue.

---
 src/libpython_clj/require.clj | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index b2f88d2..684464e 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -197,7 +197,7 @@
   boolean flags '[foo :reload true] to support Clojure
   style 'require syntax.  Possibly overengineered."
   [supported-flags reqs]
-  
+
   (letfn [(supported-flag-item
             ;; scanned a supported tag token
             [supported-flags flag results item items]
@@ -216,7 +216,7 @@
                              (first items)
                              (rest items))
 
-              
+
               :else
               ;; unary flag -- add flag but scan current item/s
               (next-flag-item
@@ -264,7 +264,7 @@
 (defn ^:private load-python-lib [req]
   (let [supported-flags     #{:reload :no-arglists}
         [module-name & etc] req
-        flags               (flags* supported-flags etc)
+        flags               (parse-flags supported-flags etc)
         etc                 (into {}
                                   (comp
                                    (remove supported-flags)

From 4084ddfcd271a9c336bf67aa163c17cc3e945a44 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 14 Dec 2019 16:17:01 -0700
Subject: [PATCH 084/456] 1.26

---
 project.clj                   | 2 +-
 src/libpython_clj/require.clj | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/project.clj b/project.clj
index d9103d4..a78f432 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.26-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.26"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 684464e..80d5d3d 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -291,7 +291,8 @@
       reload?
       (do
         (remove-ns module-name)
-        (reload-module this-module))
+        (reload-module this-module)
+        (create-ns module-name-or-ns))
       (not python-namespace)
       (create-ns module-name-or-ns))
 

From 09ca9e3c547d9d549b456d61b49289fed943b4cd Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 14 Dec 2019 16:17:20 -0700
Subject: [PATCH 085/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index a78f432..5831f26 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.26"
+(defproject cnuernber/libpython-clj "1.27-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 70c2ae842eb34c85380f488c01e03a064cb2341e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 14 Dec 2019 16:19:01 -0700
Subject: [PATCH 086/456] Changelog update

---
 CHANGELOG.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f05e9a7..c48d224 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,12 +1,13 @@
 # Time for a ChangeLog!
 
 
-## 1.26-SNAPSHOT
-
+## 1.26
 
 
 * [python startup work](https://github.com/cnuernber/libpython-clj/commit/16da3d885f29bde59ea219c9438b9d3654387971)
 * [python generates & clojure transducers](https://github.com/cnuernber/libpython-clj/pull/27) 
+* [requre-python reload fix](https://github.com/cnuernber/libpython-clj/pull/24)
+* Bugfix with require-python :reload semantics.
 
 
 

From b2c4ba7974a732d4c1f086bfaf6e81d0d23fe304 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sun, 15 Dec 2019 11:11:39 -0500
Subject: [PATCH 087/456] Issue 25 - data driven require.clj pathway (#28)

* light overhaul; tests added

* whitespace

* formatting
---
 src/libpython_clj/require.clj              | 233 +++++++++++++--------
 test/libpython_clj/require_python_test.clj |  78 ++++++-
 2 files changed, 219 insertions(+), 92 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 80d5d3d..f738dac 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -81,7 +81,6 @@
     (number? x) ""
     :else (py-class-argspec x)))
 
-
 (defn pyarglists
   ([argspec] (pyarglists argspec
                          (if-let [defaults
@@ -142,10 +141,6 @@
                              {:or or-map})
                            (when (not-empty as-varkw)
                              as-varkw))
-
-
-
-
          opt-args
          (cond
            (and (empty? kwargs-map)
@@ -168,7 +163,6 @@
          arglists
          (recur argspec' defaults' arglists))))))
 
-
 (defn py-fn-metadata [fn-name x {:keys [no-arglists?]}]
   (let [fn-argspec (pyargspec x)
         fn-docstr  (get-pydoc x)]
@@ -183,7 +177,6 @@
          (catch Throwable e
            nil))))))
 
-
 (defn ^:private load-py-fn [f fn-name fn-module-name-or-ns
                             options]
   (let [fn-ns      (symbol (str fn-module-name-or-ns))
@@ -215,8 +208,6 @@
                              results
                              (first items)
                              (rest items))
-
-
               :else
               ;; unary flag -- add flag but scan current item/s
               (next-flag-item
@@ -225,7 +216,6 @@
                item
                items)))
 
-
           ;; scan flags
           (next-flag-item [supported-flags results item items]
             (cond
@@ -259,9 +249,37 @@
                             (rest reqs)))]
     (trampoline get-flags supported-flags reqs)))
 
-
-
-(defn ^:private load-python-lib [req]
+(defn- extract-refer-symbols
+  [{:keys [refer this-module]} public-data]
+  (cond
+    ;; include everything into the current namespace,
+    ;; ignore __all__ directive
+    (or (refer :all)
+        (and (not (py/has-attr? this-module "__all__"))
+             (refer :*)))
+    (keys public-data)
+    ;; only include that specfied by __all__ attribute
+    ;; of python module if specified, else same as :all
+    (refer :*)
+    (->> (py/get-attr this-module "__all__")
+         (map (fn [item-name]
+                (let [item-sym (symbol item-name)]
+                  (when (contains? public-data item-sym)
+                    item-sym))))
+         (remove nil?))
+
+    ;; [.. :refer [..]] behavior
+    :else
+    (do
+      (when-let [missing (->> refer
+                              (remove (partial contains? public-data))
+                              seq)]
+        (throw (Exception.
+                (format "'refer' symbols not found: %s"
+                        (vec missing)))))
+      refer)))
+
+(defn ^:private python-lib-configuration [req]
   (let [supported-flags     #{:reload :no-arglists}
         [module-name & etc] req
         flags               (parse-flags supported-flags etc)
@@ -286,80 +304,122 @@
         current-ns-sym      (symbol (str current-ns))
         python-namespace    (find-ns module-name-or-ns)
         this-module         (import-module (str module-name))]
+    {:supported-flags   supported-flags
+     :etc               etc
+     :reload?           reload?
+     :no-arglists?      no-arglists?
+     :module-name       module-name
+     :module-name-or-ns module-name-or-ns
+     :exclude           exclude
+     :refer             refer
+     :current-ns        current-ns
+     :current-ns-sym    current-ns-sym
+     :python-namespace  python-namespace
+     :this-module       this-module}))
+
+(defn- extract-public-data
+  [{:keys [exclude python-namespace module-name-or-ns]}]
+  (let [python-namespace
+        (or python-namespace
+            (find-ns module-name-or-ns))]
+    (->> (ns-publics python-namespace)
+         (remove #(exclude (first %)))
+         (into {}))))
+
+(defn- reload-python-ns!
+  [module-name this-module module-name-or-ns]
+  (do
+    (remove-ns module-name)
+    (reload-module this-module)
+    (create-ns module-name-or-ns)))
+
+(defn- create-python-ns!
+  [module-name-or-ns]
+  (create-ns module-name-or-ns))
+
+(defn ^:private maybe-reload-or-create-ns!
+  [{:keys            [reload?
+                      this-module
+                      module-name
+                      module-name-or-ns]
+    python-namespace :python-namespace}]
+  (cond
+    reload?                (reload-python-ns! module-name
+                                              this-module
+                                              module-name-or-ns)
+    (not python-namespace) (create-python-ns! module-name-or-ns)))
+
+(defn enhanced-python-lib-configuration
+  [{:keys [python-namespace exclude this-module]
+    :as   lib-config}]
+  (let [public-data (extract-public-data lib-config)]
+    (merge
+     lib-config
+     {:public-data   public-data
+      :refer-symbols (extract-refer-symbols lib-config
+                                            public-data)})))
+
+(defn- bind-py-symbols-to-ns!
+  [{:keys [reload?
+           python-namespace
+           this-module
+           module-name-or-ns
+           no-arglists?]}]
+  (when (or reload? (not python-namespace))
+    ;;Mutably define the root namespace.
+    (doseq [[att-name v] (vars this-module)]
+      (try
+        (when v
+          (if (py/callable? v)
+            (load-py-fn v (symbol att-name) module-name-or-ns
+                        {:no-arglists?
+                         no-arglists?})
+            (intern module-name-or-ns (symbol att-name) v)))
+        (catch Throwable e
+          (log/warnf e "Failed to require symbol %s" att-name))))))
+
+(defn- bind-module-ns!
+  [{:keys [current-ns-sym module-name-or-ns this-module]}]
+  (intern current-ns-sym
+          (with-meta module-name-or-ns
+            {:doc (doc this-module)})
+          this-module))
+
+(defn- intern-public-and-refer-symbols!
+  [{:keys [public-data refer-symbols current-ns-sym]}]
+  (doseq [[s v] (select-keys public-data refer-symbols)]
+    (intern current-ns-sym
+            (with-meta s (meta v))
+            (deref v))))
+
+(defn preload-python-lib! [req]
+  (let [lib-config (python-lib-configuration req)]
+    (maybe-reload-or-create-ns! lib-config)
+    (bind-py-symbols-to-ns! lib-config)
+    (bind-module-ns! lib-config)
+    (enhanced-python-lib-configuration lib-config)))
 
-    (cond
-      reload?
-      (do
-        (remove-ns module-name)
-        (reload-module this-module)
-        (create-ns module-name-or-ns))
-      (not python-namespace)
-      (create-ns module-name-or-ns))
-
-    ;; bind the python module to its symbolic name
-    ;; in the current namespace
-
-
-    ;; create namespace for module and bind python
-    ;; values to namespace symbols
-    (when (or reload?
-              (not python-namespace))
-      ;;Mutably define the root namespace.
-      (doseq [[att-name v] (vars this-module)]
-        (try
-          (when v
-            (if (py/callable? v)
-              (load-py-fn v (symbol att-name) module-name-or-ns
-                          {:no-arglists?
-                           no-arglists?})
-              (intern module-name-or-ns (symbol att-name) v)))
-          (catch Throwable e
-            (log/warnf e "Failed to require symbol %s" att-name)))))
-
-
-    (let [python-namespace (find-ns module-name-or-ns)
-          ;;ns-publics is a map of symbol to var.  Var's have metadata on them.
-          public-data      (->> (ns-publics python-namespace)
-                                (remove #(exclude (first %)))
-                                (into {}))]
-
-      ;;Always make the loaded namespace available to the current namespace.
-      (intern current-ns-sym
-              (with-meta module-name-or-ns
-                {:doc (doc this-module)})
-              this-module)
-      (let [refer-symbols
-            (cond
-              ;; include everything into the current namespace,
-              ;; ignore __all__ directive
-              (or (refer :all)
-                  (and (not (py/has-attr? this-module "__all__"))
-                       (refer :*)))
-              (keys public-data)
-              ;; only include that specfied by __all__ attribute
-              ;; of python module if specified, else same as :all
-              (refer :*)
-              (->> (py/get-attr this-module "__all__")
-                   (map (fn [item-name]
-                          (let [item-sym (symbol item-name)]
-                            (when (contains? public-data item-sym)
-                              item-sym))))
-                   (remove nil?))
-
-              ;; [.. :refer [..]] behavior
-              :else
-              (do
-                (when-let [missing (->> refer
-                                        (remove (partial contains? public-data))
-                                        seq)]
-                  (throw (Exception.
-                          (format "'refer' symbols not found: %s"
-                                  (vec missing)))))
-                refer))]
-        (doseq [[s v] (select-keys public-data refer-symbols)]
-          (intern current-ns-sym
-                  (with-meta s (meta v))
-                  (deref v)))))))
+(defn ^:private load-python-lib [req]
+  (let [{:keys [supported-flags
+                flags
+                etc
+                reload?
+                no-arglists?
+                module-name
+                module-name-or-ns
+                exclude
+                refer
+                current-ns
+                current-ns-sym
+                python-namespace
+                this-module
+                python-namespace
+                public-data
+                refer-symbols]
+         :as   lib-config}
+        (preload-python-lib! req)]
+
+    (intern-public-and-refer-symbols! lib-config)))
 
 (defn require-python
   "## Basic usage ##
@@ -438,3 +498,4 @@
     (load-python-lib (vector reqs))
     (vector? reqs)
     (load-python-lib reqs)))
+
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index 6ff616e..0076a50 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -1,16 +1,17 @@
 (ns libpython-clj.require-python-test
-  (:require [libpython-clj.require :as req :refer [require-python]]
+  (:require [libpython-clj.require :as req :refer [require-python]
+             :reload true]
             [libpython-clj.python :as py]
             [clojure.test :refer :all]))
 
-
-;;Since this test mutates the global environment we have to accept that
-;;it may not always work.
+;; Since this test mutates the global environment we have to accept that
+;; it may not always work.
 
 (require-python '[math
                   :refer :*
                   :exclude [sin cos]
-                  :as pymath])
+                  :as pymath
+                  :reload true])
 
 
 (deftest base-require-test
@@ -22,7 +23,6 @@
     (is (= pymath (py/import-module "math")))
     (is (thrown? Throwable (require-python '[math :refer [blah]])))))
 
-
 (deftest parse-flags-test
   ;; sanity check
   (is (= #{:reload :foo}
@@ -50,3 +50,69 @@
     (is (= #{:b} (parse-flags #{:a :b} '[:b true :a false])))
     (is (= #{:b} (parse-flags #{:a :b} '[:b :a false])))
     (is (= #{:b} (parse-flags #{:a :b} '[:b :a false :a true])))))
+
+(deftest python-lib-configuration-test
+  (let [python-lib-configuration #'req/python-lib-configuration
+        simple-req               '[csv]
+        simple-spec              (python-lib-configuration simple-req)
+        {:keys [exclude
+                supported-flags
+                current-ns-sym
+                module-name
+                module-name-or-ns
+                reload?
+                no-arglists?
+                etc
+                current-ns
+                this-module
+                python-namespace
+                refer]}          simple-spec
+        csv-module               (py/import-module "csv")]
+
+    ;; no exclusions
+    (is (= #{} exclude))
+    (is (= #{:no-arglists :reload} supported-flags))
+    (is (= 'libpython-clj.require-python-test
+           current-ns-sym
+           (symbol (str current-ns))))
+    (is (= 'csv module-name module-name-or-ns))
+    (is (nil? reload?))
+    (is (nil? no-arglists?))
+    (is (= {} etc))
+    (is (= csv-module this-module)))
+
+
+  (let [python-lib-configuration #'req/python-lib-configuration
+        simple-req               '[requests
+                                   :reload true
+                                   :refer [get]
+                                   :no-arglists]
+        simple-spec              (python-lib-configuration simple-req)
+        {:keys [exclude
+                supported-flags
+                current-ns-sym
+                module-name
+                module-name-or-ns
+                reload?
+                no-arglists?
+                etc
+                current-ns
+                this-module
+                python-namespace
+                refer]}          simple-spec
+        requests-module          (py/import-module "requests")]
+
+    ;; no exclusions
+    (is (= #{} exclude))
+    (is (= #{:no-arglists :reload} supported-flags))
+    (is (= 'libpython-clj.require-python-test
+           current-ns-sym
+           (symbol (str  current-ns))))
+    (is (= 'requests module-name module-name-or-ns))
+    (is (= reload? :reload))
+    (is (= no-arglists? :no-arglists))
+    (is (= { :refer '[get]}) etc)
+    (is (= requests-module this-module))
+    (is (= #{'get} refer))
+    (is (nil? python-namespace))))
+

From b26a4857a9a83abc6b31eefd9adb1f818ab1a097 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 15 Dec 2019 09:15:37 -0700
Subject: [PATCH 088/456] Getting CI going.

---
 .travis.yml                         |  8 ++++++++
 src/libpython_clj/python/bridge.clj |  2 +-
 src/libpython_clj/python/object.clj |  3 ++-
 test/libpython_clj/python_test.clj  | 16 ++++++++++++++--
 4 files changed, 25 insertions(+), 4 deletions(-)
 create mode 100644 .travis.yml

diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 0000000..0cc5d0c
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,8 @@
+language: clojure
+lein: 2.8.2
+before_install:
+  - sudo apt-get -y install python3
+  - sudo python3 -mpip install numpy
+addons:
+  apt:
+    update: true
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index 9dd4e82..5566e90 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -115,7 +115,7 @@
 (defn as-python
   "Bridge a jvm object into python"
   [item & [options]]
-  (if (not item)
+  (if (nil? item)
     (py-none)
     (py-proto/as-python item options)))
 
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index ecf7e42..8c9dbc7 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -790,7 +790,8 @@
     (with-gil
       (-> (cond
             (seq kw-arg-map)
-            (libpy/PyObject_Call callable (->py-tuple arglist)
+            (libpy/PyObject_Call callable
+                                 (->py-tuple arglist)
                                  (->py-dict kw-arg-map))
             (seq arglist)
             (libpy/PyObject_CallObject callable (->py-tuple arglist))
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 306e1cb..57e9497 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -1,16 +1,18 @@
 (ns libpython-clj.python-test
   (:require [libpython-clj.python :as py]
+            [libpython-clj.jna :as libpy]
             [tech.v2.datatype :as dtype]
             [tech.v2.datatype.functional :as dfn]
             [tech.v2.tensor :as dtt]
+            [tech.jna :as jna]
             [clojure.test :refer :all])
   (:import [java.io StringWriter]
-           [java.util Map List]))
+           [java.util Map List]
+           [com.sun.jna Pointer]))
 
 (py/initialize!)
 
 
-
 (deftest stdout-and-stderr
   (is (= "hey\n" (with-out-str
                    (py/run-simple-string "print('hey')"))))
@@ -307,3 +309,13 @@
                      (py/$a array (range 10)))]
     (is (dfn/equals (dtt/->tensor (range 10))
                     (py/as-tensor ary-data)))))
+
+
+(deftest false-is-always-py-false
+  (let [py-false (libpy/Py_False)
+        ->false (py/->python false)
+        as-false (py/as-python false)]
+    (is (= (Pointer/nativeValue (jna/as-ptr py-false))
+           (Pointer/nativeValue (jna/as-ptr ->false))))
+    (is (= (Pointer/nativeValue (jna/as-ptr py-false))
+           (Pointer/nativeValue (jna/as-ptr as-false))))))

From 28e3949b5eca75c1405b72c2114a48996941e6c8 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 15 Dec 2019 09:33:50 -0700
Subject: [PATCH 089/456] fixing unit tests.  Testing travis.

---
 src/libpython_clj/require.clj              |  9 ++++++---
 test/libpython_clj/require_python_test.clj | 11 +++++++----
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index f738dac..5e1932c 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -279,7 +279,11 @@
                         (vec missing)))))
       refer)))
 
-(defn ^:private python-lib-configuration [req]
+
+(defn- python-lib-configuration
+  "Build a configuration map of a python library.  Current ns is option and used
+  during testing but unnecessary during normal running events."
+  [req & [current-ns]]
   (let [supported-flags     #{:reload :no-arglists}
         [module-name & etc] req
         flags               (parse-flags supported-flags etc)
@@ -300,7 +304,7 @@
                               :else                 (into
                                                      #{}
                                                      (:refer etc)))
-        current-ns          *ns*
+        current-ns          (or current-ns *ns*)
         current-ns-sym      (symbol (str current-ns))
         python-namespace    (find-ns module-name-or-ns)
         this-module         (import-module (str module-name))]
@@ -498,4 +502,3 @@
     (load-python-lib (vector reqs))
     (vector? reqs)
     (load-python-lib reqs)))
-
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index 0076a50..79de85a 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -54,7 +54,9 @@
 (deftest python-lib-configuration-test
   (let [python-lib-configuration #'req/python-lib-configuration
         simple-req               '[csv]
-        simple-spec              (python-lib-configuration simple-req)
+        simple-spec              (python-lib-configuration
+                                  simple-req
+                                  (find-ns 'libpython-clj.require-python-test))
         {:keys [exclude
                 supported-flags
                 current-ns-sym
@@ -87,7 +89,9 @@
                                    :reload true
                                    :refer [get]
                                    :no-arglists]
-        simple-spec              (python-lib-configuration simple-req)
+        simple-spec              (python-lib-configuration
+                                  simple-req
+                                  (find-ns 'libpython-clj.require-python-test))
         {:keys [exclude
                 supported-flags
                 current-ns-sym
@@ -111,8 +115,7 @@
     (is (= 'requests module-name module-name-or-ns))
     (is (= reload? :reload))
     (is (= no-arglists? :no-arglists))
-    (is (= { :refer '[get]}) etc)
+    (is (= {:refer '[get]} etc))
     (is (= requests-module this-module))
     (is (= #{'get} refer))
     (is (nil? python-namespace))))
-

From face68f7a154c9c5ba3129d3a85e256e06220e68 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 15 Dec 2019 09:35:25 -0700
Subject: [PATCH 090/456] travis hacking.

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 0cc5d0c..0d45a34 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,7 @@
 language: clojure
 lein: 2.8.2
 before_install:
-  - sudo apt-get -y install python3
+  - sudo apt-get -y install python3 python3-pip
   - sudo python3 -mpip install numpy
 addons:
   apt:

From 33ed81ea57fea429fd3360b6ca374c1d3129cf84 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 15 Dec 2019 09:39:48 -0700
Subject: [PATCH 091/456] adding travis.

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 3cde429..7b222ce 100644
--- a/README.md
+++ b/README.md
@@ -3,6 +3,7 @@
 JNA libpython bindings to the tech ecosystem.
 
 [![Clojars Project](https://img.shields.io/clojars/v/cnuernber/libpython-clj.svg)](https://clojars.org/cnuernber/libpython-clj)
+[![travis integration](https://travis-ci.com/cnuernber/libpython-clj.svg?branch=master)](https://travis-ci.com/cnuernber/libpython-clj)
 
 * Bridge between JVM objects and Python objects easily; use Python in your Java and
   use some Java in your Python.

From 081cc7e2c51f7b5dd49f3e12b79235bcce58cd66 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 15 Dec 2019 09:45:47 -0700
Subject: [PATCH 092/456] 1.27

---
 CHANGELOG.md | 10 +++++++++-
 project.clj  |  2 +-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c48d224..ed73d5f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,11 +1,19 @@
 # Time for a ChangeLog!
 
 
+## 1.27
+
+* Fixed bug where (as-python {:is_train false}) results in a dictionary with a none
+  value instead of a false value.  This was found through hours of debugging why
+  mxnet's forward function call was returning different values in clojure than in
+  python.
+
+
 ## 1.26
 
 
 * [python startup work](https://github.com/cnuernber/libpython-clj/commit/16da3d885f29bde59ea219c9438b9d3654387971)
-* [python generates & clojure transducers](https://github.com/cnuernber/libpython-clj/pull/27) 
+* [python generates & clojure transducers](https://github.com/cnuernber/libpython-clj/pull/27)
 * [requre-python reload fix](https://github.com/cnuernber/libpython-clj/pull/24)
 * Bugfix with require-python :reload semantics.
 
diff --git a/project.clj b/project.clj
index 5831f26..daee8b1 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.27-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.27"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From e29cf80d767bdb28411c827fbe13ec490724fa80 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 15 Dec 2019 09:45:58 -0700
Subject: [PATCH 093/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index daee8b1..b82d48e 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.27"
+(defproject cnuernber/libpython-clj "1.28-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 0223778e93ef81f5f81160baef8f6229cda432ec Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 15 Dec 2019 10:35:07 -0700
Subject: [PATCH 094/456] Using new pathway that queries python executable for
 lib info.

---
 src/libpython_clj/python/interpreter.clj | 82 +++++++++++-------------
 1 file changed, 38 insertions(+), 44 deletions(-)

diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index bee7435..aa560bb 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -28,7 +28,7 @@
 
 
 (defn python-system-data [executable]
-  (let [{out :out err :err}
+  (let [{:keys [out err exit]}
         (sh executable "-c" "import sys, json;
 print(json.dumps(
 {\"platform\":          sys.platform,
@@ -38,7 +38,7 @@ print(json.dumps(
   \"base_exec_prefix\": sys.base_exec_prefix,
   \"exec_prefix\":      sys.exec_prefix,
   \"version\":          list(sys.version_info)[:3]}))")]
-    (when (clojure.string/blank? err)
+    (when (= 0 exit)
       (json/parse-string out true))))
 
 (defn python-system-info
@@ -136,6 +136,41 @@ print(json.dumps(
   ;;=> ["/usr/lib/x86_64-linux-gnu/libpython3.7m.so" "/usr/lib/python3.7/config-3.7m-x86_64-linux-gnu/libpython3.7m.so"]
   )
 
+(defn- ignore-shell-errors
+  [& args]
+  (try
+    (apply sh args)
+    (catch Throwable e nil)))
+
+
+(defn detect-startup-info
+  [{:keys [library-path python-home]}]
+  (let [executable "python3"
+        system-info (python-system-info executable)
+        python-home (cond
+                      python-home
+                      python-home
+                      (seq (System/getenv "PYTHONHOME"))
+                      (System/getenv "PYTHONHOME")
+                      :else
+                      (:prefix system-info))
+        java-library-path-addendum (when python-home
+                                     (-> (Paths/get python-home
+                                                    (into-array String ["lib"]))
+                                         (.toString)))
+        [ver-maj ver-med _ver-min] (:version system-info)
+        lib-version (format "%s.%s" ver-maj ver-med)
+        libname (or library-path
+                    (when (seq lib-version)
+                      (str "python" lib-version "m")))
+        retval
+        {:python-home python-home
+         :lib-version lib-version
+         :libname libname
+         :java-library-path-addendum java-library-path-addendum}]
+    (log/infof "Startup info detected: %s" retval)
+    retval))
+
 
 ;;All interpreters share the same type symbol table as types are uniform
 ;;across initializations.  So given an unknown item, we can in constant time
@@ -358,27 +393,6 @@ print(json.dumps(
 
 
 
-
-(defn- ignore-shell-errors
-  [& args]
-  (try
-    (apply sh args)
-    (catch Throwable e nil)))
-
-
-(defn- find-python-home
-  [& [python-home]]
-  (cond
-    python-home
-    python-home
-    (seq (System/getenv "PYTHONHOME"))
-    (System/getenv "PYTHONHOME")
-    :else
-    (let [{:keys [out err exit]} (ignore-shell-errors "python3-config" "--prefix")]
-      (when (= 0 exit)
-        (s/trimr out)))))
-
-
 (defn- find-python-lib-version
   []
   (let [{:keys [out err exit]} (ignore-shell-errors "python3" "--version")]
@@ -422,29 +436,9 @@ print(json.dumps(
     (catch Exception e)))
 
 
-(defn detect-startup-info
-  [{:keys [library-path python-home]}]
-  (let [python-home (find-python-home python-home)
-        java-library-path-addendum
-        (when python-home
-          (-> (Paths/get python-home (into-array String ["lib"]))
-              (.toString)))
-        lib-version (find-python-lib-version)
-        libname (when (seq lib-version)
-                  (str "python" lib-version "m"))
-        retval
-        {:python-home python-home
-         :lib-version lib-version
-         :libname libname
-         :java-library-path-addendum java-library-path-addendum}]
-    (log/infof "Startup info detected: %s" retval)
-    retval))
-
-
 (defn initialize!
   [& {:keys [program-name
-             library-path
-             python-home]
+             library-path]
       :as options}]
   (when-not @*main-interpreter*
     (log-info "Executing python initialize!")

From ef1ec57cfc83b47279b5f0cdae6ccd47ee53dbe5 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 15 Dec 2019 10:35:54 -0700
Subject: [PATCH 095/456] Adding comments to repl starter

---
 scripts/conda-repl | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/scripts/conda-repl b/scripts/conda-repl
index c39c4b3..94e04c0 100755
--- a/scripts/conda-repl
+++ b/scripts/conda-repl
@@ -2,6 +2,8 @@
 
 source activate pyclj
 
+## This is absolutely necessary.
+## https://github.com/conda/conda/issues/9500#issuecomment-565753807
 export LD_LIBRARY_PATH="$(python3-config --prefix)/lib"
 
 lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\

From 87be94fb8ee5da2a67cd85f9efb477acb689bee8 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sun, 15 Dec 2019 14:29:35 -0500
Subject: [PATCH 096/456] remove failing unit tests (#31)

---
 test/libpython_clj/require_python_test.clj | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index 79de85a..17240d5 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -74,9 +74,6 @@
     ;; no exclusions
     (is (= #{} exclude))
     (is (= #{:no-arglists :reload} supported-flags))
-    (is (= 'libpython-clj.require-python-test
-           current-ns-sym
-           (symbol (str current-ns))))
     (is (= 'csv module-name module-name-or-ns))
     (is (nil? reload?))
     (is (nil? no-arglists?))
@@ -109,9 +106,6 @@
     ;; no exclusions
     (is (= #{} exclude))
     (is (= #{:no-arglists :reload} supported-flags))
-    (is (= 'libpython-clj.require-python-test
-           current-ns-sym
-           (symbol (str  current-ns))))
     (is (= 'requests module-name module-name-or-ns))
     (is (= reload? :reload))
     (is (= no-arglists? :no-arglists))

From a2adb18186633376bc2e1caeeb692ad8bf0f864a Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sun, 15 Dec 2019 17:14:08 -0500
Subject: [PATCH 097/456] Issue 29 - class ns syntax (#32)

* added alpha framework for ns-class syntax

* cleanup

* fix tests

* fix merge bug in tests
---
 src/libpython_clj/require.clj              | 118 ++++++++++++++++++++-
 test/libpython_clj/require_python_test.clj |   4 +-
 2 files changed, 115 insertions(+), 7 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 5e1932c..a340f42 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -47,6 +47,8 @@
 
 (def ^:private vars (py/get-attr builtins "vars"))
 
+(def ^:private pyclass? (py/get-attr inspect "isclass"))
+
 (defn ^:private py-fn-argspec [f]
   (if-let [spec (try (argspec f) (catch Throwable e nil))]
     {:args           (py/->jvm (py/get-attr spec "args"))
@@ -181,8 +183,11 @@
                             options]
   (let [fn-ns      (symbol (str fn-module-name-or-ns))
         fn-sym     (symbol fn-name)]
-    (intern fn-ns (with-meta fn-sym (py-fn-metadata fn-name f
-                                                    options)) f)))
+    (intern fn-ns
+            (with-meta
+              fn-sym
+              (py-fn-metadata fn-name f
+                              options)) f)))
 
 (defn- parse-flags
   "FSM style parser for flags.  Designed to support both
@@ -279,12 +284,11 @@
                         (vec missing)))))
       refer)))
 
-
 (defn- python-lib-configuration
   "Build a configuration map of a python library.  Current ns is option and used
   during testing but unnecessary during normal running events."
   [req & [current-ns]]
-  (let [supported-flags     #{:reload :no-arglists}
+  (let [supported-flags     #{:reload :no-arglists :alpha-load-ns-classes}
         [module-name & etc] req
         flags               (parse-flags supported-flags etc)
         etc                 (into {}
@@ -296,6 +300,7 @@
                                   etc)
         reload?             (:reload flags)
         no-arglists?        (:no-arglists flags)
+        load-ns-classes?    (:alpha-load-ns-classes flags)
         module-name-or-ns   (:as etc module-name)
         exclude             (into #{} (:exclude etc))
         refer               (cond
@@ -312,6 +317,7 @@
      :etc               etc
      :reload?           reload?
      :no-arglists?      no-arglists?
+     :load-ns-classes?  load-ns-classes?
      :module-name       module-name
      :module-name-or-ns module-name-or-ns
      :exclude           exclude
@@ -389,6 +395,100 @@
             {:doc (doc this-module)})
           this-module))
 
+(defn- generate-class-namespace-configs
+  [{:keys [module-name-or-ns this-module] :as lib-config}]
+  (letfn [(pyclass-pair? [[attr attr-val]] (pyclass? attr-val))
+          (pyclass-ns-config [[attr attr-val]]
+            {:namespace      module-name-or-ns
+             :attribute-type :class
+             :classname      attr
+             :class-symbol   (symbol attr)
+             :class          attr-val
+             :attributes     ((comp
+                               (py/get-attr builtins "dict")
+                               vars) attr-val)})
+          (pyclass-attribute-fanout
+            [{:keys [namespace
+                     classname
+                     class-symbol
+                     class
+                     attributes]
+              :as   attr-config}]
+            (into [attr-config]
+                  (for [[attr attr-val] (seq attributes)
+                        :let
+                        [attr-type
+                         (if (and (not (nil? attr-val))
+                                  (py/callable?  attr-val))
+
+                           :method
+                           :attribute)]]
+                    (merge
+                     (dissoc attr-config :attributes :type)
+                     {:attribute-type attr-type
+                      :type           :class-attribute
+                      :attribute      attr-val
+                      :attribute-name attr}))))]
+    (into []
+          (comp
+           (filter pyclass-pair?)
+           (map pyclass-ns-config)
+           (map pyclass-attribute-fanout)
+           cat)
+          (seq (vars this-module)))))
+
+(defmulti class-sort :attribute-type)
+(defmethod class-sort :class [_] 0)
+(defmethod class-sort :method [_] 1)
+(defmethod class-sort :attribute [_] 2)
+
+(defmulti intern-ns-class :attribute-type)
+
+(defmethod intern-ns-class :class
+  [{original-namespace :namespace
+    cls-name           :classname
+    cls-sym            :class-symbol
+    cls                :class
+    :as cls-ns-config}]
+  (let [cls-ns (symbol (str original-namespace "." cls-sym))]
+    (create-ns cls-ns)
+    cls-ns-config))
+
+(defmethod intern-ns-class :method
+  [{original-namespace :namespace
+    cls-name           :classname
+    cls-sym            :class-symbol
+    cls                :class
+    method-name        :attribute-name
+    method             :attribute
+    :as cls-ns-config}]
+  (let [cls-ns (symbol (str original-namespace "." cls-sym))]
+    (load-py-fn method (symbol method-name)
+                cls-ns {})
+    cls-ns-config))
+
+(defmethod intern-ns-class :attribute
+  [{original-namespace :namespace
+    cls-name           :classname
+    cls-sym            :class-symbol
+    cls                :class
+    attribute-name     :attribute-name
+    attribute          :attribute
+    :as cls-ns-config}]
+  (let [cls-ns (symbol (str original-namespace "." cls-sym))]
+    (intern cls-ns (symbol attribute-name) attribute)
+    cls-ns-config))
+
+(defn- bind-class-namespaces!
+  [lib-config]
+  (let [class-namespace-configs
+        (->>
+         (generate-class-namespace-configs
+          lib-config)
+         (sort-by class-sort))]
+    (doseq [cls-namespace-config class-namespace-configs]
+      (intern-ns-class cls-namespace-config))))
+
 (defn- intern-public-and-refer-symbols!
   [{:keys [public-data refer-symbols current-ns-sym]}]
   (doseq [[s v] (select-keys public-data refer-symbols)]
@@ -409,6 +509,7 @@
                 etc
                 reload?
                 no-arglists?
+                load-ns-classes?
                 module-name
                 module-name-or-ns
                 exclude
@@ -423,7 +524,13 @@
          :as   lib-config}
         (preload-python-lib! req)]
 
-    (intern-public-and-refer-symbols! lib-config)))
+    (intern-public-and-refer-symbols! lib-config)
+
+    ;; alpha
+    ;; TODO: does not respect reloading or much of the other
+    ;;   ..: syntax (yet)
+    (when load-ns-classes?
+      (bind-class-namespaces! lib-config))))
 
 (defn require-python
   "## Basic usage ##
@@ -502,3 +609,4 @@
     (load-python-lib (vector reqs))
     (vector? reqs)
     (load-python-lib reqs)))
+
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index 17240d5..68771b5 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -73,7 +73,8 @@
 
     ;; no exclusions
     (is (= #{} exclude))
-    (is (= #{:no-arglists :reload} supported-flags))
+    (is (= #{:no-arglists :reload :alpha-load-ns-classes}
+           supported-flags))
     (is (= 'csv module-name module-name-or-ns))
     (is (nil? reload?))
     (is (nil? no-arglists?))
@@ -105,7 +106,6 @@
 
     ;; no exclusions
     (is (= #{} exclude))
-    (is (= #{:no-arglists :reload} supported-flags))
     (is (= 'requests module-name module-name-or-ns))
     (is (= reload? :reload))
     (is (= no-arglists? :no-arglists))

From c39f25077c2e20ee98bceb868d762f35ebf3ebf7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 17 Dec 2019 13:52:32 -0700
Subject: [PATCH 098/456] Major changes.  jvm-as-python derive from abc
 classes.  ranges get translated into ranges if possible

---
 src/libpython_clj/python.clj             |   1 +
 src/libpython_clj/python/bridge.clj      | 333 ++++++++++++++++++-----
 src/libpython_clj/python/object.clj      |  71 +++--
 test/libpython_clj/iter_gen_seq_test.clj |  24 ++
 test/libpython_clj/python_test.clj       |  15 +
 5 files changed, 353 insertions(+), 91 deletions(-)
 create mode 100644 test/libpython_clj/iter_gen_seq_test.clj

diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index e33c5d7..1eaa601 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -9,6 +9,7 @@
             [tech.jna :as jna])
   (:import [com.sun.jna Pointer]
            [com.sun.jna.ptr PointerByReference]
+           [java.lang.reflect Field]
            [java.io Writer]
            [libpython_clj.jna PyObject
             CFunction$KeyWordFunction
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index 5566e90..2e695ad 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -48,10 +48,12 @@
             [tech.v2.datatype.functional :as dtype-fn]
             [tech.v2.datatype :as dtype]
             [tech.resource :as resource]
-            [clojure.set :as c-set])
-  (:import [java.util Map RandomAccess List Map$Entry Iterator]
+            [clojure.set :as c-set]
+            [clojure.tools.logging :as log])
+  (:import [java.util Map RandomAccess List Map$Entry Iterator UUID]
+           [java.util.concurrent ConcurrentHashMap]
            [clojure.lang IFn Symbol Keyword Seqable
-            Fn MapEntry]
+            Fn MapEntry Range LongRange]
            [tech.v2.datatype ObjectReader ObjectWriter ObjectMutable
             ObjectIter MutableRemove]
            [tech.v2.datatype.typed_buffer TypedBuffer]
@@ -201,6 +203,12 @@
   (->jvm pyobj))
 
 
+(defmethod pyobject-as-jvm :range
+  [pyobj]
+  (->jvm pyobj))
+
+
+
 (defn- mostly-copy-arg
   "This is the dirty boundary between the languages.  Copying as often faster
   for simple things but we have to be careful not to attempt a copy of things that
@@ -714,28 +722,6 @@
                   (st/print-stack-trace e#)))))))
 
 
-(defn jvm-iterator-as-python
-  ^Pointer [^Iterator item]
-  (with-gil nil
-    (let [next-fn #(if (.hasNext item)
-                     (-> (.next item)
-                         ;;As python tracks the object in a jvm context
-                         (as-python)
-                         (jna/->ptr-backing-store)
-                         ;;But we are handing the object back to python which is expecting
-                         ;;a new reference.
-                         (pyobj/incref))
-                     (do
-                       (libpy/PyErr_SetNone
-                        (err/PyExc_StopIteration))
-                       nil))
-          att-map
-          {"__next__" (pyobj/make-tuple-fn next-fn
-                                           :arg-converter nil
-                                           :result-converter nil)}]
-      (create-bridge-from-att-map item att-map))))
-
-
 (defn as-python-incref
   "Convert to python and add a reference.  Necessary for return values from
   functions as python expects a new reference and the as-python pathway
@@ -752,65 +738,260 @@
                        :result-converter as-python-incref))
 
 
+(defonce ^:private jvm-handle-map (ConcurrentHashMap.))
+
+(defn- make-jvm-object-handle
+  ^long [item]
+  (let [^ConcurrentHashMap hash-map jvm-handle-map]
+    (loop [handle (pyinterp/get-object-handle item)]
+      (let [handle (long handle)]
+        (if (not (.containsKey hash-map handle))
+          (do
+            (.put hash-map handle item)
+            handle)
+          (recur (.hashCode (UUID/randomUUID))))))))
+
+(defn- get-jvm-object
+  [handle]
+  (.get ^ConcurrentHashMap jvm-handle-map (long handle)))
+
+(defn- remove-jvm-object
+  [handle]
+  (.remove ^ConcurrentHashMap jvm-handle-map (long handle))
+  nil)
+
+(defn- py-self->jvm-handle
+  [self]
+  (->jvm (py-proto/get-attr self "jvm_handle")))
+
+(defn- py-self->jvm-obj
+  ^Object [self]
+  (-> (py-self->jvm-handle self)
+      get-jvm-object))
+
+(defn- as-tuple-instance-fn
+  [fn-obj]
+  (pyobj/make-tuple-instance-fn fn-obj :result-converter as-python-incref))
+
+
+(defn- self->map
+  ^Map [self]
+  (py-self->jvm-obj self))
+
+
+(defonce mapping-type
+  (delay
+    (with-gil
+      (let [mod (pyinterop/import-module "collections.abc")
+            map-type (py-proto/get-attr mod "MutableMapping")]
+        ;;In order to make things work ingeneral
+        (pyobj/create-class
+         "jvm-map-as-python"
+         [map-type]
+         {"__init__" (as-tuple-instance-fn
+                      (fn [self jvm-handle]
+                        (py-proto/set-attr! self "jvm_handle" jvm-handle)
+                        nil))
+          "__del__" (as-tuple-instance-fn
+                     #(try
+                        (remove-jvm-object (py-self->jvm-handle %))
+                        (catch Throwable e
+                          (log/warnf e "Error removing object"))))
+          "__contains__" (as-tuple-instance-fn #(.containsKey (self->map %1) (as-jvm %2)))
+          "__eq__" (as-tuple-instance-fn #(.equals (self->map %1) (as-jvm %2)))
+          "__getitem__" (as-tuple-instance-fn
+                         #(do (println "getting" (as-jvm %2))
+                              (.get (self->map %1) (as-jvm %2))))
+          "__setitem__" (as-tuple-instance-fn #(.put (self->map %1) (as-jvm %2) %3))
+          "__delitem__" (as-tuple-instance-fn #(.remove (self->map %1) (as-jvm %2)))
+          "__hash__" (as-tuple-instance-fn #(.hashCode (self->map %1)))
+          "__iter__" (as-tuple-instance-fn #(.iterator ^Iterable (keys (self->map %1))))
+          "__len__" (as-tuple-instance-fn #(.size (self->map %1)))
+          "__str__" (as-tuple-instance-fn #(.toString (self->map %1)))
+          "clear" (as-tuple-instance-fn #(.clear (self->map %1)))
+          "keys" (as-tuple-instance-fn #(seq (.keySet (self->map %1))))
+          "values" (as-tuple-instance-fn #(seq (.values (self->map %1))))
+          "pop" (as-tuple-instance-fn #(.remove (self->map %1) (as-jvm %2)))})))))
+
+
 (defn jvm-map-as-python
-  ^Pointer [^Map jvm-data]
+  [^Map jvm-data]
   (with-gil
-    (let [att-map
-          {"__contains__" (as-py-fn #(.containsKey jvm-data %))
-           "__eq__" (as-py-fn #(.equals jvm-data %))
-           "__getitem__" (as-py-fn #(.get jvm-data %))
-           "__setitem__" (as-py-fn #(.put jvm-data %1 %2))
-           "__delitem__" (as-py-fn #(.remove jvm-data %))
-           "__hash__" (as-py-fn #(.hashCode jvm-data))
-           "__iter__" (as-py-fn #(.iterator ^Iterable (keys jvm-data)))
-           "__len__" (as-py-fn #(.size jvm-data))
-           "__str__" (as-py-fn #(.toString jvm-data))
-           "clear" (as-py-fn #(.clear jvm-data))
-           "keys" (as-py-fn #(seq (.keySet jvm-data)))
-           "values" (as-py-fn #(seq (.values jvm-data)))
-           "pop" (as-py-fn #(.remove jvm-data %))}]
-      (create-bridge-from-att-map jvm-data att-map))))
+    (py-proto/call (jna/as-ptr (deref mapping-type)) (make-jvm-object-handle jvm-data))))
+
+
+(defmethod py-proto/pyobject->jvm :jvm-map-as-python
+  [pyobj]
+  (py-self->jvm-obj pyobj))
+
+
+(defmethod pyobject-as-jvm :jvm-map-as-python
+  [pyobj]
+  (->jvm pyobj))
+
+
+(defn- self->list
+  ^List [self]
+  (py-self->jvm-obj self))
+
+(defonce sequence-type
+  (delay
+    (let [mod (pyinterop/import-module "collections.abc")
+          seq-type (py-proto/get-attr mod "MutableSequence")]
+      (pyobj/create-class
+       "jvm-list-as-python"
+       [seq-type]
+       {"__init__" (as-tuple-instance-fn
+                      (fn [self jvm-handle]
+                        (py-proto/set-attr! self "jvm_handle" jvm-handle)
+                        nil))
+        "__del__" (as-tuple-instance-fn
+                   #(try
+                      (remove-jvm-object (py-self->jvm-handle %))
+                      (catch Throwable e
+                        (log/warnf e "Error removing object"))))
+        "__contains__" (as-tuple-instance-fn #(.contains (self->list %1) %2))
+        "__eq__" (as-tuple-instance-fn #(.equals (self->list %1) (->jvm %2)))
+        "__getitem__" (as-tuple-instance-fn #(.get (self->list %1) (int (->jvm %2))))
+        "__setitem__" (as-tuple-instance-fn #(.set (self->list %1)
+                                                   (int (->jvm %2))
+                                                   (as-jvm %3)))
+        "__delitem__" (as-tuple-instance-fn #(.remove (self->list %1)
+                                                      (int (->jvm %2))))
+        "__hash__" (as-tuple-instance-fn #(.hashCode (self->list %1)))
+        "__iter__" (as-tuple-instance-fn #(.iterator (self->list %1)))
+        "__len__" (as-tuple-instance-fn #(.size (self->list %1)))
+        "__str__" (as-tuple-instance-fn #(.toString (self->list %1)))
+        "clear" (as-tuple-instance-fn #(.clear (self->list %1)))
+        "sort" (as-tuple-instance-fn #(.sort (self->list %1) nil))
+        "append" (as-tuple-instance-fn #(.add (self->list %1) %2))
+        "insert" (as-tuple-instance-fn #(.add (self->list %1) (int (->jvm %2)) %3))
+        "pop" (as-tuple-instance-fn
+               (fn [self & args]
+                 (let [jvm-data (self->list self)
+                       args (map ->jvm args)
+                       index (int (if (first args)
+                                     (first args)
+                                     -1))
+                       index (if (< index 0)
+                               (- (.size jvm-data) index)
+                               index)]
+                   #(.remove jvm-data index))))}))))
 
 
 (defn jvm-list-as-python
-  ^Pointer [^List jvm-data]
+  [^List jvm-data]
   (with-gil
-    (let [att-map
-          {"__contains__" (as-py-fn #(.contains jvm-data %))
-           "__eq__" (as-py-fn #(.equals jvm-data %))
-           "__getitem__" (as-py-fn #(.get jvm-data (int %)))
-           "__setitem__" (as-py-fn #(.set jvm-data (int %1) %2))
-           "__delitem__" (as-py-fn #(.remove jvm-data (int %)))
-           "__hash__" (as-py-fn #(.hashCode jvm-data))
-           "__iter__" (as-py-fn #(.iterator jvm-data))
-           "__len__" (as-py-fn #(.size jvm-data))
-           "__str__" (as-py-fn #(.toString jvm-data))
-           "clear" (as-py-fn #(.clear jvm-data))
-           "sort" (as-py-fn #(.sort jvm-data nil))
-           "append" (as-py-fn #(.add jvm-data %))
-           "insert" (as-py-fn #(.add jvm-data (int %1) %2))
-           "pop" (as-py-fn (fn [& args]
-                             (let [index (int (if (first args)
-                                                (first args)
-                                                -1))
-                                   index (if (< index 0)
-                                           (- (.size jvm-data) index)
-                                           index)]
-                               #(.remove jvm-data index))))}]
-      (create-bridge-from-att-map jvm-data att-map))))
+    (py-proto/call (jna/as-ptr (deref sequence-type)) (make-jvm-object-handle jvm-data))))
+
+
+(defmethod py-proto/pyobject->jvm :jvm-list-as-python
+  [pyobj]
+  (py-self->jvm-obj pyobj))
+
+
+(defmethod pyobject-as-jvm :jvm-list-as-python
+  [pyobj]
+  (->jvm pyobj))
+
+
+(defonce iterable-type
+  (delay
+    (with-gil
+      (let [mod (pyinterop/import-module "collections.abc")
+            iter-base-cls (py-proto/get-attr mod "Iterable")]
+        (pyobj/create-class
+         "jvm-iterable-as-python"
+         [iter-base-cls]
+         {"__init__" (as-tuple-instance-fn
+                      (fn [self jvm-handle]
+                        (py-proto/set-attr! self "jvm_handle" jvm-handle)
+                        nil))
+          "__del__" (as-tuple-instance-fn
+                     #(try
+                        (remove-jvm-object (py-self->jvm-handle %))
+                        (catch Throwable e
+                          (log/warnf e "Error removing object"))))
+          "__iter__" (as-tuple-instance-fn
+                      #(.iterator ^Iterable (py-self->jvm-obj %)))
+          "__eq__" (as-tuple-instance-fn #(.equals (py-self->jvm-obj %1)
+                                                   (as-jvm %2)))
+          "__hash__" (as-tuple-instance-fn
+                      #(.hashCode (py-self->jvm-obj %)))
+          "__str__" (as-tuple-instance-fn
+                     #(.toString (py-self->jvm-obj %)))})))))
 
 
 (defn jvm-iterable-as-python
-  ^Pointer [^Iterable jvm-data]
+  [^Iterable jvm-data]
   (with-gil
-    (let [att-map
-          {"__iter__" (as-py-fn #(.iterator jvm-data))
-           "__eq__" (as-py-fn #(.equals jvm-data %))
-           "__hash__" (as-py-fn #(.hashCode jvm-data))
-           "__str__" (as-py-fn #(.toString jvm-data))}]
-      (create-bridge-from-att-map jvm-data att-map))))
+    (py-proto/call (jna/as-ptr (deref iterable-type)) (make-jvm-object-handle jvm-data))))
 
 
+(defmethod py-proto/pyobject->jvm :jvm-iterable-as-python
+  [pyobj]
+  (py-self->jvm-obj pyobj))
+
+
+(defmethod pyobject-as-jvm :jvm-iterable-as-python
+  [pyobj]
+  (->jvm pyobj))
+
+
+(defonce iterator-type
+  (delay
+    (with-gil
+      (let [mod (pyinterop/import-module "collections.abc")
+            iter-base-cls (py-proto/get-attr mod "Iterator")
+            next-fn (fn [self]
+                      (let [^Iterator item (py-self->jvm-obj self)]
+                        (if (.hasNext item)
+                          (-> (.next item)
+                              ;;As python tracks the object in a jvm context
+                              (as-python)
+                              (jna/->ptr-backing-store)
+                              ;;But we are handing the object back to python which is expecting
+                              ;;a new reference.
+                              (pyobj/incref))
+                          (do
+                            (libpy/PyErr_SetNone
+                             (err/PyExc_StopIteration))
+                            nil))))]
+        (pyobj/create-class
+         "jvm-iterator-as-python"
+         [iter-base-cls]
+         {"__init__" (as-tuple-instance-fn
+                      (fn [self jvm-handle]
+                        (py-proto/set-attr! self "jvm_handle" jvm-handle)
+                        nil))
+          "__del__" (as-tuple-instance-fn
+                     #(try
+                        (remove-jvm-object (py-self->jvm-handle %))
+                        (catch Throwable e
+                          (log/warnf e "Error removing object"))))
+          "__next__" (pyobj/make-tuple-instance-fn
+                      next-fn
+                      ;;In this case we are explicitly taking care of all conversions
+                      ;;to python and back so we do not ask for any converters.
+                      :arg-converter nil
+                      :result-converter nil)})))))
+
+
+(defn jvm-iterator-as-python
+  [^Iterator jvm-data]
+  (with-gil
+    (py-proto/call (jna/as-ptr (deref iterator-type)) (make-jvm-object-handle jvm-data))))
+
+
+(defmethod py-proto/pyobject->jvm :jvm-iterator-as-python
+  [pyobj]
+  (py-self->jvm-obj pyobj))
+
+
+(defmethod pyobject-as-jvm :jvm-iterator-as-python
+  [pyobj]
+  (->jvm pyobj))
+
 (extend-protocol py-proto/PBridgeToPython
   Number
   (as-python [item options] (->python item))
@@ -822,6 +1003,14 @@
   (as-python [item options] (->python item))
   Boolean
   (as-python [item options] (->python item))
+  Range
+  (as-python [item options]
+    (if (casting/integer-type? (dtype/get-datatype item))
+      (->python item options)
+      (jvm-iterable-as-python item)))
+  LongRange
+  (as-python [item options]
+    (->python item options))
   Iterable
   (as-python [item options]
     (cond
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 8c9dbc7..147a99c 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -44,6 +44,7 @@
             [clojure.tools.logging :as log])
   (:import [com.sun.jna Pointer CallbackReference]
            [com.sun.jna.ptr PointerByReference]
+           [java.lang.reflect Field]
            [libpython_clj.jna
             PyObject
             CFunction$KeyWordFunction
@@ -58,7 +59,8 @@
            [clojure.lang Symbol Keyword
             IPersistentMap
             IPersistentVector
-            IPersistentSet]))
+            IPersistentSet
+            Range LongRange]))
 
 
 (set! *warn-on-reflection* true)
@@ -574,6 +576,13 @@
           new-cls (py-proto/call (libpy/PyType_Type) name bases cls-dict)]
       (py-proto/as-jvm new-cls nil))))
 
+(def ^:private lr-step-field (doto (.getDeclaredField ^Class LongRange "step")
+                               (.setAccessible true)))
+
+
+(def ^:private r-step-field (doto (.getDeclaredField ^Class Range "step")
+                              (.setAccessible true)))
+
 
 (extend-protocol py-proto/PCopyToPython
   Number
@@ -595,6 +604,20 @@
     (if item
       (py-true)
       (py-false)))
+  Range
+  (->python [item options]
+    (if (casting/integer-type? (dtype/get-datatype item))
+      (let [start (first item)
+            step (.get ^Field r-step-field item)
+            stop (+ start (* step (count item)))]
+        (py-proto/call (libpy/PyRange_Type) start stop step))
+      (->py-list item)))
+  LongRange
+  (->python [item options]
+    (let [start (first item)
+          step (.get ^Field lr-step-field item)
+          stop (+ start (* step (count item)))]
+      (py-proto/call (libpy/PyRange_Type) start stop step)))
   Iterable
   (->python [item options]
     (cond
@@ -1033,26 +1056,36 @@
   (numpy-scalar->jvm pyobj))
 
 
+(defmethod pyobject->jvm :range
+  [pyobj]
+  (with-gil
+    (let [start (->jvm (py-proto/get-attr pyobj "start"))
+          step (->jvm (py-proto/get-attr pyobj "step"))
+          stop (->jvm (py-proto/get-attr pyobj "stop"))]
+      (range start stop step))))
+
+
 (defmethod pyobject->jvm :default
   [pyobj]
-  (cond
-    ;;Things could implement mapping and sequence logically so mapping
-    ;;takes precedence
-    (= 1 (libpy/PyMapping_Check pyobj))
-    (if-let [map-items (try (-> (libpy/PyMapping_Items pyobj)
-                                wrap-pyobject)
-                            (catch Throwable e nil))]
-      (python->jvm-copy-hashmap pyobj map-items)
-      (do
-        ;;Ignore error.  The mapping check isn't thorough enough to work.
-        (libpy/PyErr_Clear)
-        (python->jvm-copy-persistent-vector pyobj)))
-    ;;Sequences become persistent vectors
-    (= 1 (libpy/PySequence_Check pyobj))
-    (python->jvm-copy-persistent-vector pyobj)
-    :else
-    {:type (python-type pyobj)
-     :value (Pointer/nativeValue (jna/as-ptr pyobj))}))
+  (with-gil
+    (cond
+      ;;Things could implement mapping and sequence logically so mapping
+      ;;takes precedence
+      (= 1 (libpy/PyMapping_Check pyobj))
+      (if-let [map-items (try (-> (libpy/PyMapping_Items pyobj)
+                                  wrap-pyobject)
+                              (catch Throwable e nil))]
+        (python->jvm-copy-hashmap pyobj map-items)
+        (do
+          ;;Ignore error.  The mapping check isn't thorough enough to work.
+          (libpy/PyErr_Clear)
+          (python->jvm-copy-persistent-vector pyobj)))
+      ;;Sequences become persistent vectors
+      (= 1 (libpy/PySequence_Check pyobj))
+      (python->jvm-copy-persistent-vector pyobj)
+      :else
+      {:type (python-type pyobj)
+       :value (Pointer/nativeValue (jna/as-ptr pyobj))})))
 
 
 (defn is-instance?
diff --git a/test/libpython_clj/iter_gen_seq_test.clj b/test/libpython_clj/iter_gen_seq_test.clj
new file mode 100644
index 0000000..433f520
--- /dev/null
+++ b/test/libpython_clj/iter_gen_seq_test.clj
@@ -0,0 +1,24 @@
+(ns libpython-clj.iter-gen-seq-test
+  "Iterators/sequences and such are crucial to handling lots of forms
+  of data and thus they have to work correctly between the languages."
+  (:require [libpython-clj.python :as py]
+            [libpython-clj.require :refer [require-python]]
+            [clojure.test :refer :all]))
+
+
+(require-python '[builtins :as python])
+
+(deftest generate-sequence-test
+  (let [{{:strs [fortwice]} :globals}
+        (py/run-simple-string "
+def fortwice(xs):
+    for x in xs:
+        yield x
+    for x in xs:
+        yield x")]
+    (is (= [1 2 3 4 5 6 7 8 9 10]
+           (vec (fortwice  (python/map inc (range 10))))))  ;;=> [1 2 3 4 5 6 7 8 9 10]
+    (is (= [1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10]
+           (vec (fortwice (map inc (range 10)))))) ;;=> [1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10]
+    (is (= [1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10]
+           (vec (fortwice  (vec (python/map inc (range 10)))))))))
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 57e9497..e5983e1 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -319,3 +319,18 @@
            (Pointer/nativeValue (jna/as-ptr ->false))))
     (is (= (Pointer/nativeValue (jna/as-ptr py-false))
            (Pointer/nativeValue (jna/as-ptr as-false))))))
+
+
+(deftest instance-abc-classes
+  (let [py-dict (py/->python {"a" 1 "b" 2})
+        bridged-dict (py/as-python {"a" 1 "b" 2})
+        bridged-iter (py/as-python (repeat 5 1))
+        bridged-list (py/as-python (vec (range 10)))
+        pycol (py/import-module "collections")
+        mapping-type (py/get-attr pycol "Mapping")
+        iter-type (py/get-attr pycol "Iterable")
+        sequence-type (py/get-attr pycol "Sequence")]
+    (is (py/is-instance? py-dict mapping-type))
+    (is (py/is-instance? bridged-dict mapping-type))
+    (is (py/is-instance? bridged-iter iter-type))
+    (is (py/is-instance? bridged-list sequence-type))))

From 4e35ffe5fd2ca08a19473268159ef9f7dc5cd616 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 17 Dec 2019 13:58:54 -0700
Subject: [PATCH 099/456] 1.28

---
 CHANGELOG.md                             | 11 +++++++++++
 project.clj                              |  2 +-
 test/libpython_clj/iter_gen_seq_test.clj |  4 ++--
 3 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ed73d5f..94c425f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,17 @@
 # Time for a ChangeLog!
 
 
+## 1.28
+
+
+* `(range 5)` - clojure ranges <-> python ranges when possible.
+* bridged types derive from collections.abc.* so that they pass instance checks in
+  libraries that are checking for generic types.
+* Really interesting unit test for 
+  [generators, ranges and sequences](test/libpython-clj.iter_gen_seq_test.clj).
+
+
+
 ## 1.27
 
 * Fixed bug where (as-python {:is_train false}) results in a dictionary with a none
diff --git a/project.clj b/project.clj
index b82d48e..0d82858 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.28-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.28"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"
diff --git a/test/libpython_clj/iter_gen_seq_test.clj b/test/libpython_clj/iter_gen_seq_test.clj
index 433f520..dfa8006 100644
--- a/test/libpython_clj/iter_gen_seq_test.clj
+++ b/test/libpython_clj/iter_gen_seq_test.clj
@@ -17,8 +17,8 @@ def fortwice(xs):
     for x in xs:
         yield x")]
     (is (= [1 2 3 4 5 6 7 8 9 10]
-           (vec (fortwice  (python/map inc (range 10))))))  ;;=> [1 2 3 4 5 6 7 8 9 10]
+           (vec (fortwice  (python/map inc (range 10))))))
     (is (= [1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10]
-           (vec (fortwice (map inc (range 10)))))) ;;=> [1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10]
+           (vec (fortwice (map inc (range 10))))))
     (is (= [1 2 3 4 5 6 7 8 9 10 1 2 3 4 5 6 7 8 9 10]
            (vec (fortwice  (vec (python/map inc (range 10)))))))))

From 54965e0a0cf42738e7d907da180b9d7995781f8c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 17 Dec 2019 13:59:02 -0700
Subject: [PATCH 100/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 0d82858..b069c92 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.28"
+(defproject cnuernber/libpython-clj "1.29-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 547ab6dae5f4bea580166da978ffc9f2bd06a5a1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 17 Dec 2019 16:02:44 -0700
Subject: [PATCH 101/456] editing

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 94c425f..1fcbf06 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -24,7 +24,7 @@
 
 
 * [python startup work](https://github.com/cnuernber/libpython-clj/commit/16da3d885f29bde59ea219c9438b9d3654387971)
-* [python generates & clojure transducers](https://github.com/cnuernber/libpython-clj/pull/27)
+* [python generators & clojure transducers](https://github.com/cnuernber/libpython-clj/pull/27)
 * [requre-python reload fix](https://github.com/cnuernber/libpython-clj/pull/24)
 * Bugfix with require-python :reload semantics.
 

From 043b868cde92ef3c286d6d6b129e7ebdcbd6650c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 17 Dec 2019 16:03:35 -0700
Subject: [PATCH 102/456] editing

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1fcbf06..f9cb3c6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,7 +8,7 @@
 * bridged types derive from collections.abc.* so that they pass instance checks in
   libraries that are checking for generic types.
 * Really interesting unit test for 
-  [generators, ranges and sequences](test/libpython-clj.iter_gen_seq_test.clj).
+  [generators, ranges and sequences](test/libpython_clj.iter_gen_seq_test.clj).
 
 
 

From bc4eb1329bc7b97bc1db999ebe4c2ee02cfc0c1e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 17 Dec 2019 16:03:56 -0700
Subject: [PATCH 103/456] editing

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f9cb3c6..86e0e6e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,7 +8,7 @@
 * bridged types derive from collections.abc.* so that they pass instance checks in
   libraries that are checking for generic types.
 * Really interesting unit test for 
-  [generators, ranges and sequences](test/libpython_clj.iter_gen_seq_test.clj).
+  [generators, ranges and sequences](test/libpython_clj/iter_gen_seq_test.clj).
 
 
 

From 84d704e84a02cd48bf8cc5e28151bcc9462b5a47 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 18 Dec 2019 07:26:09 -0700
Subject: [PATCH 104/456] Added error checking for misspelled flags

---
 src/libpython_clj/require.clj              | 16 ++++++++++++++--
 test/libpython_clj/require_python_test.clj |  1 -
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index a340f42..fd68b5c 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -49,6 +49,8 @@
 
 (def ^:private pyclass? (py/get-attr inspect "isclass"))
 
+(def ^:private pymodule? (py/get-attr inspect "ismodule"))
+
 (defn ^:private py-fn-argspec [f]
   (if-let [spec (try (argspec f) (catch Throwable e nil))]
     {:args           (py/->jvm (py/get-attr spec "args"))
@@ -195,7 +197,17 @@
   boolean flags '[foo :reload true] to support Clojure
   style 'require syntax.  Possibly overengineered."
   [supported-flags reqs]
-
+  ;; Ensure we error out when flags passed in are mistyped.
+  ;; First attempt is to filter keywords and make sure any keywords are
+  ;; in supported-flags
+  (let [total-flags (set (concat supported-flags [:as :refer :exclude
+                                                  :* :all]))]
+    (when-let [missing-flags (->> reqs
+                                  (filter #(and (not (total-flags %))
+                                                (keyword? %)))
+                                  seq)]
+      (throw (Exception. (format "Unsupported flags: %s"
+                                 (set missing-flags))))))
   (letfn [(supported-flag-item
             ;; scanned a supported tag token
             [supported-flags flag results item items]
@@ -479,6 +491,7 @@
     (intern cls-ns (symbol attribute-name) attribute)
     cls-ns-config))
 
+
 (defn- bind-class-namespaces!
   [lib-config]
   (let [class-namespace-configs
@@ -609,4 +622,3 @@
     (load-python-lib (vector reqs))
     (vector? reqs)
     (load-python-lib reqs)))
-
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index 68771b5..95e0cec 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -31,7 +31,6 @@
     (is (= #{:reload} (parse-flags
                        #{:reload}
                        '[:reload foo])))
-    (is (= #{} (parse-flags #{} '[:reload foo])))
     (is (= #{:reload} (parse-flags #{:reload} '[:reload true])))
     (is (= #{:reload} (parse-flags #{:reload} '[:reload :as foo])))
     (is (= #{:reload} (parse-flags #{:reload} '[:reload foo :as])))

From dd5b40912c3d01eb9a2f6ea79d33a4ecf5c3b2f7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 19 Dec 2019 10:15:26 -0700
Subject: [PATCH 105/456] Instructions to install pip3 packages and cleaning up
 comments.

---
 dockerfiles/CondaDockerfile | 10 +++++++---
 scripts/run-conda-docker    |  4 +---
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/dockerfiles/CondaDockerfile b/dockerfiles/CondaDockerfile
index 1320a77..906bf88 100644
--- a/dockerfiles/CondaDockerfile
+++ b/dockerfiles/CondaDockerfile
@@ -10,7 +10,6 @@ RUN apt-get -qq update && apt-get -qq -y install curl wget bzip2 openjdk-8-jdk-h
     && rm -rf /tmp/miniconda.sh \
     && conda install -y python=3 \
     && conda update conda \
-    && conda install -y mxnet numpy \
     && curl -O https://download.clojure.org/install/linux-install-1.10.1.492.sh \
     && chmod +x linux-install-1.10.1.492.sh \
     && ./linux-install-1.10.1.492.sh && rm linux-install-1.10.1.492.sh \
@@ -34,5 +33,10 @@ RUN groupadd -g $GROUPID $USERNAME
 RUN useradd -u $USERID -g $GROUPID $USERNAME
 RUN mkdir /home/$USERNAME && chown $USERNAME:$USERNAME /home/$USERNAME
 USER $USERNAME
-RUN conda create -n pyclj python=3.6 && conda install -n pyclj numpy mxnet\
-    && echo "source activate pyclj" > /home/$USERNAME/.bashrc
\ No newline at end of file
+
+RUN conda create -n pyclj python=3.6 && conda install -n pyclj numpy mxnet \
+    && echo "source activate pyclj" > /home/$USERNAME/.bashrc
+
+
+## To install pip packages into the pyclj environment do
+RUN conda run -n pyclj python3 -mpip install xyz
\ No newline at end of file
diff --git a/scripts/run-conda-docker b/scripts/run-conda-docker
index 0e1688c..479e83e 100755
--- a/scripts/run-conda-docker
+++ b/scripts/run-conda-docker
@@ -1,8 +1,6 @@
 #!/bin/bash
 
-## This is incomplete, you still have to mess around with pythonpath and such.  The
-## goal at this stage is to get this docker container to launch a repl that allows
-## initialize! to work out of the box.
+scripts/build-conda-docker
 
 docker run --rm -it -u $(id -u):$(id -g) \
   -e LEIN_REPL_HOST="0.0.0.0" \

From c9bd7aa9c984fcc707e0d926f6b4c1e1a421b47c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 19 Dec 2019 10:21:24 -0700
Subject: [PATCH 106/456] working container

---
 dockerfiles/CondaDockerfile | 2 +-
 scripts/conda-repl          | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/dockerfiles/CondaDockerfile b/dockerfiles/CondaDockerfile
index 906bf88..385da77 100644
--- a/dockerfiles/CondaDockerfile
+++ b/dockerfiles/CondaDockerfile
@@ -39,4 +39,4 @@ RUN conda create -n pyclj python=3.6 && conda install -n pyclj numpy mxnet \
 
 
 ## To install pip packages into the pyclj environment do
-RUN conda run -n pyclj python3 -mpip install xyz
\ No newline at end of file
+RUN conda run -n pyclj python3 -mpip install numpy
\ No newline at end of file
diff --git a/scripts/conda-repl b/scripts/conda-repl
index 94e04c0..17a78c8 100755
--- a/scripts/conda-repl
+++ b/scripts/conda-repl
@@ -6,6 +6,7 @@ source activate pyclj
 ## https://github.com/conda/conda/issues/9500#issuecomment-565753807
 export LD_LIBRARY_PATH="$(python3-config --prefix)/lib"
 
+
 lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
      -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
      -- repl :headless :host localhost

From 6819ccb22e17262be022e4797c17a912d0a6ab99 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 19 Dec 2019 11:30:42 -0700
Subject: [PATCH 107/456] 1.29

---
 CHANGELOG.md                        |  7 ++++++-
 project.clj                         |  2 +-
 src/libpython_clj/python/object.clj | 14 +++++++++-----
 test/libpython_clj/python_test.clj  |  8 ++++++++
 4 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 86e0e6e..4a2297b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,13 +1,18 @@
 # Time for a ChangeLog!
 
 
+## 1.20
+
+* Found/fixed issue with ->jvm and large python dictionaries.
+
+
 ## 1.28
 
 
 * `(range 5)` - clojure ranges <-> python ranges when possible.
 * bridged types derive from collections.abc.* so that they pass instance checks in
   libraries that are checking for generic types.
-* Really interesting unit test for 
+* Really interesting unit test for
   [generators, ranges and sequences](test/libpython_clj/iter_gen_seq_test.clj).
 
 
diff --git a/project.clj b/project.clj
index b069c92..256dd38 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.29-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.29"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 147a99c..f5f65b7 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -980,15 +980,19 @@
     (let [ppos (jna/size-t-ref 0)
           pkey (PointerByReference.)
           pvalue (PointerByReference.)
-          retval (transient {})]
+          retval (java.util.ArrayList.)]
+      ;;Dictionary iteration doesn't appear to be reentrant so we have
+      ;;to do 2 passes.
       (loop [next-retval (libpy/PyDict_Next pyobj ppos pkey pvalue)]
         (if (not= 0 next-retval)
           (do
-            (assoc! retval
-                    (->jvm (jna/as-ptr pkey))
-                    (->jvm (jna/as-ptr pvalue)))
+            (.add retval [(jna/as-ptr pkey)
+                          (jna/as-ptr pvalue)])
             (recur (libpy/PyDict_Next pyobj ppos pkey pvalue)))
-          (persistent! retval))))))
+          (->> retval
+               (map (fn [[k v]]
+                      [(->jvm k) (->jvm v)]))
+               (into {})))))))
 
 
 (defmethod pyobject->jvm :set
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index e5983e1..2553fbf 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -334,3 +334,11 @@
     (is (py/is-instance? bridged-dict mapping-type))
     (is (py/is-instance? bridged-iter iter-type))
     (is (py/is-instance? bridged-list sequence-type))))
+
+
+(deftest nested-map-and-back
+  (let [py-dict (-> (py/run-simple-string "testdata={'camera_id': 'CODOT-10106-12067', 'country': 'United States', 'state': 'Colorado', 'city': 'Fountain', 'provider': 'CO DOT', 'description': '0.6 mi N of Ray Nixon Rd Int', 'direction': 'North', 'video': False, 'links': {'jpeg': {'url': 'https://www.cotrip.org/dimages/camera?imageURL=remote/CTMCCAM025S125-20-N.jpg'}}, 'tags': ['auto_rerated'], 'ratings': {'road_weather': 4, 'visibility': 4}, 'health': {}, 'created_at': '2016-04-19T20:27:45.030Z', 'time_zone_offset': -25200}")
+                    (get-in [:globals "testdata"]))
+        jvm-dict (py/->jvm py-dict)]
+    (is (= (get jvm-dict "ratings")
+           (py/->jvm (py/get-item py-dict "ratings"))))))

From dd41a2a48e3ac3456f654b5a2b5f87b050c65f91 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 19 Dec 2019 11:32:57 -0700
Subject: [PATCH 108/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 256dd38..f3a93f5 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.29"
+(defproject cnuernber/libpython-clj "1.30-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From b6c0bc69d12c39760d3f43449a84b45e8df1dfe9 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 19 Dec 2019 15:20:42 -0700
Subject: [PATCH 109/456] editing

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4a2297b..0cceae8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,7 @@
 # Time for a ChangeLog!
 
 
-## 1.20
+## 1.29
 
 * Found/fixed issue with ->jvm and large python dictionaries.
 

From a11cdcd4d3c499d62ba236c95480bbb3d40842fb Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Fri, 20 Dec 2019 10:37:02 -0500
Subject: [PATCH 110/456] Issue-35a: (require-python 'module.class) and
 '[module.class :as module-alias.class-alias] (#37)

* add require module.class syntax

* wrap findspec to prevent bootstrapping issue on importlib.util

* wrap findspec to prevent bootstrapping issue on importlib.util
---
 src/libpython_clj/require.clj              | 236 ++++++++++++++++++---
 test/libpython_clj/require_python_test.clj |  32 +++
 2 files changed, 236 insertions(+), 32 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index fd68b5c..b7e1363 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -1,10 +1,14 @@
 (ns libpython-clj.require
   (:refer-clojure :exclude [fn? doc])
   (:require [libpython-clj.python :as py]
-            [clojure.tools.logging :as log]))
+            [clojure.tools.logging :as log]
+            [clojure.java.io :as io]))
 
 (py/initialize!)
 
+;; for hot reloading multimethod in development
+(ns-unmap 'libpython-clj.require 'intern-ns-class)
+
 (def ^:private builtins (py/import-module "builtins"))
 
 (def ^:private inspect (py/import-module "inspect"))
@@ -38,6 +42,8 @@
 
 (def ^:private importlib (py/import-module "importlib"))
 
+(def ^:private importlib_util (py/import-module "importlib.util"))
+
 (def ^:private reload-module (py/get-attr importlib "reload"))
 
 (def ^:priviate import-module (py/get-attr importlib "import_module"))
@@ -51,6 +57,45 @@
 
 (def ^:private pymodule? (py/get-attr inspect "ismodule"))
 
+(defn ^:private findspec [x]
+  (let [-findspec
+        (-> importlib_util (py/get-attr "find_spec"))]
+    (-findspec x)))
+
+(def ^:private hasattr (py/get-attr builtins "hasattr"))
+
+(defn ^:private module-string? [x]
+  (try
+    (findspec x)
+    (catch Throwable e
+      false)))
+
+(defn module-path-string
+  "Given a.b, return a
+   Given a.b.c, return a.b
+   Given a.b.c.d, return a.b.c  etc."
+  [x]
+  (clojure.string/join
+   "."
+   (pop (clojure.string/split (str x) #"[.]"))))
+
+(defn module-path-last-string
+  "Given a.b.c.d, return d"
+  [x]
+  (last (clojure.string/split (str x) #"[.]")))
+
+(defn ^:private possible-class?
+  "The presumption here is that, given a symbol like 'builtins.list,
+  if 'builtins.list does not have a __path__ attribute but 'builtins does,
+  it's possible that 'list is a class of 'builtins.
+
+  This is a slightly cheaper test than a try/except wrapper around
+  a module."
+  [pos-class]
+  (let [module? (module-path-string pos-class)]
+    (and (not (module-string? pos-class))
+         (boolean (module-string? module?)))))
+
 (defn ^:private py-fn-argspec [f]
   (if-let [spec (try (argspec f) (catch Throwable e nil))]
     {:args           (py/->jvm (py/get-attr spec "args"))
@@ -296,6 +341,21 @@
                         (vec missing)))))
       refer)))
 
+(defn import-module-or-cls! [x]
+  (if (possible-class? x)
+    (let [module? (module-path-string x)
+          class?  (module-path-last-string x)]
+      (try
+        (let [m   (import-module module?)
+              cls (py/get-attr m class?)]
+          (if (nil? cls)
+            (throw (Exception. "Unable to load " x)))
+          [m cls])
+        (catch Exception e
+          (log/error (str "Unable to load " x))
+          (throw e))))
+    [(import-module (str x)) nil]))
+
 (defn- python-lib-configuration
   "Build a configuration map of a python library.  Current ns is option and used
   during testing but unnecessary during normal running events."
@@ -324,20 +384,52 @@
         current-ns          (or current-ns *ns*)
         current-ns-sym      (symbol (str current-ns))
         python-namespace    (find-ns module-name-or-ns)
-        this-module         (import-module (str module-name))]
+        [this-module cls]   (import-module-or-cls! module-name)]
+
     {:supported-flags   supported-flags
      :etc               etc
      :reload?           reload?
      :no-arglists?      no-arglists?
-     :load-ns-classes?  load-ns-classes?
-     :module-name       module-name
-     :module-name-or-ns module-name-or-ns
+     :load-ns-classes?  true
+
+     ;; if something like 'builtins.list was requested,
+     ;; the module name is 'builtins
+     :module-name       (if (pyclass? cls)
+                          (module-path-string module-name)
+                          module-name)
+
+     ;; if something like 'builtins.list was requested,
+     ;; the module-name is 'builtins
+     ;; or in the situation of
+     ;; '[builtins.list :as python.pylist]
+     ;; 'python would be bound to :module-name-or-ns
+     :module-name-or-ns (if (and (pyclass? cls)
+                                 (or (symbol? module-name-or-ns)
+                                     (string? module-name-or-ns)))
+                          (module-path-string module-name-or-ns)
+                          module-name-or-ns)
+
+     ;; presumes possibilty of alias in situations like
+     ;; '[builtins.list :as python.pylist]
+     ;; 'pylist would be bound to :class-name-or-ns in this case
+
+     :class-name-or-ns (if (and (pyclass? cls)
+                                (or (symbol? module-name-or-ns)
+                                    (string? module-name-or-ns)))
+                         (module-path-last-string module-name-or-ns)
+                         nil)
+
      :exclude           exclude
      :refer             refer
      :current-ns        current-ns
      :current-ns-sym    current-ns-sym
      :python-namespace  python-namespace
-     :this-module       this-module}))
+     :this-module       this-module
+     :module?           (pymodule? this-module)
+     :class?            (pyclass? cls)
+     :class-name        (when (pyclass? cls)
+                          (module-path-last-string
+                           module-name))}))
 
 (defn- extract-public-data
   [{:keys [exclude python-namespace module-name-or-ns]}]
@@ -364,8 +456,13 @@
                       this-module
                       module-name
                       module-name-or-ns]
+    cls?             :class?
     python-namespace :python-namespace}]
+
+  ;; in the event of '[builtins.list :as python.pylist]
+  ;; this function is a no-op
   (cond
+    cls?                   nil
     reload?                (reload-python-ns! module-name
                                               this-module
                                               module-name-or-ns)
@@ -373,21 +470,29 @@
 
 (defn enhanced-python-lib-configuration
   [{:keys [python-namespace exclude this-module]
+    cls? :class?
     :as   lib-config}]
-  (let [public-data (extract-public-data lib-config)]
-    (merge
-     lib-config
-     {:public-data   public-data
-      :refer-symbols (extract-refer-symbols lib-config
-                                            public-data)})))
+  ;; in the even of '[builtins.list :as python.pylist]
+  ;; or something similar, we do not provide enhanced
+  ;; data
+  (if cls?
+    lib-config
+    (let [public-data (extract-public-data lib-config)]
+      (merge
+       lib-config
+       {:public-data   public-data
+        :refer-symbols (extract-refer-symbols
+                        lib-config
+                        public-data)}))))
 
 (defn- bind-py-symbols-to-ns!
   [{:keys [reload?
            python-namespace
            this-module
            module-name-or-ns
-           no-arglists?]}]
-  (when (or reload? (not python-namespace))
+           no-arglists?]
+    cls?   :class?}]
+  (when (and (or reload? (not python-namespace)) (not cls?))
     ;;Mutably define the root namespace.
     (doseq [[att-name v] (vars this-module)]
       (try
@@ -401,20 +506,59 @@
           (log/warnf e "Failed to require symbol %s" att-name))))))
 
 (defn- bind-module-ns!
-  [{:keys [current-ns-sym module-name-or-ns this-module]}]
-  (intern current-ns-sym
-          (with-meta module-name-or-ns
-            {:doc (doc this-module)})
-          this-module))
+  [{:keys [current-ns-sym
+           module-name-or-ns
+           class-name-or-ns
+           this-module]
+    cls? :class?}]
+
+  ;; in event of '[builtins.list :as python.pylist]
+  ;; this is a no-op
+  (when (not cls?)
+    (intern current-ns-sym
+            (with-meta module-name-or-ns
+              {:doc (doc this-module)})
+            this-module)))
 
 (defn- generate-class-namespace-configs
-  [{:keys [module-name-or-ns this-module] :as lib-config}]
-  (letfn [(pyclass-pair? [[attr attr-val]] (pyclass? attr-val))
+  [{:keys [module-name-or-ns
+           this-module
+           class-name
+           class-name-or-ns
+           ]
+    cls?  :class?
+    :as   lib-config}]
+  (letfn [(pyclass-pair? [[attr attr-val]]
+
+            (or
+
+             ;; in the event that something like
+             ;; builtins.list was requested,
+             ;; we do not want to bind every
+             ;; class in the module to the ns, only the
+             ;; requested class
+
+             (and cls?
+                  (pyclass? attr-val)
+                  (and (hasattr attr-val "__name__")
+                       (= class-name
+                          (py/get-attr
+                           attr-val
+                           "__name__"))))
+
+             ;; if a module like 'builtins was specified
+             ;; without a class like 'builtins.list,
+             ;; we bind every class in the module to the module-ns
+
+             (and (not cls?)
+                  (pyclass? attr-val))))
           (pyclass-ns-config [[attr attr-val]]
             {:namespace      module-name-or-ns
              :attribute-type :class
-             :classname      attr
+             :classname      attr             
              :class-symbol   (symbol attr)
+             :class-binding  (or class-name-or-ns
+                                 class-name)
              :class          attr-val
              :attributes     ((comp
                                (py/get-attr builtins "dict")
@@ -439,6 +583,8 @@
                      (dissoc attr-config :attributes :type)
                      {:attribute-type attr-type
                       :type           :class-attribute
+                      :class-binding  (or class-name-or-ns
+                                          class-name)
                       :attribute      attr-val
                       :attribute-name attr}))))]
     (into []
@@ -461,8 +607,17 @@
     cls-name           :classname
     cls-sym            :class-symbol
     cls                :class
-    :as cls-ns-config}]
-  (let [cls-ns (symbol (str original-namespace "." cls-sym))]
+    cls-binding        :class-binding
+    :as                cls-ns-config}]
+
+  ;; cls-binding percolates down to here in the situation where
+  ;; '[builtins.list :as python.pylist] occurs
+  
+  (let [cls-ns (symbol (str original-namespace
+                            "."
+                            (or
+                             cls-binding
+                             cls-sym)))]
     (create-ns cls-ns)
     cls-ns-config))
 
@@ -471,10 +626,16 @@
     cls-name           :classname
     cls-sym            :class-symbol
     cls                :class
+    cls-binding        :class-binding
     method-name        :attribute-name
     method             :attribute
-    :as cls-ns-config}]
-  (let [cls-ns (symbol (str original-namespace "." cls-sym))]
+    :as                cls-ns-config}]
+
+  ;; cls-binding percolates down to here in the situation where
+  ;; '[builtins.list :as python.pylist] occurs
+
+  (let [cls-ns (symbol (str original-namespace "."
+                            (or  cls-binding cls-sym)))]
     (load-py-fn method (symbol method-name)
                 cls-ns {})
     cls-ns-config))
@@ -484,16 +645,23 @@
     cls-name           :classname
     cls-sym            :class-symbol
     cls                :class
+    cls-binding        :class-binding
     attribute-name     :attribute-name
     attribute          :attribute
-    :as cls-ns-config}]
-  (let [cls-ns (symbol (str original-namespace "." cls-sym))]
+    :as                cls-ns-config}]
+
+  ;; cls-binding percolates down to here in the situation where
+  ;; '[builtins.list :as python.pylist] occurs
+
+  (let [cls-ns (symbol (str original-namespace "."
+                            (or  cls-binding cls-sym)))]
     (intern cls-ns (symbol attribute-name) attribute)
     cls-ns-config))
 
-
 (defn- bind-class-namespaces!
-  [lib-config]
+  [{cls?   :class?
+    module :module?
+    :as    lib-config}]
   (let [class-namespace-configs
         (->>
          (generate-class-namespace-configs
@@ -533,11 +701,14 @@
                 this-module
                 python-namespace
                 public-data
-                refer-symbols]
+                refer-symbols
+                class?
+                module?]
          :as   lib-config}
         (preload-python-lib! req)]
 
-    (intern-public-and-refer-symbols! lib-config)
+    (when (not class?)
+      (intern-public-and-refer-symbols! lib-config))
 
     ;; alpha
     ;; TODO: does not respect reloading or much of the other
@@ -622,3 +793,4 @@
     (load-python-lib (vector reqs))
     (vector? reqs)
     (load-python-lib reqs)))
+
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index 95e0cec..1147735 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -112,3 +112,35 @@
     (is (= requests-module this-module))
     (is (= #{'get} refer))
     (is (nil? python-namespace))))
+
+
+(require-python '([builtins :as python]
+                  [builtins.list :as python.pylist]))
+
+;; NOTE -- even though builtins.list has been aliased to
+;; to python.pylist, you are still required to require
+;; "builtins as python" in order to construct a list
+
+(deftest require-python-classes-with-alias-test
+  (let [l (python/list)]
+    (is (= (vec l) []))
+    (python.pylist/append l 1)
+    (is (= (vec l) [1]))
+    (python.pylist/append l 3)
+    (is (= (vec l) [1 3]))
+    (python.pylist/append l 5)
+    (is (= (vec l) [1 3 5]))
+    (is (= python.pylist/append python.list/append))
+    (python.pylist/clear l)
+    (is (= (python/list) (vec l)))))
+
+
+(require-python 'csv.DictWriter)
+
+(deftest require-python-classes
+  ;; simple creation/recall test
+  (is csv.DictWriter/__init__)
+  (is csv.DictWriter/writeheader)
+  (is csv.DictWriter/writerow)
+  (is csv.DictWriter/writerows))
+

From 461e07eb9c76a64364662760213a6bb18524e9f8 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 22 Dec 2019 10:41:44 -0700
Subject: [PATCH 111/456] Fixed potential crashes related to delay and added
 error on bad refcount.

---
 src/libpython_clj/python/bridge.clj | 21 +++++++++---
 src/libpython_clj/python/object.clj | 50 ++++++++++++++++-------------
 2 files changed, 44 insertions(+), 27 deletions(-)

diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index 2e695ad..de258c4 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -779,8 +779,21 @@
   (py-self->jvm-obj self))
 
 
+(defmacro pydelay
+  "Create a delay object that uses only gc reference semantics.  If stack reference
+  semantics happen to be in effect when this delay executes the object may still be
+  reachable by your program when it's reference counts are released leading to
+  bad/crashy behavior.  This ensures that can't happen at the cost of possibly an object
+  sticking around."
+  [& body]
+  `(delay
+     (with-gil
+       (with-bindings {#'pyobj/*pyobject-tracking-flags* [:gc]}
+         ~@body))))
+
+
 (defonce mapping-type
-  (delay
+  (pydelay
     (with-gil
       (let [mod (pyinterop/import-module "collections.abc")
             map-type (py-proto/get-attr mod "MutableMapping")]
@@ -835,7 +848,7 @@
   (py-self->jvm-obj self))
 
 (defonce sequence-type
-  (delay
+  (pydelay
     (let [mod (pyinterop/import-module "collections.abc")
           seq-type (py-proto/get-attr mod "MutableSequence")]
       (pyobj/create-class
@@ -896,7 +909,7 @@
 
 
 (defonce iterable-type
-  (delay
+  (pydelay
     (with-gil
       (let [mod (pyinterop/import-module "collections.abc")
             iter-base-cls (py-proto/get-attr mod "Iterable")]
@@ -939,7 +952,7 @@
 
 
 (defonce iterator-type
-  (delay
+  (pydelay
     (with-gil
       (let [mod (pyinterop/import-module "collections.abc")
             iter-base-cls (py-proto/get-attr mod "Iterator")
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index f5f65b7..33dad65 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -106,6 +106,19 @@
 (def ^:dynamic *pyobject-tracking-flags* [:gc])
 
 
+(defn incref
+  "Incref and return object"
+  [pyobj]
+  (let [pyobj (jna/as-ptr pyobj)]
+    (libpy/Py_IncRef pyobj)
+    pyobj))
+
+
+(defn refcount
+  ^long [pyobj]
+  (long (.ob_refcnt (PyObject. (jna/as-ptr pyobj)))))
+
+
 (defn wrap-pyobject
   "Wrap object such that when it is no longer accessible via the program decref is
   called. Used for new references.  This is some of the meat of the issue, however,
@@ -135,16 +148,20 @@
       (resource/track pyobj
                       #(with-interpreter interpreter
                          (try
-                           (when *object-reference-logging*
-                             (let [obj-data (PyObject. (Pointer. pyobj-value))]
-                               (println (format "releasing object - 0x%x:%4d:%s"
-                                                pyobj-value
-                                                (.ob_refcnt obj-data)
-                                                py-type-name))))
-                           (when *object-reference-tracker*
-                             (swap! *object-reference-tracker*
-                                    update pyobj-value (fn [arg]
-                                                         (dec (or arg 0)))))
+                           (let [refcount (refcount pyobj)
+                                 obj-data (PyObject. (Pointer. pyobj-value))]
+                             (if (< refcount 1)
+                               (log/errorf "Fatal error -- releasing object - 0x%x:%4d:%s
+Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
+                               (when *object-reference-logging*
+                                 (println (format "releasing object - 0x%x:%4d:%s"
+                                                  pyobj-value
+                                                  (.ob_refcnt obj-data)
+                                                  py-type-name))))
+                             (when *object-reference-tracker*
+                               (swap! *object-reference-tracker*
+                                      update pyobj-value (fn [arg]
+                                                           (dec (or arg 0))))))
                            (libpy/Py_DecRef (Pointer. pyobj-value))
                            (catch Throwable e
                              (log/error e "Exception while releasing object"))))
@@ -172,19 +189,6 @@
       (wrap-pyobject pyobj))))
 
 
-(defn incref
-  "Incref and return object"
-  [pyobj]
-  (let [pyobj (jna/as-ptr pyobj)]
-    (libpy/Py_IncRef pyobj)
-    pyobj))
-
-
-(defn refcount
-  [pyobj]
-  (.ob_refcnt (PyObject. (jna/as-ptr pyobj))))
-
-
 (defn py-true
   []
   (libpy/Py_True))

From 2f69fed89b2be7e38882b0f747e30ef7676ce23c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 22 Dec 2019 10:43:04 -0700
Subject: [PATCH 112/456] editing changelog

---
 CHANGELOG.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0cceae8..06a3d40 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Time for a ChangeLog!
 
+## 1.30-SNAPSHOT
+
+
+* Fixed potential crash related to use of delay mechanism and stack based gc.
+* Added logging to complain loudly if refcounts appear to be bad.
+
 
 ## 1.29
 

From e655f80a2669c8163e538f9ce9f74b7521c87454 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 25 Dec 2019 08:47:33 -0700
Subject: [PATCH 113/456] Deeper datatype integration (#38)

* Some numpy functionality if datatype is upgraded.

* added unit test for basic binary op.

* Differentiating between python object ptrs and data ptrs

* numpy <-> datatype integration
---
 project.clj                                  |   2 +-
 src/libpython_clj/jna.clj                    |   9 +-
 src/libpython_clj/jna/base.clj               |  11 ++
 src/libpython_clj/jna/concrete/bytes.clj     |   3 +-
 src/libpython_clj/jna/concrete/cfunction.clj |   3 +-
 src/libpython_clj/jna/interpreter.clj        |   1 +
 src/libpython_clj/jna/protocols/object.clj   |   5 +-
 src/libpython_clj/python.clj                 |  27 +--
 src/libpython_clj/python/bridge.clj          |  39 ++--
 src/libpython_clj/python/interop.clj         |   4 +-
 src/libpython_clj/python/interpreter.clj     |   2 +-
 src/libpython_clj/python/np_array.clj        | 180 +++++++++++++++++++
 src/libpython_clj/python/object.clj          |  20 +--
 test/libpython_clj/python/numpy_test.clj     |  21 +++
 14 files changed, 263 insertions(+), 64 deletions(-)
 create mode 100644 src/libpython_clj/python/np_array.clj
 create mode 100644 test/libpython_clj/python/numpy_test.clj

diff --git a/project.clj b/project.clj
index f3a93f5..c4414a3 100644
--- a/project.clj
+++ b/project.clj
@@ -5,7 +5,7 @@
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
                  [camel-snake-kebab "0.4.0"]
-                 [techascent/tech.datatype "4.61"]
+                 [techascent/tech.datatype "4.65"]
                  [cheshire "5.9.0"]]
   :repl-options {:init-ns user}
   :java-source-paths ["java"])
diff --git a/src/libpython_clj/jna.clj b/src/libpython_clj/jna.clj
index 2121f5d..9ae0c1e 100644
--- a/src/libpython_clj/jna.clj
+++ b/src/libpython_clj/jna.clj
@@ -5,10 +5,7 @@
             [tech.v2.datatype.typecast :as typecast]
             [camel-snake-kebab.core :refer [->kebab-case]]
             [tech.parallel.utils :refer [export-symbols]]
-            [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj]
-             :as libpy-base]
+            [libpython-clj.jna.base :as libpy-base]
             [libpython-clj.jna.base]
             [libpython-clj.jna.interpreter :as jnainterp]
             [libpython-clj.jna.protocols.object]
@@ -34,7 +31,9 @@
 
 
 (export-symbols libpython-clj.jna.base
-                find-pylib-symbol)
+                find-pylib-symbol
+                as-pyobj
+                ensure-pyobj)
 
 
 (export-symbols libpython-clj.jna.interpreter
diff --git a/src/libpython_clj/jna/base.clj b/src/libpython_clj/jna/base.clj
index b179fd6..9cdf94b 100644
--- a/src/libpython_clj/jna/base.clj
+++ b/src/libpython_clj/jna/base.clj
@@ -33,6 +33,17 @@
   (convertible-to-pyobject-ptr? [item] true)
   (->py-object-ptr [item] item))
 
+(extend-type Object
+  PToPyObjectPtr
+  (convertible-to-pyobject-ptr? [item] (jna/is-jna-ptr-convertible? item))
+  (->py-object-ptr [item] (jna/->ptr-backing-store item)))
+
+
+(defn as-pyobj
+  [item]
+  (when (and item (convertible-to-pyobject-ptr? item))
+    (->py-object-ptr item)))
+
 
 (defn ensure-pyobj
   [item]
diff --git a/src/libpython_clj/jna/concrete/bytes.clj b/src/libpython_clj/jna/concrete/bytes.clj
index 8082853..2c510ef 100644
--- a/src/libpython_clj/jna/concrete/bytes.clj
+++ b/src/libpython_clj/jna/concrete/bytes.clj
@@ -1,6 +1,7 @@
 (ns libpython-clj.jna.concrete.bytes
   (:require [libpython-clj.jna.base
              :refer [def-pylib-fn
+                     as-pyobj
                      ensure-pyobj
                      ensure-pytuple
                      ensure-pydict
@@ -80,7 +81,7 @@
   Integer
   [obj ensure-pyobj]
   [ptr-to-buffer jna/ensure-ptr-ptr]
-  [length jna/as-ptr])
+  [length as-pyobj])
 
 
 
diff --git a/src/libpython_clj/jna/concrete/cfunction.clj b/src/libpython_clj/jna/concrete/cfunction.clj
index d078a9e..05d9765 100644
--- a/src/libpython_clj/jna/concrete/cfunction.clj
+++ b/src/libpython_clj/jna/concrete/cfunction.clj
@@ -2,6 +2,7 @@
   (:require [libpython-clj.jna.base
              :refer [def-pylib-fn
                      ensure-pyobj
+                     as-pyobj
                      ensure-pytuple
                      ensure-pydict
                      size-t-type
@@ -54,7 +55,7 @@
   "Create a new callable from an item."
   Pointer
   [method-def (partial jna/ensure-type PyMethodDef)]
-  [self jna/as-ptr])
+  [self as-pyobj])
 
 
 (def-pylib-fn PyInstanceMethod_New
diff --git a/src/libpython_clj/jna/interpreter.clj b/src/libpython_clj/jna/interpreter.clj
index 9a6bacc..59dcabe 100644
--- a/src/libpython_clj/jna/interpreter.clj
+++ b/src/libpython_clj/jna/interpreter.clj
@@ -2,6 +2,7 @@
   (:require [libpython-clj.jna.base
              :refer [def-pylib-fn
                      def-no-gil-pylib-fn
+                     as-pyobj
                      ensure-pyobj
                      ensure-pytuple
                      ensure-pydict
diff --git a/src/libpython_clj/jna/protocols/object.clj b/src/libpython_clj/jna/protocols/object.clj
index e2f9691..32c2847 100644
--- a/src/libpython_clj/jna/protocols/object.clj
+++ b/src/libpython_clj/jna/protocols/object.clj
@@ -2,6 +2,7 @@
   (:require [libpython-clj.jna.base
              :refer [def-pylib-fn
                      ensure-pyobj
+                     as-pyobj
                      ensure-pytuple
                      ensure-pydict
                      size-t-type
@@ -288,7 +289,7 @@
   Pointer
   [callable ensure-pyobj]
   [args ensure-pytuple]
-  [kwargs jna/as-ptr])
+  [kwargs as-pyobj])
 
 (def-pylib-fn PyObject_CallObject
   "Return value: New reference.
@@ -301,7 +302,7 @@
    This is the equivalent of the Python expression: callable(*args)."
   Pointer
   [callable ensure-pyobj]
-  [args jna/as-ptr])
+  [args as-pyobj])
 
 
 (def-pylib-fn PyObject_Hash
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 1eaa601..0cb0c75 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -5,7 +5,9 @@
              :refer [with-interpreter]]
             [libpython-clj.python.object :as pyobj]
             [libpython-clj.python.bridge :as pybridge]
-            [libpython-clj.jna :as pyjna]
+            [libpython-clj.jna :as libpy]
+            ;;Protocol implementations purely for nd-ness
+            [libpython-clj.python.np-array]
             [tech.jna :as jna])
   (:import [com.sun.jna Pointer]
            [com.sun.jna.ptr PointerByReference]
@@ -246,20 +248,9 @@
   :ok)
 
 
-(defn jvm-type-test
-  []
-  (initialize! :no-io-redirect? true)
-  (let [retval
-        (-> (add-module "libpython_clj")
-            (get-attr "jvm_bridge_type")
-            (jna/as-ptr))]
-    (println (.ob_refcnt (libpython_clj.jna.PyObject. retval)))
-    retval))
-
-
 (defn ptr-refcnt
   [item]
-  (-> (jna/as-ptr item)
+  (-> (libpy/as-pyobj item)
       (libpython_clj.jna.PyObject. )
       (.ob_refcnt)))
 
@@ -277,7 +268,7 @@
   (let [ptype# (PointerByReference.)
         pvalue# (PointerByReference.)
         ptraceback# (PointerByReference.)
-        _# (pyjna/PyErr_Fetch ptype# pvalue# ptraceback#)
+        _# (libpy/PyErr_Fetch ptype# pvalue# ptraceback#)
         ptype# (-> (jna/->ptr-backing-store ptype#)
                    (pyobj/wrap-pyobject true))
         pvalue# (-> (jna/->ptr-backing-store pvalue#)
@@ -308,10 +299,10 @@
           (do
             ;;Manual incref here because we cannot detach the object
             ;;from our gc decref hook added during earlier pyerr-fetch handler.
-            (pyjna/Py_IncRef ptype)
-            (pyjna/Py_IncRef pvalue)
-            (pyjna/Py_IncRef ptraceback)
-            (pyjna/PyErr_Restore ptype pvalue ptraceback)
+            (libpy/Py_IncRef ptype)
+            (libpy/Py_IncRef pvalue)
+            (libpy/Py_IncRef ptraceback)
+            (libpy/PyErr_Restore ptype pvalue ptraceback)
             (pyinterp/check-error-throw))))
       (do
         (call-attr with-var "__exit__" nil nil nil)
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index de258c4..a385f70 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -209,14 +209,14 @@
 
 
 
-(defn- mostly-copy-arg
+(defn mostly-copy-arg
   "This is the dirty boundary between the languages.  Copying as often faster
   for simple things but we have to be careful not to attempt a copy of things that
   are only iterable (and not random access)."
   [arg]
   (cond
-    (jna/as-ptr arg)
-    (jna/as-ptr arg)
+    (libpy/as-pyobj arg)
+    (libpy/as-pyobj arg)
     (dtype/reader? arg)
     (->python arg)
     (instance? Map arg)
@@ -233,12 +233,9 @@
          interpreter# ~interpreter]
      (with-meta
        (reify
-         jna/PToPtr
-         (is-jna-ptr-convertible? [item#] true)
-         (->ptr-backing-store [item#] (jna/as-ptr pyobj#))
          libpy-base/PToPyObjectPtr
          (convertible-to-pyobject-ptr? [item#] true)
-         (->py-object-ptr [item#] (jna/as-ptr pyobj#))
+         (->py-object-ptr [item#] (libpy/as-pyobj pyobj#))
          py-proto/PPythonType
          (get-python-type [item]
            (with-interpreter interpreter#
@@ -513,6 +510,10 @@
 
 (defn obj-dtype->dtype
   [py-dtype]
+  (when-let [fields (get-attr py-dtype "fields")]
+    (throw (ex-info (format "Cannot convert numpy object with fields: %s"
+                            (call-attr fields "__str__"))
+                    {})))
   (if-let [retval (->> (py-proto/get-attr py-dtype "name")
                        (get py-dtype->dtype-map))]
     retval
@@ -524,18 +525,10 @@
 (defn numpy->desc
   [np-obj]
   (with-gil
-    (let [np-obj (as-jvm np-obj)
-          np (-> (pyinterop/import-module "numpy")
-                 (as-jvm))
-          ctypes (get-attr np-obj "ctypes")
-          ptr-dtype (-> (call-attr np "dtype" "p")
-                        obj-dtype->dtype)
-          obj-dtype (get-attr np-obj "dtype")
-          np-dtype  (obj-dtype->dtype obj-dtype)
-          _ (when-let [fields (get-attr obj-dtype "fields")]
-              (throw (ex-info (format "Cannot convert numpy object with fields: %s"
-                                      (call-attr fields "__str__"))
-                              {})))
+    (let [np (pyinterop/import-module "numpy")
+          ctypes (py-proto/as-jvm (get-attr np-obj "ctypes") {})
+          np-dtype (-> (py-proto/as-jvm (get-attr np-obj "dtype") {})
+                       (obj-dtype->dtype))
           shape (-> (get-attr ctypes "shape")
                     (as-list)
                     vec)
@@ -830,7 +823,7 @@
 (defn jvm-map-as-python
   [^Map jvm-data]
   (with-gil
-    (py-proto/call (jna/as-ptr (deref mapping-type)) (make-jvm-object-handle jvm-data))))
+    (py-proto/call (libpy/as-pyobj (deref mapping-type)) (make-jvm-object-handle jvm-data))))
 
 
 (defmethod py-proto/pyobject->jvm :jvm-map-as-python
@@ -895,7 +888,7 @@
 (defn jvm-list-as-python
   [^List jvm-data]
   (with-gil
-    (py-proto/call (jna/as-ptr (deref sequence-type)) (make-jvm-object-handle jvm-data))))
+    (py-proto/call (libpy/as-pyobj (deref sequence-type)) (make-jvm-object-handle jvm-data))))
 
 
 (defmethod py-proto/pyobject->jvm :jvm-list-as-python
@@ -938,7 +931,7 @@
 (defn jvm-iterable-as-python
   [^Iterable jvm-data]
   (with-gil
-    (py-proto/call (jna/as-ptr (deref iterable-type)) (make-jvm-object-handle jvm-data))))
+    (py-proto/call (libpy/as-pyobj (deref iterable-type)) (make-jvm-object-handle jvm-data))))
 
 
 (defmethod py-proto/pyobject->jvm :jvm-iterable-as-python
@@ -993,7 +986,7 @@
 (defn jvm-iterator-as-python
   [^Iterator jvm-data]
   (with-gil
-    (py-proto/call (jna/as-ptr (deref iterator-type)) (make-jvm-object-handle jvm-data))))
+    (py-proto/call (libpy/as-pyobj (deref iterator-type)) (make-jvm-object-handle jvm-data))))
 
 
 (defmethod py-proto/pyobject->jvm :jvm-iterator-as-python
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
index 935eed6..55713a3 100644
--- a/src/libpython_clj/python/interop.clj
+++ b/src/libpython_clj/python/interop.clj
@@ -340,7 +340,7 @@
                    (pyinvoke [this self]
                      (if-let [attr (-> (pybridge->bridge self)
                                          (.getAttr "__iter__"))]
-                       (libpy/PyObject_CallObject (jna/as-ptr attr) nil)
+                       (libpy/PyObject_CallObject (libpy/as-pyobj attr) nil)
                        (do
                          (libpy/PyErr_SetNone (libpy/PyExc_Exception))
                          nil))))
@@ -348,7 +348,7 @@
                        (pyinvoke [this self]
                          (if-let [next (-> (pybridge->bridge self)
                                            (.getAttr "__next__"))]
-                           (libpy/PyObject_CallObject (jna/as-ptr next) nil)
+                           (libpy/PyObject_CallObject (libpy/as-pyobj next) nil)
                            (do
                              (libpy/PyErr_SetNone (libpy/PyExc_Exception))
                              nil))))}))))
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index aa560bb..ec023f8 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -328,7 +328,7 @@ print(json.dumps(
   "Get a keyword that corresponds to the current type.  Uses global type symbol
   table. Add the type to the symbol table if it does not exist already."
   [typeobj]
-  (let [type-addr (Pointer/nativeValue (jna/as-ptr typeobj))
+  (let [type-addr (Pointer/nativeValue (libpy/as-pyobj typeobj))
         interpreter (ensure-bound-interpreter)
         symbol-table (-> (swap! (:shared-state* interpreter)
                                 (fn [{:keys [type-symbol-table] :as shared-state}]
diff --git a/src/libpython_clj/python/np_array.clj b/src/libpython_clj/python/np_array.clj
new file mode 100644
index 0000000..a9076cd
--- /dev/null
+++ b/src/libpython_clj/python/np_array.clj
@@ -0,0 +1,180 @@
+(ns libpython-clj.python.np-array
+  (:require [tech.v2.datatype.protocols :as dtype-proto]
+            [tech.v2.datatype.operation-provider :as op-provider]
+            [tech.v2.tensor :as dtt]
+            [tech.v2.datatype.argtypes :as argtypes]
+            [libpython-clj.python.interpreter :as py-interp]
+            [libpython-clj.python.protocols :as py-proto]
+            [libpython-clj.python.bridge :as py-bridge]
+            [libpython-clj.python.object :as py-object]
+            [libpython-clj.python.interop :as py-interop]
+            [tech.jna :as jna]))
+
+
+
+(defmethod py-proto/pyobject->jvm :ndarray
+  [pyobj]
+  (-> (py-bridge/numpy->desc pyobj)
+      (dtt/buffer-descriptor->tensor)
+      (dtt/clone)))
+
+
+(defmethod py-proto/pyobject-as-jvm :ndarray
+  [pyobj]
+  (py-interp/with-gil
+    (let [interpreter (py-interp/ensure-bound-interpreter)]
+      (py-bridge/bridge-pyobject
+       pyobj
+       interpreter
+       Iterable
+       (iterator [this]
+                 (py-proto/python-obj-iterator pyobj interpreter))
+       py-proto/PPyObjectBridgeToMap
+       (as-map [item]
+               (py-bridge/generic-python-as-map pyobj))
+       py-proto/PPyObjectBridgeToList
+       (as-list [item]
+                (py-bridge/generic-python-as-list pyobj))
+       py-proto/PPyObjectBridgeToTensor
+       (as-tensor [item]
+                  (-> (py-bridge/numpy->desc item)
+                      dtt/buffer-descriptor->tensor))
+       dtype-proto/PDatatype
+       (get-datatype
+        [this]
+        (-> (py-proto/get-attr pyobj "dtype")
+            (py-proto/as-jvm {})
+            (py-bridge/obj-dtype->dtype)))
+
+
+       dtype-proto/POperationType
+       (operation-type
+        [this]
+        :numpy-array)
+
+       dtype-proto/PCountable
+       (ecount [this] (apply * (dtype-proto/shape this)))
+
+       dtype-proto/PShape
+       (shape
+        [this]
+        (-> (py-proto/get-attr pyobj "shape")
+            (py-proto/->jvm {})))
+
+       dtype-proto/PToNioBuffer
+       (convertible-to-nio-buffer? [item] true)
+       (->buffer-backing-store
+        [item]
+        (-> (py-proto/as-tensor item)
+            (dtype-proto/->buffer-backing-store)))
+
+       dtype-proto/PToJNAPointer
+       (convertible-to-data-ptr? [item] true)
+       (->jna-ptr
+        [item]
+        (:ptr (py-bridge/numpy->desc item)))
+
+       dtype-proto/PBuffer
+       (sub-buffer
+        [buffer offset length]
+        (-> (py-proto/as-tensor buffer)
+            (dtype-proto/sub-buffer offset length)))
+
+       dtype-proto/PToBufferDesc
+       (convertible-to-buffer-desc? [item] true)
+       (->buffer-descriptor
+        [item]
+        (py-bridge/numpy->desc item))
+
+       dtype-proto/PToReader
+       (convertible-to-reader? [item] true)
+       (->reader
+        [item options]
+        (-> (py-proto/as-tensor item)
+            (dtype-proto/->reader options)))
+
+       dtype-proto/PToWriter
+       (convertible-to-writer? [item] true)
+       (->writer
+        [item options]
+        (-> (py-proto/as-tensor item)
+            (dtype-proto/->writer options)))))))
+
+
+(def np-mod
+  (py-bridge/pydelay
+   (-> (py-interop/import-module "numpy")
+       (py-proto/as-jvm {}))))
+
+
+(defn- dispatch-unary-op
+  [op lhs options]
+  (if (keyword? op)
+    (if (= op :-)
+      (py-proto/call-attr lhs "__neg__")
+      (py-proto/call-attr @np-mod (name op) lhs))
+    (throw (Exception. "Unimplemented"))))
+
+
+(defmethod op-provider/half-dispatch-unary-op :numpy-array
+  [op lhs options]
+  (dispatch-unary-op op lhs options))
+
+
+(defmethod op-provider/half-dispatch-boolean-unary-op :numpy-array
+  [op lhs options]
+  (dispatch-unary-op op lhs options))
+
+
+(defn- dispatch-binary-op
+  [op lhs rhs options]
+  (case op
+    :max (py-proto/call-attr @np-mod "max" lhs rhs)
+    :min (py-proto/call-attr @np-mod "min" lhs rhs)
+    :+ (py-proto/call-attr @np-mod "add" lhs rhs)
+    :- (py-proto/call-attr @np-mod "subtract" lhs rhs)
+    :div (py-proto/call-attr @np-mod "divide" lhs rhs)
+    :* (py-proto/call-attr @np-mod "multiply" lhs rhs)
+    :pow (py-proto/call-attr @np-mod "power" lhs rhs)
+    :quot (py-proto/call-attr @np-mod "floor_divide" lhs rhs)
+    :rem (py-proto/call-attr @np-mod "mod" lhs rhs)
+    :bit-and (py-proto/call-attr @np-mod "bitwise_and" lhs rhs)
+    :bit-flip (py-proto/call-attr @np-mod "bitwise_not" lhs rhs)
+    :bit-or (py-proto/call-attr @np-mod "bitwise_or" lhs rhs)
+    :bit-xor (py-proto/call-attr @np-mod "bitwise_xor" lhs rhs)
+    :bit-shift-left (py-proto/call-attr @np-mod "left_shift" lhs rhs)
+    :bit-shift-right (py-proto/call-attr @np-mod "right_shift" lhs rhs)
+    :and (py-proto/call-attr @np-mod "logical_and" lhs rhs)
+    :or (py-proto/call-attr @np-mod "logical_or" lhs rhs)
+    :not (py-proto/call-attr @np-mod "logical_not" lhs rhs)
+    :xor (py-proto/call-attr @np-mod "logical_xor" lhs rhs)
+    :< (py-proto/call-attr @np-mod "less" lhs rhs)
+    :<= (py-proto/call-attr @np-mod "less_equal" lhs rhs)
+    :eq (py-proto/call-attr @np-mod "equal" lhs rhs)
+    :> (py-proto/call-attr @np-mod "greater" lhs rhs)
+    :>= (py-proto/call-attr @np-mod "greater_equal" lhs rhs)))
+
+
+(def binary-op-dispatch-table
+  [[:numpy-array :scalar]
+   [:scalar :numpy-array]
+   [:numpy-array :numpy-array]])
+
+
+(defmacro implement-binary-ops
+  []
+  `(do
+     ~@(for [targets binary-op-dispatch-table]
+         `(do
+            (defmethod op-provider/half-dispatch-binary-op
+              ~targets
+              [op# lhs# rhs# options#]
+              (dispatch-binary-op op# lhs# rhs# options#))
+            (defmethod op-provider/half-dispatch-boolean-binary-op
+              ~targets
+              [op# lhs# rhs# options#]
+              (dispatch-binary-op op# lhs# rhs# options#))
+            ))))
+
+
+(implement-binary-ops)
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 33dad65..2c6f8be 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -109,14 +109,14 @@
 (defn incref
   "Incref and return object"
   [pyobj]
-  (let [pyobj (jna/as-ptr pyobj)]
+  (let [pyobj (libpy/as-pyobj pyobj)]
     (libpy/Py_IncRef pyobj)
     pyobj))
 
 
 (defn refcount
   ^long [pyobj]
-  (long (.ob_refcnt (PyObject. (jna/as-ptr pyobj)))))
+  (long (.ob_refcnt (PyObject. (libpy/as-pyobj pyobj)))))
 
 
 (defn wrap-pyobject
@@ -129,10 +129,10 @@
     (check-error-throw))
   ;;We don't wrap pynone
   (if (and pyobj
-             (not= (Pointer/nativeValue (jna/as-ptr pyobj))
-                   (Pointer/nativeValue (jna/as-ptr (libpy/Py_None)))))
+             (not= (Pointer/nativeValue (libpy/as-pyobj pyobj))
+                   (Pointer/nativeValue (libpy/as-pyobj (libpy/Py_None)))))
     (let [interpreter (ensure-bound-interpreter)
-          pyobj-value (Pointer/nativeValue (jna/as-ptr pyobj))
+          pyobj-value (Pointer/nativeValue (libpy/as-pyobj pyobj))
           py-type-name (name (python-type pyobj))]
       (when *object-reference-logging*
         (let [obj-data (PyObject. (Pointer. pyobj-value))]
@@ -184,7 +184,7 @@ Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
   references that need to escape the current scope."
   [pyobj]
   (with-gil
-    (let [pyobj (jna/as-ptr pyobj)]
+    (let [pyobj (libpy/as-pyobj pyobj)]
       (libpy/Py_IncRef pyobj)
       (wrap-pyobject pyobj))))
 
@@ -220,7 +220,7 @@ Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
 
 (defn py-raw-type
   ^Pointer [pyobj]
-  (let [pyobj (PyObject. (jna/as-ptr pyobj))]
+  (let [pyobj (PyObject. (libpy/as-pyobj pyobj))]
     (.ob_type pyobj)))
 
 
@@ -990,8 +990,8 @@ Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
       (loop [next-retval (libpy/PyDict_Next pyobj ppos pkey pvalue)]
         (if (not= 0 next-retval)
           (do
-            (.add retval [(jna/as-ptr pkey)
-                          (jna/as-ptr pvalue)])
+            (.add retval [(libpy/as-pyobj pkey)
+                          (libpy/as-pyobj pvalue)])
             (recur (libpy/PyDict_Next pyobj ppos pkey pvalue)))
           (->> retval
                (map (fn [[k v]]
@@ -1093,7 +1093,7 @@ Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
       (python->jvm-copy-persistent-vector pyobj)
       :else
       {:type (python-type pyobj)
-       :value (Pointer/nativeValue (jna/as-ptr pyobj))})))
+       :value (Pointer/nativeValue (libpy/as-pyobj pyobj))})))
 
 
 (defn is-instance?
diff --git a/test/libpython_clj/python/numpy_test.clj b/test/libpython_clj/python/numpy_test.clj
new file mode 100644
index 0000000..0d98463
--- /dev/null
+++ b/test/libpython_clj/python/numpy_test.clj
@@ -0,0 +1,21 @@
+(ns libpython-clj.python.numpy-test
+  (:require [libpython-clj.python :as py]
+            [tech.v2.datatype :as dtype]
+            [tech.v2.datatype.functional :as dfn]
+            [tech.v2.tensor :as dtt]
+            [clojure.test :refer :all]))
+
+(py/initialize!)
+
+(def np-mod (py/import-module "numpy"))
+
+
+;;The basic math operations of the dfn namespace must work on numpy objects.
+(deftest basic-numpy
+  (let [test-data [[1 2] [3 4]]
+        np-ary (py/$a np-mod array test-data)
+        tens (dtt/->tensor test-data)]
+    (is (dfn/equals (dfn/- np-ary 4)
+                    (dfn/- tens 4)))
+    (is (dfn/equals [1 2 3 4]
+                    (dtype/make-container :java-array :int64 np-ary)))))

From 961377cfbc118641ec837f9e04127cecd1054a88 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 25 Dec 2019 09:10:30 -0700
Subject: [PATCH 114/456] Readying changelog

---
 CHANGELOG.md | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 06a3d40..c47f429 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,27 @@
 
 ## 1.30-SNAPSHOT
 
+This release is a big one.  With finalizing `require-python` we have a clear way
+to use python in daily use and make it look good in normal clojure usage.  There 
+is a demo of [facial recognition](https://github.com/cnuernber/facial-rec) using some 
+of the best open systems for doing this; this demo would absolutely not be possible 
+without this library due to the extensive use of numpy and cython to implement the 
+face detection.  We can now interact with even very complex python systems with 
+roughly the same performance as a pure-python system.
+
+#### Finalized `require-python`
+
+Lots of work put in to make the require-python pathway work with
+classes and some serious refactoring overall.
+
+#### Better Numpy Support
+
+* Most of the datatype libraries math operators supported by numpy objects (+,-,etc).
+* Numpy objects can be used in datatype library functions (like copy, make-container)
+  and work in optimized ways.
+
+
+#### Bugs Fixed
 
 * Fixed potential crash related to use of delay mechanism and stack based gc.
 * Added logging to complain loudly if refcounts appear to be bad.

From a519172f59202126221ee4ba19d6465ff47c6762 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 25 Dec 2019 09:47:04 -0700
Subject: [PATCH 115/456] editing

---
 CHANGELOG.md | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c47f429..08a3494 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,11 +3,11 @@
 ## 1.30-SNAPSHOT
 
 This release is a big one.  With finalizing `require-python` we have a clear way
-to use python in daily use and make it look good in normal clojure usage.  There 
-is a demo of [facial recognition](https://github.com/cnuernber/facial-rec) using some 
-of the best open systems for doing this; this demo would absolutely not be possible 
-without this library due to the extensive use of numpy and cython to implement the 
-face detection.  We can now interact with even very complex python systems with 
+to use python in daily use and make it look good in normal clojure usage.  There
+is a demo of [facial recognition](https://github.com/cnuernber/facial-rec) using some
+of the best open systems for doing this; this demo would absolutely not be possible
+without this library due to the extensive use of numpy and cython to implement the
+face detection.  We can now interact with even very complex python systems with
 roughly the same performance as a pure-python system.
 
 #### Finalized `require-python`
@@ -21,6 +21,25 @@ classes and some serious refactoring overall.
 * Numpy objects can be used in datatype library functions (like copy, make-container)
   and work in optimized ways.
 
+```clojure
+libpython-clj.python.numpy-test> (def test-ary (py/$a np-mod array (->> (range 9)
+                                                                        (partition 3)
+                                                                        (mapv vec))))
+#'libpython-clj.python.numpy-test/test-ary
+libpython-clj.python.numpy-test> test-ary
+[[0 1 2]
+ [3 4 5]
+ [6 7 8]]
+libpython-clj.python.numpy-test> (dfn/+ test-ary 2)
+[[ 2  3  4]
+ [ 5  6  7]
+ [ 8  9 10]]
+libpython-clj.python.numpy-test> (dfn/> test-ary 4)
+[[False False False]
+ [False False  True]
+ [ True  True  True]]
+```
+
 
 #### Bugs Fixed
 

From b9a45aa8bf686f9c950a6c83fce0140d2c63a0c5 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 25 Dec 2019 15:29:33 -0700
Subject: [PATCH 116/456] Aligning require-python with require

---
 src/libpython_clj/require.clj              | 14 +++++++-------
 test/libpython_clj/require_python_test.clj |  4 +---
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index b7e1363..0e491b0 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -360,7 +360,8 @@
   "Build a configuration map of a python library.  Current ns is option and used
   during testing but unnecessary during normal running events."
   [req & [current-ns]]
-  (let [supported-flags     #{:reload :no-arglists :alpha-load-ns-classes}
+  (let [supported-flags     #{:reload
+                              :no-arglists}
         [module-name & etc] req
         flags               (parse-flags supported-flags etc)
         etc                 (into {}
@@ -372,7 +373,6 @@
                                   etc)
         reload?             (:reload flags)
         no-arglists?        (:no-arglists flags)
-        load-ns-classes?    (:alpha-load-ns-classes flags)
         module-name-or-ns   (:as etc module-name)
         exclude             (into #{} (:exclude etc))
         refer               (cond
@@ -384,13 +384,14 @@
         current-ns          (or current-ns *ns*)
         current-ns-sym      (symbol (str current-ns))
         python-namespace    (find-ns module-name-or-ns)
-        [this-module cls]   (import-module-or-cls! module-name)]
+        [this-module cls]   (import-module-or-cls! module-name)
+        load-ns-classes?    (pyclass? cls)]
 
     {:supported-flags   supported-flags
      :etc               etc
      :reload?           reload?
      :no-arglists?      no-arglists?
-     :load-ns-classes?  true
+     :load-ns-classes?  load-ns-classes?
 
      ;; if something like 'builtins.list was requested,
      ;; the module name is 'builtins
@@ -555,7 +556,7 @@
           (pyclass-ns-config [[attr attr-val]]
             {:namespace      module-name-or-ns
              :attribute-type :class
-             :classname      attr             
+             :classname      attr
              :class-symbol   (symbol attr)
              :class-binding  (or class-name-or-ns
                                  class-name)
@@ -612,7 +613,7 @@
 
   ;; cls-binding percolates down to here in the situation where
   ;; '[builtins.list :as python.pylist] occurs
-  
+
   (let [cls-ns (symbol (str original-namespace
                             "."
                             (or
@@ -793,4 +794,3 @@
     (load-python-lib (vector reqs))
     (vector? reqs)
     (load-python-lib reqs)))
-
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index 1147735..7c35457 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -72,7 +72,7 @@
 
     ;; no exclusions
     (is (= #{} exclude))
-    (is (= #{:no-arglists :reload :alpha-load-ns-classes}
+    (is (= #{:no-arglists :reload}
            supported-flags))
     (is (= 'csv module-name module-name-or-ns))
     (is (nil? reload?))
@@ -130,7 +130,6 @@
     (is (= (vec l) [1 3]))
     (python.pylist/append l 5)
     (is (= (vec l) [1 3 5]))
-    (is (= python.pylist/append python.list/append))
     (python.pylist/clear l)
     (is (= (python/list) (vec l)))))
 
@@ -143,4 +142,3 @@
   (is csv.DictWriter/writeheader)
   (is csv.DictWriter/writerow)
   (is csv.DictWriter/writerows))
-

From 0c73da1f4f3c3934f7f00775d5690466e379c50c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 27 Dec 2019 07:54:52 -0700
Subject: [PATCH 117/456] editing

---
 README.md     | 407 +++++++++++---------------------------------------
 docs/Usage.md | 306 +++++++++++++++++++++++++++++++++++++
 2 files changed, 393 insertions(+), 320 deletions(-)
 create mode 100644 docs/Usage.md

diff --git a/README.md b/README.md
index 7b222ce..3f88b1c 100644
--- a/README.md
+++ b/README.md
@@ -10,350 +10,109 @@ JNA libpython bindings to the tech ecosystem.
 * Python objects are linked to the JVM GC such that when they are no longer reachable
   from the JVM their references are released.  Scope based resource contexts are
   [also available](https://github.com/cnuernber/libpython-clj/blob/master/docs/scopes-and-gc.md).
-* The exact same binary can run top of on multiple version of python reducing version
-  dependency chain management issues.
-* Development of new functionality is faster because it can be done from purely from the
-  REPL.
+* Finding the python libraries is done dynamically allowing one system to run on multiple versions
+  of python.
+* REPL oriented design means fast, smooth, iterative development.
 
 
-#### Clojure Conj 2019
+## Vision
 
-* [video](https://www.youtube.com/watch?v=vQPW16_jixs)
-* [slides](https://docs.google.com/presentation/d/1uegYhpS6P2AtEfhpg6PlgBmTSIPqCXvFTWcGYG_Qk2o/edit?usp=sharing)
+We aim to integrate Python into Clojure at a deep level.  This means that we want to
+be able to load/use python modules almost as if they were Clojure namespaces.  We
+also want to be able to use Clojure to extend Python objects.  I gave a
+[talk at Clojure Conj 2019](https://www.youtube.com/watch?v=vQPW16_jixs) that
+outlines more of what is going on.
 
-
-We have a [video](https://www.youtube.com/watch?v=ajDiGS73i2o) up of a scicloj community
-discussion with demos.
-
-
-TechAscent has a [blog post](http://www.techascent.com/blog/functions-across-languages.html)
-up about how the inter-language bindings actually work at a very low level.
-
-
-A walkthough using libpython-clj to render some graphs via matplotlib is on
-[nextjournal](https://nextjournal.com/chrisn/fun-with-matplotlib).
-
-
-If you want to quickly start using python from clojure your fastest path is probably
-the [panthera](https://github.com/alanmarazzi/panthera) library in addition to
-learning how the primitives in this library work.
-
-
-New to Clojure or the JVM?  Try remixing the nextjournal entry and playing around
-there.  For more resources on learning and getting more comfortable with Clojure,
-we have an [introductory document](docs/new-to-clojure.md).
-
-
-## Usage
-
-
-Python objects are essentially two dictionaries, one for 'attributes' and one for
-'items'.  When you use python and use the '.' operator, you are referencing attributes.
-If you use the '[]' operator, then you are referencing items.  Attributes are built in,
-item access is optional and happens via the `__getitem__` and `__setitem__` attributes.
-This is important to realize in that the code below doesn't look like python because we are
-referencing the item and attribute systems by name and not via '.' or '[]'.
-
-
-### Installation
-
-#### Ubuntu
-
-```console
-sudo apt install libpython3.6
-# numpy and pandas are required for unit tests.  Numpy is required for
-# zero copy support.
-python3.6 -m pip install numpy pandas --user
-```
-
-#### MacOSX
-
-Python installation instructions [here](https://docs.python-guide.org/starting/install3/osx/).
-
-
-
-### Initialize python
+This code is a concrete example that generates an
+[embedding for faces](https://github.com/cnuernber/facial-rec):
 
 ```clojure
-user>
-
-user> (require '[libpython-clj.python
-                 :refer [as-python as-jvm
-                         ->python ->jvm
-                         get-attr call-attr call-attr-kw
-                         get-item att-type-map
-                         call call-kw initialize!
-                         as-numpy as-tensor ->numpy
-                         run-simple-string
-                         add-module module-dict
-                         import-module
-                         python-type]])
-nil
-
-
-user> (initialize!)
-Jun 30, 2019 4:47:39 PM clojure.tools.logging$eval7369$fn__7372 invoke
-INFO: executing python initialize!
-Jun 30, 2019 4:47:39 PM clojure.tools.logging$eval7369$fn__7372 invoke
-INFO: Library python3.6m found at [:system "python3.6m"]
-Jun 30, 2019 4:47:39 PM clojure.tools.logging$eval7369$fn__7372 invoke
-INFO: Reference thread starting
-:ok
+(ns facial-rec.face-feature
+  (:require [libpython-clj.require :refer [require-python]]
+            [libpython-clj.python :as py]
+            [tech.v2.datatype :as dtype]))
+
+
+(require-python '(mxnet mxnet.ndarray mxnet.module mxnet.io mxnet.model))
+(require-python 'cv2)
+(require-python '[numpy :as np])
+
+(defn load-model
+  [& {:keys [model-path checkpoint]
+      :or {model-path "models/recognition/model"
+           checkpoint 0}}]
+  (let [[sym arg-params aux-params] (mxnet.model/load_checkpoint model-path checkpoint)
+        all-layers (py/$a sym get_internals)
+        target-layer (py/get-item all-layers "fc1_output")
+        ;;TODO - We haven't overloaded enough of the IFn invoke methods for
+		;;this to work without using call-kw
+        model (py/call-kw mxnet.module/Module [] {:symbol target-layer :context (mxnet/cpu) :label_names nil})]
+    (py/$a model bind :data_shapes [["data" [1 3 112 112]]])
+    (py/$a model set_params arg-params aux-params)
+    model))
+
+(defonce model (load-model))
+
+(defn face->feature
+  [img-path]
+  (py/with-gil-stack-rc-context
+    (if-let [new-img (cv2/imread img-path)]
+      (let [new-img (cv2/cvtColor new-img cv2/COLOR_BGR2RGB)
+            new-img (np/transpose new-img [2 0 1])
+            input-blob (np/expand_dims new-img :axis 0)
+            data (mxnet.ndarray/array input-blob)
+            batch (mxnet.io/DataBatch :data [data])]
+        (py/$a model forward batch :is_train false)
+        (-> (py/$a model get_outputs)
+            first
+            (py/$a asnumpy)
+            (#(dtype/make-container :java-array :float32 %))))
+      (throw (Exception. (format "Failed to load img: %s" img-path))))))
 ```
 
-This dynamically finds the python shared library and loads it.  If you desire a
-different shared library you can override
-[here](https://github.com/cnuernber/libpython-clj/blob/master/src/libpython_clj/jna/base.clj#L12).
-
-
-### Execute Some Python
-
-`*out*` and `*err*` capture python stdout and stderr respectively.
-
-```clojure
 
-user> (run-simple-string "print('hey')")
-hey
-{:globals
- {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>},
- :locals
- {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}}
-```
-
-The results have been 'bridged' into java meaning they are still python objects but
-there are java wrappers over the top of them.  For instance, `Object.toString` forwards
-its implementation to the python function `__str__`.
-
-```clojure
-(def bridged (run-simple-string "print('hey')"))
-(instance? java.util.Map (:globals bridged))
-true
-user> (:globals bridged)
-{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
-```
-
-We can get and set global variables here.  If we run another string, these are in the
-environment.  The globals map itself is the global dict of the main module:
+## Usage
 
 ```clojure
-(def main-globals (-> (add-module "__main__")
-                            (module-dict)))
-#'user/main-globals
-
-user> main-globals
-{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
-user> (keys main-globals)
-("__name__"
- "__doc__"
- "__package__"
- "__loader__"
- "__spec__"
- "__annotations__"
- "__builtins__")
-user> (get main-globals "__name__")
-"__main__"
-user> (.put main-globals "my_var" 200)
+user> (require '[libpython-clj.require :refer [require-python]])
+...logging info....
 nil
-
-user> (run-simple-string "print('your variable is:' + str(my_var))")
-your variable is:200
-{:globals
- {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'my_var': 200},
- :locals
- {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'my_var': 200}}
-```
-
-Running python isn't ever really necessary, however, although it may at times be
-convenient.  You can call attributes from clojure easily:
-
-```clojure
-user> (def np (import-module "numpy"))
-#'user/np
-user> (def ones-ary (call-attr np "ones" [2 3]))
-#'user/ones-ary
-user> ones-ary
-[[1. 1. 1.]
- [1. 1. 1.]]
-user> (call-attr ones-ary "__len__")
-2
-user> (vec ones-ary)
-[[1. 1. 1.] [1. 1. 1.]]
-user> (type (first *1))
-:pyobject
-user> (get-attr ones-ary "shape")
-(2, 3)
-user> (vec (get-attr ones-ary "shape"))
-[2 3]
-
-user> (att-type-map ones-ary)
-{"T" :ndarray,
- "__abs__" :method-wrapper,
- "__add__" :method-wrapper,
- "__and__" :method-wrapper,
- "__array__" :builtin-function-or-method,
- "__array_finalize__" :none-type,
- "__array_function__" :builtin-function-or-method,
- "__array_interface__" :dict,
- "__array_prepare__" :builtin-function-or-method,
- "__array_priority__" :float,
- "__array_struct__" :py-capsule,
- "__array_ufunc__" :builtin-function-or-method,
- "__array_wrap__" :builtin-function-or-method,
- "__bool__" :method-wrapper,
- "__class__" :type,
- "__complex__" :builtin-function-or-method,
- "__contains__" :method-wrapper,
- ...
- "std" :builtin-function-or-method,
- "strides" :tuple,
- "sum" :builtin-function-or-method,
- "swapaxes" :builtin-function-or-method,
- "take" :builtin-function-or-method,
- "tobytes" :builtin-function-or-method,
- "tofile" :builtin-function-or-method,
- "tolist" :builtin-function-or-method,
- "tostring" :builtin-function-or-method,
- "trace" :builtin-function-or-method,
- "transpose" :builtin-function-or-method,
- "var" :builtin-function-or-method,
- "view" :builtin-function-or-method}
-```
-
-
-### att-type-map
-
-It can be extremely helpful to print out the attribute name->attribute type map:
-
-```clojure
-user> (att-type-map ones-ary)
-{"T" :ndarray,
- "__abs__" :method-wrapper,
- "__add__" :method-wrapper,
- "__and__" :method-wrapper,
- "__array__" :builtin-function-or-method,
- "__array_finalize__" :none-type,
- "__array_function__" :builtin-function-or-method,
- "__array_interface__" :dict,
- ...
-  "real" :ndarray,
- "repeat" :builtin-function-or-method,
- "reshape" :builtin-function-or-method,
- "resize" :builtin-function-or-method,
- "round" :builtin-function-or-method,
- "searchsorted" :builtin-function-or-method,
- "setfield" :builtin-function-or-method,
- "setflags" :builtin-function-or-method,
- "shape" :tuple,
- "size" :int,
- "sort" :builtin-function-or-method,
- ...
-}
-```
-
-
-### Errors
-
-
-Errors are caught and an exception is thrown.  The error text is saved verbatim
-in the exception:
-
-
-```clojure
-user> (run-simple-string "print('syntax errrr")
-Execution error (ExceptionInfo) at libpython-clj.python.interpreter/check-error-throw (interpreter.clj:260).
-  File "<string>", line 1
-    print('syntax errrr
-                      ^
-SyntaxError: EOL while scanning string literal
-```
-
-### Some Syntax Sugar
-
-```clojure
-user> (py/from-import numpy linspace)
-#'user/linspace
-user> (linspace 2 3 :num 10)
-[2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
- 2.66666667 2.77777778 2.88888889 3.        ]
-user> (doc linspace)
--------------------------
-user/linspace
-
-    Return evenly spaced numbers over a specified interval.
-
-    Returns `num` evenly spaced samples, calculated over the
-    interval [`start`, `stop`].
-
-```
-
-* `from-import` - sugar around python `from a import b`.  Takes multiple b's.
-* `import-as` - surgar around python `import a as b`.
-* `$a` - call an attribute using symbol att name.  Keywords map to kwargs
-* `$c` - call an object mapping keywords to kwargs
-
-
-#### Experimental Sugar
-
-We are trying to find the best way to handle attributes in order to shorten
-generic python notebook-type usage.  The currently implemented direction is:
-
-* `$.` - get an attribute.  Can pass in symbol, string, or keyword
-* `$..` - get an attribute.  If more args are present, get the attribute on that
-result.
-
-```clojure
-user> (py/$. numpy linspace)
-<function linspace at 0x7fa6642766a8>
-user> (py/$.. numpy random shuffle)
-<built-in method shuffle of numpy.random.mtrand.RandomState object at 0x7fa66410cca8>
+user> (require-python '[numpy :as np])
+nil
+user> (def test-ary (np/array [[1 2][3 4]]))
+#'user/test-ary
+user> test-ary
+[[1 2]
+ [3 4]]
 ```
 
+We have a [document](docs/Usage.md) on all the features but beginning usage is
+pretty simple.  Import your modules, use the things from Clojure.  We have put
+effort into making sure things like sequences and ranges transfer between the two
+languages.
 
-### Numpy
-
-Speaking of numpy, you can move data between numpy and java easily.
-
-```clojure
-user> (def tens-data (as-tensor ones-ary))
-#'user/tens-data
-user> (println tens-data)
-#tech.v2.tensor<float64>[2 3]
-[[1.000 1.000 1.000]
- [1.000 1.000 1.000]]
-nil
 
+#### Environments
 
-user> (require '[tech.v2.datatype :as dtype])
-nil
-user> (def ignored (dtype/copy! (repeat 6 5) tens-data))
-#'user/ignored
-user> (.put main-globals "ones_ary" ones_ary)
-Syntax error compiling at (*cider-repl cnuernber/libpython-clj:localhost:39019(clj)*:191:7).
-Unable to resolve symbol: ones_ary in this context
-user> (.put main-globals "ones_ary" ones-ary)
-nil
 
-user> (run-simple-string "print(ones_ary)")
-[[5. 5. 5.]
- [5. 5. 5.]]
-{:globals
- {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'my_var': 200, 'ones_ary': array([[5., 5., 5.],
-       [5., 5., 5.]])},
- :locals
- {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'my_var': 200, 'ones_ary': array([[5., 5., 5.],
-       [5., 5., 5.]])}}
-```
+One very complimentary aspect of Python with respect to Clojure is it's integration
+with cutting edge native libraries.  Our support isn't perfect so some understanding
+of the mechanism is important to diagnose errors and issues.
 
-So heavy data has a zero-copy route.  Anything backed by a `:native-buffer` has a
-zero copy pathway to and from numpy.  For more information on how this happens,
-please refer to the datatype library [documentation](https://github.com/techascent/tech.datatype/tree/master/docs).
+Current, we launch the python3 executable and print out various different bits of
+configuration as json.  We parse the json and use the output to attempt to find
+the `libpython3.Xm.so` shared library so for example if we are loading python
+3.6 we look for `libpython3.6m.so` on Linux or `libpython3.6m.dylib` on the Mac.
 
-Just keep in mind, careless usage of zero copy is going to cause spooky action at a
-distance.
+This pathway has allowed us support Conda albeit with some work.  For examples
+using Conda, check out the facial rec repository above or look into how we build
+our test docker containers in [this project](scripts/run-conda-docker).
 
 
 ## Further Information
 
+* Clojure Conj 2019 [video](https://www.youtube.com/watch?v=vQPW16_jixs) and
+  [slides](https://docs.google.com/presentation/d/1uegYhpS6P2AtEfhpg6PlgBmTSIPqCXvFTWcGYG_Qk2o/edit?usp=sharing).
 * [development discussion forum](https://clojurians.zulipchat.com/#narrow/stream/215609-libpython-clj-dev)
 * [design documentation](docs/design.md)
 * [scope and garbage collection docs](https://github.com/cnuernber/libpython-clj/blob/master/docs/scopes-and-gc.md)
@@ -365,6 +124,14 @@ distance.
 * [Clojure/Python interop technical blog post](www.techascent.com/blogs/functions-across-languages.html)
 * [persistent datastructures in python](https://github.com/tobgu/pyrsistent)
 
+
+## New To Clojure
+
+New to Clojure or the JVM?  Try remixing the nextjournal entry and playing around
+there.  For more resources on learning and getting more comfortable with Clojure,
+we have an [introductory document](docs/new-to-clojure.md).
+
+
 ## Resources
 
 * [libpython C api](https://docs.python.org/3.7/c-api/index.html#c-api-index)
diff --git a/docs/Usage.md b/docs/Usage.md
new file mode 100644
index 0000000..1edb379
--- /dev/null
+++ b/docs/Usage.md
@@ -0,0 +1,306 @@
+# Usage
+
+
+Python objects are essentially two dictionaries, one for 'attributes' and one for
+'items'.  When you use python and use the '.' operator, you are referencing attributes.
+If you use the '[]' operator, then you are referencing items.  Attributes are built in,
+item access is optional and happens via the `__getitem__` and `__setitem__` attributes.
+This is important to realize in that the code below doesn't look like python because we are
+referencing the item and attribute systems by name and not via '.' or '[]'.
+
+
+### Installation
+
+#### Ubuntu
+
+```console
+sudo apt install libpython3.6
+# numpy and pandas are required for unit tests.  Numpy is required for
+# zero copy support.
+python3.6 -m pip install numpy pandas --user
+```
+
+#### MacOSX
+
+Python installation instructions [here](https://docs.python-guide.org/starting/install3/osx/).
+
+
+
+### Initialize python
+
+```clojure
+user>
+
+user> (require '[libpython-clj.python
+                 :refer [as-python as-jvm
+                         ->python ->jvm
+                         get-attr call-attr call-attr-kw
+                         get-item att-type-map
+                         call call-kw initialize!
+                         as-numpy as-tensor ->numpy
+                         run-simple-string
+                         add-module module-dict
+                         import-module
+                         python-type]])
+nil
+
+
+user> (initialize!)
+Jun 30, 2019 4:47:39 PM clojure.tools.logging$eval7369$fn__7372 invoke
+INFO: executing python initialize!
+Jun 30, 2019 4:47:39 PM clojure.tools.logging$eval7369$fn__7372 invoke
+INFO: Library python3.6m found at [:system "python3.6m"]
+Jun 30, 2019 4:47:39 PM clojure.tools.logging$eval7369$fn__7372 invoke
+INFO: Reference thread starting
+:ok
+```
+
+This dynamically finds the python shared library and loads it.  If you desire a
+different shared library you can override
+[here](https://github.com/cnuernber/libpython-clj/blob/master/src/libpython_clj/jna/base.clj#L12).
+
+
+### Execute Some Python
+
+`*out*` and `*err*` capture python stdout and stderr respectively.
+
+```clojure
+
+user> (run-simple-string "print('hey')")
+hey
+{:globals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>},
+ :locals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}}
+```
+
+The results have been 'bridged' into java meaning they are still python objects but
+there are java wrappers over the top of them.  For instance, `Object.toString` forwards
+its implementation to the python function `__str__`.
+
+```clojure
+(def bridged (run-simple-string "print('hey')"))
+(instance? java.util.Map (:globals bridged))
+true
+user> (:globals bridged)
+{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
+```
+
+We can get and set global variables here.  If we run another string, these are in the
+environment.  The globals map itself is the global dict of the main module:
+
+```clojure
+(def main-globals (-> (add-module "__main__")
+                            (module-dict)))
+#'user/main-globals
+
+user> main-globals
+{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
+user> (keys main-globals)
+("__name__"
+ "__doc__"
+ "__package__"
+ "__loader__"
+ "__spec__"
+ "__annotations__"
+ "__builtins__")
+user> (get main-globals "__name__")
+"__main__"
+user> (.put main-globals "my_var" 200)
+nil
+
+user> (run-simple-string "print('your variable is:' + str(my_var))")
+your variable is:200
+{:globals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'my_var': 200},
+ :locals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'my_var': 200}}
+```
+
+Running python isn't ever really necessary, however, although it may at times be
+convenient.  You can call attributes from clojure easily:
+
+```clojure
+user> (def np (import-module "numpy"))
+#'user/np
+user> (def ones-ary (call-attr np "ones" [2 3]))
+#'user/ones-ary
+user> ones-ary
+[[1. 1. 1.]
+ [1. 1. 1.]]
+user> (call-attr ones-ary "__len__")
+2
+user> (vec ones-ary)
+[[1. 1. 1.] [1. 1. 1.]]
+user> (type (first *1))
+:pyobject
+user> (get-attr ones-ary "shape")
+(2, 3)
+user> (vec (get-attr ones-ary "shape"))
+[2 3]
+
+user> (att-type-map ones-ary)
+{"T" :ndarray,
+ "__abs__" :method-wrapper,
+ "__add__" :method-wrapper,
+ "__and__" :method-wrapper,
+ "__array__" :builtin-function-or-method,
+ "__array_finalize__" :none-type,
+ "__array_function__" :builtin-function-or-method,
+ "__array_interface__" :dict,
+ "__array_prepare__" :builtin-function-or-method,
+ "__array_priority__" :float,
+ "__array_struct__" :py-capsule,
+ "__array_ufunc__" :builtin-function-or-method,
+ "__array_wrap__" :builtin-function-or-method,
+ "__bool__" :method-wrapper,
+ "__class__" :type,
+ "__complex__" :builtin-function-or-method,
+ "__contains__" :method-wrapper,
+ ...
+ "std" :builtin-function-or-method,
+ "strides" :tuple,
+ "sum" :builtin-function-or-method,
+ "swapaxes" :builtin-function-or-method,
+ "take" :builtin-function-or-method,
+ "tobytes" :builtin-function-or-method,
+ "tofile" :builtin-function-or-method,
+ "tolist" :builtin-function-or-method,
+ "tostring" :builtin-function-or-method,
+ "trace" :builtin-function-or-method,
+ "transpose" :builtin-function-or-method,
+ "var" :builtin-function-or-method,
+ "view" :builtin-function-or-method}
+```
+
+
+### att-type-map
+
+It can be extremely helpful to print out the attribute name->attribute type map:
+
+```clojure
+user> (att-type-map ones-ary)
+{"T" :ndarray,
+ "__abs__" :method-wrapper,
+ "__add__" :method-wrapper,
+ "__and__" :method-wrapper,
+ "__array__" :builtin-function-or-method,
+ "__array_finalize__" :none-type,
+ "__array_function__" :builtin-function-or-method,
+ "__array_interface__" :dict,
+ ...
+  "real" :ndarray,
+ "repeat" :builtin-function-or-method,
+ "reshape" :builtin-function-or-method,
+ "resize" :builtin-function-or-method,
+ "round" :builtin-function-or-method,
+ "searchsorted" :builtin-function-or-method,
+ "setfield" :builtin-function-or-method,
+ "setflags" :builtin-function-or-method,
+ "shape" :tuple,
+ "size" :int,
+ "sort" :builtin-function-or-method,
+ ...
+}
+```
+
+
+### Errors
+
+
+Errors are caught and an exception is thrown.  The error text is saved verbatim
+in the exception:
+
+
+```clojure
+user> (run-simple-string "print('syntax errrr")
+Execution error (ExceptionInfo) at libpython-clj.python.interpreter/check-error-throw (interpreter.clj:260).
+  File "<string>", line 1
+    print('syntax errrr
+                      ^
+SyntaxError: EOL while scanning string literal
+```
+
+### Some Syntax Sugar
+
+```clojure
+user> (py/from-import numpy linspace)
+#'user/linspace
+user> (linspace 2 3 :num 10)
+[2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
+ 2.66666667 2.77777778 2.88888889 3.        ]
+user> (doc linspace)
+-------------------------
+user/linspace
+
+    Return evenly spaced numbers over a specified interval.
+
+    Returns `num` evenly spaced samples, calculated over the
+    interval [`start`, `stop`].
+
+```
+
+* `from-import` - sugar around python `from a import b`.  Takes multiple b's.
+* `import-as` - surgar around python `import a as b`.
+* `$a` - call an attribute using symbol att name.  Keywords map to kwargs
+* `$c` - call an object mapping keywords to kwargs
+
+
+#### Experimental Sugar
+
+We are trying to find the best way to handle attributes in order to shorten
+generic python notebook-type usage.  The currently implemented direction is:
+
+* `$.` - get an attribute.  Can pass in symbol, string, or keyword
+* `$..` - get an attribute.  If more args are present, get the attribute on that
+result.
+
+```clojure
+user> (py/$. numpy linspace)
+<function linspace at 0x7fa6642766a8>
+user> (py/$.. numpy random shuffle)
+<built-in method shuffle of numpy.random.mtrand.RandomState object at 0x7fa66410cca8>
+```
+
+
+### Numpy
+
+Speaking of numpy, you can move data between numpy and java easily.
+
+```clojure
+user> (def tens-data (as-tensor ones-ary))
+#'user/tens-data
+user> (println tens-data)
+#tech.v2.tensor<float64>[2 3]
+[[1.000 1.000 1.000]
+ [1.000 1.000 1.000]]
+nil
+
+
+user> (require '[tech.v2.datatype :as dtype])
+nil
+user> (def ignored (dtype/copy! (repeat 6 5) tens-data))
+#'user/ignored
+user> (.put main-globals "ones_ary" ones_ary)
+Syntax error compiling at (*cider-repl cnuernber/libpython-clj:localhost:39019(clj)*:191:7).
+Unable to resolve symbol: ones_ary in this context
+user> (.put main-globals "ones_ary" ones-ary)
+nil
+
+user> (run-simple-string "print(ones_ary)")
+[[5. 5. 5.]
+ [5. 5. 5.]]
+{:globals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'my_var': 200, 'ones_ary': array([[5., 5., 5.],
+       [5., 5., 5.]])},
+ :locals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'my_var': 200, 'ones_ary': array([[5., 5., 5.],
+       [5., 5., 5.]])}}
+```
+
+So heavy data has a zero-copy route.  Anything backed by a `:native-buffer` has a
+zero copy pathway to and from numpy.  For more information on how this happens,
+please refer to the datatype library [documentation](https://github.com/techascent/tech.datatype/tree/master/docs).
+
+Just keep in mind, careless usage of zero copy is going to cause spooky action at a
+distance.

From 8110dc829503d724836ed1d5c775f9966071adff Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 27 Dec 2019 07:59:17 -0700
Subject: [PATCH 118/456] Updating usage

---
 docs/Usage.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/docs/Usage.md b/docs/Usage.md
index 1edb379..18be975 100644
--- a/docs/Usage.md
+++ b/docs/Usage.md
@@ -55,9 +55,10 @@ INFO: Reference thread starting
 :ok
 ```
 
-This dynamically finds the python shared library and loads it.  If you desire a
-different shared library you can override
-[here](https://github.com/cnuernber/libpython-clj/blob/master/src/libpython_clj/jna/base.clj#L12).
+This dynamically finds the python shared library and loads it using output from
+the python3 executable on your system.  For information about how that works,
+please checkout the code 
+[here](https://github.com/cnuernber/libpython-clj/blob/master/src/libpython_clj/python/interpreter.clj#L30).
 
 
 ### Execute Some Python

From aadb781eacb2eebce79fb3f5f88b2c960a5a3619 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 27 Dec 2019 08:01:42 -0700
Subject: [PATCH 119/456] editing

---
 README.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 3f88b1c..941dbf9 100644
--- a/README.md
+++ b/README.md
@@ -105,8 +105,9 @@ the `libpython3.Xm.so` shared library so for example if we are loading python
 3.6 we look for `libpython3.6m.so` on Linux or `libpython3.6m.dylib` on the Mac.
 
 This pathway has allowed us support Conda albeit with some work.  For examples
-using Conda, check out the facial rec repository above or look into how we build
-our test docker containers in [this project](scripts/run-conda-docker).
+using Conda, check out the facial rec repository above or look into how we 
+[build](scripts/build-conda-docker)
+our test [docker containers](dockerfiles/CondaDockerfile).
 
 
 ## Further Information

From 7a01196bba77bf7f0aaee59b7ba8825fa60b1d50 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 27 Dec 2019 14:07:57 -0700
Subject: [PATCH 120/456] making stress tests mandatory

---
 test/libpython_clj/stress_test.clj | 54 +++++++++++++-----------------
 1 file changed, 24 insertions(+), 30 deletions(-)

diff --git a/test/libpython_clj/stress_test.clj b/test/libpython_clj/stress_test.clj
index 939d2d0..e4eecd1 100644
--- a/test/libpython_clj/stress_test.clj
+++ b/test/libpython_clj/stress_test.clj
@@ -67,9 +67,8 @@ def getmultidata():
 (alter-var-root #'tech.resource.stack/*resource-context*
                 (constantly nil))
 
-(defn forever-test
-  []
-  (doseq [items (partition 999 (get-data))]
+(deftest forever-test
+  (doseq [items (take 10 (partition 999 (get-data)))]
     ;;One way is to use the GC
     (time
      (do
@@ -90,60 +89,57 @@ def getmultidata():
          items))))))
 
 
-(defn multidata-test
-  []
-  (doseq [items (partition 1000 (get-multi-data))]
+(deftest multidata-test
+  (doseq [items (take 5 (partition 1000 (get-multi-data)))]
     (time (do (py/with-gil-stack-rc-context
                 (mapv py/->jvm items))
               :ok))))
 
 
-(defn str-marshal-test
-  []
+(deftest str-marshal-test
   (let [test-str (py/->python "a nice string to work with")]
     (time
      (py/with-gil-stack-rc-context
-       (dotimes [iter 100000]
+       (dotimes [iter 1000]
          (py/->jvm test-str))))))
 
 
-(defn dict-marshal-test
-  []
+(deftest dict-marshal-test
   (let [test-item (py/->python {:a 1 :b 2})]
     (time
      (py/with-gil-stack-rc-context
-       (dotimes [iter 10000]
+       (dotimes [iter 100]
          (py/->jvm test-item))))))
 
 
-(defn print-stress-test
-  []
-  (dotimes [iter 10000]
+(deftest print-stress-test
+  (dotimes [iter 100]
     (with-out-str
       (print-data))))
 
 
-(defn new-cls-stress-test
-  []
-  (dotimes [iter 1000]
+(deftest new-cls-stress-test
+  (dotimes [iter 100]
     (py/with-gil-stack-rc-context
       (let [test-cls (py/create-class "testcls" nil
-                                      {"__init__" (py/make-tuple-fn
+                                      {"__init__" (py/make-tuple-instance-fn
                                                    (fn [self name shares price]
                                                      (py/set-attr! self "name" name)
                                                      (py/set-attr! self "shares" shares)
                                                      (py/set-attr! self "price" price)
                                                      nil))
-                                       "cost" (py/make-tuple-fn
+                                       "cost" (py/make-tuple-instance-fn
                                                (fn [self]
-                                                 (* (py/$. self shares)
-                                                    (py/$. self price))))
-                                       "__str__" (py/make-tuple-fn
+                                                 (let [self (py/as-jvm self)]
+                                                   (* (py/$. self shares)
+                                                      (py/$. self price)))))
+                                       "__str__" (py/make-tuple-instance-fn
                                                   (fn [self]
-                                                    ;;Self is just a dict so it converts to a hashmap
-                                                    (pr-str {"name" (py/$. self name)
-                                                             "shares" (py/$. self shares)
-                                                             "price" (py/$. self price)})))
+                                                    (let [self (py/as-jvm self)]
+                                                      ;;Self is just a dict so it converts to a hashmap
+                                                      (pr-str {"name" (py/$. self name)
+                                                               "shares" (py/$. self shares)
+                                                               "price" (py/$. self price)}))))
                                        "testvar" 55}
                                       )
             new-inst (test-cls "ACME" 50 90)]
@@ -152,6 +148,4 @@ def getmultidata():
         (is (= 55 (py/$. new-inst testvar)))
 
         (is (= {"name" "ACME", "shares" 50, "price" 90}
-               (edn/read-string (.toString new-inst))))
-
-        ))))
+               (edn/read-string (.toString new-inst))))))))

From b1ea809db27782ede88174eb856b27a6dcdb95d7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 1 Jan 2020 16:06:01 -0700
Subject: [PATCH 121/456] support for java characters

---
 src/libpython_clj/python/bridge.clj | 2 ++
 src/libpython_clj/python/object.clj | 8 ++++++++
 test/libpython_clj/python_test.clj  | 5 +++++
 3 files changed, 15 insertions(+)

diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index a385f70..0a6d8dc 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -1003,6 +1003,8 @@
   (as-python [item options] (->python item))
   String
   (as-python [item options] (->python item))
+  Character
+  (as-python [item options] (->python item))
   Symbol
   (as-python [item options] (->python item))
   Keyword
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 2c6f8be..10ab9d7 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -358,6 +358,11 @@ Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
   (->py-object-ptr [item]
     (with-gil
       (->python item)))
+  Character
+  (convertible-to-pyobject-ptr? [item] true)
+  (->py-object-ptr [item]
+    (with-gil
+      (->python (str item))))
   String
   (convertible-to-pyobject-ptr? [item] true)
   (->py-object-ptr [item]
@@ -597,6 +602,9 @@ Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
   String
   (->python [item options]
     (->py-string item))
+  Character
+  (->python [item options]
+    (->py-string (str item)))
   Symbol
   (->python [item options]
     (->py-string (name item)))
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 2553fbf..8151c5f 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -342,3 +342,8 @@
         jvm-dict (py/->jvm py-dict)]
     (is (= (get jvm-dict "ratings")
            (py/->jvm (py/get-item py-dict "ratings"))))))
+
+
+(deftest characters
+  (is (= (py/->jvm (py/->python "c"))
+         (py/->jvm (py/->python \c)))))

From c22efe5d057a0048941e3a7fd93ac6aeff5e9920 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 2 Jan 2020 12:07:29 -0700
Subject: [PATCH 122/456] editing

---
 CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 08a3494..f313b2d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,6 +20,9 @@ classes and some serious refactoring overall.
 * Most of the datatype libraries math operators supported by numpy objects (+,-,etc).
 * Numpy objects can be used in datatype library functions (like copy, make-container)
   and work in optimized ways.
+  
+#### Bugs
+* Support for java character <-> py string
 
 ```clojure
 libpython-clj.python.numpy-test> (def test-ary (py/$a np-mod array (->> (range 9)

From 1576bf280ec04dffeafdd140a38d35e6d165d686 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Fri, 3 Jan 2020 14:03:05 -0500
Subject: [PATCH 123/456] Changelog edit (#40)

* minor edits

* minor edits

* minor edits

* minor edits
---
 CHANGELOG.md | 81 ++++++++++++++++++++++++----------------------------
 1 file changed, 38 insertions(+), 43 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f313b2d..95d267e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,27 +3,24 @@
 ## 1.30-SNAPSHOT
 
 This release is a big one.  With finalizing `require-python` we have a clear way
-to use python in daily use and make it look good in normal clojure usage.  There
+to use Python in daily use and make it look good in normal Clojure usage.  There
 is a demo of [facial recognition](https://github.com/cnuernber/facial-rec) using some
 of the best open systems for doing this; this demo would absolutely not be possible
 without this library due to the extensive use of numpy and cython to implement the
-face detection.  We can now interact with even very complex python systems with
-roughly the same performance as a pure-python system.
+face detection.  We can now interact with even very complex Python systems with
+roughly the same performance as a pure Python system.
 
 #### Finalized `require-python`
 
-Lots of work put in to make the require-python pathway work with
+Lots of work put in to make the `require-python` pathway work with
 classes and some serious refactoring overall.
 
 #### Better Numpy Support
 
 * Most of the datatype libraries math operators supported by numpy objects (+,-,etc).
-* Numpy objects can be used in datatype library functions (like copy, make-container)
+* Numpy objects can be used in datatype library functions (like `copy`, `make-container`)
   and work in optimized ways.
   
-#### Bugs
-* Support for java character <-> py string
-
 ```clojure
 libpython-clj.python.numpy-test> (def test-ary (py/$a np-mod array (->> (range 9)
                                                                         (partition 3)
@@ -43,6 +40,10 @@ libpython-clj.python.numpy-test> (dfn/> test-ary 4)
  [ True  True  True]]
 ```
 
+  
+#### Bugs
+* Support for java character <-> py string
+
 
 #### Bugs Fixed
 
@@ -52,56 +53,49 @@ libpython-clj.python.numpy-test> (dfn/> test-ary 4)
 
 ## 1.29
 
-* Found/fixed issue with ->jvm and large python dictionaries.
+* Found/fixed issue with `->jvm` and large Python dictionaries.
 
 
 ## 1.28
 
-
-* `(range 5)` - clojure ranges <-> python ranges when possible.
-* bridged types derive from collections.abc.* so that they pass instance checks in
+* `(range 5)` - Clojure ranges <-> Python ranges when possible.
+* bridged types derive from `collections.abc.*` so that they pass instance checks in
   libraries that are checking for generic types.
 * Really interesting unit test for
   [generators, ranges and sequences](test/libpython_clj/iter_gen_seq_test.clj).
 
 
-
 ## 1.27
 
-* Fixed bug where (as-python {:is_train false}) results in a dictionary with a none
+* Fixed bug where `(as-python {:is_train false})` results in a dictionary with a none
   value instead of a false value.  This was found through hours of debugging why
-  mxnet's forward function call was returning different values in clojure than in
-  python.
+  mxnet's forward function call was returning different values in Clojure than in
+  Python.
 
 
 ## 1.26
 
-
 * [python startup work](https://github.com/cnuernber/libpython-clj/commit/16da3d885f29bde59ea219c9438b9d3654387971)
 * [python generators & clojure transducers](https://github.com/cnuernber/libpython-clj/pull/27)
 * [requre-python reload fix](https://github.com/cnuernber/libpython-clj/pull/24)
-* Bugfix with require-python :reload semantics.
-
+* Bugfix with `require-python` :reload semantics.
 
 
 ## 1.25
 
-
-Fixed (with tests) major issue with require-python.
+Fixed (with tests) major issue with `require-python`.
 
 
 ## 1.24
 
-
 Clojure's range is now respected in two different ways:
-* `(range)` - bridges to a python iterable
-* `(range 5)` - copies to a python list
+* `(range)` - bridges to a Python iterable
+* `(range 5)` - copies to a Python list
 
 
 ## 1.23
 
-
-Equals, hashcode, nice default .toString of python types:
+Equals, hashcode, nice default `.toString` of Python types:
 
 ```clojure
 user> (require '[libpython-clj.python :as py])
@@ -141,39 +135,39 @@ user> (py/python-type *1)
 
 ## 1.22
 
-Working to make more python environments work out of the box.  Currently have a
+Working to make more Python environments work out of the box.  Currently have a
 testcase for conda working in a clean install of a docker container.  There is now a
 new method: `libpython-clj.python.interpreter/detect-startup-info` that attempts
 call `python3-config --prefix` and `python3 --version` in order to automagically
-configure the python library.
+configure the Python library.
 
 
 ## 1.21
 
-Bugfix release.  Passing infinite sequences to python functions was
+Bugfix release.  Passing infinite sequences to Python functions was
 causing a hang as libpython-clj attempted to copy the sequence.  The
 current calling convention does a shallow copy of things that are list-like
 or map-like, while bridging things that are iterable or don't fall into
 the above categories.
 
 This exposed a bug that caused reference counting to be subtly wrong when
-python iterated through a bridged object.  And that was my life for a day.
+Python iterated through a bridged object.  And that was my life for a day.
 
 ## 1.20
 
-With two many huge things we had to skip a few versions!
+With too many huge things we had to skip a few versions!
 
 #### require-python
 
-`require-python` works like require but it works on python modules.
+`require-python` works like require but it works on Python modules.
 `require-python` dynamically loads the module and exports it's symbols into
-a clojure namespace.  There are many options available for this pathway.
+a Clojure namespace.  There are many options available for this pathway.
 
 
-This implements a big step towards embedding python in Clojure in a simple,
+This implements a big step towards embedding Python in Clojure in a simple,
 clear, and easy to use way.  One important thing to consider is the require
-has a `:reload:` option to allow you to actively develop a python module and
-test it via clojure.
+has a `:reload:` option to allow you to actively develop a Python module and
+test it via Clojure.
 
 
 This excellent work was in large part done by [James Tolton](https://github.com/jjtolton).
@@ -184,7 +178,7 @@ This excellent work was in large part done by [James Tolton](https://github.com/
 
 #### Clojure-defined Python classes
 
-You can now extend a tuple of python classes (or implement a new one).  This system
+You can now extend a tuple of Python classes (or implement a new one).  This system
 allows, among many things, us to use frameworks that use derivation as part of their
 public API.  Please see [classes-test](test/libpython_clj/classes_test.clj) for a documented
 example of a simple pathway through the new API.  Note that if you use vanilla
@@ -201,13 +195,13 @@ a refcount to their return values.
 
 ## 1.16
 
-Fixed a bug where the system would load multiple python libraries, not stopping
+Fixed a bug where the system would load multiple Python libraries, not stopping
 after the first valid library loaded.  There are two ways to control the system's
-python library loading mechanism:
+Python library loading mechanism:
 
-1. Pass in a library name in initialize!
-2. alter-var-root the list of libraries in libpython-clj.jna.base before
-   calling initialize!.
+1. Pass in a library name in `initialize!`
+2. `alter-var-root` the list of libraries in `libpython-clj.jna.base` before
+   calling `initialize!`.
 
 
 ## 1.15
@@ -225,11 +219,12 @@ user> (py/$.. numpy random shuffle)
 
 libpython-clj now searches for several shared libraries instead of being hardcoded
 to just one of them.  Because of this, there is now:
+
 ```clojure
 libpython-clj.jna.base/*python-library-names*
 ```
 
 This is a sequence of library names that will be tried in order.
 
-You can also pass in the desired library name as part of the initialize! call and
+You can also pass in the desired library name as part of the `initialize!` call and
 only this name will be tried.

From cf27606166fd3e3891411fdbbd0f06a45bb5b77e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 3 Jan 2020 12:05:10 -0700
Subject: [PATCH 124/456] editing

---
 CHANGELOG.md | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 95d267e..d9a2459 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -39,14 +39,9 @@ libpython-clj.python.numpy-test> (dfn/> test-ary 4)
  [False False  True]
  [ True  True  True]]
 ```
-
   
-#### Bugs
-* Support for java character <-> py string
-
-
 #### Bugs Fixed
-
+* Support for java character <-> py string
 * Fixed potential crash related to use of delay mechanism and stack based gc.
 * Added logging to complain loudly if refcounts appear to be bad.
 

From c59ac238f839e4e571dafbb8e22b7c47c6993106 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 4 Jan 2020 11:47:39 -0700
Subject: [PATCH 125/456] upgrade dtype

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index c4414a3..bc0b495 100644
--- a/project.clj
+++ b/project.clj
@@ -5,7 +5,7 @@
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
                  [camel-snake-kebab "0.4.0"]
-                 [techascent/tech.datatype "4.65"]
+                 [techascent/tech.datatype "4.67"]
                  [cheshire "5.9.0"]]
   :repl-options {:init-ns user}
   :java-source-paths ["java"])

From 4a7a0cb3a0ab0b75d69478e57ead451e5b8c06c1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 5 Jan 2020 12:37:10 -0700
Subject: [PATCH 126/456] upgrade dtype

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index bc0b495..8272704 100644
--- a/project.clj
+++ b/project.clj
@@ -5,7 +5,7 @@
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
                  [camel-snake-kebab "0.4.0"]
-                 [techascent/tech.datatype "4.67"]
+                 [techascent/tech.datatype "4.68"]
                  [cheshire "5.9.0"]]
   :repl-options {:init-ns user}
   :java-source-paths ["java"])

From dc0fcd559e144ffc51c68755f11727b168f0e2dd Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 5 Jan 2020 13:06:08 -0700
Subject: [PATCH 127/456] upgrade dtype-fix binary-search

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 8272704..70bb98a 100644
--- a/project.clj
+++ b/project.clj
@@ -5,7 +5,7 @@
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
                  [camel-snake-kebab "0.4.0"]
-                 [techascent/tech.datatype "4.68"]
+                 [techascent/tech.datatype "4.69"]
                  [cheshire "5.9.0"]]
   :repl-options {:init-ns user}
   :java-source-paths ["java"])

From 3b22a653cdc11b0519928208b15b31b959989274 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 7 Jan 2020 11:18:39 -0700
Subject: [PATCH 128/456] moved to clojure.data.json

---
 project.clj                              | 2 +-
 src/libpython_clj/python/interpreter.clj | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/project.clj b/project.clj
index 70bb98a..36ae7b2 100644
--- a/project.clj
+++ b/project.clj
@@ -6,6 +6,6 @@
   :dependencies [[org.clojure/clojure "1.10.1"]
                  [camel-snake-kebab "0.4.0"]
                  [techascent/tech.datatype "4.69"]
-                 [cheshire "5.9.0"]]
+                 [org.clojure/data.json "0.2.7"]]
   :repl-options {:init-ns user}
   :java-source-paths ["java"])
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index ec023f8..e59cf56 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -9,7 +9,7 @@
             [clojure.java.io :as io]
             [clojure.string :as s]
             [clojure.tools.logging :as log]
-            [cheshire.core :as json])
+            [clojure.data.json :as json])
   (:import [libpython_clj.jna
             JVMBridge
             PyObject]
@@ -39,7 +39,7 @@ print(json.dumps(
   \"exec_prefix\":      sys.exec_prefix,
   \"version\":          list(sys.version_info)[:3]}))")]
     (when (= 0 exit)
-      (json/parse-string out true))))
+      (json/read-str out :key-fn keyword))))
 
 (defn python-system-info
   "An information map about the Python system information provided

From d8f5c315bd61c91821bed38ec9e41fc963d756ad Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 7 Jan 2020 11:20:51 -0700
Subject: [PATCH 129/456] 1.30

---
 CHANGELOG.md | 2 +-
 project.clj  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d9a2459..00ef5a6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Time for a ChangeLog!
 
-## 1.30-SNAPSHOT
+## 1.30
 
 This release is a big one.  With finalizing `require-python` we have a clear way
 to use Python in daily use and make it look good in normal Clojure usage.  There
diff --git a/project.clj b/project.clj
index 36ae7b2..6cf5177 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.30-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.30"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From f19ce98bef7ac6f8505d926fac1d3711003b52e3 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 7 Jan 2020 11:20:59 -0700
Subject: [PATCH 130/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 6cf5177..4219e1c 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.30"
+(defproject cnuernber/libpython-clj "1.31-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 6dcdaaa95c177d7dbb682d8ec757263dc29db693 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 7 Jan 2020 13:23:59 -0700
Subject: [PATCH 131/456] Attempt at datafy/nav metadata pathway

---
 src/libpython_clj/python/bridge.clj   |   4 +-
 src/libpython_clj/python/metadata.clj | 234 ++++++++++++++++++++++++++
 src/libpython_clj/require.clj         |   3 +-
 3 files changed, 238 insertions(+), 3 deletions(-)
 create mode 100644 src/libpython_clj/python/metadata.clj

diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index 0a6d8dc..d8ec7d0 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -418,7 +418,9 @@
                 (let [arglist (vec arglist)]
                   (case (count arglist)
                     1 (.get this (first arglist))
-                    2 (.put this (first arglist) (second arglist)))))))))
+                    2 (.put this (first arglist) (second arglist)))))
+       py-proto/PPyObjectBridgeToMap
+       (as-map [item] item)))))
 
 
 (defn generic-python-as-list
diff --git a/src/libpython_clj/python/metadata.clj b/src/libpython_clj/python/metadata.clj
new file mode 100644
index 0000000..62b186f
--- /dev/null
+++ b/src/libpython_clj/python/metadata.clj
@@ -0,0 +1,234 @@
+(ns libpython-clj.python.metadata
+  (:refer-clojure :exclude [fn? doc])
+  (:require [libpython-clj.python
+             :refer [import-module as-jvm get-attr call-attr callable? has-attr?
+                     ->jvm with-gil]
+             :as py]
+            [libpython-clj.python.protocols :as py-proto]
+            [clojure.core.protocols :as clj-proto]
+            [clojure.tools.logging :as log])
+  (:import [libpython_clj.python.protocols PPyObject]))
+
+
+(py/initialize!)
+
+
+(def ^:private builtins (as-jvm (import-module "builtins") {}))
+(def ^:private inspect (as-jvm (import-module "inspect") {}))
+(def ^:private argspec (get-attr inspect "getfullargspec"))
+(def ^:private py-source (get-attr inspect "getsource"))
+(def ^:private types (import-module "types"))
+(def ^:private fn-type
+  (call-attr builtins "tuple"
+             [(get-attr types "FunctionType")
+              (get-attr types "BuiltinFunctionType")]))
+
+(def ^:private method-type
+  (call-attr builtins "tuple"
+             [(get-attr types "MethodType")
+              (get-attr types "BuiltinMethodType")]))
+
+(def ^:private isinstance? (get-attr builtins "isinstance"))
+(def ^:private fn? #(isinstance? % fn-type))
+(def ^:private method? #(isinstance? % method-type))
+(def ^:private doc #(try
+                      (get-attr % "__doc__")
+                      (catch Exception e
+                        "")))
+(def ^{:private false :public true}
+  get-pydoc doc)
+(def ^:private vars (get-attr builtins "vars"))
+(def ^:private pyclass? (get-attr inspect "isclass"))
+(def ^:private pymodule? (get-attr inspect "ismodule"))
+(def ^:private importlib_util (import-module "importlib.util"))
+(defn ^:private findspec [x]
+  (let [-findspec
+        (-> importlib_util (get-attr "find_spec"))]
+    (-findspec x)))
+
+(defn ^:private py-fn-argspec [f]
+  (if-let [spec (try (when-not (pyclass? f)
+                       (argspec f))
+                     (catch Throwable e nil))]
+    {:args           (->jvm (get-attr spec "args") {})
+     :varargs        (->jvm (get-attr spec "varargs") {})
+     :varkw          (->jvm (get-attr spec "varkw") {})
+     :defaults       (->jvm (get-attr spec "defaults") {})
+     :kwonlyargs     (->jvm (get-attr spec "kwonlyargs") {})
+     :kwonlydefaults (->jvm (get-attr spec "kwonlydefaults") {})
+     :annotations    (->jvm (get-attr spec "annotations") {})}
+    (py-fn-argspec (get-attr f "__init__"))))
+
+(defn ^:private py-class-argspec [class]
+  (let [constructor (get-attr class "__init__")]
+    (py-fn-argspec constructor)))
+
+
+(defn pyargspec [x]
+  ;; TODO: certain builtin functions have
+  ;;   ..: signatures that are found in the first line
+  ;;   ..: of their docstring, aka, print.
+  ;;   ..: These seem to be uniform enough that
+  ;;   ..: most IDEs have a way of creating stubs
+  ;;   ..: for the signature.  If there is a uniform way
+  ;;   ..: to do this that doesn't simply involve an
+  ;;   ..: army of devs doing transcription I'd like to
+  ;;   ..: pull that in here
+  (cond
+    (fn? x) (py-fn-argspec x)
+    (method? x) (py-fn-argspec x)
+    ;; (builtin-function? x) (py-builtin-fn-argspec x)
+    ;; (builtin-method? x) (py-builtin-method-argspec x)
+    (string? x) ""
+    (number? x) ""
+    :else (py-class-argspec x)))
+
+
+(defn pyarglists
+  ([argspec] (pyarglists argspec
+                         (if-let [defaults
+                                  (not-empty (:defaults argspec))]
+                           defaults
+                           [])))
+  ([argspec defaults] (pyarglists argspec defaults []))
+  ([{:as            argspec
+     args           :args
+     varkw          :varkw
+     varargs        :varargs
+     kwonlydefaults :kwonlydefaults
+     kwonlyargs     :kwonlyargs}
+    defaults res]
+   (let [n-args          (count args)
+         n-defaults      (count defaults)
+         n-pos-args      (- n-args n-defaults)
+         pos-args        (transduce
+                          (comp
+                           (take n-pos-args)
+                           (map symbol))
+                          (completing conj)
+                          []
+                          args)
+         kw-default-args (transduce
+                          (comp
+                           (drop n-pos-args)
+                           (map symbol))
+                          (completing conj)
+                          []
+                          args)
+         or-map          (transduce
+                          (comp
+                           (partition-all 2)
+                           (map vec)
+                           (map (fn [[k v]] [(symbol k) v])))
+                          (completing (partial apply assoc))
+                          {}
+                          (concat
+                           (interleave kw-default-args defaults)
+                           (flatten (seq kwonlydefaults))))
+
+         as-varkw    (when (not (nil? varkw))
+                       {:as (symbol varkw)})
+         default-map (transduce
+                      (comp
+                       (partition-all 2)
+                       (map vec)
+                       (map (fn [[k v]] [(symbol k) (keyword k)])))
+                      (completing (partial apply assoc))
+                      {}
+                      (concat
+                       (interleave kw-default-args defaults)
+                       (flatten (seq kwonlydefaults))))
+
+         kwargs-map (merge default-map
+                           (when (not-empty or-map)
+                             {:or or-map})
+                           (when (not-empty as-varkw)
+                             as-varkw))
+         opt-args
+         (cond
+           (and (empty? kwargs-map)
+                (nil? varargs)) '()
+           (empty? kwargs-map)  (list '& [(symbol varargs)])
+           (nil? varargs)       (list '& [kwargs-map])
+           :else                (list '& [(symbol varargs)
+                                          kwargs-map]))
+
+         arglist  ((comp vec concat) (list* pos-args) opt-args)]
+     (let [arglists  (conj res arglist)
+           defaults' (if (not-empty defaults) (pop defaults) [])
+           argspec'  (update argspec :args
+                             (fn [args]
+                               (if (not-empty args)
+                                 (pop args)
+                                 args)))]
+
+       (if (and (empty? defaults) (empty? defaults'))
+         arglists
+         (recur argspec' defaults' arglists))))))
+
+(defn py-fn-metadata [fn-name x {:keys [no-arglists?]}]
+  (let [fn-argspec (pyargspec x)
+        fn-docstr  (get-pydoc x)]
+    (merge
+     fn-argspec
+     {:doc  fn-docstr
+      :name fn-name}
+     (when (and (callable? x)
+                (not no-arglists?))
+       (try
+         {:arglists (pyarglists fn-argspec)}
+         (catch Throwable e
+           nil))))))
+
+
+(extend-type PPyObject
+  clj-proto/Datafiable
+  (datafy [item]
+    (with-meta
+      (with-gil
+        (->> (vars item)
+             (py-proto/as-map)
+             (map (fn [[att-name att-val]]
+                    (when att-val
+                      (try
+                        (let [att-type (py-proto/python-type att-val)]
+                          [att-name
+                           (merge {:type att-type
+                                   :doc (doc att-val)
+                                   :str (.toString att-val)
+                                   :flags (->> {:pyclass? pyclass?
+                                                :callable? callable?
+                                                :fn? fn?
+                                                :method? method?
+                                                :pymodule? pymodule?}
+                                               (map (fn [[kwd f]]
+                                                      (when (f att-val)
+                                                        kwd)))
+                                               (remove nil?)
+                                               set)}
+
+                                  (when (callable? att-val)
+                                    (py-fn-metadata att-name att-val {}))
+                                  (when (has-attr? att-val "__module__")
+                                    {:module (get-attr att-val "__module__")})
+                                  (when (has-attr? att-val "__name__")
+                                    {:name (get-attr att-val "__name__")}))])
+                        (catch Throwable e
+                          (log/warnf "Metadata generation failed for %s:%s"
+                                     (.toString item)
+                                     att-name)
+                          nil)))))
+             (remove nil?)
+             (into {})))
+      {`clj-proto/nav
+       (fn nav-pyval
+         [coll f val]
+         (cond
+           (= :module (:type val))
+           (as-jvm (import-module (:name val)) {})
+           (= :type (:type val))
+           (let [mod (as-jvm (import-module (:module val)) {})
+                 cls-obj (get-attr mod (:name val))]
+             cls-obj)
+           :else
+           val))})))
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 0e491b0..029d5d3 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -1,8 +1,7 @@
 (ns libpython-clj.require
   (:refer-clojure :exclude [fn? doc])
   (:require [libpython-clj.python :as py]
-            [clojure.tools.logging :as log]
-            [clojure.java.io :as io]))
+            [clojure.tools.logging :as log]))
 
 (py/initialize!)
 

From 459551e68582604c63e56141c8d31ce211a73aaa Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 7 Jan 2020 20:34:36 -0700
Subject: [PATCH 132/456] Moved metadata and moving towards modularized
 metadata <-> namespace

---
 src/libpython_clj/{python => }/metadata.clj |  77 +++++++--------
 src/libpython_clj/require.clj               | 102 +++++++-------------
 2 files changed, 70 insertions(+), 109 deletions(-)
 rename src/libpython_clj/{python => }/metadata.clj (81%)

diff --git a/src/libpython_clj/python/metadata.clj b/src/libpython_clj/metadata.clj
similarity index 81%
rename from src/libpython_clj/python/metadata.clj
rename to src/libpython_clj/metadata.clj
index 62b186f..5343e05 100644
--- a/src/libpython_clj/python/metadata.clj
+++ b/src/libpython_clj/metadata.clj
@@ -1,4 +1,4 @@
-(ns libpython-clj.python.metadata
+(ns libpython-clj.metadata
   (:refer-clojure :exclude [fn? doc])
   (:require [libpython-clj.python
              :refer [import-module as-jvm get-attr call-attr callable? has-attr?
@@ -101,43 +101,30 @@
    (let [n-args          (count args)
          n-defaults      (count defaults)
          n-pos-args      (- n-args n-defaults)
-         pos-args        (transduce
-                          (comp
-                           (take n-pos-args)
-                           (map symbol))
-                          (completing conj)
-                          []
-                          args)
-         kw-default-args (transduce
-                          (comp
-                           (drop n-pos-args)
-                           (map symbol))
-                          (completing conj)
-                          []
-                          args)
-         or-map          (transduce
-                          (comp
-                           (partition-all 2)
-                           (map vec)
-                           (map (fn [[k v]] [(symbol k) v])))
-                          (completing (partial apply assoc))
-                          {}
-                          (concat
-                           (interleave kw-default-args defaults)
-                           (flatten (seq kwonlydefaults))))
-
+         pos-args        (->> args
+                              (take n-pos-args)
+                              (map symbol)
+                              (into []))
+         kw-default-args (->> args
+                              (drop n-pos-args)
+                              (map symbol)
+                              (into []))
+         or-map          (->> (concat
+                               (interleave kw-default-args defaults)
+                               (flatten (seq kwonlydefaults)))
+                              (partition-all 2)
+                              (map vec)
+                              (map (fn [[k v]] [(symbol k) v]))
+                              (into {}))
          as-varkw    (when (not (nil? varkw))
                        {:as (symbol varkw)})
-         default-map (transduce
-                      (comp
-                       (partition-all 2)
-                       (map vec)
-                       (map (fn [[k v]] [(symbol k) (keyword k)])))
-                      (completing (partial apply assoc))
-                      {}
-                      (concat
-                       (interleave kw-default-args defaults)
-                       (flatten (seq kwonlydefaults))))
+         default-map (->> (concat
+                           (interleave kw-default-args defaults)
+                           (flatten (seq kwonlydefaults)))
+                          (partition-all 2)
+                          (map vec)
+                          (map (fn [[k v]] [(symbol k) (keyword k)]))
+                          (into {}))
 
          kwargs-map (merge default-map
                            (when (not-empty or-map)
@@ -223,12 +210,14 @@
       {`clj-proto/nav
        (fn nav-pyval
          [coll f val]
-         (cond
-           (= :module (:type val))
-           (as-jvm (import-module (:name val)) {})
-           (= :type (:type val))
-           (let [mod (as-jvm (import-module (:module val)) {})
-                 cls-obj (get-attr mod (:name val))]
-             cls-obj)
-           :else
+         (if (map? val)
+           (cond
+             (= :module (:type val))
+             (as-jvm (import-module (:name val)) {})
+             (= :type (:type val))
+             (let [mod (as-jvm (import-module (:module val)) {})
+                   cls-obj (get-attr mod (:name val))]
+               cls-obj)
+             :else
+             val)
            val))})))
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 029d5d3..edccaa9 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -1,6 +1,9 @@
 (ns libpython-clj.require
   (:refer-clojure :exclude [fn? doc])
   (:require [libpython-clj.python :as py]
+            [clojure.datafy :refer [datafy nav]]
+            ;;Binds datafy/nav to python objects
+            [libpython-clj.metadata]
             [clojure.tools.logging :as log]))
 
 (py/initialize!)
@@ -252,63 +255,32 @@
                                   seq)]
       (throw (Exception. (format "Unsupported flags: %s"
                                  (set missing-flags))))))
-  (letfn [(supported-flag-item
-            ;; scanned a supported tag token
-            [supported-flags flag results item items]
-            (cond
-              ;; add flag, continue scanning
-              (true? item) (next-flag-item
-                            supported-flags
-                            (conj results flag)
-                            (first items)
-                            (rest items))
-
-              ;; don't add flag, continue scanning
-              (false? item) (next-flag-item
-                             supported-flags
-                             results
-                             (first items)
-                             (rest items))
-              :else
-              ;; unary flag -- add flag but scan current item/s
-              (next-flag-item
-               supported-flags
-               (conj  results flag)
-               item
-               items)))
-
-          ;; scan flags
-          (next-flag-item [supported-flags results item items]
-            (cond
-              ;; supported flag scanned, begin FSM parse
-              (get supported-flags item)
-              (let [flag            (get supported-flags item)
-                    remaining-flags (clojure.set/difference
-                                     supported-flags #{flag})]
-                (supported-flag-item
-                 remaining-flags
-                 flag
-                 results
-                 (first items)
-                 (rest items)))
-
-              ;; FSM complete
-              (nil? item) (into #{} results)
-
-              ;; no flag scanned, continue scanning
-              :else (recur
-                     supported-flags
-                     results
-                     (first items)
-                     (rest items))))
-
-          ;; entrypoint
-          (get-flags [supported-flags reqs]
-            (next-flag-item supported-flags
-                            []
-                            (first reqs)
-                            (rest reqs)))]
-    (trampoline get-flags supported-flags reqs)))
+  ;;Loop through reqs.  If a keyword is found and it is a supported flag,
+  ;;see if the next thing is a boolean with a default to true.
+  ;;If the flag is enabled (as false could be passed in), conj (or disj) to flag set
+  ;;Return reqs minus flags and booleans.
+  (loop [reqs reqs
+         retval-reqs []
+         retval-flags #{}]
+    (if (seq reqs)
+      (let [next-item (first reqs)
+            reqs (rest reqs)
+            [bool-flag reqs]
+            (if (and (supported-flags next-item)
+                     (boolean? (first reqs)))
+              [(first reqs) (rest reqs)]
+              [true reqs])
+            retval-flags (if (supported-flags next-item)
+                           (if bool-flag
+                             (conj retval-flags next-item)
+                             (disj retval-flags next-item))
+                           retval-flags)
+            retval-reqs (if (not (supported-flags next-item))
+                          (conj retval-reqs next-item)
+                          retval-reqs)]
+        (recur reqs retval-reqs retval-flags))
+      {:reqs retval-reqs
+       :flags retval-flags})))
 
 (defn- extract-refer-symbols
   [{:keys [refer this-module]} public-data]
@@ -362,14 +334,14 @@
   (let [supported-flags     #{:reload
                               :no-arglists}
         [module-name & etc] req
-        flags               (parse-flags supported-flags etc)
-        etc                 (into {}
-                                  (comp
-                                   (remove supported-flags)
-                                   (remove boolean?)
-                                   (partition-all 2)
-                                   (map vec))
-                                  etc)
+        {flags :flags
+         etc :reqs}     (parse-flags supported-flags etc)
+        etc             (->> etc
+                             (remove supported-flags)
+                             (remove boolean?)
+                             (partition-all 2)
+                             (map vec)
+                             (into {}))
         reload?             (:reload flags)
         no-arglists?        (:no-arglists flags)
         module-name-or-ns   (:as etc module-name)

From 78f56317ef1e4b18fe3eafaf3db67932826fd9d9 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 9 Jan 2020 13:01:08 -0700
Subject: [PATCH 133/456] Working through better metadata generation

---
 src/libpython_clj/jna/base.clj             |   2 +-
 src/libpython_clj/metadata.clj             | 122 ++++++++++++++++-----
 src/libpython_clj/require.clj              |   6 +-
 test/libpython_clj/require_python_test.clj |  14 +--
 4 files changed, 107 insertions(+), 37 deletions(-)

diff --git a/src/libpython_clj/jna/base.clj b/src/libpython_clj/jna/base.clj
index 9cdf94b..6bd6c14 100644
--- a/src/libpython_clj/jna/base.clj
+++ b/src/libpython_clj/jna/base.clj
@@ -47,7 +47,7 @@
 
 (defn ensure-pyobj
   [item]
-  (if-let [retval (->py-object-ptr item)]
+  (if-let [retval (as-pyobj item)]
     retval
     (throw (ex-info "Failed to get a pyobject pointer from object." {}))))
 
diff --git a/src/libpython_clj/metadata.clj b/src/libpython_clj/metadata.clj
index 5343e05..0439c19 100644
--- a/src/libpython_clj/metadata.clj
+++ b/src/libpython_clj/metadata.clj
@@ -167,46 +167,65 @@
          (catch Throwable e
            nil))))))
 
+(defn pyobj-flags
+  [item]
+  (->> {:pyclass? pyclass?
+        :callable? callable?
+        :fn? fn?
+        :method? method?
+        :pymodule? pymodule?}
+       (map (fn [[kwd f]]
+              (when (f item)
+                kwd)))
+       (remove nil?)
+       set))
+
+
+(defn base-pyobj-map
+  [item]
+  (merge {:type (py/python-type item)
+          :doc (doc item)
+          :str (.toString item)
+          :flags (pyobj-flags item)}
+         (when (has-attr? item "__module__")
+           {:module (get-attr item "__module__")})
+         (when (has-attr? item "__name__")
+           {:name (get-attr item "__name__")})))
+
+
+(defn scalar?
+  [att-val]
+  (or (string? att-val)
+      (number? att-val)))
+
 
 (extend-type PPyObject
   clj-proto/Datafiable
   (datafy [item]
     (with-meta
       (with-gil
-        (->> (vars item)
-             (py-proto/as-map)
+        (->> (if (or (pyclass? item)
+                     (pymodule? item))
+               (-> (vars item)
+                   (py-proto/as-map))
+               (->> (py/dir item)
+                    (map (juxt identity #(get-attr item %)))))
              (map (fn [[att-name att-val]]
                     (when att-val
                       (try
-                        (let [att-type (py-proto/python-type att-val)]
-                          [att-name
-                           (merge {:type att-type
-                                   :doc (doc att-val)
-                                   :str (.toString att-val)
-                                   :flags (->> {:pyclass? pyclass?
-                                                :callable? callable?
-                                                :fn? fn?
-                                                :method? method?
-                                                :pymodule? pymodule?}
-                                               (map (fn [[kwd f]]
-                                                      (when (f att-val)
-                                                        kwd)))
-                                               (remove nil?)
-                                               set)}
-
-                                  (when (callable? att-val)
-                                    (py-fn-metadata att-name att-val {}))
-                                  (when (has-attr? att-val "__module__")
-                                    {:module (get-attr att-val "__module__")})
-                                  (when (has-attr? att-val "__name__")
-                                    {:name (get-attr att-val "__name__")}))])
+                        [att-name
+                         (merge (base-pyobj-map att-val)
+                                (when (callable? att-val)
+                                  (py-fn-metadata att-name att-val {}))
+                                (when (scalar? att-val)
+                                  {:value att-val}))]
                         (catch Throwable e
                           (log/warnf "Metadata generation failed for %s:%s"
                                      (.toString item)
                                      att-name)
                           nil)))))
              (remove nil?)
-             (into {})))
+             (into (base-pyobj-map item))))
       {`clj-proto/nav
        (fn nav-pyval
          [coll f val]
@@ -221,3 +240,56 @@
              :else
              val)
            val))})))
+
+
+(defn metadata-map->py-obj
+  [metadata-map]
+  (case (:type metadata-map)
+    :module (import-module (:name metadata-map))
+    :type (-> (import-module (:module metadata-map))
+              (get-attr (:name metadata-map)))))
+
+
+(defn get-or-create-namespace!
+  [ns-symbol ns-doc]
+  (if-let [ns-obj (find-ns ns-symbol)]
+    ns-obj
+    (create-ns (with-meta ns-symbol
+                 (merge (meta ns-symbol)
+                        {:doc ns-doc})))))
+
+
+(defn apply-static-metadata-to-namespace!
+  "Given a metadata map, find the item associated with the map and for each
+  string keyword apply it to the namespace.  Namespace is created if it does not
+  already exist.  Returns the namespace symbol."
+  [ns-symbol metadata-map]
+  (let [target-item (metadata-map->py-obj metadata-map)]
+    (get-or-create-namespace! ns-symbol (:doc metadata-map))
+    (doseq [[k v] metadata-map]
+      (when (has-attr? target-item k)
+        (let [att-val (get-attr target-item k)]
+          (intern ns-symbol (with-meta (symbol k) v) att-val))))
+    ns-symbol))
+
+
+(defn apply-instance-metadata-to-namespace!
+  "In this case we have at some point in the past generated metadata from an instance
+  and we want to create an namespace to get intellisense on objects of that type.
+  The use case for this is you get a generic 'thing' back and you export its metadata
+  to a resource edn file.  You can then always create a namespace from this metadata
+  and use that namespace to explore/use the instance and this will work regardless
+  of if a factory returns a derived object.
+  Returns the namespace symbol."
+  [ns-symbol metadata-map]
+  (get-or-create-namespace! ns-symbol (:doc metadata-map))
+  (doseq [[k v] metadata-map]
+    (when (map? v)
+      (cond
+        (contains? (:flags v) :callable?)
+        (intern ns-symbol (with-meta (symbol k) v)
+                (fn [inst & args]
+                  (apply (get-attr inst k) args)))
+        (contains? v :value)
+        (intern ns-symbol (with-meta (symbol k) v) (:value v)))))
+  ns-symbol)
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index edccaa9..2cde861 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -279,8 +279,7 @@
                           (conj retval-reqs next-item)
                           retval-reqs)]
         (recur reqs retval-reqs retval-flags))
-      {:reqs retval-reqs
-       :flags retval-flags})))
+      retval-flags)))
 
 (defn- extract-refer-symbols
   [{:keys [refer this-module]} public-data]
@@ -334,8 +333,7 @@
   (let [supported-flags     #{:reload
                               :no-arglists}
         [module-name & etc] req
-        {flags :flags
-         etc :reqs}     (parse-flags supported-flags etc)
+        flags           (parse-flags supported-flags etc)
         etc             (->> etc
                              (remove supported-flags)
                              (remove boolean?)
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index 7c35457..c1a8d27 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -36,19 +36,19 @@
     (is (= #{:reload} (parse-flags #{:reload} '[:reload foo :as])))
     (is (= #{:reload} (parse-flags #{:reload} '[foo :reload :as bar])))
     (is (= #{} (parse-flags #{:reload} '[:reload false])))
-    (is (= #{} (parse-flags #{:reload} '[:reload false :reload])))
-    (is (= #{} (parse-flags #{:reload} '[:reload false :reload true])))
-    (is (= #{:reload} (parse-flags  #{:reload} '[:reload :reload false])))
-    (is (= #{:reload} (parse-flags #{:reload} '[:reload true :reload false])))
-    (is (= #{:a :b}) (parse-flags #{:a :b} '[:a true :b]))
-    (is (= #{:a :b}) (parse-flags #{:a :b} '[:a :b]))
+    (is (= #{:reload} (parse-flags #{:reload} '[:reload false :reload])))
+    (is (= #{:reload} (parse-flags #{:reload} '[:reload false :reload true])))
+    (is (= #{} (parse-flags  #{:reload} '[:reload :reload false])))
+    (is (= #{} (parse-flags #{:reload} '[:reload true :reload false])))
+    (is (= #{:a :b} (parse-flags #{:a :b} '[:a true :b])))
+    (is (= #{:a :b} (parse-flags #{:a :b} '[:a :b])))
     (is (= #{:a :b} (parse-flags #{:a :b} '[:a true :b])))
     (is (= #{:a :b} (parse-flags #{:a :b} '[:a  :b true])))
     (is (= #{:a :b} (parse-flags #{:a :b} '[:a  true :b true])))
     (is (= #{:b} (parse-flags #{:a :b} '[:a  false :b true])))
     (is (= #{:b} (parse-flags #{:a :b} '[:b true :a false])))
     (is (= #{:b} (parse-flags #{:a :b} '[:b :a false])))
-    (is (= #{:b} (parse-flags #{:a :b} '[:b :a false :a true])))))
+    (is (= #{:b :a} (parse-flags #{:a :b} '[:b :a false :a true])))))
 
 (deftest python-lib-configuration-test
   (let [python-lib-configuration #'req/python-lib-configuration

From 760c9fd72472a7544e35bf0cb8aaf5e12bdf3b0a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 11 Jan 2020 15:37:46 -0700
Subject: [PATCH 134/456] completed the require code, now need to test/try it
 for a bit.

---
 src/libpython_clj/jna/interpreter.clj |  16 +-
 src/libpython_clj/metadata.clj        |  94 +++-
 src/libpython_clj/require.clj         | 637 ++------------------------
 3 files changed, 117 insertions(+), 630 deletions(-)

diff --git a/src/libpython_clj/jna/interpreter.clj b/src/libpython_clj/jna/interpreter.clj
index 59dcabe..b2ce582 100644
--- a/src/libpython_clj/jna/interpreter.clj
+++ b/src/libpython_clj/jna/interpreter.clj
@@ -13,7 +13,8 @@
             [tech.jna :as jna]
             [libpython-clj.jna.protocols.object :as pyobj]
             [libpython-clj.jna.concrete.unicode :as pyuni]
-            [camel-snake-kebab.core :refer [->kebab-case]])
+            [camel-snake-kebab.core :refer [->kebab-case]]
+            [clojure.tools.logging :as log])
   (:import [com.sun.jna Pointer Native NativeLibrary]
            [com.sun.jna.ptr PointerByReference]
            [libpython_clj.jna PyObject]))
@@ -215,11 +216,14 @@
 
 (defn get-type-name
   [type-pyobj]
-  (-> (pyobj/PyObject_GetAttrString type-pyobj "__name__")
-      (pyuni/PyUnicode_AsUTF8)
-      (jna/variable-byte-ptr->string)
-      ->kebab-case
-      keyword))
+  (if-let [obj-name (pyobj/PyObject_GetAttrString type-pyobj "__name__")]
+    (-> (pyuni/PyUnicode_AsUTF8 obj-name)
+        (jna/variable-byte-ptr->string)
+        ->kebab-case
+        keyword)
+    (do
+      (log/warn "Failed to get typename for object")
+      :typename-lookup-failure)))
 
 
 (defn lookup-type-symbols
diff --git a/src/libpython_clj/metadata.clj b/src/libpython_clj/metadata.clj
index 0439c19..b6c3ef7 100644
--- a/src/libpython_clj/metadata.clj
+++ b/src/libpython_clj/metadata.clj
@@ -13,40 +13,41 @@
 (py/initialize!)
 
 
-(def ^:private builtins (as-jvm (import-module "builtins") {}))
-(def ^:private inspect (as-jvm (import-module "inspect") {}))
-(def ^:private argspec (get-attr inspect "getfullargspec"))
-(def ^:private py-source (get-attr inspect "getsource"))
-(def ^:private types (import-module "types"))
-(def ^:private fn-type
+(def builtins (as-jvm (import-module "builtins") {}))
+(def inspect (as-jvm (import-module "inspect") {}))
+(def argspec (get-attr inspect "getfullargspec"))
+(def py-source (get-attr inspect "getsource"))
+(def types (import-module "types"))
+(def fn-type
   (call-attr builtins "tuple"
              [(get-attr types "FunctionType")
               (get-attr types "BuiltinFunctionType")]))
 
-(def ^:private method-type
+(def method-type
   (call-attr builtins "tuple"
              [(get-attr types "MethodType")
               (get-attr types "BuiltinMethodType")]))
 
-(def ^:private isinstance? (get-attr builtins "isinstance"))
-(def ^:private fn? #(isinstance? % fn-type))
-(def ^:private method? #(isinstance? % method-type))
-(def ^:private doc #(try
-                      (get-attr % "__doc__")
-                      (catch Exception e
-                        "")))
-(def ^{:private false :public true}
-  get-pydoc doc)
-(def ^:private vars (get-attr builtins "vars"))
-(def ^:private pyclass? (get-attr inspect "isclass"))
-(def ^:private pymodule? (get-attr inspect "ismodule"))
-(def ^:private importlib_util (import-module "importlib.util"))
-(defn ^:private findspec [x]
+(def isinstance? (get-attr builtins "isinstance"))
+(def fn? #(isinstance? % fn-type))
+(def method? #(isinstance? % method-type))
+(def doc #(try
+             (get-attr % "__doc__")
+             (catch Exception e
+               "")))
+(def get-pydoc doc)
+(def vars (get-attr builtins "vars"))
+(def pyclass? (get-attr inspect "isclass"))
+(def pymodule? (get-attr inspect "ismodule"))
+(def importlib (py/import-module "importlib"))
+(def importlib_util (import-module "importlib.util"))
+(def reload-module (py/get-attr importlib "reload"))
+(defn findspec [x]
   (let [-findspec
         (-> importlib_util (get-attr "find_spec"))]
     (-findspec x)))
 
-(defn ^:private py-fn-argspec [f]
+(defn py-fn-argspec [f]
   (if-let [spec (try (when-not (pyclass? f)
                        (argspec f))
                      (catch Throwable e nil))]
@@ -59,7 +60,7 @@
      :annotations    (->jvm (get-attr spec "annotations") {})}
     (py-fn-argspec (get-attr f "__init__"))))
 
-(defn ^:private py-class-argspec [class]
+(defn py-class-argspec [class]
   (let [constructor (get-attr class "__init__")]
     (py-fn-argspec constructor)))
 
@@ -153,6 +154,12 @@
          arglists
          (recur argspec' defaults' arglists))))))
 
+
+(defn py-class-argspec [class]
+  (let [constructor (py/get-attr class "__init__")]
+    (py-fn-argspec constructor)))
+
+
 (defn py-fn-metadata [fn-name x {:keys [no-arglists?]}]
   (let [fn-argspec (pyargspec x)
         fn-docstr  (get-pydoc x)]
@@ -242,6 +249,38 @@
            val))})))
 
 
+(defn module-path-string
+  "Given a.b, return a
+   Given a.b.c, return a.b
+   Given a.b.c.d, return a.b.c  etc."
+  [x]
+  (clojure.string/join
+   "."
+   (pop (clojure.string/split (str x) #"[.]"))))
+
+
+(defn module-path-last-string
+  "Given a.b.c.d, return d"
+  [x]
+  (last (clojure.string/split (str x) #"[.]")))
+
+
+(defn path->py-obj
+  [item-path & {:keys [reload?]}]
+  (when (seq item-path)
+    (if-let [module-retval (try
+                             (import-module item-path)
+                             (catch Throwable e nil))]
+      (if reload?
+        (reload-module module-retval)
+        module-retval)
+      (let [butlast (module-path-string item-path)]
+        (if-let [parent-mod (path->py-obj butlast :reload? reload?)]
+          (get-attr parent-mod (module-path-last-string item-path))
+          (throw (Exception. (format "Failed to find module or class %s"
+                                     item-path))))))))
+
+
 (defn metadata-map->py-obj
   [metadata-map]
   (case (:type metadata-map)
@@ -263,13 +302,18 @@
   "Given a metadata map, find the item associated with the map and for each
   string keyword apply it to the namespace.  Namespace is created if it does not
   already exist.  Returns the namespace symbol."
-  [ns-symbol metadata-map]
+  [ns-symbol metadata-map & {:keys [no-arglists?]}]
   (let [target-item (metadata-map->py-obj metadata-map)]
     (get-or-create-namespace! ns-symbol (:doc metadata-map))
     (doseq [[k v] metadata-map]
       (when (has-attr? target-item k)
         (let [att-val (get-attr target-item k)]
-          (intern ns-symbol (with-meta (symbol k) v) att-val))))
+          (intern ns-symbol
+                  (with-meta (symbol k)
+                    (if no-arglists?
+                      (dissoc v :arglists)
+                      v))
+                  att-val))))
     ns-symbol))
 
 
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 2cde861..ab50ce9 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -1,242 +1,15 @@
 (ns libpython-clj.require
   (:refer-clojure :exclude [fn? doc])
   (:require [libpython-clj.python :as py]
+            [libpython-clj.metadata :as pymeta]
             [clojure.datafy :refer [datafy nav]]
             ;;Binds datafy/nav to python objects
             [libpython-clj.metadata]
             [clojure.tools.logging :as log]))
 
-(py/initialize!)
-
 ;; for hot reloading multimethod in development
 (ns-unmap 'libpython-clj.require 'intern-ns-class)
 
-(def ^:private builtins (py/import-module "builtins"))
-
-(def ^:private inspect (py/import-module "inspect"))
-
-(def ^:private argspec (py/get-attr inspect "getfullargspec"))
-
-(def ^:private py-source (py/get-attr inspect "getsource"))
-
-(def ^:private types (py/import-module "types"))
-
-(def ^:private fn-type
-  (py/call-attr builtins "tuple"
-                [(py/get-attr types "FunctionType")
-                 (py/get-attr types "BuiltinFunctionType")]))
-
-(def ^:private method-type
-  (py/call-attr builtins "tuple"
-                [(py/get-attr types "MethodType")
-                 (py/get-attr types "BuiltinMethodType")]))
-
-(def ^:private isinstance? (py/get-attr builtins "isinstance"))
-
-(def ^:private fn? #(isinstance? % fn-type))
-
-(def ^:private method? #(isinstance? % method-type))
-
-(def ^:private doc #(try
-                      (py/get-attr % "__doc__")
-                      (catch Exception e
-                        "")))
-
-(def ^:private importlib (py/import-module "importlib"))
-
-(def ^:private importlib_util (py/import-module "importlib.util"))
-
-(def ^:private reload-module (py/get-attr importlib "reload"))
-
-(def ^:priviate import-module (py/get-attr importlib "import_module"))
-
-(def ^{:private false :public true}
-  get-pydoc doc)
-
-(def ^:private vars (py/get-attr builtins "vars"))
-
-(def ^:private pyclass? (py/get-attr inspect "isclass"))
-
-(def ^:private pymodule? (py/get-attr inspect "ismodule"))
-
-(defn ^:private findspec [x]
-  (let [-findspec
-        (-> importlib_util (py/get-attr "find_spec"))]
-    (-findspec x)))
-
-(def ^:private hasattr (py/get-attr builtins "hasattr"))
-
-(defn ^:private module-string? [x]
-  (try
-    (findspec x)
-    (catch Throwable e
-      false)))
-
-(defn module-path-string
-  "Given a.b, return a
-   Given a.b.c, return a.b
-   Given a.b.c.d, return a.b.c  etc."
-  [x]
-  (clojure.string/join
-   "."
-   (pop (clojure.string/split (str x) #"[.]"))))
-
-(defn module-path-last-string
-  "Given a.b.c.d, return d"
-  [x]
-  (last (clojure.string/split (str x) #"[.]")))
-
-(defn ^:private possible-class?
-  "The presumption here is that, given a symbol like 'builtins.list,
-  if 'builtins.list does not have a __path__ attribute but 'builtins does,
-  it's possible that 'list is a class of 'builtins.
-
-  This is a slightly cheaper test than a try/except wrapper around
-  a module."
-  [pos-class]
-  (let [module? (module-path-string pos-class)]
-    (and (not (module-string? pos-class))
-         (boolean (module-string? module?)))))
-
-(defn ^:private py-fn-argspec [f]
-  (if-let [spec (try (argspec f) (catch Throwable e nil))]
-    {:args           (py/->jvm (py/get-attr spec "args"))
-     :varargs        (py/->jvm (py/get-attr spec "varargs"))
-     :varkw          (py/->jvm (py/get-attr spec "varkw"))
-     :defaults       (py/->jvm (py/get-attr spec "defaults"))
-     :kwonlyargs     (py/->jvm  (py/get-attr spec "kwonlyargs"))
-     :kwonlydefaults (py/->jvm  (py/get-attr spec "kwonlydefaults"))
-     :annotations    (py/->jvm  (py/get-attr spec "annotations"))}
-    (py-fn-argspec (py/get-attr f "__init__"))))
-
-(defn ^:private py-class-argspec [class]
-  (let [constructor (py/get-attr class "__init__")]
-    (py-fn-argspec constructor)))
-
-(defn pyargspec [x]
-  ;; TODO: certain builtin functions have
-  ;;   ..: signatures that are found in the first line
-  ;;   ..: of their docstring, aka, print.
-  ;;   ..: These seem to be uniform enough that
-  ;;   ..: most IDEs have a way of creating stubs
-  ;;   ..: for the signature.  If there is a uniform way
-  ;;   ..: to do this that doesn't simply involve an
-  ;;   ..: army of devs doing transcription I'd like to
-  ;;   ..: pull that in here
-  (cond
-    (fn? x) (py-fn-argspec x)
-    (method? x) (py-fn-argspec x)
-    ;; (builtin-function? x) (py-builtin-fn-argspec x)
-    ;; (builtin-method? x) (py-builtin-method-argspec x)
-    (string? x) ""
-    (number? x) ""
-    :else (py-class-argspec x)))
-
-(defn pyarglists
-  ([argspec] (pyarglists argspec
-                         (if-let [defaults
-                                  (not-empty (:defaults argspec))]
-                           defaults
-                           [])))
-  ([argspec defaults] (pyarglists argspec defaults []))
-  ([{:as            argspec
-     args           :args
-     varkw          :varkw
-     varargs        :varargs
-     kwonlydefaults :kwonlydefaults
-     kwonlyargs     :kwonlyargs}
-    defaults res]
-   (let [n-args          (count args)
-         n-defaults      (count defaults)
-         n-pos-args      (- n-args n-defaults)
-         pos-args        (transduce
-                          (comp
-                           (take n-pos-args)
-                           (map symbol))
-                          (completing conj)
-                          []
-                          args)
-         kw-default-args (transduce
-                          (comp
-                           (drop n-pos-args)
-                           (map symbol))
-                          (completing conj)
-                          []
-                          args)
-         or-map          (transduce
-                          (comp
-                           (partition-all 2)
-                           (map vec)
-                           (map (fn [[k v]] [(symbol k) v])))
-                          (completing (partial apply assoc))
-                          {}
-                          (concat
-                           (interleave kw-default-args defaults)
-                           (flatten (seq kwonlydefaults))))
-
-         as-varkw    (when (not (nil? varkw))
-                       {:as (symbol varkw)})
-         default-map (transduce
-                      (comp
-                       (partition-all 2)
-                       (map vec)
-                       (map (fn [[k v]] [(symbol k) (keyword k)])))
-                      (completing (partial apply assoc))
-                      {}
-                      (concat
-                       (interleave kw-default-args defaults)
-                       (flatten (seq kwonlydefaults))))
-
-         kwargs-map (merge default-map
-                           (when (not-empty or-map)
-                             {:or or-map})
-                           (when (not-empty as-varkw)
-                             as-varkw))
-         opt-args
-         (cond
-           (and (empty? kwargs-map)
-                (nil? varargs)) '()
-           (empty? kwargs-map)  (list '& [(symbol varargs)])
-           (nil? varargs)       (list '& [kwargs-map])
-           :else                (list '& [(symbol varargs)
-                                          kwargs-map]))
-
-         arglist  ((comp vec concat) (list* pos-args) opt-args)]
-     (let [arglists  (conj res arglist)
-           defaults' (if (not-empty defaults) (pop defaults) [])
-           argspec'  (update argspec :args
-                             (fn [args]
-                               (if (not-empty args)
-                                 (pop args)
-                                 args)))]
-
-       (if (and (empty? defaults) (empty? defaults'))
-         arglists
-         (recur argspec' defaults' arglists))))))
-
-(defn py-fn-metadata [fn-name x {:keys [no-arglists?]}]
-  (let [fn-argspec (pyargspec x)
-        fn-docstr  (get-pydoc x)]
-    (merge
-     fn-argspec
-     {:doc  fn-docstr
-      :name fn-name}
-     (when (and (py/callable? x)
-                (not no-arglists?))
-       (try
-         {:arglists (pyarglists fn-argspec)}
-         (catch Throwable e
-           nil))))))
-
-(defn ^:private load-py-fn [f fn-name fn-module-name-or-ns
-                            options]
-  (let [fn-ns      (symbol (str fn-module-name-or-ns))
-        fn-sym     (symbol fn-name)]
-    (intern fn-ns
-            (with-meta
-              fn-sym
-              (py-fn-metadata fn-name f
-                              options)) f)))
 
 (defn- parse-flags
   "FSM style parser for flags.  Designed to support both
@@ -281,6 +54,7 @@
         (recur reqs retval-reqs retval-flags))
       retval-flags)))
 
+
 (defn- extract-refer-symbols
   [{:keys [refer this-module]} public-data]
   (cond
@@ -299,7 +73,6 @@
                   (when (contains? public-data item-sym)
                     item-sym))))
          (remove nil?))
-
     ;; [.. :refer [..]] behavior
     :else
     (do
@@ -311,33 +84,18 @@
                         (vec missing)))))
       refer)))
 
-(defn import-module-or-cls! [x]
-  (if (possible-class? x)
-    (let [module? (module-path-string x)
-          class?  (module-path-last-string x)]
-      (try
-        (let [m   (import-module module?)
-              cls (py/get-attr m class?)]
-          (if (nil? cls)
-            (throw (Exception. "Unable to load " x)))
-          [m cls])
-        (catch Exception e
-          (log/error (str "Unable to load " x))
-          (throw e))))
-    [(import-module (str x)) nil]))
-
-(defn- python-lib-configuration
-  "Build a configuration map of a python library.  Current ns is option and used
-  during testing but unnecessary during normal running events."
-  [req & [current-ns]]
-  (let [supported-flags     #{:reload
-                              :no-arglists}
-        [module-name & etc] req
-        flags           (parse-flags supported-flags etc)
-        etc             (->> etc
-                             (remove supported-flags)
-                             (remove boolean?)
-                             (partition-all 2)
+
+(defn- do-require-python
+  [reqs-vec]
+  (let [[module-name & etc] reqs-vec
+        supported-flags #{:reload :no-arglists}
+        flags (parse-flags supported-flags etc)
+        etc (->> etc
+                 (remove supported-flags)
+                 (remove boolean?))
+        _  (when-not (= 0 (rem (count etc) 2))
+             (throw (Exception. "Must have even number of entries")))
+        etc             (->> etc (partition-all 2)
                              (map vec)
                              (into {}))
         reload?             (:reload flags)
@@ -345,346 +103,25 @@
         module-name-or-ns   (:as etc module-name)
         exclude             (into #{} (:exclude etc))
         refer               (cond
-                              (= :all (:refer etc)) #{:all}
-                              (= :* (:refer etc))   #{:*}
-                              :else                 (into
-                                                     #{}
-                                                     (:refer etc)))
-        current-ns          (or current-ns *ns*)
-        current-ns-sym      (symbol (str current-ns))
-        python-namespace    (find-ns module-name-or-ns)
-        [this-module cls]   (import-module-or-cls! module-name)
-        load-ns-classes?    (pyclass? cls)]
-
-    {:supported-flags   supported-flags
-     :etc               etc
-     :reload?           reload?
-     :no-arglists?      no-arglists?
-     :load-ns-classes?  load-ns-classes?
-
-     ;; if something like 'builtins.list was requested,
-     ;; the module name is 'builtins
-     :module-name       (if (pyclass? cls)
-                          (module-path-string module-name)
-                          module-name)
-
-     ;; if something like 'builtins.list was requested,
-     ;; the module-name is 'builtins
-     ;; or in the situation of
-     ;; '[builtins.list :as python.pylist]
-     ;; 'python would be bound to :module-name-or-ns
-     :module-name-or-ns (if (and (pyclass? cls)
-                                 (or (symbol? module-name-or-ns)
-                                     (string? module-name-or-ns)))
-                          (module-path-string module-name-or-ns)
-                          module-name-or-ns)
-
-     ;; presumes possibilty of alias in situations like
-     ;; '[builtins.list :as python.pylist]
-     ;; 'pylist would be bound to :class-name-or-ns in this case
-
-     :class-name-or-ns (if (and (pyclass? cls)
-                                (or (symbol? module-name-or-ns)
-                                    (string? module-name-or-ns)))
-                         (module-path-last-string module-name-or-ns)
-                         nil)
-
-     :exclude           exclude
-     :refer             refer
-     :current-ns        current-ns
-     :current-ns-sym    current-ns-sym
-     :python-namespace  python-namespace
-     :this-module       this-module
-     :module?           (pymodule? this-module)
-     :class?            (pyclass? cls)
-     :class-name        (when (pyclass? cls)
-                          (module-path-last-string
-                           module-name))}))
-
-(defn- extract-public-data
-  [{:keys [exclude python-namespace module-name-or-ns]}]
-  (let [python-namespace
-        (or python-namespace
-            (find-ns module-name-or-ns))]
-    (->> (ns-publics python-namespace)
-         (remove #(exclude (first %)))
-         (into {}))))
-
-(defn- reload-python-ns!
-  [module-name this-module module-name-or-ns]
-  (do
-    (remove-ns module-name)
-    (reload-module this-module)
-    (create-ns module-name-or-ns)))
-
-(defn- create-python-ns!
-  [module-name-or-ns]
-  (create-ns module-name-or-ns))
-
-(defn ^:private maybe-reload-or-create-ns!
-  [{:keys            [reload?
-                      this-module
-                      module-name
-                      module-name-or-ns]
-    cls?             :class?
-    python-namespace :python-namespace}]
-
-  ;; in the event of '[builtins.list :as python.pylist]
-  ;; this function is a no-op
-  (cond
-    cls?                   nil
-    reload?                (reload-python-ns! module-name
-                                              this-module
-                                              module-name-or-ns)
-    (not python-namespace) (create-python-ns! module-name-or-ns)))
-
-(defn enhanced-python-lib-configuration
-  [{:keys [python-namespace exclude this-module]
-    cls? :class?
-    :as   lib-config}]
-  ;; in the even of '[builtins.list :as python.pylist]
-  ;; or something similar, we do not provide enhanced
-  ;; data
-  (if cls?
-    lib-config
-    (let [public-data (extract-public-data lib-config)]
-      (merge
-       lib-config
-       {:public-data   public-data
-        :refer-symbols (extract-refer-symbols
-                        lib-config
-                        public-data)}))))
-
-(defn- bind-py-symbols-to-ns!
-  [{:keys [reload?
-           python-namespace
-           this-module
-           module-name-or-ns
-           no-arglists?]
-    cls?   :class?}]
-  (when (and (or reload? (not python-namespace)) (not cls?))
-    ;;Mutably define the root namespace.
-    (doseq [[att-name v] (vars this-module)]
-      (try
-        (when v
-          (if (py/callable? v)
-            (load-py-fn v (symbol att-name) module-name-or-ns
-                        {:no-arglists?
-                         no-arglists?})
-            (intern module-name-or-ns (symbol att-name) v)))
-        (catch Throwable e
-          (log/warnf e "Failed to require symbol %s" att-name))))))
-
-(defn- bind-module-ns!
-  [{:keys [current-ns-sym
-           module-name-or-ns
-           class-name-or-ns
-           this-module]
-    cls? :class?}]
-
-  ;; in event of '[builtins.list :as python.pylist]
-  ;; this is a no-op
-  (when (not cls?)
-    (intern current-ns-sym
-            (with-meta module-name-or-ns
-              {:doc (doc this-module)})
-            this-module)))
-
-(defn- generate-class-namespace-configs
-  [{:keys [module-name-or-ns
-           this-module
-           class-name
-           class-name-or-ns
-           ]
-    cls?  :class?
-    :as   lib-config}]
-  (letfn [(pyclass-pair? [[attr attr-val]]
-
-            (or
-
-             ;; in the event that something like
-             ;; builtins.list was requested,
-             ;; we do not want to bind every
-             ;; class in the module to the ns, only the
-             ;; requested class
-
-             (and cls?
-                  (pyclass? attr-val)
-                  (and (hasattr attr-val "__name__")
-                       (= class-name
-                          (py/get-attr
-                           attr-val
-                           "__name__"))))
-
-             ;; if a module like 'builtins was specified
-             ;; without a class like 'builtins.list,
-             ;; we bind every class in the module to the module-ns
-
-             (and (not cls?)
-                  (pyclass? attr-val))))
-          (pyclass-ns-config [[attr attr-val]]
-            {:namespace      module-name-or-ns
-             :attribute-type :class
-             :classname      attr
-             :class-symbol   (symbol attr)
-             :class-binding  (or class-name-or-ns
-                                 class-name)
-             :class          attr-val
-             :attributes     ((comp
-                               (py/get-attr builtins "dict")
-                               vars) attr-val)})
-          (pyclass-attribute-fanout
-            [{:keys [namespace
-                     classname
-                     class-symbol
-                     class
-                     attributes]
-              :as   attr-config}]
-            (into [attr-config]
-                  (for [[attr attr-val] (seq attributes)
-                        :let
-                        [attr-type
-                         (if (and (not (nil? attr-val))
-                                  (py/callable?  attr-val))
-
-                           :method
-                           :attribute)]]
-                    (merge
-                     (dissoc attr-config :attributes :type)
-                     {:attribute-type attr-type
-                      :type           :class-attribute
-                      :class-binding  (or class-name-or-ns
-                                          class-name)
-                      :attribute      attr-val
-                      :attribute-name attr}))))]
-    (into []
-          (comp
-           (filter pyclass-pair?)
-           (map pyclass-ns-config)
-           (map pyclass-attribute-fanout)
-           cat)
-          (seq (vars this-module)))))
-
-(defmulti class-sort :attribute-type)
-(defmethod class-sort :class [_] 0)
-(defmethod class-sort :method [_] 1)
-(defmethod class-sort :attribute [_] 2)
-
-(defmulti intern-ns-class :attribute-type)
-
-(defmethod intern-ns-class :class
-  [{original-namespace :namespace
-    cls-name           :classname
-    cls-sym            :class-symbol
-    cls                :class
-    cls-binding        :class-binding
-    :as                cls-ns-config}]
-
-  ;; cls-binding percolates down to here in the situation where
-  ;; '[builtins.list :as python.pylist] occurs
-
-  (let [cls-ns (symbol (str original-namespace
-                            "."
-                            (or
-                             cls-binding
-                             cls-sym)))]
-    (create-ns cls-ns)
-    cls-ns-config))
-
-(defmethod intern-ns-class :method
-  [{original-namespace :namespace
-    cls-name           :classname
-    cls-sym            :class-symbol
-    cls                :class
-    cls-binding        :class-binding
-    method-name        :attribute-name
-    method             :attribute
-    :as                cls-ns-config}]
-
-  ;; cls-binding percolates down to here in the situation where
-  ;; '[builtins.list :as python.pylist] occurs
-
-  (let [cls-ns (symbol (str original-namespace "."
-                            (or  cls-binding cls-sym)))]
-    (load-py-fn method (symbol method-name)
-                cls-ns {})
-    cls-ns-config))
-
-(defmethod intern-ns-class :attribute
-  [{original-namespace :namespace
-    cls-name           :classname
-    cls-sym            :class-symbol
-    cls                :class
-    cls-binding        :class-binding
-    attribute-name     :attribute-name
-    attribute          :attribute
-    :as                cls-ns-config}]
-
-  ;; cls-binding percolates down to here in the situation where
-  ;; '[builtins.list :as python.pylist] occurs
-
-  (let [cls-ns (symbol (str original-namespace "."
-                            (or  cls-binding cls-sym)))]
-    (intern cls-ns (symbol attribute-name) attribute)
-    cls-ns-config))
-
-(defn- bind-class-namespaces!
-  [{cls?   :class?
-    module :module?
-    :as    lib-config}]
-  (let [class-namespace-configs
-        (->>
-         (generate-class-namespace-configs
-          lib-config)
-         (sort-by class-sort))]
-    (doseq [cls-namespace-config class-namespace-configs]
-      (intern-ns-class cls-namespace-config))))
-
-(defn- intern-public-and-refer-symbols!
-  [{:keys [public-data refer-symbols current-ns-sym]}]
-  (doseq [[s v] (select-keys public-data refer-symbols)]
-    (intern current-ns-sym
-            (with-meta s (meta v))
-            (deref v))))
-
-(defn preload-python-lib! [req]
-  (let [lib-config (python-lib-configuration req)]
-    (maybe-reload-or-create-ns! lib-config)
-    (bind-py-symbols-to-ns! lib-config)
-    (bind-module-ns! lib-config)
-    (enhanced-python-lib-configuration lib-config)))
-
-(defn ^:private load-python-lib [req]
-  (let [{:keys [supported-flags
-                flags
-                etc
-                reload?
-                no-arglists?
-                load-ns-classes?
-                module-name
-                module-name-or-ns
-                exclude
-                refer
-                current-ns
-                current-ns-sym
-                python-namespace
-                this-module
-                python-namespace
-                public-data
-                refer-symbols
-                class?
-                module?]
-         :as   lib-config}
-        (preload-python-lib! req)]
-
-    (when (not class?)
-      (intern-public-and-refer-symbols! lib-config))
-
-    ;; alpha
-    ;; TODO: does not respect reloading or much of the other
-    ;;   ..: syntax (yet)
-    (when load-ns-classes?
-      (bind-class-namespaces! lib-config))))
+                                (= :all (:refer etc)) #{:all}
+                                (= :* (:refer etc))   #{:*}
+                                :else (into #{} (:refer etc)))
+        pyobj (pymeta/path->py-obj (str module-name) :reload? reload?)
+        existing-py-ns? (find-ns module-name)]
+    (when (and reload? existing-py-ns?)
+      (remove-ns module-name))
+    (create-ns module-name)
+    (when (or (not existing-py-ns?)
+              reload?)
+      (pymeta/apply-static-metadata-to-namespace! module-name (datafy pyobj)
+                                                  :no-arglists? no-arglists?))
+    (refer module-name
+           :exclude exclude
+           :only (extract-refer-symbols {:refer refer
+                                         :this-module pyobj}
+                                        (ns-publics (find-ns module-name))))
+    (alias module-name-or-ns module-name)))
+
 
 (defn require-python
   "## Basic usage ##
@@ -758,8 +195,10 @@
 
   (cond
     (list? reqs)
-    (doseq [req (vec reqs)] (require-python req))
+    (doseq [req reqs] (require-python req))
     (symbol? reqs)
-    (load-python-lib (vector reqs))
+    (require-python (vector reqs))
     (vector? reqs)
-    (load-python-lib reqs)))
+    (do-require-python reqs)
+    :else
+    (throw (Exception. "Invalid argument: %s" reqs))))

From be6ecdd82a6126a918db38421fd01cfcde93031a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 12 Jan 2020 13:11:03 -0700
Subject: [PATCH 135/456] Reworked require-python to work like clojure's
 require

---
 src/libpython_clj/metadata.clj             |  4 +-
 src/libpython_clj/require.clj              | 29 +++++----
 test/libpython_clj/require_python_test.clj | 69 +---------------------
 3 files changed, 18 insertions(+), 84 deletions(-)

diff --git a/src/libpython_clj/metadata.clj b/src/libpython_clj/metadata.clj
index b6c3ef7..b38669f 100644
--- a/src/libpython_clj/metadata.clj
+++ b/src/libpython_clj/metadata.clj
@@ -306,7 +306,9 @@
   (let [target-item (metadata-map->py-obj metadata-map)]
     (get-or-create-namespace! ns-symbol (:doc metadata-map))
     (doseq [[k v] metadata-map]
-      (when (has-attr? target-item k)
+      (when (and (string? k)
+                 (map? v)
+                 (has-attr? target-item k))
         (let [att-val (get-attr target-item k)]
           (intern ns-symbol
                   (with-meta (symbol k)
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index ab50ce9..25e3ba5 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -100,27 +100,26 @@
                              (into {}))
         reload?             (:reload flags)
         no-arglists?        (:no-arglists flags)
-        module-name-or-ns   (:as etc module-name)
+        alias-name          (:as etc)
         exclude             (into #{} (:exclude etc))
-        refer               (cond
-                                (= :all (:refer etc)) #{:all}
-                                (= :* (:refer etc))   #{:*}
-                                :else (into #{} (:refer etc)))
+        refer-data          (cond
+                              (= :all (:refer etc)) #{:all}
+                              (= :* (:refer etc))   #{:*}
+                              :else (into #{} (:refer etc)))
         pyobj (pymeta/path->py-obj (str module-name) :reload? reload?)
         existing-py-ns? (find-ns module-name)]
-    (when (and reload? existing-py-ns?)
-      (remove-ns module-name))
     (create-ns module-name)
-    (when (or (not existing-py-ns?)
-              reload?)
+    (when (or (not existing-py-ns?) reload?)
       (pymeta/apply-static-metadata-to-namespace! module-name (datafy pyobj)
                                                   :no-arglists? no-arglists?))
-    (refer module-name
-           :exclude exclude
-           :only (extract-refer-symbols {:refer refer
-                                         :this-module pyobj}
-                                        (ns-publics (find-ns module-name))))
-    (alias module-name-or-ns module-name)))
+    (when-let [refer-symbols (->> (extract-refer-symbols {:refer refer-data
+                                                          :this-module pyobj}
+                                                         (ns-publics
+                                                          (find-ns module-name)))
+                                  seq)]
+      (refer module-name :exclude exclude :only refer-symbols))
+    (when alias-name
+      (alias alias-name module-name))))
 
 
 (defn require-python
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index c1a8d27..453b579 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -10,17 +10,13 @@
 (require-python '[math
                   :refer :*
                   :exclude [sin cos]
-                  :as pymath
-                  :reload true])
+                  :as pymath])
 
 
 (deftest base-require-test
   (let [publics (ns-publics (find-ns 'libpython-clj.require-python-test))]
-    (is (contains? publics 'acos))
-    (is (contains? publics 'floor))
     (is (not (contains? publics 'sin)))
     (is (= 10.0 (double (floor 10.1))))
-    (is (= pymath (py/import-module "math")))
     (is (thrown? Throwable (require-python '[math :refer [blah]])))))
 
 (deftest parse-flags-test
@@ -50,69 +46,6 @@
     (is (= #{:b} (parse-flags #{:a :b} '[:b :a false])))
     (is (= #{:b :a} (parse-flags #{:a :b} '[:b :a false :a true])))))
 
-(deftest python-lib-configuration-test
-  (let [python-lib-configuration #'req/python-lib-configuration
-        simple-req               '[csv]
-        simple-spec              (python-lib-configuration
-                                  simple-req
-                                  (find-ns 'libpython-clj.require-python-test))
-        {:keys [exclude
-                supported-flags
-                current-ns-sym
-                module-name
-                module-name-or-ns
-                reload?
-                no-arglists?
-                etc
-                current-ns
-                this-module
-                python-namespace
-                refer]}          simple-spec
-        csv-module               (py/import-module "csv")]
-
-    ;; no exclusions
-    (is (= #{} exclude))
-    (is (= #{:no-arglists :reload}
-           supported-flags))
-    (is (= 'csv module-name module-name-or-ns))
-    (is (nil? reload?))
-    (is (nil? no-arglists?))
-    (is (= {} etc))
-    (is (= csv-module this-module)))
-
-
-  (let [python-lib-configuration #'req/python-lib-configuration
-        simple-req               '[requests
-                                   :reload true
-                                   :refer [get]
-                                   :no-arglists]
-        simple-spec              (python-lib-configuration
-                                  simple-req
-                                  (find-ns 'libpython-clj.require-python-test))
-        {:keys [exclude
-                supported-flags
-                current-ns-sym
-                module-name
-                module-name-or-ns
-                reload?
-                no-arglists?
-                etc
-                current-ns
-                this-module
-                python-namespace
-                refer]}          simple-spec
-        requests-module          (py/import-module "requests")]
-
-    ;; no exclusions
-    (is (= #{} exclude))
-    (is (= 'requests module-name module-name-or-ns))
-    (is (= reload? :reload))
-    (is (= no-arglists? :no-arglists))
-    (is (= {:refer '[get]} etc))
-    (is (= requests-module this-module))
-    (is (= #{'get} refer))
-    (is (nil? python-namespace))))
-
 
 (require-python '([builtins :as python]
                   [builtins.list :as python.pylist]))

From 65296443e68ec273ea45d1a607904ab40809c4a0 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 12 Jan 2020 13:16:36 -0700
Subject: [PATCH 136/456] editing

---
 CHANGELOG.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 00ef5a6..3f319aa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Time for a ChangeLog!
 
+## 1.31-SNAPSHOT
+
+* Python objects are now datafy-able and nav-igable.  `require-python`
+  is now rebuilt using datafy.
+  
+
 ## 1.30
 
 This release is a big one.  With finalizing `require-python` we have a clear way

From 1a97bc646b411cf8d81e5c7b249f279f11d1d4e9 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Fri, 17 Jan 2020 09:51:21 -0500
Subject: [PATCH 137/456] ISSUE-44 (syntax sugar) (#45)

* Add syntax sugar for issue 44 https://github.com/cnuernber/libpython-clj/issues/44

* Fix failing tests

* more convincing tests

* whitespace

* update Usage and changelog

* fix typo
---
 CHANGELOG.md                       |  4 ++
 docs/Usage.md                      | 74 +++++++++++++++++++++++-
 src/libpython_clj/python.clj       | 42 ++++++++++++++
 test/libpython_clj/python_test.clj | 93 ++++++++++++++++++++----------
 4 files changed, 179 insertions(+), 34 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3f319aa..b6dc3b9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,10 @@
 * Python objects are now datafy-able and nav-igable.  `require-python`
   is now rebuilt using datafy.
   
+* `py.`, `py.-`, and `py..` added to the `libpython-clj` APIs
+  to allow method/attribute access more consistent with idiomatic
+  Clojure forms.
+  
 
 ## 1.30
 
diff --git a/docs/Usage.md b/docs/Usage.md
index 18be975..ce30b01 100644
--- a/docs/Usage.md
+++ b/docs/Usage.md
@@ -118,7 +118,7 @@ your variable is:200
  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'my_var': 200}}
 ```
 
-Running python isn't ever really necessary, however, although it may at times be
+Running Python isn't ever really necessary, however, although it may at times be
 convenient.  You can call attributes from clojure easily:
 
 ```clojure
@@ -263,6 +263,76 @@ user> (py/$.. numpy random shuffle)
 <built-in method shuffle of numpy.random.mtrand.RandomState object at 0x7fa66410cca8>
 ```
 
+##### New sugar (fixme)
+
+`libpython-clj` offers syntactic forms similar to those offered by 
+Clojure for interacting with Python classes and objects. 
+
+**Class/object methods**
+Where in Clojure you would use `(. obj method arg1 arg2 ... argN)`,
+you can use `(py. pyobj method arg1 arg2 ... argN)`.  
+
+In Python, this is equivalent to `pyobj.method(arg1, arg2, ..., argN)`.
+Concrete examples are shown below.
+
+**Class/object attributes**
+Where in Clojure you would use `(.- obj attr)`, you can use 
+`(py.- pyobj attr)`.
+
+In Python, this is equivalent to `pyobj.attr`. 
+Concrete examples shown below.
+
+**Nested attribute access**
+To achieve a chain of method/attribute access, use the `py..` for.
+
+```clojure 
+(py.. (requests/get "http://www.google.com") 
+      -content
+      (decode "latin-1"))
+```
+(**Note**: requires Python `requests` module installled)
+
+**Examples**
+
+```clojure 
+user=> (require '[libpython-clj.python :as py :refer [py. py.. py.-]])
+nil
+user=> (require '[libpython-clj.require :refer [require-python]])
+
+... debug info ...
+
+user=> (require-python '[builtins :as python])
+WARNING: AssertionError already refers to: class java.lang.AssertionError in namespace: builtins, being replaced by: #'builtins/AssertionError
+WARNING: Exception already refers to: class java.lang.Exception in namespace: builtins, being replaced by: #'builtins/Exception
+nil
+user=> (def xs (python/list))
+#'user/xs
+user=> (py. xs append 1)
+nil
+user=> xs
+[1]
+user=> (py. xs extend [1 2 3])
+nil
+user=> xs
+[1, 1, 2, 3]
+user=> (py. xs __len__)
+4
+user=> ((py.- xs __len__)) ;; attribute syntax to get then call method
+4
+user=> (py. xs pop)
+3
+user=> (py. xs clear)
+nil
+;; requires Python requests module installed
+user=> (require-python 'requests)
+nil
+user=> (def requests (py/import-module "requests"))
+#'user/requests
+user=> (py.. requests (get "http://www.google.com") -content (decode "latin-1"))
+"<!doctype html><html itemscope=\"\" ... snip ... "
+```
+
+
 
 ### Numpy
 
@@ -304,4 +374,4 @@ zero copy pathway to and from numpy.  For more information on how this happens,
 please refer to the datatype library [documentation](https://github.com/techascent/tech.datatype/tree/master/docs).
 
 Just keep in mind, careless usage of zero copy is going to cause spooky action at a
-distance.
+    distance.
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 0cb0c75..afefb0b 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -416,3 +416,45 @@
                    (alter-meta! #'~varname assoc :doc (get-attr ~'var-data "__doc__"))
                    #'~varname))
               (concat [item] args)))))
+
+
+(defmacro py.-
+  "Class/object getter syntax.  (py.- obj attr) is equivalent to
+  Python's obj.attr syntax."
+  [x arg]
+  (list #'$. x arg))
+
+
+(defmacro py.
+  "Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
+  is equivalent to Python's obj.method(arg1, arg2, ..., argN) syntax."
+  [x & args]
+  (list* (into (vector #'$a x) args)))
+
+
+(defn ^:private handle-pydotdot
+  ([x form]
+   (if (list? form)
+     (let [form-data (vec form)
+           [instance-member & args] form-data
+           symbol-str (str instance-member)]
+       (if (clojure.string/starts-with? symbol-str "-")
+         (list #'py.- x (symbol (subs symbol-str 1 (count symbol-str))))
+         (list* (into (vector #'py. x instance-member) args))))
+     (handle-pydotdot x (list form))))
+  ([x form & more]
+   (apply handle-pydotdot (handle-pydotdot x form) more)))
+
+
+(defmacro py..
+  "Extended accessor notation, similar to the `..` macro in Clojure.
+
+  (require-python 'sys)
+  (py.. sys -path (append \"/home/user/bin\"))
+
+  is equivalent to Python's
+
+  import sys
+  sys.path.append('/home/user/bin')"
+  [x & args]
+  (apply handle-pydotdot x args))
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 8151c5f..903d325 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -12,7 +12,6 @@
 
 (py/initialize!)
 
-
 (deftest stdout-and-stderr
   (is (= "hey\n" (with-out-str
                    (py/run-simple-string "print('hey')"))))
@@ -23,7 +22,6 @@
   ;;Python exceptions get translated into actual java exceptions.
   (is (thrown? Throwable (py/run-simple-string "import sys\nprint('hey', stderr"))))
 
-
 (deftest dicts
   (let [py-dict (py/->python {:a 1 :b 2})]
     (is (= :dict (py/python-type py-dict)))
@@ -41,7 +39,6 @@
       (is (= {"a" 1 "b" 2}
              (into {} bridge-dict))))))
 
-
 (deftest lists
   (let [py-list (py/->py-list [4 3 2 1])]
     (is (= :list (py/python-type py-list)))
@@ -58,11 +55,10 @@
       (.sort ^List bridge-list nil)
       (is (= [1 2 3 4] (into [] bridge-list))))))
 
-
 (deftest global-dict
   (let [main-module (py/add-module "__main__")
         ^Map globals (-> (py/module-dict main-module)
-                    (py/as-jvm))]
+                         (py/as-jvm))]
     (is (instance? Map globals))
     (.put globals "item" 100)
     (py/set-item! globals "item2" 200)
@@ -71,7 +67,6 @@
     (py/run-simple-string "item3 = item + item2")
     (is (= 300 (globals "item3")))))
 
-
 (deftest numpy-and-back
   (let [jvm-tens (dtt/->tensor (->> (range 9)
                                     (partition 3)))]
@@ -85,11 +80,11 @@
       ;;This operation is in-place
       (let [py-trans (py/call-attr py-tens "transpose" [1 0])]
         (is (= [[0.0 1.0 2.0] [3.0 4.0 5.0] [6.0 7.0 8.0]]
-             (-> (py/as-tensor py-tens)
-                 dtt/->jvm)))
+               (-> (py/as-tensor py-tens)
+                   dtt/->jvm)))
         (is (= [[0.0 3.0 6.0] [1.0 4.0 7.0] [2.0 5.0 8.0]]
-             (-> (py/as-tensor py-trans)
-                 dtt/->jvm)))
+               (-> (py/as-tensor py-trans)
+                   dtt/->jvm)))
         ;;But they are sharing backing store, so mutation will travel both
         ;;ways.  Creepy action at a distance indeed
         (dtype/copy! [5 6 7] (py/as-tensor py-trans))
@@ -120,7 +115,6 @@
                      double))
           (str "Item type " constructor)))))
 
-
 (deftest dict-with-complex-key
   (let [py-dict (py/->python {["a" "b"] 1
                               ["c" "d"] 2})
@@ -132,12 +126,10 @@
                 (map vec)
                 set)))))
 
-
 (deftest simple-print-crashed
   (let [numpy (py/import-module "numpy")]
     (println (py/as-tensor (py/call-attr numpy "ones" [3 3])))))
 
-
 (deftest true-false-list
   (is (= [false true]
          (-> '(false true)
@@ -151,7 +143,6 @@
                   a)
                 vec)))))
 
-
 (deftest aspy-iter
   (let [testcode-module (py/import-module "testcode")]
     (is (= [1 2 3 4 5]
@@ -163,7 +154,6 @@
                              "for_iter" (py/as-python {"a" 1 "b" 2 "c" 3}))
                (py/->jvm))))))
 
-
 (deftest basic-with-test
   (let [testcode-module (py/import-module "testcode")]
     (let [fn-list (py/->py-list [])]
@@ -192,18 +182,15 @@
       (is (= ["enter" "exit: None"]
              (py/->jvm fn-list))))))
 
-
 (deftest arrow-as-fns-with-nil
   (is (= nil (py/->jvm nil)))
   (is (= nil (py/as-jvm nil))))
 
-
 (deftest pydict-nil-get
   (let [dict (py/->python {:a 1 :b {:a 1 :b 2}})
         bridged (py/as-jvm dict)]
     (is (= nil (bridged nil)))))
 
-
 (deftest custom-clojure-item
   (let [att-map {"clojure_fn" (py/->python #(vector 1 2 3))}
         my-python-item (py/create-bridge-from-att-map
@@ -213,8 +200,7 @@
                         att-map
                         ;;second is the list of attributes.  In this case, since this
                         ;;object isn't iterable or anything, this function will do.
-                        att-map
-                        )
+                        att-map)
         py-mod (py/import-module "testcode")]
     (is (= [1 2 3]
            (py/call-attr py-mod "calling_custom_clojure_fn" my-python-item)))
@@ -234,21 +220,18 @@
                           my-obj
                           ;;second is the list of attributes.  In this case, since this
                           ;;object isn't iterable or anything, this function will do.
-                          att-map
-                          )]
+                          att-map)]
       (is (= [4 5 6]
              (vec my-obj)))
       (is (= [4 5 6]
              (vec (py/call-attr py-mod "for_iter" my-python-item)))))))
 
-
 (deftest bridged-dict-to-jvm
   (let [py-dict (py/->py-dict {:a 1 :b 2})
         bridged (py/as-jvm py-dict)
         copied-back (py/->jvm bridged)]
     (is (instance? clojure.lang.PersistentArrayMap copied-back))))
 
-
 (deftest calling-conventions
   (let [np (py/import-module "numpy")
         linspace (py/$. np linspace)]
@@ -267,8 +250,60 @@
            (str (py/get-attr np "linspace"))))
     (is (= (str (py/$.. np random shuffle))
            (str (-> (py/get-attr np "random")
-                    (py/get-attr "shuffle")))))))
+                    (py/get-attr "shuffle"))))))
 
+  
+  (let [builtins (py/import-module "builtins")
+        l        (py/call-attr builtins "list")]
+    (is (= (py/py. l __len__) 0))
+    (py/py. l append 1)
+    (is (= (py/py. l __len__) 1))
+    (py/py.. l (extend [1 2 3]))
+    (is (= ((py/py.- l __len__)) 4)))
+
+  (let [sys (py/import-module "sys")]
+    (is (int? (py/py.. sys -path __len__))))
+
+
+  (let [{{Foo :Foo} :globals}
+        (py/run-simple-string "
+class Foo:
+
+    def __init__(self, a, b):
+        self.a = a
+        self.b = b
+        self._res = []
+
+    def res(self):
+        return self._res
+
+    def extend(self, arg):
+        self._res.extend(arg)
+        return self
+
+    def count(self):
+        return len(self._res)
+
+    def append(self, *args):
+        return self.extend(args)
+
+
+    def math(self, c):
+        return self.append(self.a + self.b + c)
+
+")
+        f (Foo 1 2)]
+    (is (= [] ((py/py.- f res)) (py/py. f res)))
+    (is (= 6 (py/py.. f (append 1)
+                      (append 2)
+                      (math 3)
+                      (extend [4 5 6]) count)))
+    (is (= [1 2 6 4 5 6] ((py/py.- f res)) (py/py. f res)))
+    (is (= 6
+           (py/py.. f res __len__)
+           ((py/py.. f res -__len__))
+           (py/py.. f count)
+           ((py/py.. f -count))))))
 
 (deftest infinite-seq
   (let [islice (-> (py/import-module "itertools")
@@ -280,7 +315,6 @@
                (islice 0 10)
                (vec))))))
 
-
 (deftest persistent-vector-nparray
   (testing "Create numpy array from nested persistent vectors"
     (let [ary-data (-> (py/import-module "numpy")
@@ -290,7 +324,6 @@
                                      [4 5 6]])
                       (py/as-tensor ary-data))))))
 
-
 (deftest python-tuple-equals
   (testing "Python tuples have nice equal semantics."
     (let [lhs (py/->py-tuple [1 2])
@@ -303,14 +336,12 @@
       (is (not= (.hashCode lhs)
                 (.hashCode not-same))))))
 
-
 (deftest range-nparray
   (let [ary-data (-> (py/import-module "numpy")
                      (py/$a array (range 10)))]
     (is (dfn/equals (dtt/->tensor (range 10))
                     (py/as-tensor ary-data)))))
 
-
 (deftest false-is-always-py-false
   (let [py-false (libpy/Py_False)
         ->false (py/->python false)
@@ -320,7 +351,6 @@
     (is (= (Pointer/nativeValue (jna/as-ptr py-false))
            (Pointer/nativeValue (jna/as-ptr as-false))))))
 
-
 (deftest instance-abc-classes
   (let [py-dict (py/->python {"a" 1 "b" 2})
         bridged-dict (py/as-python {"a" 1 "b" 2})
@@ -335,7 +365,6 @@
     (is (py/is-instance? bridged-iter iter-type))
     (is (py/is-instance? bridged-list sequence-type))))
 
-
 (deftest nested-map-and-back
   (let [py-dict (-> (py/run-simple-string "testdata={'camera_id': 'CODOT-10106-12067', 'country': 'United States', 'state': 'Colorado', 'city': 'Fountain', 'provider': 'CO DOT', 'description': '0.6 mi N of Ray Nixon Rd Int', 'direction': 'North', 'video': False, 'links': {'jpeg': {'url': 'https://www.cotrip.org/dimages/camera?imageURL=remote/CTMCCAM025S125-20-N.jpg'}}, 'tags': ['auto_rerated'], 'ratings': {'road_weather': 4, 'visibility': 4}, 'health': {}, 'created_at': '2016-04-19T20:27:45.030Z', 'time_zone_offset': -25200}")
                     (get-in [:globals "testdata"]))
@@ -343,7 +372,7 @@
     (is (= (get jvm-dict "ratings")
            (py/->jvm (py/get-item py-dict "ratings"))))))
 
-
 (deftest characters
   (is (= (py/->jvm (py/->python "c"))
          (py/->jvm (py/->python \c)))))
+

From 933b38c0fc1e2ede97d5e5f9cddbbd9029443dad Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 19 Jan 2020 12:34:57 -0700
Subject: [PATCH 138/456] 1.31

---
 CHANGELOG.md | 2 +-
 project.clj  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b6dc3b9..37c82e1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Time for a ChangeLog!
 
-## 1.31-SNAPSHOT
+## 1.31
 
 * Python objects are now datafy-able and nav-igable.  `require-python`
   is now rebuilt using datafy.
diff --git a/project.clj b/project.clj
index 4219e1c..18c48ef 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.31-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.31"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From dd9c27a78913d35d35f66dffaa0c88ccd8bd26d8 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 19 Jan 2020 12:35:17 -0700
Subject: [PATCH 139/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 18c48ef..f4c6014 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.31"
+(defproject cnuernber/libpython-clj "1.32-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 216adaa6c2022f6dcff683fa9c4003331e557acb Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 20 Jan 2020 15:55:18 -0700
Subject: [PATCH 140/456] some simplification/speed improvements (#51)

---
 src/libpython_clj/jna/base.clj           |  21 ++-
 src/libpython_clj/python.clj             |   5 +-
 src/libpython_clj/python/bridge.clj      |  49 +++----
 src/libpython_clj/python/interop.clj     |   4 +-
 src/libpython_clj/python/interpreter.clj | 179 +++++++++--------------
 src/libpython_clj/python/object.clj      |   7 +-
 6 files changed, 120 insertions(+), 145 deletions(-)

diff --git a/src/libpython_clj/jna/base.clj b/src/libpython_clj/jna/base.clj
index 6bd6c14..ad77dea 100644
--- a/src/libpython_clj/jna/base.clj
+++ b/src/libpython_clj/jna/base.clj
@@ -3,9 +3,10 @@
             [tech.jna.base :as jna-base]
             [camel-snake-kebab.core :refer [->kebab-case]])
   (:import [com.sun.jna Pointer NativeLibrary]
-           [libpython_clj.jna PyObject]))
-
+           [libpython_clj.jna PyObject]
+           [java.util.concurrent.atomic AtomicLong]))
 
+(set! *warn-on-reflection* true)
 
 (def ^:dynamic *python-library* "python3.6m")
 
@@ -64,7 +65,19 @@
   (ensure-pyobj item))
 
 
-(def ^:dynamic *gil-captured* false)
+(definline current-thread-id
+  ^long []
+  (-> (Thread/currentThread)
+      (.getId)))
+
+(def gil-thread-id (AtomicLong. Long/MAX_VALUE))
+
+
+(defn set-gil-thread-id!
+  ^long [^long expected ^long new-value]
+  (when-not (.compareAndSet ^AtomicLong gil-thread-id expected new-value)
+    (throw (Exception. "Failed to set gil thread id")))
+  new-value)
 
 
 (defmacro def-no-gil-pylib-fn
@@ -78,7 +91,7 @@
   `(defn ~fn-name
      ~docstring
      ~(mapv first argpairs)
-     (when-not *gil-captured*
+     (when-not (== (current-thread-id) (.get ^AtomicLong gil-thread-id))
        (throw (Exception. "Failure to capture gil when calling into libpython")))
      (let [~'tvm-fn (jna/find-function ~(str fn-name) *python-library*)
            ~'fn-args (object-array
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index afefb0b..922e790 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -1,8 +1,7 @@
 (ns libpython-clj.python
   (:require [tech.parallel.utils :refer [export-symbols]]
             [libpython-clj.python.interop :as pyinterop]
-            [libpython-clj.python.interpreter :as pyinterp
-             :refer [with-interpreter]]
+            [libpython-clj.python.interpreter :as pyinterp]
             [libpython-clj.python.object :as pyobj]
             [libpython-clj.python.bridge :as pybridge]
             [libpython-clj.jna :as libpy]
@@ -236,7 +235,7 @@
              library-path
              python-home
              no-io-redirect?]}]
-  (when-not @pyinterp/*main-interpreter*
+  (when-not @pyinterp/main-interpreter*
     (pyinterp/initialize! :program-name program-name
                           :library-path library-path
                           :python-home python-home)
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index d8ec7d0..c52183d 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -13,7 +13,6 @@
             [libpython-clj.python.interpreter
              :refer
              [with-gil
-              with-interpreter
               ensure-bound-interpreter
               check-error-throw
               initialize!]
@@ -238,7 +237,7 @@
          (->py-object-ptr [item#] (libpy/as-pyobj pyobj#))
          py-proto/PPythonType
          (get-python-type [item]
-           (with-interpreter interpreter#
+           (with-gil
              (py-proto/get-python-type pyobj#)))
          py-proto/PCopyToPython
          (->python [item# options#] pyobj#)
@@ -248,43 +247,43 @@
          (as-jvm [item# options#] item#)
          py-proto/PCopyToJVM
          (->jvm [item# options#]
-           (with-interpreter interpreter#
+           (with-gil
              (->jvm pyobj# options#)))
          py-proto/PPyObject
          (dir [item#]
-           (with-interpreter interpreter#
+           (with-gil
              (py-proto/dir pyobj#)))
          (has-attr? [item# item-name#]
-           (with-interpreter interpreter#
+           (with-gil
              (py-proto/has-attr? pyobj# item-name#)))
          (get-attr [item# item-name#]
-           (with-interpreter interpreter#
+           (with-gil
              (-> (py-proto/get-attr pyobj# item-name#)
                  as-jvm)))
          (set-attr! [item# item-name# item-value#]
-           (with-interpreter interpreter#
+           (with-gil
              (py-proto/set-attr! pyobj# item-name#
                                  (as-python item-value#))))
          (callable? [item#]
-           (with-interpreter interpreter#
+           (with-gil
              (py-proto/callable? pyobj#)))
          (has-item? [item# item-name#]
-           (with-interpreter interpreter#
+           (with-gil
              (py-proto/has-item? pyobj# item-name#)))
          (get-item [item# item-name#]
-           (with-interpreter interpreter#
+           (with-gil
              (-> (py-proto/get-item pyobj# item-name#)
                  as-jvm)))
          (set-item! [item# item-name# item-value#]
-           (with-interpreter interpreter#
+           (with-gil
              (py-proto/set-item! pyobj# item-name# (as-python item-value#))))
          py-proto/PPyAttMap
          (att-type-map [item#]
-           (with-interpreter interpreter#
+           (with-gil
              (py-proto/att-type-map pyobj#)))
          py-proto/PyCall
          (do-call-fn [callable# arglist# kw-arg-map#]
-           (with-interpreter interpreter#
+           (with-gil
              (let [arglist# (mapv mostly-copy-arg arglist#)
                    kw-arg-map# (->> kw-arg-map#
                                     (map (fn [[k# v#]]
@@ -294,7 +293,7 @@
                    (as-jvm)))))
          Object
          (toString [this#]
-           (with-interpreter interpreter#
+           (with-gil
              (if (= 1 (libpy/PyObject_IsInstance pyobj# (libpy/PyType_Type)))
                (format "%s.%s"
                        (->jvm (py-proto/get-attr pyobj# "__module__"))
@@ -363,7 +362,7 @@
                             (map (juxt identity (partial py-proto/get-attr pyobj)))
                             (into {}))
           py-call (fn [fn-name & args]
-                    (with-interpreter interpreter
+                    (with-gil
                       (py-impl-call-as fn-name dict-att-map args)))]
 
       (bridge-pyobject
@@ -405,7 +404,7 @@
               (->> (raw-python-iterator dict-att-map)
                    iterator-seq
                    (map (fn [pyobj-key]
-                          (with-interpreter interpreter
+                          (with-gil
                             (let [k (as-jvm pyobj-key)
                                   v (.get this pyobj-key)
                                   tuple [k v]]
@@ -435,7 +434,7 @@
                             (map (juxt identity (partial py-proto/get-attr pyobj)))
                             (into {}))
           py-call (fn [fn-name & args]
-                    (with-interpreter interpreter
+                    (with-gil
                       (py-impl-call-as fn-name dict-att-map args)))]
       (bridge-pyobject
        pyobj
@@ -550,7 +549,7 @@
 
 (defmethod py-proto/python-obj-iterator :default
   [pyobj interpreter]
-  (with-interpreter interpreter
+  (with-gil
     (let [iter-fn (py-proto/get-attr pyobj "__iter__")]
       (python->jvm-iterator iter-fn as-jvm))))
 
@@ -647,32 +646,32 @@
            IFn
            ;;uggh
            (invoke [this]
-                   (with-interpreter interpreter
+                   (with-gil
                      (cfn this)))
 
            (invoke [this arg0]
-                   (with-interpreter interpreter
+                   (with-gil
                      (cfn this arg0)))
 
            (invoke [this arg0 arg1]
-                   (with-interpreter interpreter
+                   (with-gil
                      (cfn this arg0 arg1)))
 
            (invoke [this arg0 arg1 arg2]
-                   (with-interpreter interpreter
+                   (with-gil
                      (cfn this arg0 arg1 arg2)))
 
            (invoke [this arg0 arg1 arg2 arg3]
-                   (with-interpreter interpreter
+                   (with-gil
                      (cfn this arg0 arg1 arg2 arg3)))
 
 
            (invoke [this arg0 arg1 arg2 arg3 arg4]
-                   (with-interpreter interpreter
+                   (with-gil
                      (cfn this arg0 arg1 arg2 arg3 arg4)))
 
            (applyTo [this arglist]
-                    (with-interpreter interpreter
+                    (with-gil
                       (apply cfn this arglist)))
            ;;Mark this as executable
            Fn
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
index 55713a3..e1a9efc 100644
--- a/src/libpython_clj/python/interop.clj
+++ b/src/libpython_clj/python/interop.clj
@@ -10,7 +10,7 @@
             [libpython-clj.python.interpreter
              :refer
              [get-object-handle
-              with-gil with-interpreter
+              with-gil
               ensure-bound-interpreter
               ensure-interpreter
               find-jvm-bridge-entry
@@ -357,7 +357,7 @@
 (defn expose-bridge-to-python!
   "Create a python object for this bridge."
   [^JVMBridge bridge & [libpython-module]]
-  (with-interpreter (.interpreter bridge)
+  (with-gil
     (let [libpython-module (or libpython-module
                                (add-module libpython-clj-module-name))
           ^Pointer bridge-type-ptr (get-attr libpython-module
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index e59cf56..dbea6dd 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -1,5 +1,5 @@
 (ns libpython-clj.python.interpreter
-  (:require [libpython-clj.jna :as libpy]
+  (:require [libpython-clj.jna :as libpy ]
             [libpython-clj.jna.base :as libpy-base]
             [tech.resource :as resource]
             [libpython-clj.python.logging
@@ -13,6 +13,7 @@
   (:import [libpython_clj.jna
             JVMBridge
             PyObject]
+           [java.util.concurrent.atomic AtomicLong]
            [com.sun.jna Pointer]
            [com.sun.jna.ptr PointerByReference]
            [java.io StringWriter]
@@ -181,39 +182,19 @@ print(json.dumps(
                         ])
 
 
-;;Map of interpreter handle to interpreter
-(defonce ^:dynamic *interpreters* (atom {}))
-
-
 ;; Main interpreter booted up during initialize!
-(defonce ^:dynamic *main-interpreter* (atom nil))
-
-
-
-(defn add-interpreter-handle!
-  [interpreter]
-  (swap! *interpreters* assoc
-         (get-object-handle interpreter)
-         interpreter))
-
+;; * in the right to indicate atom
+(def main-interpreter* (atom nil))
+(defn main-interpreter
+  ^Interpreter []
+  @main-interpreter*)
 
-(defn remove-interpreter-handle!
-  [interpreter]
-  (swap! *interpreters* dissoc
-         (get-object-handle interpreter)))
 
 
-(defn handle->interpreter
-  [interpreter-handle]
-  (if-let [retval (get @*interpreters* interpreter-handle)]
-    retval
-    (throw (ex-info "Failed to convert from handle to interpreter"
-                    {}))))
-
 (defn handle-or-interpreter->interpreter
   [hdl-or-interp]
   (if (number? hdl-or-interp)
-    (handle->interpreter hdl-or-interp)
+    (throw (Exception. "Interpreters are no long handles"))
     hdl-or-interp))
 
 
@@ -229,7 +210,7 @@ print(json.dumps(
 
 (defn get-jvm-bridge
   ^JVMBridge [handle interpreter]
-  (if-let [bridge-obj (find-jvm-bridge-entry handle interpreter)]
+  (if-let [bridge-obj (find-jvm-bridge-entry handle (main-interpreter))]
     (:jvm-bridge bridge-obj)
     (throw (Exception.
             (format "Unable to find bridge for interpreter %s and handle %s"
@@ -262,18 +243,22 @@ print(json.dumps(
 
 (defn- construct-main-interpreter!
   [thread-state type-symbol-table]
-  (when @*main-interpreter*
-    (throw (ex-info "Main interpreter is already constructed" {})))
-  (let [retval (->Interpreter (atom {:thread-state thread-state
-                                     :bridge-objects {}
-                                     :sub-interpreters []})
-                              ;;This that have to live as long as the main
-                              ;;interpreter does
-                              (atom {:type-symbol-table type-symbol-table
-                                     :forever []}))]
-    (reset! *main-interpreter* retval)
-    (add-interpreter-handle! retval)
-    :ok))
+  (swap!
+   main-interpreter*
+   (fn [existing-interpreter]
+     (when existing-interpreter
+       (throw (Exception. "Main interpreter is already constructed")))
+
+     (let [retval (->Interpreter
+                                 (atom {:thread-state thread-state
+                                        :bridge-objects {}
+                                        :sub-interpreters []})
+                                 ;;This that have to live as long as the main
+                                 ;;interpreter does
+                                 (atom {:type-symbol-table type-symbol-table
+                                        :forever []}))]
+       retval)))
+  :ok)
 
 
 (defn- python-thread-state
@@ -285,13 +270,15 @@ print(json.dumps(
   "non-reentrant pathway to release the gil.  It must not be held by this thread."
   [interpreter]
   (let [thread-state (libpy/PyEval_SaveThread)]
+    (libpy-base/set-gil-thread-id! (libpy-base/current-thread-id) Long/MAX_VALUE)
     (assoc @(:interpreter-state* interpreter) :thread-state thread-state)))
 
 
 (defn acquire-gil!
   "Non-reentrant pathway to acquire gil.  It must not be held by this thread."
   [interpreter]
-  (libpy/PyEval_RestoreThread (python-thread-state interpreter)))
+  (libpy/PyEval_RestoreThread (python-thread-state interpreter))
+  (libpy-base/set-gil-thread-id! Long/MAX_VALUE (libpy-base/current-thread-id)))
 
 
 (defn swap-interpreters!
@@ -302,26 +289,27 @@ print(json.dumps(
                             (python-thread-state new-interp)))
 
 
+(defn main-interpreter-thread-id
+  ^long []
+  (.get ^AtomicLong libpy-base/gil-thread-id))
 
 
-;;Interpreter for current thread that holds the gil
-(defonce ^:dynamic *current-thread-interpreter* nil)
-
 
 (defn ensure-interpreter
-  []
-  (if-let [retval (or @*main-interpreter*
-                      *current-thread-interpreter*)]
-    retval
-    (throw (ex-info "No interpreters found, perhaps an initialize! call is missing?"
-                    {}))))
+  ^Interpreter []
+  (let [retval (main-interpreter)]
+    (when-not retval
+      (throw (Exception. "No interpreters found, perhaps an initialize! call is missing?")))
+    retval))
 
 
 (defn ensure-bound-interpreter
   []
-  (when-not *current-thread-interpreter*
-    (throw (ex-info "No interpreter bound to current thread" {})))
-  *current-thread-interpreter*)
+  (let [interp (main-interpreter)]
+    (if (and interp
+             (= (libpy-base/current-thread-id) (main-interpreter-thread-id)))
+      interp
+      (throw (Exception. "No interpreters found, perhaps an initialize! call is missing?")))))
 
 
 (defn py-type-keyword
@@ -343,50 +331,25 @@ print(json.dumps(
     (get-in symbol-table [type-addr :typename])))
 
 
-(defn with-gil-fn
-  "Run a function with the gil aquired.  If you acquired the gil, release
-  it when finished.  Note we also lock the interpreter so that even
-  if some code releases thegil, this interpreter cannot be entered."
-  ([interpreter body-fn]
-   (let [interpreter (or interpreter (ensure-interpreter))]
-     (cond
-       ;;No interpreters bound
-       (not *current-thread-interpreter*)
-       (locking interpreter
-         (with-bindings {#'*current-thread-interpreter* interpreter}
-           (acquire-gil! interpreter)
-           (with-bindings {#'libpy-base/*gil-captured* true}
-             (try
-               (body-fn)
-               (finally
-                 (release-gil! interpreter))))))
-       ;;Switch interpreters in the current thread...deadlock
-       ;;is possible here.
-       (not (identical? interpreter *current-thread-interpreter*))
-       (locking interpreter
-         (let [old-interp *current-thread-interpreter*]
-           (try
-             (with-bindings {#'*current-thread-interpreter* interpreter}
-               (swap-interpreters! old-interp interpreter)
-               (body-fn))
-             (finally
-               (swap-interpreters! interpreter old-interp)))))
-       :else
-       (do
-         (assert (identical? interpreter *current-thread-interpreter*))
-         (body-fn))))))
-
 
 (defmacro with-gil
-  "See with-gil-fn"
+  "Grab the gil and use the main interpreter.  Do not grab gil if already grabbed"
   [& body]
-  `(with-gil-fn nil (fn [] (do ~@body))))
-
-
-(defmacro with-interpreter
-  "See with-gil-fn"
-  [interp & body]
-  `(with-gil-fn ~interp (fn [] (do ~@body))))
+  `(do
+     (let [interp# (ensure-interpreter)
+           ^AtomicLong bound-thread# libpy-base/gil-thread-id
+           thread-id# (libpy-base/current-thread-id)]
+       (locking interp#
+         (let [new-binding?# (if-not (= thread-id# (.get bound-thread#))
+                               (do
+                                 (acquire-gil! interp#)
+                                 true)
+                               false)]
+           (try
+             ~@body
+             (finally
+               (when new-binding?#
+                 (release-gil! interp#)))))))))
 
 
 (defonce ^:dynamic *program-name* "")
@@ -440,7 +403,7 @@ print(json.dumps(
   [& {:keys [program-name
              library-path]
       :as options}]
-  (when-not @*main-interpreter*
+  (when-not (main-interpreter)
     (log-info "Executing python initialize!")
     (let [{:keys [python-home libname java-library-path-addendum] :as startup-info}
           (detect-startup-info options)
@@ -474,8 +437,11 @@ print(json.dumps(
        (libpy/PySys_SetArgv 0 (-> program-name
                                   (jna/string->wide-ptr)))))
     (let [type-symbols (libpy/lookup-type-symbols)
-          context (with-bindings {#'libpy-base/*gil-captured* true}
-                    (libpy/PyEval_SaveThread))]
+          context (do
+                    (libpy-base/set-gil-thread-id! Long/MAX_VALUE (libpy-base/current-thread-id))
+                    (let [retval (libpy/PyEval_SaveThread)]
+                      (libpy-base/set-gil-thread-id! (libpy-base/current-thread-id) Long/MAX_VALUE)
+                      retval))]
       (construct-main-interpreter! context type-symbols))))
 
 
@@ -509,18 +475,17 @@ print(json.dumps(
 
 (defn finalize!
   []
-  (when *current-thread-interpreter*
-    (throw (ex-info "There cannot be an interpreter bound when finalize! is called"
-                    {})))
-  (check-error-throw)
-  (when-let [main-interpreter (first (swap-vals! *main-interpreter* (constantly nil)))]
-    (log-info "executing python finalize!")
-    (with-bindings {#'*current-thread-interpreter* main-interpreter}
-      (acquire-gil! main-interpreter)
+  (when-not (== Long/MAX_VALUE (.get ^AtomicLong libpy-base/gil-thread-id))
+    (throw (Exception. (format "A thread still owns the interpreter: "
+                               (.get ^AtomicLong libpy-base/gil-thread-id)))))
+  (let [interp (ensure-interpreter)]
+    (locking interp
+      (check-error-throw)
+      (log-info "executing python finalize!")
+      (acquire-gil! interp)
       (let [finalize-value (libpy/Py_FinalizeEx)]
         (when-not (= 0 finalize-value)
-          (log-error (format "PyFinalize returned nonzero value: %s" finalize-value)))))
-    (remove-interpreter-handle! main-interpreter)))
+          (log-error (format "PyFinalize returned nonzero value: %s" finalize-value)))))))
 
 
 (defn conj-forever!
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 10ab9d7..97ab6cb 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -23,7 +23,6 @@
   get pointers back *but* they don't have to manage the gil."
   (:require [libpython-clj.python.interpreter
              :refer [with-gil
-                     with-interpreter
                      ensure-interpreter
                      ensure-bound-interpreter
                      check-error-throw]
@@ -146,7 +145,7 @@
       ;;We ask the garbage collector to track the python object and notify
       ;;us when it is released.  We then decref on that event.
       (resource/track pyobj
-                      #(with-interpreter interpreter
+                      #(with-gil
                          (try
                            (let [refcount (refcount pyobj)
                                  obj-data (PyObject. (Pointer. pyobj-value))]
@@ -461,7 +460,7 @@ Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
       (reify ObjectReader
         (lsize [_] n-items)
         (read [_ idx]
-          (with-interpreter interpreter
+          (with-gil
             (libpy/PyTuple_GetItem tuple idx)))))))
 
 
@@ -884,7 +883,7 @@ Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
       (let [py-iter (py-proto/call iter-fn)
             py-next-fn (when py-iter (py-proto/get-attr py-iter "__next__"))
             next-fn (fn [last-item]
-                      (with-interpreter interpreter
+                      (with-gil
                         (let [retval (libpy/PyObject_CallObject py-next-fn nil)]
                           (if (libpy/PyErr_Occurred)
                             (let [ptype (PointerByReference.)

From c17c7a0ddf78b2450c9ce565d62d227f82e82775 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Tue, 21 Jan 2020 09:07:41 -0500
Subject: [PATCH 141/456] ISSUE-52 (specify python executable) (#53)

* Ability to specify python-executable

* default to "python3"
---
 src/libpython_clj/python.clj             |  6 ++--
 src/libpython_clj/python/interpreter.clj | 42 +++++++++++++-----------
 2 files changed, 27 insertions(+), 21 deletions(-)

diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 922e790..f026df0 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -234,11 +234,13 @@
   [& {:keys [program-name
              library-path
              python-home
-             no-io-redirect?]}]
+             no-io-redirect?
+             python-executable]}]
   (when-not @pyinterp/main-interpreter*
     (pyinterp/initialize! :program-name program-name
                           :library-path library-path
-                          :python-home python-home)
+                          :python-home python-home
+                          :python-executable python-executable)
     ;;setup bridge mechansim and io redirection
     (pyinterop/register-bridge-type!)
     (when-not no-io-redirect?
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index dbea6dd..08ae981 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -145,29 +145,32 @@ print(json.dumps(
 
 
 (defn detect-startup-info
-  [{:keys [library-path python-home]}]
-  (let [executable "python3"
-        system-info (python-system-info executable)
-        python-home (cond
-                      python-home
-                      python-home
-                      (seq (System/getenv "PYTHONHOME"))
-                      (System/getenv "PYTHONHOME")
-                      :else
-                      (:prefix system-info))
+  [{:keys [library-path python-home python-executable]}]
+  (log-info
+   (str "Detecting startup-info for Python executable: "
+        python-executable))
+  (let [executable                 (or python-executable "python3")
+        system-info                (python-system-info executable)
+        python-home                (cond
+                                     python-home
+                                     python-home
+                                     (seq (System/getenv "PYTHONHOME"))
+                                     (System/getenv "PYTHONHOME")
+                                     :else
+                                     (:prefix system-info))
         java-library-path-addendum (when python-home
                                      (-> (Paths/get python-home
                                                     (into-array String ["lib"]))
                                          (.toString)))
         [ver-maj ver-med _ver-min] (:version system-info)
-        lib-version (format "%s.%s" ver-maj ver-med)
-        libname (or library-path
-                    (when (seq lib-version)
-                      (str "python" lib-version "m")))
+        lib-version                (format "%s.%s" ver-maj ver-med)
+        libname                    (or library-path
+                                       (when (seq lib-version)
+                                         (str "python" lib-version "m")))
         retval
-        {:python-home python-home
-         :lib-version lib-version
-         :libname libname
+        {:python-home                python-home
+         :lib-version                lib-version
+         :libname                    libname
          :java-library-path-addendum java-library-path-addendum}]
     (log/infof "Startup info detected: %s" retval)
     retval))
@@ -401,10 +404,11 @@ print(json.dumps(
 
 (defn initialize!
   [& {:keys [program-name
-             library-path]
+             library-path
+             python-executable]
       :as options}]
   (when-not (main-interpreter)
-    (log-info "Executing python initialize!")
+    (log-info (str "Executing python initialize with options:" options) )
     (let [{:keys [python-home libname java-library-path-addendum] :as startup-info}
           (detect-startup-info options)
           library-names (cond

From 3ee5f8695ba0110556c5fdaee8326575b12c5877 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 21 Jan 2020 07:09:57 -0700
Subject: [PATCH 142/456] Python gc in python thread (#54)

* some simplification/speed improvements

* This aint workin' yet

* all tests pass with cooperative reference cleanup

* editing comments

* simplification after reading more of concurrent-deque api

* This aint workin' yet

* all tests pass with cooperative reference cleanup

* editing comments

* simplification after reading more of concurrent-deque api

* updated tech.resource
---
 project.clj                              |   2 +-
 src/libpython_clj/python/bridge.clj      |  12 +-
 src/libpython_clj/python/gc.clj          |  67 +++++++++++
 src/libpython_clj/python/interpreter.clj |   5 +-
 src/libpython_clj/python/object.clj      | 146 +++++++++++------------
 test/libpython_clj/stress_test.clj       |   4 -
 6 files changed, 150 insertions(+), 86 deletions(-)
 create mode 100644 src/libpython_clj/python/gc.clj

diff --git a/project.clj b/project.clj
index f4c6014..42725a0 100644
--- a/project.clj
+++ b/project.clj
@@ -5,7 +5,7 @@
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
                  [camel-snake-kebab "0.4.0"]
-                 [techascent/tech.datatype "4.69"]
+                 [techascent/tech.datatype "4.70"]
                  [org.clojure/data.json "0.2.7"]]
   :repl-options {:init-ns user}
   :java-source-paths ["java"])
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index c52183d..bb3234a 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -40,17 +40,17 @@
              [expose-bridge-to-python!
               pybridge->bridge
               create-bridge-from-att-map]]
+            [libpython-clj.python.gc :as pygc]
             [clojure.stacktrace :as st]
             [tech.jna :as jna]
             [tech.v2.tensor :as dtt]
             [tech.v2.datatype.casting :as casting]
             [tech.v2.datatype.functional :as dtype-fn]
             [tech.v2.datatype :as dtype]
-            [tech.resource :as resource]
             [clojure.set :as c-set]
             [clojure.tools.logging :as log])
   (:import [java.util Map RandomAccess List Map$Entry Iterator UUID]
-           [java.util.concurrent ConcurrentHashMap]
+           [java.util.concurrent ConcurrentHashMap ConcurrentLinkedQueue]
            [clojure.lang IFn Symbol Keyword Seqable
             Fn MapEntry Range LongRange]
            [tech.v2.datatype ObjectReader ObjectWriter ObjectMutable
@@ -58,6 +58,7 @@
            [tech.v2.datatype.typed_buffer TypedBuffer]
            [tech.v2.tensor.protocols PTensor]
            [com.sun.jna Pointer]
+           [tech.resource GCReference]
            [java.io Writer]
            [libpython_clj.jna JVMBridge
             CFunction$KeyWordFunction
@@ -539,8 +540,7 @@
           long-addr (get-attr ctypes "data")
           hash-ary {:ctypes-map ctypes}
           ptr-val (-> (Pointer. long-addr)
-                      (resource/track #(get hash-ary :ctypes-map)
-                                      pyobj/*pyobject-tracking-flags*))]
+                      (pygc/track #(get hash-ary :ctypes-map)))]
       {:ptr ptr-val
        :datatype np-dtype
        :shape shape
@@ -782,7 +782,7 @@
   [& body]
   `(delay
      (with-gil
-       (with-bindings {#'pyobj/*pyobject-tracking-flags* [:gc]}
+       (with-bindings {#'pygc/*stack-gc-context* nil}
          ~@body))))
 
 
@@ -1094,7 +1094,7 @@
                             initial-buffer
                             (->py-tuple shape)
                             (->py-tuple strides))]
-      (resource/track retval #(get buffer-desc :ptr) pyobj/*pyobject-tracking-flags*))))
+      (pygc/track retval #(get buffer-desc :ptr)))))
 
 
 (extend-type Object
diff --git a/src/libpython_clj/python/gc.clj b/src/libpython_clj/python/gc.clj
new file mode 100644
index 0000000..23b47af
--- /dev/null
+++ b/src/libpython_clj/python/gc.clj
@@ -0,0 +1,67 @@
+(ns libpython-clj.python.gc
+  "Binding of various sort of gc semantics optimized specifically for
+  libpython-clj.  For general bindings, see tech.resource"
+  (:import [java.util.concurrent ConcurrentHashMap ConcurrentLinkedDeque]
+           [java.lang.ref ReferenceQueue]
+           [tech.resource GCReference]))
+
+
+(set! *warn-on-reflection* true)
+
+
+(defonce ^:dynamic *stack-gc-context* nil)
+(defn stack-context
+  ^ConcurrentLinkedDeque []
+  *stack-gc-context*)
+
+
+(defonce reference-queue-var (ReferenceQueue.))
+(defn reference-queue
+  ^ReferenceQueue []
+  reference-queue-var)
+
+
+(defonce ptr-set-var (ConcurrentHashMap/newKeySet))
+(defn ptr-set
+  ^java.util.Set []
+  ptr-set-var)
+
+
+(defn track
+  [item dispose-fn]
+  (let [ptr-val (GCReference. item (reference-queue) (fn [ptr-val]
+                                                       (.remove (ptr-set) ptr-val)
+                                                       (dispose-fn)))
+        ^ConcurrentLinkedDeque stack-context (stack-context)]
+    ;;We have to keep track of the pointer.  If we do not the pointer gets gc'd then
+    ;;it will not be put on the reference queue when the object itself is gc'd.
+    ;;Nice little gotcha there.
+    (if stack-context
+      (.add stack-context ptr-val)
+      ;;Ensure we don't lose track of the weak reference.  If it gets cleaned up
+      ;;the gc system will fail.
+      (.add (ptr-set) ptr-val))
+    item))
+
+
+(defn clear-reference-queue
+  []
+  (when-let [next-ref (.poll (reference-queue))]
+    (.run ^Runnable next-ref)
+    (recur)))
+
+
+(defn clear-stack-context
+  []
+  (when-let [next-ref (.pollLast (stack-context))]
+    (.run ^Runnable next-ref)
+    (recur)))
+
+
+(defmacro with-stack-context
+  [& body]
+  `(with-bindings {#'*stack-gc-context* (ConcurrentLinkedDeque.)}
+     (try
+       ~@body
+       (finally
+         (clear-stack-context)))))
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 08ae981..26aecf3 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -1,7 +1,7 @@
 (ns libpython-clj.python.interpreter
   (:require [libpython-clj.jna :as libpy ]
             [libpython-clj.jna.base :as libpy-base]
-            [tech.resource :as resource]
+            [libpython-clj.python.gc :as pygc]
             [libpython-clj.python.logging
              :refer [log-error log-warn log-info]]
             [tech.jna :as jna]
@@ -351,6 +351,7 @@ print(json.dumps(
            (try
              ~@body
              (finally
+               (pygc/clear-reference-queue)
                (when new-binding?#
                  (release-gil! interp#)))))))))
 
@@ -437,7 +438,7 @@ print(json.dumps(
           (recur library-names))))
     ;;Set program name
     (when-let [program-name (or program-name *program-name* "")]
-      (resource/stack-resource-context
+      (pygc/with-stack-context
        (libpy/PySys_SetArgv 0 (-> program-name
                                   (jna/string->wide-ptr)))))
     (let [type-symbols (libpy/lookup-type-symbols)
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 97ab6cb..9b0be72 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -33,12 +33,13 @@
              :as py-proto]
             [libpython-clj.jna.base :as libpy-base]
             [libpython-clj.jna :as libpy]
+            [libpython-clj.python.gc :as pygc]
             [clojure.stacktrace :as st]
             [tech.jna :as jna]
-            [tech.resource :as resource]
             [tech.v2.datatype :as dtype]
             [tech.v2.datatype.protocols :as dtype-proto]
             [tech.v2.datatype.casting :as casting]
+            [tech.resource :as resource]
             [tech.v2.tensor]
             [clojure.tools.logging :as log])
   (:import [com.sun.jna Pointer CallbackReference]
@@ -96,13 +97,10 @@
     (py-proto/->jvm item options)))
 
 
-(def ^:dynamic *object-reference-logging* false)
-
+(def object-reference-logging nil)
 
-(def ^:dynamic *object-reference-tracker* nil)
 
-
-(def ^:dynamic *pyobject-tracking-flags* [:gc])
+(def object-reference-tracker nil)
 
 
 (defn incref
@@ -130,41 +128,44 @@
   (if (and pyobj
              (not= (Pointer/nativeValue (libpy/as-pyobj pyobj))
                    (Pointer/nativeValue (libpy/as-pyobj (libpy/Py_None)))))
-    (let [interpreter (ensure-bound-interpreter)
-          pyobj-value (Pointer/nativeValue (libpy/as-pyobj pyobj))
-          py-type-name (name (python-type pyobj))]
-      (when *object-reference-logging*
-        (let [obj-data (PyObject. (Pointer. pyobj-value))]
-          (println (format "tracking object  - 0x%x:%4d:%s"
-                            pyobj-value
-                            (.ob_refcnt obj-data)
-                            py-type-name))))
-      (when *object-reference-tracker*
-        (swap! *object-reference-tracker*
-               update pyobj-value #(inc (or % 0))))
-      ;;We ask the garbage collector to track the python object and notify
-      ;;us when it is released.  We then decref on that event.
-      (resource/track pyobj
-                      #(with-gil
-                         (try
-                           (let [refcount (refcount pyobj)
-                                 obj-data (PyObject. (Pointer. pyobj-value))]
-                             (if (< refcount 1)
-                               (log/errorf "Fatal error -- releasing object - 0x%x:%4d:%s
+    (do
+      (ensure-bound-interpreter)
+      (let [pyobj-value (Pointer/nativeValue (libpy/as-pyobj pyobj))
+            py-type-name (name (python-type pyobj))]
+        (when object-reference-logging
+          (let [obj-data (PyObject. (Pointer. pyobj-value))]
+            (println (format "tracking object  - 0x%x:%4d:%s"
+                             pyobj-value
+                             (.ob_refcnt obj-data)
+                             py-type-name))))
+        (when object-reference-tracker
+          (swap! object-reference-tracker
+                 update pyobj-value #(inc (or % 0))))
+        ;;We ask the garbage collector to track the python object and notify
+        ;;us when it is released.  We then decref on that event.
+        (pygc/track pyobj
+                    ;;No longer with-gil.  Because cleanup is cooperative, the gil is
+                    ;;guaranteed to be captured here already.
+                    #(try
+                       ;;Intentionally overshadow pyobj.  We cannot access it here.
+                       (let [pyobj (Pointer. pyobj-value)
+                             refcount (refcount pyobj)
+                             obj-data (PyObject. pyobj)]
+                         (if (< refcount 1)
+                           (log/errorf "Fatal error -- releasing object - 0x%x:%4d:%s
 Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
-                               (when *object-reference-logging*
-                                 (println (format "releasing object - 0x%x:%4d:%s"
-                                                  pyobj-value
-                                                  (.ob_refcnt obj-data)
-                                                  py-type-name))))
-                             (when *object-reference-tracker*
-                               (swap! *object-reference-tracker*
-                                      update pyobj-value (fn [arg]
-                                                           (dec (or arg 0))))))
-                           (libpy/Py_DecRef (Pointer. pyobj-value))
-                           (catch Throwable e
-                             (log/error e "Exception while releasing object"))))
-                      *pyobject-tracking-flags*))
+                           (when object-reference-logging
+                             (println (format "releasing object - 0x%x:%4d:%s"
+                                              pyobj-value
+                                              (.ob_refcnt obj-data)
+                                              py-type-name))))
+                         (when object-reference-tracker
+                           (swap! object-reference-tracker
+                                  update pyobj-value (fn [arg]
+                                                       (dec (or arg 0))))))
+                       (libpy/Py_DecRef (Pointer. pyobj-value))
+                       (catch Throwable e
+                         (log/error e "Exception while releasing object"))))))
     (do
       ;;Special handling for PyNone types
       (libpy/Py_DecRef pyobj)
@@ -173,9 +174,8 @@ Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
 
 (defmacro stack-resource-context
   [& body]
-  `(with-bindings {#'*pyobject-tracking-flags* [:stack :gc]}
-     (resource/stack-resource-context
-      ~@body)))
+  `(pygc/with-stack-context
+     ~@body))
 
 
 (defn incref-wrap-pyobject
@@ -391,37 +391,37 @@ Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
                                    doc
                                    function]
                             :as method-data}]
-  (resource/stack-resource-context
-   (when-not (cfunc-instance? function)
-     (throw (Exception.
-             (format "Callbacks must implement one of the CFunction interfaces:
+  ;;Here we really do need a resource stack context
+  (when-not (cfunc-instance? function)
+    (throw (Exception.
+            (format "Callbacks must implement one of the CFunction interfaces:
 %s" (type function)))))
-   (let [meth-flags (long (cond
-                            (instance? CFunction$NoArgFunction function)
-                            @libpy/METH_NOARGS
-
-                            (instance? CFunction$TupleFunction function)
-                            @libpy/METH_VARARGS
-
-                            (instance? CFunction$KeyWordFunction function)
-                            (bit-or @libpy/METH_KEYWORDS @libpy/METH_VARARGS)
-                            :else
-                            (throw (ex-info (format "Failed due to type: %s"
-                                                    (type function))
-                                            {}))))
-         name-ptr (jna/string->ptr name)
-         doc-ptr (jna/string->ptr doc)]
-     (set! (.ml_name method-def) name-ptr)
-     (set! (.ml_meth method-def) (CallbackReference/getFunctionPointer function))
-     (set! (.ml_flags method-def) (int meth-flags))
-     (set! (.ml_doc method-def) doc-ptr)
-     (.write method-def)
-     (pyinterp/conj-forever! (assoc method-data
-                                    :name-ptr name-ptr
-                                    :doc-ptr doc-ptr
-                                    :callback-object function
-                                    :method-definition method-def))
-     method-def)))
+  (let [meth-flags (long (cond
+                           (instance? CFunction$NoArgFunction function)
+                           @libpy/METH_NOARGS
+
+                           (instance? CFunction$TupleFunction function)
+                           @libpy/METH_VARARGS
+
+                           (instance? CFunction$KeyWordFunction function)
+                           (bit-or @libpy/METH_KEYWORDS @libpy/METH_VARARGS)
+                           :else
+                           (throw (ex-info (format "Failed due to type: %s"
+                                                   (type function))
+                                           {}))))
+        name-ptr (jna/string->ptr-untracked name)
+        doc-ptr (jna/string->ptr-untracked doc)]
+    (set! (.ml_name method-def) name-ptr)
+    (set! (.ml_meth method-def) (CallbackReference/getFunctionPointer function))
+    (set! (.ml_flags method-def) (int meth-flags))
+    (set! (.ml_doc method-def) doc-ptr)
+    (.write method-def)
+    (pyinterp/conj-forever! (assoc method-data
+                                   :name-ptr name-ptr
+                                   :doc-ptr doc-ptr
+                                   :callback-object function
+                                   :method-definition method-def))
+    method-def))
 
 
 (defn method-def-data->method-def
diff --git a/test/libpython_clj/stress_test.clj b/test/libpython_clj/stress_test.clj
index e4eecd1..615c709 100644
--- a/test/libpython_clj/stress_test.clj
+++ b/test/libpython_clj/stress_test.clj
@@ -56,10 +56,6 @@ def getmultidata():
     (gd-fn)))
 
 
-;;If you want to see how the sausage is made...
-(alter-var-root #'libpython-clj.python.object/*object-reference-logging*
-                (constantly false))
-
 ;;Ensure that failure to open resource context before tracking for stack
 ;;related things causes immediate failure.  Unless you feel like being pedantic,
 ;;this isn't necessary.  The python library automatically switches to normal gc-only

From 2088b9f062dc01317467ae23bb7c5d65d8a10078 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Tue, 21 Jan 2020 09:11:27 -0500
Subject: [PATCH 143/456] ISSUE-49: Namespace bindings for modules (#55)

* bind namespace to symbol

* throw error if invalid symbol name
---
 src/libpython_clj/require.clj | 54 +++++++++++++++++++++++++----------
 1 file changed, 39 insertions(+), 15 deletions(-)

diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 25e3ba5..7b33685 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -21,7 +21,7 @@
   ;; First attempt is to filter keywords and make sure any keywords are
   ;; in supported-flags
   (let [total-flags (set (concat supported-flags [:as :refer :exclude
-                                                  :* :all]))]
+                                                  :* :all :bind-ns]))]
     (when-let [missing-flags (->> reqs
                                   (filter #(and (not (total-flags %))
                                                 (keyword? %)))
@@ -88,31 +88,48 @@
 (defn- do-require-python
   [reqs-vec]
   (let [[module-name & etc] reqs-vec
-        supported-flags #{:reload :no-arglists}
-        flags (parse-flags supported-flags etc)
-        etc (->> etc
-                 (remove supported-flags)
-                 (remove boolean?))
-        _  (when-not (= 0 (rem (count etc) 2))
-             (throw (Exception. "Must have even number of entries")))
-        etc             (->> etc (partition-all 2)
-                             (map vec)
-                             (into {}))
+        supported-flags     #{:reload :no-arglists :bind-ns}
+        flags               (parse-flags supported-flags etc)
+        etc                 (->> etc
+                                 (remove supported-flags)
+                                 (remove boolean?))
+        _                   (when-not (= 0 (rem (count etc) 2))
+                              (throw (Exception. "Must have even number of entries")))
+        etc                 (->> etc (partition-all 2)
+                                 (map vec)
+                                 (into {}))
         reload?             (:reload flags)
         no-arglists?        (:no-arglists flags)
+        bind-ns?            (:bind-ns flags)
         alias-name          (:as etc)
         exclude             (into #{} (:exclude etc))
+
         refer-data          (cond
                               (= :all (:refer etc)) #{:all}
                               (= :* (:refer etc))   #{:*}
-                              :else (into #{} (:refer etc)))
-        pyobj (pymeta/path->py-obj (str module-name) :reload? reload?)
-        existing-py-ns? (find-ns module-name)]
+                              :else                 (into #{} (:refer etc)))
+        pyobj               (pymeta/path->py-obj (str module-name) :reload? reload?)
+        existing-py-ns?     (find-ns module-name)]
     (create-ns module-name)
+
+    (when bind-ns?
+      (let [import-name (or  (not-empty (str alias-name))
+                             (str module-name))
+            ns-dots (re-find #"[.]" import-name)]
+        (when (not (zero? (count ns-dots)))
+          (throw (Exception. (str "Cannot have periods in module/class"
+                                  "name. Please :alias "
+                                  import-name
+                                  " to something without periods."))))        
+        (intern
+         (symbol (str *ns*))
+         (symbol import-name)
+         pyobj)))
+    
     (when (or (not existing-py-ns?) reload?)
       (pymeta/apply-static-metadata-to-namespace! module-name (datafy pyobj)
                                                   :no-arglists? no-arglists?))
-    (when-let [refer-symbols (->> (extract-refer-symbols {:refer refer-data
+    (when-let [refer-symbols (->> (extract-refer-symbols {:refer       refer-data
                                                           :this-module pyobj}
                                                          (ns-publics
                                                           (find-ns module-name)))
@@ -150,6 +167,12 @@
 
    (require-python '[numpy :refer [linspace] :no-arglists :as np])
 
+   If you would like to bind the Python module to the namespace, use
+   the :bind-ns flag.
+
+   (require-python '[requests :bind-ns true]) or
+   (require-python '[requests :bind-ns])
+
    ## Use with custom modules ##
 
    For use with a custom namespace foo.py while developing, you can
@@ -201,3 +224,4 @@
     (do-require-python reqs)
     :else
     (throw (Exception. "Invalid argument: %s" reqs))))
+

From 12e5eb600b815e56ce78d9cab27108ae4ba18793 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 21 Jan 2020 09:29:31 -0700
Subject: [PATCH 144/456] Final round of perf opts.  Next step is jna direct
 mapping.

---
 project.clj                         |   2 +-
 src/libpython_clj/python/object.clj | 111 ++++++++++++++--------------
 2 files changed, 58 insertions(+), 55 deletions(-)

diff --git a/project.clj b/project.clj
index 42725a0..88c046a 100644
--- a/project.clj
+++ b/project.clj
@@ -5,7 +5,7 @@
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
                  [camel-snake-kebab "0.4.0"]
-                 [techascent/tech.datatype "4.70"]
+                 [techascent/tech.datatype "4.71"]
                  [org.clojure/data.json "0.2.7"]]
   :repl-options {:init-ns user}
   :java-source-paths ["java"])
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 9b0be72..8ca7428 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -97,10 +97,7 @@
     (py-proto/->jvm item options)))
 
 
-(def object-reference-logging nil)
-
-
-(def object-reference-tracker nil)
+(def object-reference-logging (atom false))
 
 
 (defn incref
@@ -116,60 +113,66 @@
   (long (.ob_refcnt (PyObject. (libpy/as-pyobj pyobj)))))
 
 
+(def ^:private non-native-val
+  (delay (Pointer/nativeValue (libpy/as-pyobj (libpy/Py_None)))))
+
+
 (defn wrap-pyobject
   "Wrap object such that when it is no longer accessible via the program decref is
   called. Used for new references.  This is some of the meat of the issue, however,
   in that getting the two system's garbage collectors to play nice is kind
-  of tough."
-  [pyobj & [skip-check-error?]]
-  (when-not skip-check-error?
-    (check-error-throw))
-  ;;We don't wrap pynone
-  (if (and pyobj
-             (not= (Pointer/nativeValue (libpy/as-pyobj pyobj))
-                   (Pointer/nativeValue (libpy/as-pyobj (libpy/Py_None)))))
-    (do
-      (ensure-bound-interpreter)
-      (let [pyobj-value (Pointer/nativeValue (libpy/as-pyobj pyobj))
-            py-type-name (name (python-type pyobj))]
-        (when object-reference-logging
-          (let [obj-data (PyObject. (Pointer. pyobj-value))]
-            (println (format "tracking object  - 0x%x:%4d:%s"
-                             pyobj-value
-                             (.ob_refcnt obj-data)
-                             py-type-name))))
-        (when object-reference-tracker
-          (swap! object-reference-tracker
-                 update pyobj-value #(inc (or % 0))))
-        ;;We ask the garbage collector to track the python object and notify
-        ;;us when it is released.  We then decref on that event.
-        (pygc/track pyobj
-                    ;;No longer with-gil.  Because cleanup is cooperative, the gil is
-                    ;;guaranteed to be captured here already.
-                    #(try
-                       ;;Intentionally overshadow pyobj.  We cannot access it here.
-                       (let [pyobj (Pointer. pyobj-value)
-                             refcount (refcount pyobj)
-                             obj-data (PyObject. pyobj)]
-                         (if (< refcount 1)
-                           (log/errorf "Fatal error -- releasing object - 0x%x:%4d:%s
-Object's refcount is bad.  Crash is imminent" pyobj-value refcount py-type-name)
-                           (when object-reference-logging
-                             (println (format "releasing object - 0x%x:%4d:%s"
-                                              pyobj-value
-                                              (.ob_refcnt obj-data)
-                                              py-type-name))))
-                         (when object-reference-tracker
-                           (swap! object-reference-tracker
-                                  update pyobj-value (fn [arg]
-                                                       (dec (or arg 0))))))
-                       (libpy/Py_DecRef (Pointer. pyobj-value))
-                       (catch Throwable e
-                         (log/error e "Exception while releasing object"))))))
-    (do
-      ;;Special handling for PyNone types
-      (libpy/Py_DecRef pyobj)
-      nil)))
+  of tough.
+  This is a hot path; it is called quite a lot from a lot of places."
+  ([pyobj skip-check-error?]
+   ;;We don't wrap pynone
+   (if pyobj
+     (let [pyobj-value (Pointer/nativeValue (libpy/as-pyobj pyobj))
+           ^PyObject obj-data (when @object-reference-logging
+                                (PyObject. (Pointer. pyobj-value)))]
+       (if (not= pyobj-value
+                 (long @non-native-val))
+         (do
+           (ensure-bound-interpreter)
+           (when @object-reference-logging
+             (println (format "tracking object  - 0x%x:%4d:%s"
+                              pyobj-value
+                              (.ob_refcnt obj-data)
+                              (name (python-type pyobj)))))
+           ;;We ask the garbage collector to track the python object and notify
+           ;;us when it is released.  We then decref on that event.
+           (pygc/track
+            pyobj
+            ;;No longer with-gil.  Because cleanup is cooperative, the gil is
+            ;;guaranteed to be captured here already.
+            #(try
+               ;;Intentionally overshadow pyobj.  We cannot access it here.
+               (let [pyobj (Pointer. pyobj-value)]
+                 (when @object-reference-logging
+                   (let [_ (.read obj-data)
+                         refcount (.ob_refcnt obj-data)]
+                     (if (< refcount 1)
+                       (log/errorf "Fatal error -- releasing object - 0x%x:%4d:%s
+Object's refcount is bad.  Crash is imminent"
+                                   pyobj-value
+                                   refcount
+                                   (name (python-type pyobj)))
+                       (println (format "releasing object - 0x%x:%4d:%s"
+                                        pyobj-value
+                                        refcount
+                                        (name (python-type pyobj))))))))
+               (libpy/Py_DecRef pyobj)
+               (catch Throwable e
+                 (log/error e "Exception while releasing object"))))
+           (when-not skip-check-error? (check-error-throw))
+           pyobj)
+         (do
+           ;;Special handling for PyNone types
+           (libpy/Py_DecRef pyobj)
+           (when-not skip-check-error? (check-error-throw))
+           nil)))
+     (when-not skip-check-error? (check-error-throw))))
+  ([pyobj]
+   (wrap-pyobject pyobj false)))
 
 
 (defmacro stack-resource-context

From 78d8660dfbabfe25b49914563d034fe3b9cd1241 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 21 Jan 2020 16:40:40 -0700
Subject: [PATCH 145/456] Smallest possible step towards directmapping

---
 java/libpython_clj/jna/DirectMapped.java   | 10 ++++++++++
 src/libpython_clj/jna/protocols/object.clj | 14 +++++++-------
 src/libpython_clj/python.clj               |  2 +-
 src/libpython_clj/python/interpreter.clj   | 13 +++++++++----
 4 files changed, 27 insertions(+), 12 deletions(-)
 create mode 100644 java/libpython_clj/jna/DirectMapped.java

diff --git a/java/libpython_clj/jna/DirectMapped.java b/java/libpython_clj/jna/DirectMapped.java
new file mode 100644
index 0000000..e861ae7
--- /dev/null
+++ b/java/libpython_clj/jna/DirectMapped.java
@@ -0,0 +1,10 @@
+package libpython_clj.jna;
+
+import com.sun.jna.Pointer;
+
+
+public class DirectMapped
+{
+  public static native void Py_IncRef(Pointer ptr);
+  public static native void Py_DecRef(Pointer ptr);
+}
diff --git a/src/libpython_clj/jna/protocols/object.clj b/src/libpython_clj/jna/protocols/object.clj
index 32c2847..a4cf4c5 100644
--- a/src/libpython_clj/jna/protocols/object.clj
+++ b/src/libpython_clj/jna/protocols/object.clj
@@ -13,21 +13,21 @@
             [camel-snake-kebab.core :refer [->kebab-case]])
   (:import [com.sun.jna Pointer Native NativeLibrary]
            [com.sun.jna.ptr PointerByReference]
-           [libpython_clj.jna PyObject]))
+           [libpython_clj.jna PyObject DirectMapped]))
 
 
 ;; Object Protocol
 
-(def-pylib-fn Py_DecRef
+(defn Py_DecRef
   "Decrement the refference count on an object"
-  nil
-  [py-obj ensure-pyobj])
+  [py-obj]
+  (DirectMapped/Py_DecRef (ensure-pyobj py-obj)))
 
 
-(def-pylib-fn Py_IncRef
+(defn Py_IncRef
   "Increment the reference count on an object"
-  nil
-  [py-obj ensure-pyobj])
+  [py-obj]
+  (DirectMapped/Py_IncRef (ensure-pyobj py-obj)))
 
 
 ;; object.h:937
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index f026df0..9568953 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -12,7 +12,7 @@
            [com.sun.jna.ptr PointerByReference]
            [java.lang.reflect Field]
            [java.io Writer]
-           [libpython_clj.jna PyObject
+           [libpython_clj.jna PyObject DirectMapped
             CFunction$KeyWordFunction
             CFunction$TupleFunction
             CFunction$NoArgFunction]))
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 26aecf3..2c8d8a5 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -10,9 +10,7 @@
             [clojure.string :as s]
             [clojure.tools.logging :as log]
             [clojure.data.json :as json])
-  (:import [libpython_clj.jna
-            JVMBridge
-            PyObject]
+  (:import [libpython_clj.jna JVMBridge PyObject DirectMapped]
            [java.util.concurrent.atomic AtomicLong]
            [com.sun.jna Pointer]
            [com.sun.jna.ptr PointerByReference]
@@ -403,6 +401,12 @@ print(json.dumps(
     (catch Exception e)))
 
 
+(defn- setup-direct-mapping!
+  []
+  (let [library (jna/load-library libpy-base/*python-library*)]
+    (com.sun.jna.Native/register DirectMapped library)))
+
+
 (defn initialize!
   [& {:keys [program-name
              library-path
@@ -435,7 +439,8 @@ print(json.dumps(
                  (not (try-load-python-library! library-name
                                                 @python-home-wide-ptr*
                                                 @python-path-wide-ptr*)))
-          (recur library-names))))
+          (recur library-names)))
+      (setup-direct-mapping!))
     ;;Set program name
     (when-let [program-name (or program-name *program-name* "")]
       (pygc/with-stack-context

From 6b3b1bcf1d682eefbe1a39ae9fef25437215fcfa Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Tue, 21 Jan 2020 18:42:02 -0500
Subject: [PATCH 146/456] CHANGELOG update for 1.32-SNAPSHOT (#56)

* update changelog

* fix typo

* fix formatting

* fix formatting

* caveats
---
 CHANGELOG.md | 47 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 37c82e1..2ce5583 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,52 @@
 # Time for a ChangeLog!
 
+## 1.32
+
+* Python executables can now be specified directly using the syntax
+  ```clojure 
+  (py/initialize! :python-executable <executable>)
+  ```
+  where **executable** can be a system installation of Python
+  such as `"python3"`, `"python3.7"`; it can also be a fully qualified
+  path such as `"/usr/bin/python3.7"`; or any Python executable along
+  your discoverable system path.
+  
+* Python virtual environments can now be used instead of system 
+  installations! This has been tested on Linux/Ubuntu variants
+  with virtual environments installed with 
+  ```bash 
+  virtualenv -p $(which <python-version>) env
+  ```
+  and then invoked using 
+  ```clojure 
+  (py/initialize! :python-executable "/abs/path/to/env/bin/python")
+  ```
+  
+  Tested on Python 3.6.8 and Python 3.7.
+  
+  **WARNING**: This is suitable for casual hacking and exploratory
+  development -- however, at this time, we still strongly recommend 
+  using Docker and a system installation of Python in production
+  environments.
+  
+* **breaking change** (and remediation): `require-python` no longer
+  automatically binds the Python module to the Clojure the namespace 
+  symbol.  If you wish to bind the module to the namespace symbol,
+  you need to use the `:bind-ns` flag.  Example:
+  
+  ```clojure 
+  (require-python 'requests) ;;=> nil
+  requests ;;=> throws Exception
+  
+  (require-python '[requests :bind-ns]) ;;=> nil
+  (py.. requests 
+        (get "https://www.google.com)
+        -content 
+        (decode "latin-1)) ;; works
+  ```
+
+
+
 ## 1.31
 
 * Python objects are now datafy-able and nav-igable.  `require-python`

From 76708c286d0a8696fc3aa683fc43ade19da8a927 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Wed, 22 Jan 2020 11:51:43 -0500
Subject: [PATCH 147/456] ISSUE-46: programmatic method helper syntax (#57)

* ISSUE-49 changes

* ISSUE-49 changes

* revert bad test

* fix spacing
---
 src/libpython_clj/python.clj       | 69 +++++++++++++++++++++++++++++-
 src/libpython_clj/require.clj      | 12 ++++++
 test/libpython_clj/python_test.clj | 39 +++++++++++++++--
 3 files changed, 115 insertions(+), 5 deletions(-)

diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 9568953..cb10838 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -432,6 +432,37 @@
   [x & args]
   (list* (into (vector #'$a x) args)))
 
+(defmacro py*
+  "Special syntax for passing along *args and **kwargs style arguments
+  to methods.
+
+  Usage:
+
+  (py* obj method args kwargs)
+
+  Example:
+
+  (def d (python/dict))
+  d ;;=> {}
+  (def iterable [[:a 1] [:b 2]])
+  (def kwargs {:cat \"dog\" :name \"taco\"})
+  (py* d  update [iterable] kwargs)
+  d ;;=> {\"a\": 1, \"b\": 2, \"cat\": \"dog\", \"name\": \"taco\"}"
+  ([x method args]
+   (list #'call-attr-kw x (str method) args nil))
+  ([x method args kwargs]
+   (list #'call-attr-kw x (str method) args kwargs)))
+
+(defmacro py**
+  "Like py*, but it is assumed that the LAST argument is kwargs."
+  ([x method kwargs]
+   (list #'call-attr-kw x (str method) nil kwargs))
+  ([x method arg & args]
+   (let [args   (into [arg] args)
+         kwargs (last args)
+         args   (vec (pop args))]
+     (list #'call-attr-kw x (str method) args kwargs))))
+
 
 (defn ^:private handle-pydotdot
   ([x form]
@@ -439,8 +470,18 @@
      (let [form-data (vec form)
            [instance-member & args] form-data
            symbol-str (str instance-member)]
-       (if (clojure.string/starts-with? symbol-str "-")
+       (cond
+         (clojure.string/starts-with? symbol-str "-")
          (list #'py.- x (symbol (subs symbol-str 1 (count symbol-str))))
+
+         (clojure.string/starts-with? symbol-str "**")
+         (list* #'py** x (symbol (subs symbol-str 2 (count symbol-str))) args)
+         
+         (clojure.string/starts-with? symbol-str "*")
+         (list* #'py* x (symbol (subs symbol-str 1 (count symbol-str))) args)
+
+         :else ;; assumed to be method invocation
+         
          (list* (into (vector #'py. x instance-member) args))))
      (handle-pydotdot x (list form))))
   ([x form & more]
@@ -456,6 +497,30 @@
   is equivalent to Python's
 
   import sys
-  sys.path.append('/home/user/bin')"
+  sys.path.append('/home/user/bin')
+
+  SPECIAL SYNTAX for programmatic *args and **kwargs
+
+  Special syntax is provided to meet the needs required by
+  Python's *args and **kwargs syntax programmatically.
+
+
+  (= (py.. obj (*method args))
+     (py* obj methods args))
+
+  (= (py.. obj (*methods args kwargs))
+     (py* obj method args kwargs))
+
+  (= (py.. obj (**method kwargs))
+     (py** obj kwargs))
+
+  (= (py.. obj (**method arg1 arg2 arg3 ... argN kwargs))
+     (py** obj method arg1 arg2 arg3 ... argN kwargs)
+     (py*  obj method [arg1 arg2 arg3 ... argN] kwargs))
+
+
+  These forms exist for when you need to pass in a map of options
+  in the same way you would use the f(*args, **kwargs) forms in
+  Python."
   [x & args]
   (apply handle-pydotdot x args))
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 7b33685..9773371 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -225,3 +225,15 @@
     :else
     (throw (Exception. "Invalid argument: %s" reqs))))
 
+(defn import-python
+  "Loads python, python.list, python.dict, python.set, python.tuple,
+  and python.frozenset."
+  []
+  (require-python
+   '([builtins :as python]
+     [builtins.list :as python.list]
+     [builtins.dict :as python.dict]
+     [builtins.set :as python.set]
+     [builtins.tuple :as python.tuple]
+     [builtins.frozenset :as python.frozenset])))
+
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 903d325..a2de61b 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -1,5 +1,5 @@
 (ns libpython-clj.python-test
-  (:require [libpython-clj.python :as py]
+  (:require [libpython-clj.python :as py :refer [py. py.. py.- py* py**]]
             [libpython-clj.jna :as libpy]
             [tech.v2.datatype :as dtype]
             [tech.v2.datatype.functional :as dfn]
@@ -303,7 +303,41 @@ class Foo:
            (py/py.. f res __len__)
            ((py/py.. f res -__len__))
            (py/py.. f count)
-           ((py/py.. f -count))))))
+           ((py/py.. f -count)))))
+
+
+  (let [builtins (py/import-module "builtins")
+        dict (py/get-attr builtins "dict")
+        d (dict)]
+    (py* d update nil {:a 1})
+    (is  (= 1 (py* d get [:a])))
+    (let [iterable [[:a 2]]]
+      (py* d update [iterable]))
+    (is (= 2 (py* d get [:a])))
+    (let [iterable [[:a 1] [:b 2]]
+          kwargs {:name "taco"}]
+      (py* d update [iterable] kwargs))
+    (is (= {"name" "taco" "a" 1 "b" 2} d))
+
+    (py. d clear)
+
+    (py** d update {:a 1})
+    (is (= d {"a" 1}))
+
+    (py** d update [[:a 2]] {:c 3})
+    (is (= d {"a" 2 "c" 3}))
+
+
+    (py. d clear)
+
+    (doto d
+      (py.. (*update nil {:a 1}))
+      (py.. (*update [[[:b 2]]]))
+      (py.. (**update {:c 3}))
+      (py.. (**update [[:d 4]] {:e 5})))
+
+    (is (= d {"a" 1 "b" 2 "c" 3 "d" 4 "e" 5})))
+  )
 
 (deftest infinite-seq
   (let [islice (-> (py/import-module "itertools")
@@ -375,4 +409,3 @@ class Foo:
 (deftest characters
   (is (= (py/->jvm (py/->python "c"))
          (py/->jvm (py/->python \c)))))
-

From 02cdd56823d211a814de68c2a892824f71db5fb9 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Wed, 22 Jan 2020 11:52:00 -0500
Subject: [PATCH 148/456] update changelog (#58)

---
 CHANGELOG.md | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2ce5583..b8685e2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -45,6 +45,25 @@
         (decode "latin-1)) ;; works
   ```
 
+* Python method helper syntax for programmatic passing of maps
+  to satisfy `*args`, `**kwargs` situations on the `py.` family of
+  macros. Two new macros have been introduced to address this 
+  
+  ```clojure 
+  (py* obj method args)
+  (py* obj method args kwargs)
+  (py** obj method kwargs)
+  (py** obj method arg1 arg2 arg3 ... argN kwargs)
+  ```
+  and the `py..` syntax has been extended to accomodate these 
+  conventions as well.
+  
+  ```clojure 
+  (py.. obj (*method args))
+  (py.. obj (*method args kwargs))
+  (py.. obj (**method kwargs))
+  (py.. obj (**method arg1 arg2 arg3 ... argN kwargs))
+  ```
 
 
 ## 1.31

From 215595ae305f4360ae2680269ad66d20b3c2611f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 22 Jan 2020 13:09:46 -0700
Subject: [PATCH 149/456] Direct mapping (#59)

* major push into direct mapping

* Another factor of 2 with direct mapping.

* More direct mapped work to hit some more common cases.
---
 java/libpython_clj/jna/DirectMapped.java      | 35 +++++++++++++++
 project.clj                                   |  3 +-
 src/libpython_clj/jna/concrete/dict.clj       | 14 +++---
 src/libpython_clj/jna/concrete/err.clj        |  7 +--
 .../jna/concrete/numeric/float.clj            | 15 +++----
 .../jna/concrete/numeric/integer.clj          | 15 ++++---
 src/libpython_clj/jna/concrete/tuple.clj      | 25 ++++++-----
 src/libpython_clj/jna/concrete/unicode.clj    | 22 +++++-----
 src/libpython_clj/jna/interpreter.clj         | 13 +++---
 src/libpython_clj/jna/protocols/object.clj    | 43 ++++++++++---------
 src/libpython_clj/jna/protocols/sequence.clj  | 21 +++++----
 src/libpython_clj/python/interop.clj          |  4 +-
 src/libpython_clj/python/object.clj           | 11 ++---
 13 files changed, 133 insertions(+), 95 deletions(-)

diff --git a/java/libpython_clj/jna/DirectMapped.java b/java/libpython_clj/jna/DirectMapped.java
index e861ae7..d38ccd8 100644
--- a/java/libpython_clj/jna/DirectMapped.java
+++ b/java/libpython_clj/jna/DirectMapped.java
@@ -1,10 +1,45 @@
 package libpython_clj.jna;
 
 import com.sun.jna.Pointer;
+import com.sun.jna.ptr.LongByReference;
+import com.sun.jna.ptr.PointerByReference;
+import java.nio.ByteBuffer;
 
 
 public class DirectMapped
 {
   public static native void Py_IncRef(Pointer ptr);
   public static native void Py_DecRef(Pointer ptr);
+  public static native void PyEval_RestoreThread(Pointer tstate);
+  public static native Pointer PyEval_SaveThread();
+  public static native Pointer PyFloat_FromDouble(double y);
+  public static native double PyFloat_AsDouble(Pointer val);
+  public static native Pointer PyLong_FromLongLong(long v);
+  public static native long PyLong_AsLongLong(Pointer v);
+  public static native int PyDict_Next(Pointer p, LongByReference ppos,
+				       PointerByReference pkey,
+				       PointerByReference pvalue);
+  //FIXME - how to change signatures if 32 bit.
+  public static native Pointer PyTuple_New(long size);
+  public static native Pointer PyTuple_GetItem(Pointer p, long size);
+  public static native int PyTuple_SetItem(Pointer p, long pos, Pointer o);
+  public static native Pointer PyErr_Occurred();
+  public static native Pointer PyObject_CallObject(Pointer callable, Pointer argtuple);
+  public static native Pointer PyObject_Call(Pointer callable,
+					     Pointer argtuple,
+					     Pointer kwargs);
+  public static native int PyObject_HasAttrString(Pointer obj, String attrName);
+  public static native Pointer PyObject_GetAttrString(Pointer obj, String attrName);
+  public static native int PyCallable_Check(Pointer p);
+  public static native Pointer PyUnicode_AsUTF8AndSize(Pointer pyobj,
+						       LongByReference reference);
+  public static native Pointer PyUnicode_Decode(ByteBuffer bytedata,
+						long numchars, //size-t
+						String encoding,
+						String flags);
+  public static native int PySequence_Check(Pointer val);
+  //returns size-t
+  public static native long PySequence_Length(Pointer val);
+  //takes size-t
+  public static native Pointer PySequence_GetItem(Pointer val, long idx);
 }
diff --git a/project.clj b/project.clj
index 88c046a..d0bd0e2 100644
--- a/project.clj
+++ b/project.clj
@@ -5,7 +5,8 @@
             :url "https://www.eclipse.org/legal/epl-2.0/"}
   :dependencies [[org.clojure/clojure "1.10.1"]
                  [camel-snake-kebab "0.4.0"]
-                 [techascent/tech.datatype "4.71"]
+                 [techascent/tech.datatype "4.72"]
                  [org.clojure/data.json "0.2.7"]]
+  :profiles {:dev {:dependencies [[criterium "0.4.5"]]}}
   :repl-options {:init-ns user}
   :java-source-paths ["java"])
diff --git a/src/libpython_clj/jna/concrete/dict.clj b/src/libpython_clj/jna/concrete/dict.clj
index 93548a0..b194f6a 100644
--- a/src/libpython_clj/jna/concrete/dict.clj
+++ b/src/libpython_clj/jna/concrete/dict.clj
@@ -9,7 +9,7 @@
              :as libpy-base]
             [tech.jna :as jna])
   (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
+           [libpython_clj.jna PyObject DirectMapped]))
 
 
 
@@ -181,7 +181,7 @@
   [p ensure-pyobj])
 
 
-(def-pylib-fn PyDict_Next
+(defn PyDict_Next
   "Iterate over all key-value pairs in the dictionary p. The Py_ssize_t referred to by
   ppos must be initialized to 0 prior to the first call to this function to start the
   iteration; the function returns true for each pair in the dictionary, and false once
@@ -190,11 +190,11 @@
   may be NULL. Any references returned through them are borrowed. ppos should not be
   altered during iteration. Its value represents offsets within the internal dictionary
   structure, and since the structure is sparse, the offsets are not consecutive."
-  Integer
-  [p ensure-pyobj]
-  [ppos (partial jna/ensure-type jna/size-t-ref-type)]
-  [pkey jna/ensure-ptr-ptr]
-  [pvalue jna/ensure-ptr-ptr])
+  ^long [p ppos pkey pvalue]
+  (long (DirectMapped/PyDict_Next (ensure-pyobj p)
+                                  (jna/ensure-type jna/size-t-ref-type ppos)
+                                  (jna/ensure-ptr-ptr pkey)
+                                  (jna/ensure-ptr-ptr pvalue))))
 
 
 (def-pylib-fn PyDict_Merge
diff --git a/src/libpython_clj/jna/concrete/err.clj b/src/libpython_clj/jna/concrete/err.clj
index 27bdc18..7df5a24 100644
--- a/src/libpython_clj/jna/concrete/err.clj
+++ b/src/libpython_clj/jna/concrete/err.clj
@@ -10,12 +10,13 @@
              :as libpy-base]
             [tech.jna :as jna])
   (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject PyTypeObject]))
+           [libpython_clj.jna PyObject PyTypeObject DirectMapped]))
 
 
-(def-pylib-fn PyErr_Occurred
+(defn PyErr_Occurred
   "Check if the error indicator is set.  If so, return the exception type."
-  Pointer)
+  ^Pointer []
+  (DirectMapped/PyErr_Occurred))
 
 
 (def-pylib-fn PyErr_Clear
diff --git a/src/libpython_clj/jna/concrete/numeric/float.clj b/src/libpython_clj/jna/concrete/numeric/float.clj
index 56eccc8..dee3276 100644
--- a/src/libpython_clj/jna/concrete/numeric/float.clj
+++ b/src/libpython_clj/jna/concrete/numeric/float.clj
@@ -8,7 +8,7 @@
              :as libpy-base]
             [tech.jna :as jna])
   (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
+           [libpython_clj.jna PyObject DirectMapped]))
 
 
 (def-pylib-fn PyFloat_Check
@@ -31,22 +31,21 @@
   [str ensure-pyobj])
 
 
-(def-pylib-fn PyFloat_FromDouble
+(defn PyFloat_FromDouble
   "Return value: New reference.
 
    Create a PyFloatObject object from v, or NULL on failure."
-  Pointer
-  [v double])
+  ^Pointer [v]
+  (DirectMapped/PyFloat_FromDouble (double v)))
 
 
-(def-pylib-fn PyFloat_AsDouble
+(defn PyFloat_AsDouble
   "Return a C double representation of the contents of pyfloat. If pyfloat is not a
   Python floating point object but has a __float__() method, this method will first be
   called to convert pyfloat into a float. This method returns -1.0 upon failure, so one
   should call PyErr_Occurred() to check for errors."
-  Double
-  [v ensure-pyobj])
-
+  ^double [v]
+  (DirectMapped/PyFloat_AsDouble (ensure-pyobj v)))
 
 
 (def-pylib-fn PyFloat_GetInfo
diff --git a/src/libpython_clj/jna/concrete/numeric/integer.clj b/src/libpython_clj/jna/concrete/numeric/integer.clj
index c04e60b..3c8af96 100644
--- a/src/libpython_clj/jna/concrete/numeric/integer.clj
+++ b/src/libpython_clj/jna/concrete/numeric/integer.clj
@@ -8,7 +8,7 @@
              :as libpy-base]
             [tech.jna :as jna])
   (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
+           [libpython_clj.jna PyObject DirectMapped]))
 
 
 (def-pylib-fn PyLong_Check
@@ -53,12 +53,13 @@
   [v jna/size-t])
 
 
-(def-pylib-fn PyLong_FromLongLong
+(defn PyLong_FromLongLong
   "Return value: New reference.
 
    Return a new PyLongObject object from a C long long, or NULL on failure."
-  Pointer
-  [v long])
+  ^Pointer [v]
+  (DirectMapped/PyLong_FromLongLong (long v)))
+
 
 (def-pylib-fn PyLong_FromUnsignedLongLong
   "Return value: New reference.
@@ -87,7 +88,7 @@
   [obj ensure-pyobj])
 
 
-(def-pylib-fn PyLong_AsLongLong
+(defn PyLong_AsLongLong
   "Return a C long long representation of obj. If obj is not an instance of
   PyLongObject, first call its __int__() method (if present) to convert it to a
   PyLongObject.
@@ -95,5 +96,5 @@
    Raise OverflowError if the value of obj is out of range for a long.
 
    Returns -1 on error. Use PyErr_Occurred() to disambiguate."
-  Long
-  [obj ensure-pyobj])
+  ^long [obj]
+  (DirectMapped/PyLong_AsLongLong (ensure-pyobj obj)))
diff --git a/src/libpython_clj/jna/concrete/tuple.clj b/src/libpython_clj/jna/concrete/tuple.clj
index f129e06..df726a3 100644
--- a/src/libpython_clj/jna/concrete/tuple.clj
+++ b/src/libpython_clj/jna/concrete/tuple.clj
@@ -9,7 +9,7 @@
              :as libpy-base]
             [tech.jna :as jna])
   (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
+           [libpython_clj.jna PyObject DirectMapped]))
 
 
 (def-pylib-fn PyTuple_Check
@@ -18,22 +18,21 @@
   [p ensure-pyobj])
 
 
-(def-pylib-fn PyTuple_New
+(defn PyTuple_New
   "Return value: New reference.
 
    Return a new tuple object of size len, or NULL on failure."
-  Pointer
-  [len jna/size-t])
+  ^Pointer [^long len]
+  (DirectMapped/PyTuple_New (long len)))
 
 
-(def-pylib-fn PyTuple_GetItem
+(defn PyTuple_GetItem
   "Return value: Borrowed reference.
 
    Return the object at position pos in the tuple pointed to by p. If pos is out of
    bounds, return NULL and sets an IndexError exception."
-  Pointer
-  [p ensure-pyobj]
-  [pos jna/size-t])
+  ^Pointer [p pos]
+  (DirectMapped/PyTuple_GetItem (ensure-pyobj p) (long pos)))
 
 
 (def-pylib-fn PyTuple_GetSlice
@@ -47,14 +46,14 @@
   [high jna/size-t])
 
 
-(def-pylib-fn PyTuple_SetItem
+(defn PyTuple_SetItem
   "Insert a reference to object o at position pos of the tuple pointed to by p. Return 0
   on success.
 
    Note
 
    This function “steals” a reference to o"
-  Integer
-  [p ensure-pyobj]
-  [pos jna/size-t]
-  [o ensure-pyobj])
+  ^long [p pos o]
+  (long (DirectMapped/PyTuple_SetItem (ensure-pyobj p)
+                                      (long pos)
+                                      (ensure-pyobj o))))
diff --git a/src/libpython_clj/jna/concrete/unicode.clj b/src/libpython_clj/jna/concrete/unicode.clj
index af2c863..7a22d1f 100644
--- a/src/libpython_clj/jna/concrete/unicode.clj
+++ b/src/libpython_clj/jna/concrete/unicode.clj
@@ -12,11 +12,11 @@
   (:import [com.sun.jna Pointer]
            [com.sun.jna.ptr PointerByReference
             LongByReference IntByReference]
-           [libpython_clj.jna PyObject]))
+           [libpython_clj.jna PyObject DirectMapped]))
 
 
 
-(def-pylib-fn PyUnicode_Decode
+(defn PyUnicode_Decode
   "Return value: New reference.
 
    Create a Unicode object by decoding size bytes of the encoded string s. encoding and
@@ -26,11 +26,11 @@
 
   Signature:
   PyObject* (const char *s, Py_ssize_t size, const char *encoding, const char *errors)"
-  Pointer
-  [s dtype/as-nio-buffer]
-  [size jna/size-t]
-  [encoding str]
-  [errors str])
+  ^Pointer [s size encoding errors]
+  (DirectMapped/PyUnicode_Decode (dtype/as-nio-buffer s)
+                                 (jna/size-t size)
+                                 (str encoding)
+                                 (str errors)))
 
 
 (def-pylib-fn PyUnicode_AsEncodedString
@@ -55,7 +55,7 @@
     IntByReference))
 
 
-(def-pylib-fn PyUnicode_AsUTF8AndSize
+(defn PyUnicode_AsUTF8AndSize
   "Return a pointer to the UTF-8 encoding of the Unicode object, and store the size of
    the encoded representation (in bytes) in size. The size argument can be NULL; in this
    case no size will be stored. The returned buffer always has an extra null byte
@@ -71,9 +71,9 @@
    New in version 3.3.
 
    Changed in version 3.7: The return type is now const char * rather of char *."
-  Pointer
-  [py-obj ensure-pyobj]
-  [size-ptr (partial jna/ensure-type (size-t-by-reference-type))])
+  ^Pointer [py-obj size-ptr]
+  (DirectMapped/PyUnicode_AsUTF8AndSize (ensure-pyobj py-obj)
+                                        ^LongByReference size-ptr))
 
 
 (def-pylib-fn PyUnicode_AsUTF8
diff --git a/src/libpython_clj/jna/interpreter.clj b/src/libpython_clj/jna/interpreter.clj
index b2ce582..ae7b437 100644
--- a/src/libpython_clj/jna/interpreter.clj
+++ b/src/libpython_clj/jna/interpreter.clj
@@ -17,7 +17,7 @@
             [clojure.tools.logging :as log])
   (:import [com.sun.jna Pointer Native NativeLibrary]
            [com.sun.jna.ptr PointerByReference]
-           [libpython_clj.jna PyObject]))
+           [libpython_clj.jna PyObject DirectMapped]))
 
 
 
@@ -264,7 +264,7 @@
 
 
 ;;Acquire the GIL of the given thread state
-(def-no-gil-pylib-fn PyEval_RestoreThread
+(defn PyEval_RestoreThread
   "Acquire the global interpreter lock (if it has been created and thread support is
   enabled) and set the thread state to tstate, which must not be NULL. If the lock has
   been created, the current thread must not have acquired it, otherwise deadlock ensues.
@@ -275,17 +275,18 @@
   thread, even if the thread was not created by Python. You can use _Py_IsFinalizing()
   or sys.is_finalizing() to check if the interpreter is in process of being finalized
   before calling this function to avoid unwanted termination."
-  nil
-  [tstate ensure-pyobj])
+  [tstate]
+  (DirectMapped/PyEval_RestoreThread (ensure-pyobj tstate)))
 
 
 ;;Release the GIL, return thread state
-(def-pylib-fn PyEval_SaveThread
+(defn PyEval_SaveThread
   "Release the global interpreter lock (if it has been created and thread support is
   enabled) and reset the thread state to NULL, returning the previous thread state
   (which is not NULL). If the lock has been created, the current thread must have
   acquired it."
-  Pointer)
+  ^Pointer []
+  (DirectMapped/PyEval_SaveThread))
 
 
 ;;Get current thread state for interpreter
diff --git a/src/libpython_clj/jna/protocols/object.clj b/src/libpython_clj/jna/protocols/object.clj
index a4cf4c5..061b949 100644
--- a/src/libpython_clj/jna/protocols/object.clj
+++ b/src/libpython_clj/jna/protocols/object.clj
@@ -110,16 +110,17 @@
   [attr-name ensure-pyobj])
 
 
-(def-pylib-fn PyObject_HasAttrString
+(defn PyObject_HasAttrString
   "Returns 1 if o has the attribute attr_name, and 0 otherwise. This is equivalent to
   the Python expression hasattr(o, attr_name). This function always succeeds.
 
    Note that exceptions which occur while calling __getattr__() and __getattribute__()
    methods and creating a temporary string object will get suppressed. To get error
-   reporting use Pointer_GetAttrString() instead."
-  Integer
-  [pyobj ensure-pyobj]
-  [attr-name str])
+   reporting use Object_GetAttrString() instead."
+  ^long [pyobj attr-name]
+  (long
+   (DirectMapped/PyObject_HasAttrString (ensure-pyobj pyobj)
+                                        (str attr-name))))
 
 
 (def-pylib-fn PyObject_GetAttr
@@ -133,15 +134,15 @@
   [attr-name ensure-pyobj])
 
 
-(def-pylib-fn PyObject_GetAttrString
+(defn PyObject_GetAttrString
   "Return value: New reference.
 
    Retrieve an attribute named attr_name from object o. Returns the attribute value on
    success, or NULL on failure. This is the equivalent of the Python expression
    o.attr_name."
-  Pointer
-  [pyobj ensure-pyobj]
-  [attr-name str])
+  ^Pointer [pyobj attr-name]
+  (DirectMapped/PyObject_GetAttrString (ensure-pyobj pyobj)
+                                       (str attr-name)))
 
 
 (def-pylib-fn PyObject_GenericGetAttr
@@ -267,14 +268,14 @@
   [opid bool-fn-constant])
 
 
-(def-pylib-fn PyCallable_Check
+(defn PyCallable_Check
   "Determine if the object o is callable. Return 1 if the object is callable and 0
   otherwise. This function always succeeds."
-  Integer
-  [pyobj ensure-pyobj])
+  ^long [pyobj]
+  (long (DirectMapped/PyCallable_Check (ensure-pyobj pyobj))))
 
 
-(def-pylib-fn PyObject_Call
+(defn PyObject_Call
   "Return value: New reference.
 
    Call a callable Python object callable, with arguments given by the tuple args, and
@@ -286,12 +287,12 @@
    Returns the result of the call on success, or NULL on failure.
 
    This is the equivalent of the Python expression: callable(*args, **kwargs)."
-  Pointer
-  [callable ensure-pyobj]
-  [args ensure-pytuple]
-  [kwargs as-pyobj])
+  ^Pointer [callable args kwargs]
+  (DirectMapped/PyObject_Call (ensure-pyobj callable)
+                              (ensure-pytuple args)
+                              (as-pyobj kwargs)))
 
-(def-pylib-fn PyObject_CallObject
+(defn PyObject_CallObject
   "Return value: New reference.
 
    Call a callable Python object callable, with arguments given by the tuple args. If no
@@ -300,9 +301,9 @@
    Returns the result of the call on success, or NULL on failure.
 
    This is the equivalent of the Python expression: callable(*args)."
-  Pointer
-  [callable ensure-pyobj]
-  [args as-pyobj])
+  ^Pointer [callable args]
+  (DirectMapped/PyObject_CallObject (ensure-pyobj callable)
+                                    (as-pyobj args)))
 
 
 (def-pylib-fn PyObject_Hash
diff --git a/src/libpython_clj/jna/protocols/sequence.clj b/src/libpython_clj/jna/protocols/sequence.clj
index 7e9bc76..b3d67b9 100644
--- a/src/libpython_clj/jna/protocols/sequence.clj
+++ b/src/libpython_clj/jna/protocols/sequence.clj
@@ -9,24 +9,24 @@
              :as libpy-base]
             [tech.jna :as jna])
   (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
+           [libpython_clj.jna PyObject DirectMapped]))
 
 
 
-(def-pylib-fn PySequence_Check
+(defn PySequence_Check
   "Return 1 if the object provides sequence protocol, and 0 otherwise. Note that it
   returns 1 for Python classes with a __getitem__() method unless they are dict
   subclasses since in general case it is impossible to determine what the type of keys
   it supports. This function always succeeds."
-  Integer
-  [o ensure-pyobj])
+  ^long [o]
+  (long (DirectMapped/PySequence_Check (ensure-pyobj o))))
 
 
-(def-pylib-fn PySequence_Length
+(defn PySequence_Length
   "Returns the number of objects in sequence o on success, and -1 on failure. This is
   equivalent to the Python expression len(o)."
-  size-t-type
-  [o ensure-pyobj])
+  ^long [o]
+  (long (DirectMapped/PySequence_Length (ensure-pyobj o))))
 
 
 (def-pylib-fn PySequence_Concat
@@ -71,14 +71,13 @@
   [count jna/size-t])
 
 
-(def-pylib-fn PySequence_GetItem
+(defn PySequence_GetItem
   "Return value: New reference.
 
    Return the ith element of o, or NULL on failure. This is the equivalent of the Python
    expression o[i]."
-  Pointer
-  [o ensure-pyobj]
-  [i jna/size-t])
+  ^Pointer [o i]
+  (DirectMapped/PySequence_GetItem (ensure-pyobj o) (jna/size-t i)))
 
 
 (def-pylib-fn PySequence_GetSlice
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
index e1a9efc..3cad57f 100644
--- a/src/libpython_clj/python/interop.clj
+++ b/src/libpython_clj/python/interop.clj
@@ -220,8 +220,8 @@
          docstring-ptr (when docstring (jna/string->ptr-untracked docstring))
          type-name-ptr (jna/string->ptr-untracked (str module-name "." type-name))
          tp_flags (long (or tp_flags
-                            (bit-or @libpy/Py_TPFLAGS_DEFAULT
-                                    @libpy/Py_TPFLAGS_BASETYPE)))
+                            (bit-or libpy/Py_TPFLAGS_DEFAULT
+                                    libpy/Py_TPFLAGS_BASETYPE)))
          ;;We allocate our memory manually here else the system will gc the
          ;;type object memory when the type goes out of scope.
          new-mem (jna/malloc-untracked type-obj-size)
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 8ca7428..19016d1 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -222,8 +222,9 @@ Object's refcount is bad.  Crash is imminent"
 
 (defn py-raw-type
   ^Pointer [pyobj]
-  (let [pyobj (PyObject. (libpy/as-pyobj pyobj))]
-    (.ob_type pyobj)))
+  (let [^Pointer pyobj (libpy/as-pyobj pyobj)]
+    (jna/size-t-compile-time-switch
+     (.getPointer pyobj 4) (.getPointer pyobj 8))))
 
 
 (extend-protocol py-proto/PPythonType
@@ -401,13 +402,13 @@ Object's refcount is bad.  Crash is imminent"
 %s" (type function)))))
   (let [meth-flags (long (cond
                            (instance? CFunction$NoArgFunction function)
-                           @libpy/METH_NOARGS
+                           libpy/METH_NOARGS
 
                            (instance? CFunction$TupleFunction function)
-                           @libpy/METH_VARARGS
+                           libpy/METH_VARARGS
 
                            (instance? CFunction$KeyWordFunction function)
-                           (bit-or @libpy/METH_KEYWORDS @libpy/METH_VARARGS)
+                           (bit-or libpy/METH_KEYWORDS libpy/METH_VARARGS)
                            :else
                            (throw (ex-info (format "Failed due to type: %s"
                                                    (type function))

From ad8a1407377b3a77a60443214ea808b70afb6dbd Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 23 Jan 2020 09:22:16 -0700
Subject: [PATCH 150/456] fix for #50 and added gc! call

---
 src/libpython_clj/python.clj        | 12 +++-
 src/libpython_clj/python/bridge.clj | 87 ++++++++++++++++++++++++++++-
 src/libpython_clj/python/object.clj |  4 +-
 test/libpython_clj/python_test.clj  | 21 ++++++-
 4 files changed, 118 insertions(+), 6 deletions(-)

diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index cb10838..b28de7f 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -333,6 +333,14 @@
              (catch Throwable e#
                (with-exit-error-handler ~varname e#))))))))
 
+
+(defn gc!
+  "Run the system garbage collection facility and then call the cooperative
+  'cleanup python objects' queue"
+  []
+  (System/gc)
+  (with-gil))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
@@ -476,12 +484,12 @@
 
          (clojure.string/starts-with? symbol-str "**")
          (list* #'py** x (symbol (subs symbol-str 2 (count symbol-str))) args)
-         
+
          (clojure.string/starts-with? symbol-str "*")
          (list* #'py* x (symbol (subs symbol-str 1 (count symbol-str))) args)
 
          :else ;; assumed to be method invocation
-         
+
          (list* (into (vector #'py. x instance-member) args))))
      (handle-pydotdot x (list form))))
   ([x form & more]
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index bb3234a..030224e 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -665,11 +665,96 @@
                    (with-gil
                      (cfn this arg0 arg1 arg2 arg3)))
 
-
            (invoke [this arg0 arg1 arg2 arg3 arg4]
                    (with-gil
                      (cfn this arg0 arg1 arg2 arg3 arg4)))
 
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                    arg11]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                          arg11)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                    arg11 arg12]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                          arg11 arg12)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                    arg11 arg12 arg13]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                          arg11 arg12 arg13)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                    arg11 arg12 arg13 arg14]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                          arg11 arg12 arg13 arg14)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                    arg11 arg12 arg13 arg14 arg15]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                          arg11 arg12 arg13 arg14 arg15)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                    arg11 arg12 arg13 arg14 arg15 arg16]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                          arg11 arg12 arg13 arg14 arg15 arg16)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                    arg11 arg12 arg13 arg14 arg15 arg16 arg17]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                          arg11 arg12 arg13 arg14 arg15 arg16 arg17)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                    arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                          arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                    arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 arg19]
+                   (with-gil
+                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                          arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 arg19)))
+
+           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                    arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 arg19 arg20-obj-array]
+                   (with-gil
+                     (apply
+                      cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
+                      arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 arg19
+                      arg20-obj-array)))
+
            (applyTo [this arglist]
                     (with-gil
                       (apply cfn this arglist)))
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 19016d1..5495ec8 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -159,8 +159,8 @@ Object's refcount is bad.  Crash is imminent"
                        (println (format "releasing object - 0x%x:%4d:%s"
                                         pyobj-value
                                         refcount
-                                        (name (python-type pyobj))))))))
-               (libpy/Py_DecRef pyobj)
+                                        (name (python-type pyobj)))))))
+                 (libpy/Py_DecRef pyobj))
                (catch Throwable e
                  (log/error e "Exception while releasing object"))))
            (when-not skip-check-error? (check-error-throw))
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index a2de61b..3d9a499 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -252,7 +252,7 @@
            (str (-> (py/get-attr np "random")
                     (py/get-attr "shuffle"))))))
 
-  
+
   (let [builtins (py/import-module "builtins")
         l        (py/call-attr builtins "list")]
     (is (= (py/py. l __len__) 0))
@@ -409,3 +409,22 @@ class Foo:
 (deftest characters
   (is (= (py/->jvm (py/->python "c"))
          (py/->jvm (py/->python \c)))))
+
+
+(comment
+  (require '[libpython-clj.require :refer [require-python]])
+
+  (require-python '[pandas :as pd])
+  (require-python '[plotly.express :as px])
+  (def px (py/import-module "plotly.express"))
+
+  (let [data (doto (pd/DataFrame {:index [1 2] :value [2 3] :variable [1 1]})
+               (py. melt :id_vars "index"))]
+    (py. px line :data_frame data :x "index" :y "value" :color "variable"))
+
+
+  (let [data (doto (pd/DataFrame {:index [1 2] :value [2 3] :variable [1 1]})
+               (py. melt :id_vars "index"))]
+    ((py.- px line) :data_frame data :x "index" :y "value" :color "variable"))
+
+  )

From 95cdd6939d367453dedcfc77e9221309f89454d5 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 23 Jan 2020 10:08:34 -0700
Subject: [PATCH 151/456] edit

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 941dbf9..3b31194 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,8 @@ JNA libpython bindings to the tech ecosystem.
 * Finding the python libraries is done dynamically allowing one system to run on multiple versions
   of python.
 * REPL oriented design means fast, smooth, iterative development.
+* Carin Meier has written excellent posts on [plotting](http://gigasquidsoftware.com/blog/2020/01/18/parens-for-pyplot/) and
+  [advanced text generation](http://gigasquidsoftware.com/blog/2020/01/10/hugging-face-gpt-with-clojure/).
 
 
 ## Vision

From 3f5553e31a0d9f4a8b2f1b0b96e248154304ec0b Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 23 Jan 2020 10:22:13 -0700
Subject: [PATCH 152/456] Updated Changelog

---
 CHANGELOG.md | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b8685e2..f5cdfe1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,18 @@
 # Time for a ChangeLog!
 
 ## 1.32
+* DecRef now happens cooperatively in python thread.  We used to use separate threads
+  in order to do decrement the refcount on objects that aren't reachable any more.  Now
+  it happens at the end of the `with-gil` macro and thus it is possible to have all
+  python access confined to a single thread if this is desired for stability.  It is
+  also quite a bit faster as the GIL is captured once and all decrefs happen after
+  that.
+  
+* Major performance and stability enhancements.
+  1.  Doubled down on single-interpreter design.  This simplified some important aspects
+      and led to a bit of perf gain.
+  2.  Implemented JNA [DirectMapping](https://github.com/java-native-access/jna/blob/master/www/DirectMapping.md) for quite a few hotspots found via profiling some simple
+      examples.  Lots of people helped out with this (John Collins, Tom Poole (joinr)).
 
 * Python executables can now be specified directly using the syntax
   ```clojure 
@@ -64,6 +76,14 @@
   (py.. obj (**method kwargs))
   (py.. obj (**method arg1 arg2 arg3 ... argN kwargs))
   ```
+  
+### Bugs Fixed:
+
+* [attribute calls with argument given in map](https://github.com/cnuernber/libpython-clj/issues/46)
+* [allow specification of python executable](https://github.com/cnuernber/libpython-clj/issues/52)
+* [difference in calling conventions leads to strange behavior in pandas](https://github.com/cnuernber/libpython-clj/issues/50) with [screencast of fix](https://drive.google.com/file/d/1PTXzWqNaRAiIDDZWqkeffIK2KESRWSRh/view?usp=sharing)
+* [Allow single threaded use of Python](https://github.com/cnuernber/libpython-clj/issues/48)
+* [Simplify interpreter design for only one interpreter](https://github.com/cnuernber/libpython-clj/issues/47)
 
 
 ## 1.31

From 6c63efcc21a30838a0809bb0d3428f1220a058f2 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 23 Jan 2020 10:23:14 -0700
Subject: [PATCH 153/456] 1.32

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index d0bd0e2..58cb88a 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.32-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.32"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From a0765ed5299f4fe3aa0ad442ca5d9b9c29a2bbaa Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 23 Jan 2020 10:23:35 -0700
Subject: [PATCH 154/456] snap

---
 CHANGELOG.md | 60 +++++++++++++++++++++++++++-------------------------
 project.clj  |  2 +-
 2 files changed, 32 insertions(+), 30 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f5cdfe1..3682aed 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,7 @@
 # Time for a ChangeLog!
 
+## 1.33-SNAPSHOT
+
 ## 1.32
 * DecRef now happens cooperatively in python thread.  We used to use separate threads
   in order to do decrement the refcount on objects that aren't reachable any more.  Now
@@ -7,7 +9,7 @@
   python access confined to a single thread if this is desired for stability.  It is
   also quite a bit faster as the GIL is captured once and all decrefs happen after
   that.
-  
+
 * Major performance and stability enhancements.
   1.  Doubled down on single-interpreter design.  This simplified some important aspects
       and led to a bit of perf gain.
@@ -15,68 +17,68 @@
       examples.  Lots of people helped out with this (John Collins, Tom Poole (joinr)).
 
 * Python executables can now be specified directly using the syntax
-  ```clojure 
+  ```clojure
   (py/initialize! :python-executable <executable>)
   ```
   where **executable** can be a system installation of Python
   such as `"python3"`, `"python3.7"`; it can also be a fully qualified
   path such as `"/usr/bin/python3.7"`; or any Python executable along
   your discoverable system path.
-  
-* Python virtual environments can now be used instead of system 
+
+* Python virtual environments can now be used instead of system
   installations! This has been tested on Linux/Ubuntu variants
-  with virtual environments installed with 
-  ```bash 
+  with virtual environments installed with
+  ```bash
   virtualenv -p $(which <python-version>) env
   ```
-  and then invoked using 
-  ```clojure 
+  and then invoked using
+  ```clojure
   (py/initialize! :python-executable "/abs/path/to/env/bin/python")
   ```
-  
+
   Tested on Python 3.6.8 and Python 3.7.
-  
+
   **WARNING**: This is suitable for casual hacking and exploratory
-  development -- however, at this time, we still strongly recommend 
+  development -- however, at this time, we still strongly recommend
   using Docker and a system installation of Python in production
   environments.
-  
+
 * **breaking change** (and remediation): `require-python` no longer
-  automatically binds the Python module to the Clojure the namespace 
+  automatically binds the Python module to the Clojure the namespace
   symbol.  If you wish to bind the module to the namespace symbol,
   you need to use the `:bind-ns` flag.  Example:
-  
-  ```clojure 
+
+  ```clojure
   (require-python 'requests) ;;=> nil
   requests ;;=> throws Exception
-  
+
   (require-python '[requests :bind-ns]) ;;=> nil
-  (py.. requests 
+  (py.. requests
         (get "https://www.google.com)
-        -content 
+        -content
         (decode "latin-1)) ;; works
   ```
 
 * Python method helper syntax for programmatic passing of maps
   to satisfy `*args`, `**kwargs` situations on the `py.` family of
-  macros. Two new macros have been introduced to address this 
-  
-  ```clojure 
+  macros. Two new macros have been introduced to address this
+
+  ```clojure
   (py* obj method args)
   (py* obj method args kwargs)
   (py** obj method kwargs)
   (py** obj method arg1 arg2 arg3 ... argN kwargs)
   ```
-  and the `py..` syntax has been extended to accomodate these 
+  and the `py..` syntax has been extended to accomodate these
   conventions as well.
-  
-  ```clojure 
+
+  ```clojure
   (py.. obj (*method args))
   (py.. obj (*method args kwargs))
   (py.. obj (**method kwargs))
   (py.. obj (**method arg1 arg2 arg3 ... argN kwargs))
   ```
-  
+
 ### Bugs Fixed:
 
 * [attribute calls with argument given in map](https://github.com/cnuernber/libpython-clj/issues/46)
@@ -90,11 +92,11 @@
 
 * Python objects are now datafy-able and nav-igable.  `require-python`
   is now rebuilt using datafy.
-  
+
 * `py.`, `py.-`, and `py..` added to the `libpython-clj` APIs
   to allow method/attribute access more consistent with idiomatic
   Clojure forms.
-  
+
 
 ## 1.30
 
@@ -116,7 +118,7 @@ classes and some serious refactoring overall.
 * Most of the datatype libraries math operators supported by numpy objects (+,-,etc).
 * Numpy objects can be used in datatype library functions (like `copy`, `make-container`)
   and work in optimized ways.
-  
+
 ```clojure
 libpython-clj.python.numpy-test> (def test-ary (py/$a np-mod array (->> (range 9)
                                                                         (partition 3)
@@ -135,7 +137,7 @@ libpython-clj.python.numpy-test> (dfn/> test-ary 4)
  [False False  True]
  [ True  True  True]]
 ```
-  
+
 #### Bugs Fixed
 * Support for java character <-> py string
 * Fixed potential crash related to use of delay mechanism and stack based gc.
diff --git a/project.clj b/project.clj
index 58cb88a..c067e42 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.32"
+(defproject cnuernber/libpython-clj "1.33-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 526eda23df9b756ad6f2ba90912725fa650b67ac Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 23 Jan 2020 13:42:55 -0700
Subject: [PATCH 155/456] Adding in PyGILState_Check

---
 java/libpython_clj/jna/DirectMapped.java |  1 +
 src/libpython_clj/jna.clj                |  1 +
 src/libpython_clj/jna/interpreter.clj    | 11 +++++++++++
 src/libpython_clj/python/interpreter.clj | 22 +++++++++++++++-------
 4 files changed, 28 insertions(+), 7 deletions(-)

diff --git a/java/libpython_clj/jna/DirectMapped.java b/java/libpython_clj/jna/DirectMapped.java
index d38ccd8..4439e9e 100644
--- a/java/libpython_clj/jna/DirectMapped.java
+++ b/java/libpython_clj/jna/DirectMapped.java
@@ -10,6 +10,7 @@ public class DirectMapped
 {
   public static native void Py_IncRef(Pointer ptr);
   public static native void Py_DecRef(Pointer ptr);
+  public static native int PyGILState_Check();
   public static native void PyEval_RestoreThread(Pointer tstate);
   public static native Pointer PyEval_SaveThread();
   public static native Pointer PyFloat_FromDouble(double y);
diff --git a/src/libpython_clj/jna.clj b/src/libpython_clj/jna.clj
index 9ae0c1e..0cf0803 100644
--- a/src/libpython_clj/jna.clj
+++ b/src/libpython_clj/jna.clj
@@ -49,6 +49,7 @@
                 Py_None
                 Py_NotImplemented
                 PyMem_Free
+                PyGILState_Check
                 PyEval_RestoreThread
                 PyEval_SaveThread
                 PyThreadState_Get
diff --git a/src/libpython_clj/jna/interpreter.clj b/src/libpython_clj/jna/interpreter.clj
index ae7b437..5cbe405 100644
--- a/src/libpython_clj/jna/interpreter.clj
+++ b/src/libpython_clj/jna/interpreter.clj
@@ -263,6 +263,17 @@
   [data-ptr jna/as-ptr])
 
 
+(defn PyGILState_Check
+  "Return 1 if the current thread is holding the GIL and 0 otherwise. This function
+  can be called from any thread at any time. Only if it has had its Python thread
+  state initialized and currently is holding the GIL will it return 1. This is
+  mainly a helper/diagnostic function. It can be useful for example in callback
+  contexts or memory allocation functions when knowing that the GIL is locked can
+  allow the caller to perform sensitive actions or otherwise behave differently."
+  ^long []
+  (DirectMapped/PyGILState_Check))
+
+
 ;;Acquire the GIL of the given thread state
 (defn PyEval_RestoreThread
   "Acquire the global interpreter lock (if it has been created and thread support is
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 2c8d8a5..ec68f01 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -339,19 +339,27 @@ print(json.dumps(
   `(do
      (let [interp# (ensure-interpreter)
            ^AtomicLong bound-thread# libpy-base/gil-thread-id
-           thread-id# (libpy-base/current-thread-id)]
+           thread-id# (libpy-base/current-thread-id)
+           bound-thread-id# (.get bound-thread#)]
        (locking interp#
          (let [new-binding?# (if-not (= thread-id# (.get bound-thread#))
-                               (do
-                                 (acquire-gil! interp#)
-                                 true)
-                               false)]
+                               (if (== 1 (libpy/PyGILState_Check))
+                                 (do
+                                   (.set bound-thread# thread-id#)
+                                   :external-entry)
+                                 (do
+                                   (acquire-gil! interp#)
+                                   :internal-entry))
+                               nil)]
            (try
              ~@body
              (finally
                (pygc/clear-reference-queue)
-               (when new-binding?#
-                 (release-gil! interp#)))))))))
+               (cond
+                 (= new-binding?# :internal-entry)
+                 (release-gil! interp#)
+                 (= new-binding?# :external-entry)
+                 (.set bound-thread# bound-thread-id#)))))))))
 
 
 (defonce ^:dynamic *program-name* "")

From 2a6b3d9ab2c491634c38c81c3fad7a8710e9778c Mon Sep 17 00:00:00 2001
From: Tom <joinr@users.noreply.github.com>
Date: Fri, 24 Jan 2020 11:09:00 -0600
Subject: [PATCH 156/456] Added autogenerated arities and macro (#63)

bridge-callable-pyobject macro autogenerates
IFn implementation if no IFn specs are defined.Otherwise, respects existing IFn implementationas per bridge-object.

Macroexpansion will automatically generate all invoke method implementations, as well as
applyTo.

replaced brute-force expansion in generic-python-as-jvm call site with new macro.
---
 src/libpython_clj/python/bridge.clj | 159 ++++++++--------------------
 1 file changed, 43 insertions(+), 116 deletions(-)

diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index 030224e..e882487 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -621,6 +621,47 @@
     (py-proto/call-attr-kw item (key-sym-str->str attr)
                            pos-args kw-args)))
 
+;;utility fn to generate IFn arities
+(defn- emit-args
+  [bodyf varf]
+   (let [argify (fn [n argfn bodyf]
+                  (let [raw  `[~'this ~@(map #(symbol (str "arg" %))
+                                             (range n))]]
+                    `~(bodyf (argfn raw))))]
+     (concat (for [i (range 21)]
+               (argify i identity bodyf))
+             [(argify 21 (fn [xs]
+                          `[~@(butlast xs) ~'arg20-obj-array])
+                     varf)])))
+
+;;Python specific interop wrapper for IFn invocations.
+(defn- emit-py-args []
+  (emit-args    (fn [args] `(~'invoke [~@args]
+                             (~'with-gil
+                              (~'cfn ~@args))))
+                (fn [args]
+                  `(~'invoke [~@args]
+                    (~'with-gil
+                     (~'apply ~'cfn ~@(butlast args) ~(last args)))))))
+
+(defmacro bridge-callable-pyobject
+  "Like bridge-pyobject, except it populates the implementation of IFn
+   for us, where all arg permutations are supplied, as well as applyTo,
+   and the function invocation is of the form
+   (invoke [this arg] (with-gil (cfn this arg))).
+   If caller supplies an implementation for clojure.lang.IFn or aliased
+   Fn, the macro will use that instead (allowing more control but
+   requiring caller to specify implementations for all desired arities)."
+  [pyobj interpreter & body]
+  (let [fn-specs (when-not (some #{'IFn 'clojure.lang.IFn} body)
+                   `(~'IFn
+                     ~@(emit-py-args)
+                     (~'applyTo [~'this ~'arglist]
+                      (~'with-gil
+                       (~'apply ~'cfn ~'this ~'arglist)))))]
+    `(bridge-pyobject ~pyobj ~interpreter
+                      ~@fn-specs
+                      ~@body)))
 
 (defn generic-python-as-jvm
   "Given a generic pyobject, wrap it in a read-only map interface
@@ -631,7 +672,7 @@
       nil
       (let [interpreter (ensure-bound-interpreter)]
         (if (py-proto/callable? pyobj)
-          (bridge-pyobject
+          (bridge-callable-pyobject
            pyobj
            interpreter
            Iterable
@@ -643,121 +684,7 @@
            py-proto/PPyObjectBridgeToList
            (as-list [item]
                     (generic-python-as-list pyobj))
-           IFn
-           ;;uggh
-           (invoke [this]
-                   (with-gil
-                     (cfn this)))
-
-           (invoke [this arg0]
-                   (with-gil
-                     (cfn this arg0)))
-
-           (invoke [this arg0 arg1]
-                   (with-gil
-                     (cfn this arg0 arg1)))
-
-           (invoke [this arg0 arg1 arg2]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2)))
-
-           (invoke [this arg0 arg1 arg2 arg3]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                    arg11]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                          arg11)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                    arg11 arg12]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                          arg11 arg12)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                    arg11 arg12 arg13]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                          arg11 arg12 arg13)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                    arg11 arg12 arg13 arg14]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                          arg11 arg12 arg13 arg14)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                    arg11 arg12 arg13 arg14 arg15]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                          arg11 arg12 arg13 arg14 arg15)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                    arg11 arg12 arg13 arg14 arg15 arg16]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                          arg11 arg12 arg13 arg14 arg15 arg16)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                    arg11 arg12 arg13 arg14 arg15 arg16 arg17]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                          arg11 arg12 arg13 arg14 arg15 arg16 arg17)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                    arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                          arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                    arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 arg19]
-                   (with-gil
-                     (cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                          arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 arg19)))
-
-           (invoke [this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                    arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 arg19 arg20-obj-array]
-                   (with-gil
-                     (apply
-                      cfn this arg0 arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9 arg10
-                      arg11 arg12 arg13 arg14 arg15 arg16 arg17 arg18 arg19
-                      arg20-obj-array)))
-
-           (applyTo [this arglist]
-                    (with-gil
-                      (apply cfn this arglist)))
+           ;;IFn is now supplied for us by the macro.
            ;;Mark this as executable
            Fn
            PyFunction

From f3547cfd59111019010a88835796eedce19f0426 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Fri, 24 Jan 2020 12:09:26 -0500
Subject: [PATCH 157/456] ISSUE-60: Add support for prefix lists and fix
 require-python/require syntax conformity (#62)

* prefix list support in require-python

* remove TODOs, whitespace

* better string test
---
 CHANGELOG.md                               | 32 +++++++
 src/libpython_clj/require.clj              | 97 +++++++++++++++++-----
 test/libpython_clj/require_python_test.clj | 38 +++++++--
 3 files changed, 142 insertions(+), 25 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3682aed..597b25d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,38 @@
 
 ## 1.33-SNAPSHOT
 
+* **BREAKING CHANGE** `require-python` now respects prefix lists --
+  unfortunately, the previous syntax was incorrect. 
+  ```clojure 
+  ;; WRONG (syntax version < 1.33)
+  (require-python '(os math)) 
+  ```
+  would be equivalent to 
+  ```clojure 
+  ;; (do (require-python 'os) (require-python 'math))
+  ```
+  the correct syntax for this SHOULD have been
+  ```clojure 
+  (require-python 'os 'math)
+  ```
+  
+  1.33 fixes this mistake, and provides support for prefix lists, 
+  for example:
+  
+  ```clojure
+  (require-python 
+   '[builtins :as python]
+   '(builtins 
+     [list :as python.list]
+     [dict :as python.dict]
+     [tuple :as python.tuple]
+     [set :as python.set]
+     [frozenset :as python.frozenset]))
+  ```
+  (**Note**: this is done for you by the function `libpython-clj.require/import-python`)
+  
+  
+
 ## 1.32
 * DecRef now happens cooperatively in python thread.  We used to use separate threads
   in order to do decrement the refcount on objects that aren't reachable any more.  Now
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 9773371..11399fc 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -139,6 +139,37 @@
       (alias alias-name module-name))))
 
 
+(defn ^:private req-transform
+  ([req]
+   (if (symbol? req)
+     req
+     (let [base (first req)
+           reqs (rest req)]
+       (map (partial req-transform base) reqs))))
+  ([prefix req] 
+   (cond
+     (and  (symbol? req)
+           (clojure.string/includes? (name req) ".") )
+     (throw (Exception.
+             (str "After removing prefix list, requirements cannot "
+                  "contain periods. Please remove periods from " req)))
+     (symbol? req)
+     (symbol (str prefix "." req))
+     :else
+     (let [base   (first req)
+           reqs   (rest req)
+           alias? (reduce (fn [res [a b]]
+                            (cond
+                              (not b)   nil
+                              (= :as a) (reduced b)
+                              :else     nil))
+                          nil
+                          (partition 2 1 reqs))]
+       (if alias?
+         (into [(symbol (str prefix "." base))] reqs)
+         (into [(req-transform prefix base)] reqs))))))
+
+
 (defn require-python
   "## Basic usage ##
 
@@ -148,12 +179,13 @@
    (require-python '[math :as maaaath])
 
    (maaaath/sin 1.0) ;;=> 0.8414709848078965
-
-   (require-python '(math csv))
-   (require-python '([math :as pymath] csv))
-   (require-python '([math :as pymath] [csv :as py-csv])
+  
+   (require-python 'math 'csv)
+   (require-python '[math :as pymath] 'csv))
+   (require-python '[math :as pymath] '[csv :as py-csv])
    (require-python 'concurrent.futures)
    (require-python '[concurrent.futures :as fs])
+   (require-python '(concurrent [futures :as fs]))
 
    (require-python '[requests :refer [get post]])
 
@@ -201,6 +233,22 @@
    (os/chdir \"/path/to/foodir\")
 
 
+   ## prefix lists ##
+
+   For convenience, if you are loading multiple Python modules
+   with the same prefix, you can use the following notation:
+
+   (require-python '(a b c))
+   is equivalent to
+   (require-python 'a.b 'a.c)
+
+   (require-python '(foo [bar :as baz :refer [qux]]))
+   is equivalent to
+   (require-python '[foo.bar :as baz :refer [qux]])
+
+   (require-python '(foo [bar :as baz :refer [qux]] buster))
+   (require-python '[foo.bar :as baz :refer [qux]] 'foo.buster))
+  
    ## For library developers ##
 
    If you want to intern all symbols to your current namespace,
@@ -213,27 +261,36 @@
    you can do
 
    (require-python '[operators :refer :*])"
-  [reqs]
+  ([req]
+   (cond
+     (list? req) ;; prefix list
+     (let [prefix-lists (req-transform req)]
+       (doseq [req prefix-lists] (require-python req)))
+     (symbol? req) 
+     (require-python (vector req))
+     (vector? req)
+     (do-require-python req)
+     :else
+     (throw (Exception. "Invalid argument: %s" req)))
+   :ok)
+  ([req & reqs]
+   (require-python req)
+   (when (not-empty reqs)
+     (apply require-python reqs))
+   :ok))
 
-  (cond
-    (list? reqs)
-    (doseq [req reqs] (require-python req))
-    (symbol? reqs)
-    (require-python (vector reqs))
-    (vector? reqs)
-    (do-require-python reqs)
-    :else
-    (throw (Exception. "Invalid argument: %s" reqs))))
 
 (defn import-python
   "Loads python, python.list, python.dict, python.set, python.tuple,
   and python.frozenset."
   []
   (require-python
-   '([builtins :as python]
-     [builtins.list :as python.list]
-     [builtins.dict :as python.dict]
-     [builtins.set :as python.set]
-     [builtins.tuple :as python.tuple]
-     [builtins.frozenset :as python.frozenset])))
+   '(builtins
+     [list :as python.list]
+     [dict :as python.dict]
+     [set :as python.set]
+     [tuple :as python.tuple]
+     [frozenset :as python.frozenset])
+   '[builtins :as python])
+  :ok)
 
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index 453b579..e2c5c85 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -12,7 +12,6 @@
                   :exclude [sin cos]
                   :as pymath])
 
-
 (deftest base-require-test
   (let [publics (ns-publics (find-ns 'libpython-clj.require-python-test))]
     (is (not (contains? publics 'sin)))
@@ -46,9 +45,8 @@
     (is (= #{:b} (parse-flags #{:a :b} '[:b :a false])))
     (is (= #{:b :a} (parse-flags #{:a :b} '[:b :a false :a true])))))
 
-
-(require-python '([builtins :as python]
-                  [builtins.list :as python.pylist]))
+(require-python '[builtins :as python]
+                '[builtins.list :as python.pylist])
 
 ;; NOTE -- even though builtins.list has been aliased to
 ;; to python.pylist, you are still required to require
@@ -66,7 +64,6 @@
     (python.pylist/clear l)
     (is (= (python/list) (vec l)))))
 
-
 (require-python 'csv.DictWriter)
 
 (deftest require-python-classes
@@ -75,3 +72,34 @@
   (is csv.DictWriter/writeheader)
   (is csv.DictWriter/writerow)
   (is csv.DictWriter/writerows))
+
+(deftest test-req-transform
+  (let [req-transform #'libpython-clj.require/req-transform]
+
+    (is (= (req-transform 'a) 'a))
+
+    (is (= (req-transform '(a b c))
+           '(a.b a.c)))
+
+    (is (= (req-transform '(a [b :as c :refer [blah]]))
+           (list '[a.b :as c :refer [blah]])))
+
+    (is (= (req-transform  '(a [b :as c :refer [x] :flagA] d))
+           (list '[a.b :as c :refer [x] :flagA] 'a.d)))
+
+    (is (= (req-transform 'a 'b)
+           'a.b))
+
+    (is (= (req-transform 'a.b 'c)
+           'a.b.c))
+
+    (is (thrown? Exception (req-transform 'a.b 'c.d)))
+
+    (is (= (req-transform 'a '[b]) '[a.b]))
+
+    (is (= (req-transform 'a '[b :as c :refer [blah] :flagA])
+           '[a.b :as c :refer [blah] :flagA]))))
+
+
+(deftest import-python-test
+  (is (= :ok (libpython-clj.require/import-python))))

From 09813762f58c87b9e2c41092b79dd28c08a8c59d Mon Sep 17 00:00:00 2001
From: fong <FongHou@users.noreply.github.com>
Date: Sat, 25 Jan 2020 18:24:42 -0500
Subject: [PATCH 158/456] Fix Issue #43: (#64)

* Change with-gil (acquire-gil! and release-gil!) to reentrant PyGILState api.
  * Remove unnecessary acquire-gil! in interpreter/finalize!
  * Remove unnecessary nil from with-wil in (defn generic-python-as-jvm)
---
 java/libpython_clj/jna/DirectMapped.java |  2 ++
 src/libpython_clj/jna.clj                |  2 ++
 src/libpython_clj/jna/interpreter.clj    | 29 +++++++++++++++++++
 src/libpython_clj/python/bridge.clj      |  2 +-
 src/libpython_clj/python/interpreter.clj | 37 +++++++++---------------
 5 files changed, 47 insertions(+), 25 deletions(-)

diff --git a/java/libpython_clj/jna/DirectMapped.java b/java/libpython_clj/jna/DirectMapped.java
index 4439e9e..718ab90 100644
--- a/java/libpython_clj/jna/DirectMapped.java
+++ b/java/libpython_clj/jna/DirectMapped.java
@@ -10,6 +10,8 @@ public class DirectMapped
 {
   public static native void Py_IncRef(Pointer ptr);
   public static native void Py_DecRef(Pointer ptr);
+  public static native int PyGILState_Ensure();
+  public static native void PyGILState_Release(int gilState);
   public static native int PyGILState_Check();
   public static native void PyEval_RestoreThread(Pointer tstate);
   public static native Pointer PyEval_SaveThread();
diff --git a/src/libpython_clj/jna.clj b/src/libpython_clj/jna.clj
index 0cf0803..def6530 100644
--- a/src/libpython_clj/jna.clj
+++ b/src/libpython_clj/jna.clj
@@ -49,6 +49,8 @@
                 Py_None
                 Py_NotImplemented
                 PyMem_Free
+                PyGILState_Ensure
+                PyGILState_Release
                 PyGILState_Check
                 PyEval_RestoreThread
                 PyEval_SaveThread
diff --git a/src/libpython_clj/jna/interpreter.clj b/src/libpython_clj/jna/interpreter.clj
index 5cbe405..9f58c3a 100644
--- a/src/libpython_clj/jna/interpreter.clj
+++ b/src/libpython_clj/jna/interpreter.clj
@@ -263,6 +263,35 @@
   [data-ptr jna/as-ptr])
 
 
+(defn PyGILState_Ensure
+  "Ensure that the current thread is ready to call the Python C API regardless of
+   the current state of Python, or of the global interpreter lock. This may be called
+   as many times as desired by a thread as long as each call is matched with a call
+   to PyGILState_Release(). In general, other thread-related APIs may be used between
+   PyGILState_Ensure() and PyGILState_Release() calls as long as the thread state is
+   restored to its previous state before the Release(). For example, normal usage of
+   the Py_BEGIN_ALLOW_THREADS and Py_END_ALLOW_THREADS macros is acceptable.
+
+   The return value is an opaque “handle” to the thread state when PyGILState_Ensure()
+   was called, and must be passed to PyGILState_Release() to ensure Python is left in 
+   the same state. Even though recursive calls are allowed, these handles cannot be shared -
+   each unique call to PyGILState_Ensure() must save the handle for its call to PyGILState_Release().
+
+   When the function returns, the current thread will hold the GIL and be able to call
+   arbitrary Python code. Failure is a fatal error."
+  ^long []
+  (DirectMapped/PyGILState_Ensure))
+
+(defn PyGILState_Release
+  "Release any resources previously acquired. After this call, Python’s state will be
+   the same as it was prior to the corresponding PyGILState_Ensure() call (but generally
+   this state will be unknown to the caller, hence the use of the GILState API).
+
+   Every call to PyGILState_Ensure() must be matched by a call to PyGILState_Release()
+   on the same thread."
+  [^long s]
+  (DirectMapped/PyGILState_Release s))
+
 (defn PyGILState_Check
   "Return 1 if the current thread is holding the GIL and 0 otherwise. This function
   can be called from any thread at any time. Only if it has had its Python thread
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index e882487..5668a1d 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -667,7 +667,7 @@
   "Given a generic pyobject, wrap it in a read-only map interface
   where the keys are the attributes."
   [pyobj]
-  (with-gil nil
+  (with-gil
     (if (= :none-type (python-type pyobj))
       nil
       (let [interpreter (ensure-bound-interpreter)]
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index ec68f01..5a5309c 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -268,18 +268,17 @@ print(json.dumps(
 
 
 (defn release-gil!
-  "non-reentrant pathway to release the gil.  It must not be held by this thread."
-  [interpreter]
-  (let [thread-state (libpy/PyEval_SaveThread)]
-    (libpy-base/set-gil-thread-id! (libpy-base/current-thread-id) Long/MAX_VALUE)
-    (assoc @(:interpreter-state* interpreter) :thread-state thread-state)))
+  "Reentrant pathway to release the gil.  It must not be held by this thread."
+  [git-state]
+  (libpy-base/set-gil-thread-id! (libpy-base/current-thread-id) Long/MAX_VALUE)
+  (libpy/PyGILState_Release git-state))
 
 
 (defn acquire-gil!
-  "Non-reentrant pathway to acquire gil.  It must not be held by this thread."
-  [interpreter]
-  (libpy/PyEval_RestoreThread (python-thread-state interpreter))
-  (libpy-base/set-gil-thread-id! Long/MAX_VALUE (libpy-base/current-thread-id)))
+  "Reentrant pathway to acquire gil.  It must not be held by this thread."
+  []
+  (libpy-base/set-gil-thread-id! Long/MAX_VALUE (libpy-base/current-thread-id))
+  (libpy/PyGILState_Ensure))
 
 
 (defn swap-interpreters!
@@ -342,24 +341,15 @@ print(json.dumps(
            thread-id# (libpy-base/current-thread-id)
            bound-thread-id# (.get bound-thread#)]
        (locking interp#
-         (let [new-binding?# (if-not (= thread-id# (.get bound-thread#))
-                               (if (== 1 (libpy/PyGILState_Check))
-                                 (do
-                                   (.set bound-thread# thread-id#)
-                                   :external-entry)
-                                 (do
-                                   (acquire-gil! interp#)
-                                   :internal-entry))
-                               nil)]
+         (let [gil-state# (if-not (= thread-id# (.get bound-thread#))
+                            (acquire-gil!)
+                            nil)]
            (try
              ~@body
              (finally
                (pygc/clear-reference-queue)
-               (cond
-                 (= new-binding?# :internal-entry)
-                 (release-gil! interp#)
-                 (= new-binding?# :external-entry)
-                 (.set bound-thread# bound-thread-id#)))))))))
+               (when-not (nil? gil-state#)
+                 (release-gil! gil-state#)))))))))
 
 
 (defonce ^:dynamic *program-name* "")
@@ -500,7 +490,6 @@ print(json.dumps(
     (locking interp
       (check-error-throw)
       (log-info "executing python finalize!")
-      (acquire-gil! interp)
       (let [finalize-value (libpy/Py_FinalizeEx)]
         (when-not (= 0 finalize-value)
           (log-error (format "PyFinalize returned nonzero value: %s" finalize-value)))))))

From de2af0f86ca93138c47bcdeffecdb624da14a9ef Mon Sep 17 00:00:00 2001
From: fong <FongHou@users.noreply.github.com>
Date: Sun, 26 Jan 2020 17:13:07 -0500
Subject: [PATCH 159/456] make release-gil! exception safe (#65)

---
 src/libpython_clj/python/interpreter.clj | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 5a5309c..5a3323d 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -268,14 +268,14 @@ print(json.dumps(
 
 
 (defn release-gil!
-  "Reentrant pathway to release the gil.  It must not be held by this thread."
-  [git-state]
-  (libpy-base/set-gil-thread-id! (libpy-base/current-thread-id) Long/MAX_VALUE)
-  (libpy/PyGILState_Release git-state))
+  "Reentrant pathway to release the gil."
+  [gil-state]
+  (libpy/PyGILState_Release gil-state)
+  (libpy-base/set-gil-thread-id! (libpy-base/current-thread-id) Long/MAX_VALUE))
 
 
 (defn acquire-gil!
-  "Reentrant pathway to acquire gil.  It must not be held by this thread."
+  "Reentrant pathway to acquire gil."
   []
   (libpy-base/set-gil-thread-id! Long/MAX_VALUE (libpy-base/current-thread-id))
   (libpy/PyGILState_Ensure))

From 5be0e7ab4f26e663864c0530e6a7560fcfe21f8b Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 27 Jan 2020 11:26:36 -0700
Subject: [PATCH 160/456] Cleaning up gil state managment a slight bit.

---
 src/libpython_clj/jna/base.clj           |  3 +--
 src/libpython_clj/python/interpreter.clj | 26 ++++++++++++------------
 2 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/src/libpython_clj/jna/base.clj b/src/libpython_clj/jna/base.clj
index ad77dea..49427f5 100644
--- a/src/libpython_clj/jna/base.clj
+++ b/src/libpython_clj/jna/base.clj
@@ -1,7 +1,6 @@
 (ns libpython-clj.jna.base
   (:require [tech.jna :as jna]
-            [tech.jna.base :as jna-base]
-            [camel-snake-kebab.core :refer [->kebab-case]])
+            [tech.jna.base :as jna-base])
   (:import [com.sun.jna Pointer NativeLibrary]
            [libpython_clj.jna PyObject]
            [java.util.concurrent.atomic AtomicLong]))
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 5a3323d..e1bc8e9 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -269,16 +269,17 @@ print(json.dumps(
 
 (defn release-gil!
   "Reentrant pathway to release the gil."
-  [gil-state]
-  (libpy/PyGILState_Release gil-state)
-  (libpy-base/set-gil-thread-id! (libpy-base/current-thread-id) Long/MAX_VALUE))
+  [gil-state ^long original-thread-id]
+  (.set ^AtomicLong libpy-base/gil-thread-id original-thread-id)
+  (libpy/PyGILState_Release gil-state))
 
 
 (defn acquire-gil!
   "Reentrant pathway to acquire gil."
   []
-  (libpy-base/set-gil-thread-id! Long/MAX_VALUE (libpy-base/current-thread-id))
-  (libpy/PyGILState_Ensure))
+  (let [retval (libpy/PyGILState_Ensure)]
+    (.set ^AtomicLong libpy-base/gil-thread-id (libpy-base/current-thread-id))
+    retval))
 
 
 (defn swap-interpreters!
@@ -333,23 +334,22 @@ print(json.dumps(
 
 
 (defmacro with-gil
-  "Grab the gil and use the main interpreter.  Do not grab gil if already grabbed"
+  "Grab the gil and use the main interpreter using reentrant acquire-gil pathway."
   [& body]
   `(do
      (let [interp# (ensure-interpreter)
            ^AtomicLong bound-thread# libpy-base/gil-thread-id
            thread-id# (libpy-base/current-thread-id)
-           bound-thread-id# (.get bound-thread#)]
+           previously-bound-thread-id# (.get bound-thread#)]
        (locking interp#
-         (let [gil-state# (if-not (= thread-id# (.get bound-thread#))
-                            (acquire-gil!)
-                            nil)]
+         (let [gil-state# (when-not (== thread-id# previously-bound-thread-id#)
+                            (acquire-gil!))]
            (try
              ~@body
              (finally
-               (pygc/clear-reference-queue)
-               (when-not (nil? gil-state#)
-                 (release-gil! gil-state#)))))))))
+               (when gil-state#
+                 (pygc/clear-reference-queue)
+                 (release-gil! gil-state# previously-bound-thread-id#)))))))))
 
 
 (defonce ^:dynamic *program-name* "")

From e658148bca0fe0b4c291911d0fc7dadc0ba7a8e3 Mon Sep 17 00:00:00 2001
From: Oliver Rolle <oliver.rolle@googlemail.com>
Date: Tue, 28 Jan 2020 16:07:50 +0100
Subject: [PATCH 161/456] Added support for anaconda python in windows (#67)

---
 docs/Usage.md                            | 13 ++++++-
 src/libpython_clj/python.clj             | 10 ++++--
 src/libpython_clj/python/interpreter.clj | 28 +++++++--------
 src/libpython_clj/python/windows.clj     | 43 ++++++++++++++++++++++++
 4 files changed, 76 insertions(+), 18 deletions(-)
 create mode 100644 src/libpython_clj/python/windows.clj

diff --git a/docs/Usage.md b/docs/Usage.md
index ce30b01..bc646e7 100644
--- a/docs/Usage.md
+++ b/docs/Usage.md
@@ -44,7 +44,7 @@ user> (require '[libpython-clj.python
                          python-type]])
 nil
 
-
+; Mac and Linux
 user> (initialize!)
 Jun 30, 2019 4:47:39 PM clojure.tools.logging$eval7369$fn__7372 invoke
 INFO: executing python initialize!
@@ -53,6 +53,17 @@ INFO: Library python3.6m found at [:system "python3.6m"]
 Jun 30, 2019 4:47:39 PM clojure.tools.logging$eval7369$fn__7372 invoke
 INFO: Reference thread starting
 :ok
+
+; Windows with Anaconda
+(initialize! ; Python executable
+             :python-executable "C:\\Users\\USER\\AppData\\Local\\Continuum\\anaconda3\\python.exe"
+             ; Python Library
+             :library-path "C:\\Users\\USER\\AppData\\Local\\Continuum\\anaconda3\\python37.dll"
+             ; Anacondas PATH environment to load native dlls of modules (numpy, etc.)
+             :windows-anaconda-activate-bat "C:\\Users\\USER\\AppData\\Local\\Continuum\\anaconda3\\Scripts\\activate.bat"
+             )
+...
+:ok
 ```
 
 This dynamically finds the python shared library and loads it using output from
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index b28de7f..6e113fb 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -4,6 +4,7 @@
             [libpython-clj.python.interpreter :as pyinterp]
             [libpython-clj.python.object :as pyobj]
             [libpython-clj.python.bridge :as pybridge]
+            [libpython-clj.python.windows :as win]
             [libpython-clj.jna :as libpy]
             ;;Protocol implementations purely for nd-ness
             [libpython-clj.python.np-array]
@@ -235,7 +236,8 @@
              library-path
              python-home
              no-io-redirect?
-             python-executable]}]
+             python-executable
+             windows-anaconda-activate-bat]}]
   (when-not @pyinterp/main-interpreter*
     (pyinterp/initialize! :program-name program-name
                           :library-path library-path
@@ -245,14 +247,16 @@
     (pyinterop/register-bridge-type!)
     (when-not no-io-redirect?
       (pyinterop/setup-std-writer #'*err* "stderr")
-      (pyinterop/setup-std-writer #'*out* "stdout")))
+      (pyinterop/setup-std-writer #'*out* "stdout"))
+    (if-not (nil? windows-anaconda-activate-bat)
+      (win/setup-windows-conda! windows-anaconda-activate-bat)))
   :ok)
 
 
 (defn ptr-refcnt
   [item]
   (-> (libpy/as-pyobj item)
-      (libpython_clj.jna.PyObject. )
+      (libpython_clj.jna.PyObject.)
       (.ob_refcnt)))
 
 
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index e1bc8e9..e4d7ca5 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -1,5 +1,5 @@
 (ns libpython-clj.python.interpreter
-  (:require [libpython-clj.jna :as libpy ]
+  (:require [libpython-clj.jna :as libpy]
             [libpython-clj.jna.base :as libpy-base]
             [libpython-clj.python.gc :as pygc]
             [libpython-clj.python.logging
@@ -30,13 +30,13 @@
   (let [{:keys [out err exit]}
         (sh executable "-c" "import sys, json;
 print(json.dumps(
-{\"platform\":          sys.platform,
-  \"prefix\":           sys.prefix,
-  \"base_prefix\":      sys.base_prefix,
-  \"executable\":       sys.executable,
-  \"base_exec_prefix\": sys.base_exec_prefix,
-  \"exec_prefix\":      sys.exec_prefix,
-  \"version\":          list(sys.version_info)[:3]}))")]
+{'platform':          sys.platform,
+  'prefix':           sys.prefix,
+  'base_prefix':      sys.base_prefix,
+  'executable':       sys.executable,
+  'base_exec_prefix': sys.base_exec_prefix,
+  'exec_prefix':      sys.exec_prefix,
+  'version':          list(sys.version_info)[:3]}))")]
     (when (= 0 exit)
       (json/read-str out :key-fn keyword))))
 
@@ -93,7 +93,7 @@ print(json.dumps(
         ;;   ..: mac and windows are for sys.platform
         :linux   "libpython%s.%sm.so$"
         :mac     "libpython%s.%sm.dylib$"
-        :windows "python%s.%sm.dll$")
+        :win32   "python%s%s.dll$")
       major minor))))
 
 (defn python-library-paths
@@ -131,9 +131,9 @@ print(json.dumps(
   (let [executable "python3.7"
         system-info (python-system-info executable)
         pyregex (python-library-regex system-info)]
-    (python-library-paths system-info pyregex))
+    (python-library-paths system-info pyregex)))
   ;;=> ["/usr/lib/x86_64-linux-gnu/libpython3.7m.so" "/usr/lib/python3.7/config-3.7m-x86_64-linux-gnu/libpython3.7m.so"]
-  )
+
 
 (defn- ignore-shell-errors
   [& args]
@@ -179,8 +179,8 @@ print(json.dumps(
 ;;get the type of that item if we have seen it before.
 (defrecord Interpreter [
                         interpreter-state* ;;Thread state, per interpreter
-                        shared-state* ;;state shared among all interpreters
-                        ])
+                        shared-state*]) ;;state shared among all interpreters
+
 
 
 ;; Main interpreter booted up during initialize!
@@ -411,7 +411,7 @@ print(json.dumps(
              python-executable]
       :as options}]
   (when-not (main-interpreter)
-    (log-info (str "Executing python initialize with options:" options) )
+    (log-info (str "Executing python initialize with options:" options))
     (let [{:keys [python-home libname java-library-path-addendum] :as startup-info}
           (detect-startup-info options)
           library-names (cond
diff --git a/src/libpython_clj/python/windows.clj b/src/libpython_clj/python/windows.clj
new file mode 100644
index 0000000..d9ad4bf
--- /dev/null
+++ b/src/libpython_clj/python/windows.clj
@@ -0,0 +1,43 @@
+(ns libpython-clj.python.windows
+  (:require [libpython-clj.python.interop :refer [run-simple-string]]
+            [clojure.java.shell :refer [sh]]
+            [clojure.java.io :as io]
+            [clojure.string :as s]))
+
+(defn create-echo-path-bat! []
+  "Creates temporary file to extract condas PATH environment variable"
+  (let [tmp (java.io.File/createTempFile "echo-path" ".bat")]
+    (spit tmp "echo %PATH%")
+    (.toString tmp)))
+
+(defn delete-echo-path-bat! [tmp]
+  "Deletes temporary file"
+  (io/delete-file tmp))
+
+(defn- get-windows-anaconda-env-path [activate-bat echo-bat]
+  "Get anacondas windows PATH environment variable to load native dlls for numpy etc. like python with anaconda does."
+  (-> (sh "cmd.exe" "/K" (str activate-bat " & " echo-bat))
+      :out
+      (s/split #"\r\n")
+      reverse
+      (nth 2)))
+
+
+(defn- generate-python-set-env-path [path]
+  "Double quote windows path separator \\ -> \\\\"
+  (let [quoted (s/replace path "\\" "\\\\")]
+    (str
+      "import os;\n"
+      "path = '" quoted "';\n"
+      "os.environ['PATH'] = path;\n")))
+
+(defn setup-windows-conda! [windows-conda-activate-bat]
+  "Setup python PATH environment variable like in anaconda to be able to load native dlls for numpy etc. like anaconda does."
+  (let [echo-bat (create-echo-path-bat!)]
+    (->> (get-windows-anaconda-env-path
+           windows-conda-activate-bat
+           echo-bat)
+         generate-python-set-env-path
+         run-simple-string)
+    (delete-echo-path-bat! echo-bat)))
+

From b0f853179d6b286fedef6e5cbbca8b503a5d0ab3 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 28 Jan 2020 10:47:35 -0700
Subject: [PATCH 162/456] 1.33

---
 CHANGELOG.md | 11 ++++++++++-
 project.clj  |  2 +-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 597b25d..7b14bb4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,14 @@
 # Time for a ChangeLog!
 
-## 1.33-SNAPSHOT
+## 1.33
+
+* Better [windows anaconda support](https://github.com/cnuernber/libpython-clj/pull/67)
+  thanks to [orolle](https://github.com/orolle).
+
+* Moved to PyGILState* functions for GIL management.  This mainly due to 
+  [FongHou](https://github.com/cnuernber/libpython-clj/commits?author=FongHou) in
+  PRs [here](https://github.com/cnuernber/libpython-clj/pull/64) and 
+  [here](https://github.com/cnuernber/libpython-clj/pull/65).
 
 * **BREAKING CHANGE** `require-python` now respects prefix lists --
   unfortunately, the previous syntax was incorrect. 
@@ -32,6 +40,7 @@
   ```
   (**Note**: this is done for you by the function `libpython-clj.require/import-python`)
   
+  This fix brought to you by [jjtolten](https://github.com/jjtolton).
   
 
 ## 1.32
diff --git a/project.clj b/project.clj
index c067e42..7128ac2 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.33-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.33"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 3a8d65508c8f7a446a66363a7cce22c6d223082e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 28 Jan 2020 10:47:50 -0700
Subject: [PATCH 163/456] snap

---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7b14bb4..9644ff3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,7 @@
 # Time for a ChangeLog!
 
+## 1.34-SNAPSHOT
+
 ## 1.33
 
 * Better [windows anaconda support](https://github.com/cnuernber/libpython-clj/pull/67)

From 7768da6d4f323ce57fdbb68a88d62751dd609d65 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 28 Jan 2020 11:37:03 -0700
Subject: [PATCH 164/456] Less maintenance. Gigasquid's examples are cleaner

---
 CHANGELOG.md                   |   2 +
 README.md                      |  30 ++++---
 example/.gitignore             |   3 -
 example/README.md              |  36 --------
 example/project.clj            |   7 --
 example/scripts/get-data.sh    |   4 -
 example/src/keras_simple.clj   |  97 ---------------------
 example/src/matplotlib.clj     |  73 ----------------
 example/src/mxnet_autograd.clj |  63 --------------
 example/src/new_to_clojure.clj | 155 ---------------------------------
 example/src/walkthrough.clj    |  55 ------------
 11 files changed, 19 insertions(+), 506 deletions(-)
 delete mode 100644 example/.gitignore
 delete mode 100644 example/README.md
 delete mode 100644 example/project.clj
 delete mode 100755 example/scripts/get-data.sh
 delete mode 100644 example/src/keras_simple.clj
 delete mode 100644 example/src/matplotlib.clj
 delete mode 100644 example/src/mxnet_autograd.clj
 delete mode 100644 example/src/new_to_clojure.clj
 delete mode 100644 example/src/walkthrough.clj

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9644ff3..24763ee 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,8 @@
 
 ## 1.34-SNAPSHOT
 
+* [Examples are now done by gigasquid](https://github.com/gigasquid/libpython-clj-examples)
+
 ## 1.33
 
 * Better [windows anaconda support](https://github.com/cnuernber/libpython-clj/pull/67)
diff --git a/README.md b/README.md
index 3b31194..65e7f01 100644
--- a/README.md
+++ b/README.md
@@ -31,30 +31,34 @@ This code is a concrete example that generates an
 ```clojure
 (ns facial-rec.face-feature
   (:require [libpython-clj.require :refer [require-python]]
-            [libpython-clj.python :as py]
+            [libpython-clj.python :refer [py. py.. py.-] :as py]
             [tech.v2.datatype :as dtype]))
 
 
-(require-python '(mxnet mxnet.ndarray mxnet.module mxnet.io mxnet.model))
+
+(require-python 'mxnet
+                '(mxnet ndarray module io model))
 (require-python 'cv2)
 (require-python '[numpy :as np])
 
+
 (defn load-model
   [& {:keys [model-path checkpoint]
       :or {model-path "models/recognition/model"
            checkpoint 0}}]
   (let [[sym arg-params aux-params] (mxnet.model/load_checkpoint model-path checkpoint)
-        all-layers (py/$a sym get_internals)
+        all-layers (py. sym get_internals)
         target-layer (py/get-item all-layers "fc1_output")
-        ;;TODO - We haven't overloaded enough of the IFn invoke methods for
-		;;this to work without using call-kw
-        model (py/call-kw mxnet.module/Module [] {:symbol target-layer :context (mxnet/cpu) :label_names nil})]
-    (py/$a model bind :data_shapes [["data" [1 3 112 112]]])
-    (py/$a model set_params arg-params aux-params)
+        model (mxnet.module/Module :symbol target-layer
+                                   :context (mxnet/cpu)
+                                   :label_names nil)]
+    (py. model bind :data_shapes [["data" [1 3 112 112]]])
+    (py. model set_params arg-params aux-params)
     model))
 
 (defonce model (load-model))
 
+
 (defn face->feature
   [img-path]
   (py/with-gil-stack-rc-context
@@ -64,10 +68,10 @@ This code is a concrete example that generates an
             input-blob (np/expand_dims new-img :axis 0)
             data (mxnet.ndarray/array input-blob)
             batch (mxnet.io/DataBatch :data [data])]
-        (py/$a model forward batch :is_train false)
-        (-> (py/$a model get_outputs)
+        (py. model forward batch :is_train false)
+        (-> (py. model get_outputs)
             first
-            (py/$a asnumpy)
+            (py. asnumpy)
             (#(dtype/make-container :java-array :float32 %))))
       (throw (Exception. (format "Failed to load img: %s" img-path))))))
 ```
@@ -107,7 +111,7 @@ the `libpython3.Xm.so` shared library so for example if we are loading python
 3.6 we look for `libpython3.6m.so` on Linux or `libpython3.6m.dylib` on the Mac.
 
 This pathway has allowed us support Conda albeit with some work.  For examples
-using Conda, check out the facial rec repository above or look into how we 
+using Conda, check out the facial rec repository above or look into how we
 [build](scripts/build-conda-docker)
 our test [docker containers](dockerfiles/CondaDockerfile).
 
@@ -119,7 +123,7 @@ our test [docker containers](dockerfiles/CondaDockerfile).
 * [development discussion forum](https://clojurians.zulipchat.com/#narrow/stream/215609-libpython-clj-dev)
 * [design documentation](docs/design.md)
 * [scope and garbage collection docs](https://github.com/cnuernber/libpython-clj/blob/master/docs/scopes-and-gc.md)
-* [examples](example/README.md)
+* [examples](https://github.com/gigasquid/libpython-clj-examples)
 * [docker setup](https://github.com/scicloj/docker-hub)
 * [pandas bindings (!!)](https://github.com/alanmarazzi/panthera)
 * [nextjournal notebook](https://nextjournal.com/chrisn/fun-with-matplotlib)
diff --git a/example/.gitignore b/example/.gitignore
deleted file mode 100644
index fc98b99..0000000
--- a/example/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-*.csv
-test.jpg
-test.png
\ No newline at end of file
diff --git a/example/README.md b/example/README.md
deleted file mode 100644
index a2fcb51..0000000
--- a/example/README.md
+++ /dev/null
@@ -1,36 +0,0 @@
-# libpython-clj Examples
-
-
-## Usage
-
-```console
-scripts/get-data.sh
-python3.6 -m pip install tensorflow keras matplotlib --user
-```
-
-Then, potentially check that everything is installed.  From python console:
-
-```console
-Python 3.6.7 (default, Oct 22 2018, 11:32:17)
-[GCC 8.2.0] on linux
-Type "help", "copyright", "credits" or "license" for more information.
->>> import keras
-Using TensorFlow backend.
->>>
-```
-
-## Examples
-
-
-* [walkthrough](src/walkthrough.clj) - Simple, quick exploration of libpython features.
-* [keras-simple](src/keras_simple.clj) - Keras example taken from [here](https://machinelearningmastery.com/tutorial-first-neural-network-python-keras/).
-* [matplotlib](src/matplotlib.clj) - Quick demo of matplotlib, numpy including zero-copy pathways.
-
-
-## Virtual Environments
-
-
-This was lightly tested with `python3 -m venv venv`.  Simply activate the virtual environment in the same console
-before you launch the repl and things should work fine assuming the base python
-executable versions line up.  Again, see readme if they do not in order to override the
-version loaded.
diff --git a/example/project.clj b/example/project.clj
deleted file mode 100644
index 0464bad..0000000
--- a/example/project.clj
+++ /dev/null
@@ -1,7 +0,0 @@
-(defproject libpython-clj/example "0.1.0-SNAPSHOT"
-  :description "Examples of python integration"
-  :url "https://github.com/cnuernber/libpython-clj"
-  :license {:name "EPL-2.0"
-            :url "https://www.eclipse.org/legal/epl-2.0/"}
-  :dependencies [[org.clojure/clojure "1.10.1"]
-                 [cnuernber/libpython-clj "1.15"]])
diff --git a/example/scripts/get-data.sh b/example/scripts/get-data.sh
deleted file mode 100755
index f41de9a..0000000
--- a/example/scripts/get-data.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/sh
-
-
-wget https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv
diff --git a/example/src/keras_simple.clj b/example/src/keras_simple.clj
deleted file mode 100644
index 44a2236..0000000
--- a/example/src/keras_simple.clj
+++ /dev/null
@@ -1,97 +0,0 @@
-(ns keras-simple.core
-  "https://machinelearningmastery.com/tutorial-first-neural-network-python-keras/"
-  (:require [libpython-clj.python
-             :refer [import-module
-                     import-as
-                     from-import
-                     a$ ;;compile time call-attr
-                     afn ;;runtime call-attr
-                     get-item
-                     get-attr
-                     python-type
-                     call-attr
-                     call-attr-kw
-                     att-type-map
-                     ->py-dict]
-             :as py]
-            [clojure.pprint :as pp]))
-
-
-;;Uncomment this line to load a different version of your python shared library:
-
-
-;;(alter-var-root #'libpython-clj.jna.base/*python-library* (constantly "python3.7m"))
-
-
-(py/initialize!)
-
-
-(import-as numpy np)
-(import-as builtins builtins)
-(from-import builtins slice)
-(import-as keras keras)
-(from-import keras.layers Dense)
-(import-as keras.models keras-models)
-(import-as keras.layers keras-layers)
-
-
-(defonce initial-data (a$ np loadtxt "pima-indians-diabetes.data.csv" :delimiter ","))
-
-
-(def features (get-item initial-data [(slice nil) (slice 0 8)]))
-
-(def labels (get-item initial-data [(slice nil) (slice 8 9)]))
-
-(defn dense-layer
-  [output-size & args]
-  (apply py/cfn Dense output-size args))
-
-
-(defn sequential-model
-  []
-  (a$ keras-models Sequential))
-
-
-(defn add-layer!
-  [model layer]
-  (a$ model add layer)
-  model)
-
-(defn compile-model!
-  [model & args]
-  (apply py/afn model "compile" args)
-  model)
-
-
-(def model (-> (sequential-model)
-               (add-layer! (dense-layer 12 :input_dim 8 :activation :relu))
-               (add-layer! (dense-layer 8 :activation :relu))
-               (add-layer! (dense-layer 1 :activation :sigmoid))
-               (compile-model! :loss :binary_crossentropy
-                               :optimizer :adam
-                               :metrics (py/->py-list [:accuracy]))))
-
-(defn fit-model
-  [model features labels & args]
-  (apply py/afn model "fit" features labels args)
-  model)
-
-
-(def fitted-model (fit-model model features labels
-                             :epochs 150
-                             :batch_size 10))
-
-
-(defn eval-model
-  [model features lables]
-  (let [model-names (->> ($. model metrics_names)
-                         (mapv keyword))]
-    (->> (a$ model evaluate features labels)
-         (map vector model-names)
-         (into {}))))
-
-
-(def scores (eval-model fitted-model features labels))
-
-
-(pp/pprint scores)
diff --git a/example/src/matplotlib.clj b/example/src/matplotlib.clj
deleted file mode 100644
index 386beab..0000000
--- a/example/src/matplotlib.clj
+++ /dev/null
@@ -1,73 +0,0 @@
-(ns matplotlib
-  (:require [libpython-clj.python :as py]
-            [tech.v2.datatype :as dtype]
-            [tech.libs.buffered-image :as bufimg]
-            [tech.v2.tensor :as dtt]
-            [clojure.java.io :as io]
-            [clojure.java.shell :as sh]))
-
-(comment
-
-  ;;First let's use matplotlib normally
-
-  (py/initialize!)
-  (def mfig (py/import-module "matplotlib.figure"))
-  (def magg (py/import-module "matplotlib.backends.backend_agg"))
-  (def np (py/import-module "numpy"))
-  (def x (py/call-attr np "linspace" 0 2 100))
-  (py/python-type x)
-  (py/get-attr x "shape")
-  (def plt (py/import-module "matplotlib.pyplot"))
-
-
-  ;; plt.plot(x, x, label='linear')
-  ;; plt.plot(x, x**2, label='quadratic')
-  ;; plt.plot(x, x**3, label='cubic')
-
-  (defn plot-it
-    []
-    (py/call-attr-kw plt "plot" [x x] {"label" "linear"})
-    (py/call-attr-kw plt "plot" [x (py/call-attr x "__pow__" 2)] {"label" "quadratic"})
-    (py/call-attr-kw plt "plot" [x (py/call-attr x "__pow__" 3)] {"label" "cubic"})
-    (py/call-attr plt "xlabel" "x label")
-    (py/call-attr plt "ylabel" "y label")
-    (py/call-attr plt "title" "Simple Plot")
-    (py/call-attr plt "legend"))
-
-  (plot-it)
-
-  (py/call-attr plt "show")
-
-
-
-  ;;Now let's get a version of this in memory on the JVM where we
-  ;;can do something with it.
-
-  (def fig (py/call-attr plt "figure"))
-  (def canvas (py/get-attr fig "canvas"))
-  (def agg-canvas (py/call-attr magg "FigureCanvasAgg" fig))
-  ;; Redo all the drawing above
-  (plot-it)
-
-  (py/call-attr agg-canvas "draw")
-  (def np-data (py/call-attr np "array"
-                             (py/call-attr agg-canvas "buffer_rgba")))
-  (def tens (py/as-tensor np-data))
-
-  (dtype/get-datatype tens)
-  (dtype/shape tens)
-  (dtt/tensor->buffer tens)
-
-  (def bufimage (bufimg/new-image 480 640 :byte-abgr))
-
-  (def ignored (dtype/copy! tens bufimage))
-
-  ;;Now we fix the ordering (RGBA->ABGR):
-
-  (def ignored (-> (dtt/select tens :all :all (->> (range 4)
-                                                   reverse))
-                   (dtype/copy! bufimage)))
-
-  (bufimg/save! bufimage "test.png")
-
-  )
diff --git a/example/src/mxnet_autograd.clj b/example/src/mxnet_autograd.clj
deleted file mode 100644
index 33eca31..0000000
--- a/example/src/mxnet_autograd.clj
+++ /dev/null
@@ -1,63 +0,0 @@
-(ns mxnet-autograd
-  "https://mxnet.incubator.apache.org/api/python/docs/api/autograd/index.html"
-  (:require [libpython-clj.python :as py]))
-
-
-(comment
-
-  (py/initialize!)
-
-  (def mx (py/import-module "mxnet"))
-
-  (def mx-nd (py/get-attr mx "nd"))
-
-  (def autograd (py/get-attr mx "autograd"))
-
-  (def x (py/call-attr mx-nd "ones" 1))
-
-  (py/call-attr x "attach_grad")
-
-  (def z
-    (py/with
-     [r (py/call-attr autograd "record")]
-     (py/call-attr mx-nd "elemwise_add"
-                   (py/call-attr mx-nd "exp" x)
-                   x)))
-  (def dx (py/call-attr-kw autograd "grad" [z [x]] {:create_graph true}))
-
-  (def x (-> (py/call-attr mx-nd "arange" 4)
-             (py/call-attr "reshape" [4 1])))
-
-  (py/call-attr x "attach_grad")
-
-  (def y (py/with
-          [r (py/call-attr autograd "record")]
-          (->> (py/call-attr mx-nd "dot"
-                             (py/get-attr x "T")
-                             x)
-               (py/call-attr mx-nd "multiply" 2))))
-
-  (py/call-attr-kw y "backward" [] {:retain_graph true})
-
-  (py/get-attr x "grad")
-
-  x
-
-
-  (def mx-rand (py/get-attr mx-nd "random"))
-
-  (def x (py/call-attr-kw mx-rand "uniform" [] {:shape 10}))
-
-  (py/call-attr x "attach_grad")
-
-  (def m (py/with
-          [r (py/call-attr autograd "record")]
-          (py/call-attr mx-nd "sigmoid" x)))
-
-
-  (py/call-attr m "backward")
-
-  x
-  (py/get-attr x "grad")
-
-  )
diff --git a/example/src/new_to_clojure.clj b/example/src/new_to_clojure.clj
deleted file mode 100644
index 0e08797..0000000
--- a/example/src/new_to_clojure.clj
+++ /dev/null
@@ -1,155 +0,0 @@
-(ns new-to-clojure
-  "This is a clojure namespace declaration.  This goes at the top, is documented like
-  such and can contain information about how to interpret the rest of this file.
-  For now, we leave it at that.")
-
-
-;; This is a clojure line comment.  From here on out we will place everything in a
-;; comment form which, as we will see, can container evaluatable code.  If you
-;; are in emacs with clojure, leiningen, and cider installed then you can
-;; type C-c,C-e to execute each line.
-
-(comment
-  ;;First, let's talk about Clojure.  This is a a list
-  (list 1 2 3)
-
-  ;;So is this
-  '(list 1 2 3)
-
-  ;;When the reader finds a list it applies the first thing in the list
-  ;;to everything following the first thing.
-
-  (+ 1 2 3)
-
-  ;;If the first thing isn't executable, that is an error
-  (1 2 3)
-
-  ;;Clojure arrays are persisent vectors meaning they are immutable
-  ;;datastructures that have good random access semantics.  They are often
-  ;;used for data because the reader does *not* attempt to execute them.
-  [1 2 3 4]
-
-  (conj [1 2 3 4] 5)
-
-  (map inc [1 2 3 4])
-
-  (filter #(> % 2) [1 2 3 4])
-
-  ;;In Clojure, a dict is called a map and those are also immutable datastructures.
-  ;;We specify them like such:
-  {:a 1 :b 2}
-
-  (assoc {:a 1 :b 2} :c 3)
-
-  (dissoc {:a 1 :b 2} :b)
-
-  (map identity {:a 1 :b 2})
-
-  (into {} (map identity {:a 1 :b 2}))
-
-  (defn gen123plus
-    [x]
-    (map #(+ x %) [1 2 3]))
-
-  (interleave (gen123plus 10) (gen123plus 20))
-
-  (defn zigzag
-    [period]
-    (->> (concat (range period)
-                 (range period, 0 -1))
-         repeat
-         (apply concat)))
-
-  ;;When we want another library, we usually use require expects a clojure library.
-  ;;Because we are on them JVM, we sometimes have to use 'import' which targets a
-  ;;particular class
-
-  (require '[libpython-clj.python :as py])
-
-  (py/initialize!)
-
-  (def test-dict (py/->python {:a 1 :b 2}))
-
-  (py/python-type test-dict)
-
-  (py/att-type-map test-dict)
-
-  (def bridged (py/as-jvm test-dict))
-
-  (def np (py/import-module "numpy"))
-
-  (-> (py/get-attr np "linspace")
-      (py/get-attr "__doc__")
-      print)
-
-  ;; Examples
-  ;; --------
-  ;; >>> np.linspace(2.0, 3.0, num=5)
-  ;; array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])
-
-  (def np-ary (py/call-attr-kw np "linspace" [2.0 3.0] {:num 5}))
-
-  (def tens (py/as-tensor np-ary))
-
-  (map identity tens)
-
-  (require '[tech.v2.datatype :as dtype])
-
-  (dtype/set-value! tens 2 6677)
-
-  (println np-ary)
-
-
-  (def mfig (py/import-module "matplotlib.figure"))
-  (def magg (py/import-module "matplotlib.backends.backend_agg"))
-
-  (def x (py/call-attr np "linspace" 0 2 100))
-
-  (def plt (py/import-module "matplotlib.pyplot"))
-
-  (def fig (py/call-attr plt "figure"))
-  (def canvas (py/get-attr fig "canvas"))
-  (def agg-canvas (py/call-attr magg "FigureCanvasAgg" fig))
-
-  (defn plot-it
-    [x]
-    (py/call-attr-kw plt "plot" [x x] {"label" "linear"})
-    (py/call-attr-kw plt "plot" [x (py/call-attr x "__pow__" 2)]
-                     {"label" "quadratic"})
-    (py/call-attr-kw plt "plot" [x (py/call-attr x "__pow__" 3)]
-                     {"label" "cubic"})
-    (py/call-attr plt "xlabel" "x label")
-    (py/call-attr plt "ylabel" "y label")
-    (py/call-attr plt "title" "Simple Plot")
-    (py/call-attr plt "legend"))
-
-  (plot-it x)
-
-  (py/call-attr agg-canvas "draw")
-  (def np-data (py/call-attr np "array"
-                             (py/call-attr agg-canvas "buffer_rgba")))
-  (def tens (py/as-tensor np-data))
-
-  (require '[tech.v2.tensor :as dtt])
-  (require '[tech.libs.buffered-image :as bufimg])
-
-  (def jvm-img (bufimg/new-image 480 640 :byte-abgr))
-
-  ;;Copy will read the data out in row-major format.
-  (def ignored (dtype/copy! tens jvm-img))
-
-  (bufimg/save! jvm-img "test.png")
-
-  ;;Now in emacs, run M-x auto-image-file-mode`
-  ;;The color of the image is off.  The reason is that the canvas produces an
-  ;;"RGBA" image and java buffered image is ABGR.
-  ;;The fix is to create a view of the tensor that has the last dimension reversed:
-
-  (def tens-view (dtt/select tens :all :all [3 2 1 0]))
-
-  (def ignored (dtype/copy! tens-view jvm-img))
-
-  (bufimg/save! jvm-img "test.png")
-
-  ;;now the image will be correct.
-  )
diff --git a/example/src/walkthrough.clj b/example/src/walkthrough.clj
deleted file mode 100644
index 31c4780..0000000
--- a/example/src/walkthrough.clj
+++ /dev/null
@@ -1,55 +0,0 @@
-(ns walkthough)
-
-
-(comment
-  ;; First step is to initialize library
-  (require '[libpython-clj.python :as py])
-  (py/initialize!)
-
-  ;;The system uses clojure.tools.logging.
-
-
-  ;;'->' means copy, 'as' means bridge.
-
-  (def test-dict (py/->python {:a 1 :b 2}))
-  (py/python-type test-dict)
-
-  ;;This created a 'dict' object in python and returned
-  ;;a pointer to that object.  test-dict is a jna pointer.
-
-  (py/att-type-map test-dict)
-
-  (def bridged (py/as-jvm test-dict))
-
-  ;;bridged implements java.util.Map and as such things like
-  ;;count, get work.
-  ;;to add an element, use the .put method.  Also iteration works
-  ;;but you get back bridged objects.
-  (def back-to-clojure (into {} bridged))
-
-
-  ;;That is fun, and those are the basic mechanics of the language.
-  ;;Now let's actually use something
-
-  (def np (py/import-module "numpy"))
-
-  ;;Lets lookup the function documentation for 'linspace':
-  (-> (py/get-attr np "linspace")
-      (py/get-attr "__doc__")
-      print)
-
-  ;;Examples
-  ;;--------
-  ;;>>> np.linspace(2.0, 3.0, num=5)
-  (def np-ary (py/call-attr-kw np "linspace" [2.0 3.0] {:num 5}))
-
-  ;;Now we can bridge the numpy object into a tensor
-  (def tens (py/as-tensor np-ary))
-
-  ;;This means they share the backing store.
-  (require '[tech.v2.datatype :as dtype])
-  (dtype/set-value! tens 2 6677)
-
-  (vec np-ary)
-  (vec tens)
-  )

From 8d4b86079a7593757f0301b06027282ea5308d8e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 28 Jan 2020 11:39:08 -0700
Subject: [PATCH 165/456] editing

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 65e7f01..30d7407 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,8 @@ JNA libpython bindings to the tech ecosystem.
   of python.
 * REPL oriented design means fast, smooth, iterative development.
 * Carin Meier has written excellent posts on [plotting](http://gigasquidsoftware.com/blog/2020/01/18/parens-for-pyplot/) and
-  [advanced text generation](http://gigasquidsoftware.com/blog/2020/01/10/hugging-face-gpt-with-clojure/).
+  [advanced text generation](http://gigasquidsoftware.com/blog/2020/01/10/hugging-face-gpt-with-clojure/). She also has some
+  great [examples](https://github.com/gigasquid/libpython-clj-examples).
 
 
 ## Vision

From c4bacdfa1b441afb98445f15121850b272c86de7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 28 Jan 2020 11:42:21 -0700
Subject: [PATCH 166/456] editing

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 30d7407..9e04016 100644
--- a/README.md
+++ b/README.md
@@ -127,7 +127,7 @@ our test [docker containers](dockerfiles/CondaDockerfile).
 * [examples](https://github.com/gigasquid/libpython-clj-examples)
 * [docker setup](https://github.com/scicloj/docker-hub)
 * [pandas bindings (!!)](https://github.com/alanmarazzi/panthera)
-* [nextjournal notebook](https://nextjournal.com/chrisn/fun-with-matplotlib)
+* [nextjournal notebooks](https://nextjournal.com/kommen)
 * [scicloj video](https://www.youtube.com/watch?v=ajDiGS73i2o)
 * [Clojure/Python interop technical blog post](www.techascent.com/blogs/functions-across-languages.html)
 * [persistent datastructures in python](https://github.com/tobgu/pyrsistent)

From 3c22831412e96707b8b094205cb93e78d95483df Mon Sep 17 00:00:00 2001
From: Arsene Rei <arsenerei@users.noreply.github.com>
Date: Wed, 29 Jan 2020 13:41:23 -0800
Subject: [PATCH 167/456] Update technical blog post link (#69)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 9e04016..6ec38f6 100644
--- a/README.md
+++ b/README.md
@@ -129,7 +129,7 @@ our test [docker containers](dockerfiles/CondaDockerfile).
 * [pandas bindings (!!)](https://github.com/alanmarazzi/panthera)
 * [nextjournal notebooks](https://nextjournal.com/kommen)
 * [scicloj video](https://www.youtube.com/watch?v=ajDiGS73i2o)
-* [Clojure/Python interop technical blog post](www.techascent.com/blogs/functions-across-languages.html)
+* [Clojure/Python interop technical blog post](http://techascent.com/blog/functions-across-languages.html)
 * [persistent datastructures in python](https://github.com/tobgu/pyrsistent)
 
 

From 72ff8db10b7d3b7bcaca15a3d766f93c3b1a83cc Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 31 Jan 2020 07:16:41 -0700
Subject: [PATCH 168/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 7128ac2..12c07a3 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.33"
+(defproject cnuernber/libpython-clj "1.34-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "EPL-2.0"

From 4322de75f48284f0f1fdfef54732c93ec4e7b546 Mon Sep 17 00:00:00 2001
From: Carin Meier <cmeier@gigasquidsoftware.com>
Date: Sat, 1 Feb 2020 11:52:39 -0500
Subject: [PATCH 169/456] Issue 71 - Clojure deps (#75)

* Initial working of deps template

* Get docker running

* clean up unneeded lein

* Making the docker stuff work right

* clean up docker file

* Simplify aliases

* remove unneeded

* Try for travis

* try again

* Yaml is such a joy

* w/o lein deps

* Add javac

* more docs

* Add clean alias
---
 .gitignore                  |   3 +-
 .travis.yml                 |   9 ++
 README.md                   |  65 +++++++++++
 deps.edn                    |  92 +++++++++++++++
 dev/resources/logback.xml   |  11 ++
 dev/src/build.clj           | 217 ++++++++++++++++++++++++++++++++++++
 dev/src/user.clj            |   9 ++
 dockerfiles/CondaDockerfile |  11 +-
 project.clj                 |  12 --
 scripts/conda-repl          |   4 +-
 scripts/run-conda-docker    |   7 +-
 11 files changed, 412 insertions(+), 28 deletions(-)
 create mode 100644 deps.edn
 create mode 100644 dev/resources/logback.xml
 create mode 100644 dev/src/build.clj
 create mode 100644 dev/src/user.clj
 delete mode 100644 project.clj

diff --git a/.gitignore b/.gitignore
index e3921c6..217fc6e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,4 +10,5 @@ pom.xml.asc
 .nrepl-port
 .hgignore
 .hg/
-__pycache__
\ No newline at end of file
+__pycache__
+.cpcache/
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
index 0d45a34..9dceeb6 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -3,6 +3,15 @@ lein: 2.8.2
 before_install:
   - sudo apt-get -y install python3 python3-pip
   - sudo python3 -mpip install numpy
+  - curl -O https://download.clojure.org/install/linux-install-1.10.1.507.sh
+  - chmod +x linux-install-1.10.1.507.sh
+  - sudo ./linux-install-1.10.1.507.sh
+  - clojure -Sdescribe
 addons:
   apt:
     update: true
+install: clojure -Sdescribe
+script:
+  - clojure -A:javac
+  - clojure -A:test
+
diff --git a/README.md b/README.md
index 6ec38f6..d7fbb98 100644
--- a/README.md
+++ b/README.md
@@ -147,6 +147,71 @@ we have an [introductory document](docs/new-to-clojure.md).
 * [create C ptr from numpy](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.ctypes.html)
 
 
+## How to run project tasks
+This project has java sources in additon to regular clojure sources.
+The build alias have the javac built into the tasks, however for running tests or repl you would
+need to run that as a seperate step if you need to recompile the java classes.
+Example:
+
+- `clojure -A:javac`
+- `clojure -A:test`
+
+Also note, that if you have tools installed you may substitue the `clj` command for `clojure` below:
+
+- `clj -A:test`
+
+
+### Compile Java classes
+
+```bash
+$ clojure -A:javac
+```
+
+### REPL
+
+```bash
+$ clojure -A:repl
+nREPL server started on port 56785 on host localhost - nrepl://localhost:56785
+```
+
+
+### Tests
+
+```bash
+$  clojure -A:test
+```
+
+### Package jar
+
+```bash
+$ clojure -A:jar
+```
+
+### Clean target directory
+
+```bash
+$ clojure -A:clean
+```
+
+
+### Local install
+
+To install jar to local .m2 :
+
+```bash
+$ clojure -A:install
+```
+
+### Deploy to clojars
+
+Put your clojars.org credentials to settings.xml (or uncomment login and password prompt in dev/src/build.clj).
+
+```bash
+$ clojure -A:deploy
+```
+This command will sign jar before deploy, using your gpg key. (see dev/src/build.clj for signing options)
+
+
 
 ## License
 
diff --git a/deps.edn b/deps.edn
new file mode 100644
index 0000000..389864a
--- /dev/null
+++ b/deps.edn
@@ -0,0 +1,92 @@
+{
+ :mvn/repos {"clojars" {:url "https://repo.clojars.org/"}
+             "central" {:url "https://repo1.maven.org/maven2/"}}
+
+ ;; don't change target/classes (do not remove it from :paths and
+ ;; do not rename it, otherwise edit build.clj)
+ ;; uncomment java-src if you have java sources.
+ :paths     ["src" "java" "resources" "target/classes"]
+
+ :deps      {
+             org.clojure/clojure {:mvn/version "1.10.1"}
+             camel-snake-kebab {:mvn/version "0.4.0"}
+             techascent/tech.datatype {:mvn/version "4.72"}
+             org.clojure/data.json {:mvn/version "0.2.7"}}
+
+ :build     {
+             :java-source-paths "java"
+             :javac-options     ["-target" "1.8" "-source" "1.8" "-Xlint:-options"]
+
+             :group-id         "cnuernber"
+             :artifact-id      "libpython-clj"
+             :artifact-version "1.34-SNAPSHOT"
+             :description      "libpython bindings to the techascent ecosystem"
+             :url              "http://github.com/cnuernber/libpython-clj"
+             :scm              {:url "git@github.com:cnuernber/libpython-clj.git"}
+             :license          {:name "EPL-2.0"
+                                :url  "https://www.eclipse.org/legal/epl-2.0/"}}
+
+
+ :aliases   {
+             ;;; clj -A:repl
+             :repl    {:extra-deps  {criterium            {:mvn/version "0.4.5"}
+                                     nrepl                {:mvn/version "0.6.0"}
+                                     healthsamurai/matcho {:mvn/version "0.3.3"}
+                                     hashp                {:mvn/version "0.1.1"}
+                                     badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
+                                                        :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
+                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
+                       :jvm-opts    ["-Duser.timezone=UTC"]
+                       :extra-paths ["dev/src" "resources" "test"]
+                       :main-opts   ["--main" "nrepl.cmdline"]}
+             ;;; clj -A:test
+             :test {:extra-paths ["test" "src/test/clojure"]
+                    :extra-deps {org.clojure/test.check {:mvn/version "RELEASE"}
+                                 com.cognitect/test-runner
+                                 {:git/url "https://github.com/cognitect-labs/test-runner"
+                                  :sha "3cb0a9daf1cb746259dc8309b218f9211ad3b33b"}}
+                    :main-opts ["-m" "cognitect.test-runner"
+                                "-d" "test"
+                                "-d" "src/test/clojure"]}
+
+             ;; clean : clj -A:clean
+             :clean   {:main-opts ["-e" "(load-file,\"dev/src/build.clj\"),(build/clean)"]
+                       :extra-deps {badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
+                                                       :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
+                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
+                       ;;; to supress noisy logs with logback file
+                       :extra-paths ["dev/resources"]}
+                          ;; build jar (compile java, clj files): clj -A:jar
+             :jar     {:main-opts ["-e" "(load-file,\"dev/src/build.clj\"),(build/clean),(build/compile-java),(build/jar)"]
+                       :extra-deps {badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
+                                                       :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
+                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
+                       ;;; to supress noisy logs with logback file
+                       :extra-paths ["dev/resources"]}
+
+             ;; compile java classes only: clj -A:javac
+             :javac   {:main-opts  ["-e" "(load-file,\"dev/src/build.clj\"),(build/compile-java)"]
+                       :extra-deps {badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
+                                                       :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
+                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
+                       ;;; to supress noisy logs with logback file
+                       :extra-paths ["dev/resources"]}
+
+             ;; install to local .m2: clj -A:install
+             :install {:main-opts  ["-e" "(load-file,\"dev/src/build.clj\"),(build/install)"]
+                       :extra-deps {badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
+                                                       :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
+                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
+                        ;;; to supress noisy logs with logback file
+                       :extra-paths ["dev/resources"]}
+
+             ;; public to clojars: clj -A:deploy
+             :deploy  {:main-opts  ["-e" "(load-file,\"dev/src/build.clj\"),(build/deploy)"]
+                       :extra-deps {badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
+                                                       :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
+                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
+                        ;;; to supress noisy logs with logback file
+                       :extra-paths ["dev/resources"]}}}
+
+
+
diff --git a/dev/resources/logback.xml b/dev/resources/logback.xml
new file mode 100644
index 0000000..b70d039
--- /dev/null
+++ b/dev/resources/logback.xml
@@ -0,0 +1,11 @@
+<configuration>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
+    </encoder>
+  </appender>
+ 
+  <root level="warn">
+    <appender-ref ref="STDOUT" />
+  </root>
+</configuration>
diff --git a/dev/src/build.clj b/dev/src/build.clj
new file mode 100644
index 0000000..8655466
--- /dev/null
+++ b/dev/src/build.clj
@@ -0,0 +1,217 @@
+(ns build
+  (:require [badigeon.clean :as clean]
+            [badigeon.classpath :as classpath]
+            [badigeon.javac :as javac]
+            [badigeon.jar :as jar]
+            [badigeon.install :as install]
+            [badigeon.sign :as sign]
+            [badigeon.deploy :as deploy]
+            [badigeon.pom :as pom]
+            [clojure.tools.deps.alpha.reader :as deps-reader]
+            [clojure.data.xml :as xml]
+            [clojure.string :as str]
+            [clojure.data.xml.tree :as tree]
+            [clojure.data.xml.event :as event]
+            [clojure.java.io :as io])
+  (:import (java.util.jar JarEntry JarOutputStream)
+           (java.nio.file Path Paths)
+           [java.io File Reader ByteArrayOutputStream]
+           [clojure.data.xml.node Element]
+           (java.net URI)))
+
+
+(def deps-content (deps-reader/slurp-deps "deps.edn"))
+(def java-src-folder (-> deps-content :build :java-source-paths))
+(def javac-options (-> deps-content :build :javac-options))
+(def group-id (-> deps-content :build :group-id))
+(def artifact-id (-> deps-content :build :artifact-id))
+(def group-artefact-id (symbol (str group-id "/" artifact-id)))
+(def artifact-version (-> deps-content :build :artifact-version))
+(def artifact-description (-> deps-content :build :description))
+(def artifact-url (-> deps-content :build :url))
+(def artifact-scm (-> deps-content :build :scm))
+(def artifact-license (-> deps-content :build :license))
+(def jar-name (str "target/" artifact-id "-" artifact-version ".jar"))
+
+
+(defn clean
+  []
+  (clean/clean "target"
+    {;; By default, clean does not allow deleting folders outside the target directory,
+     ;; unless :allow-outside-target? is true
+     :allow-outside-target? false}))
+
+(defn make-classpath
+  []
+  ;; Builds a classpath by using the provided deps spec or, by default, the deps.edn file of the current project.
+  ;; Returns the built classpath as a string.
+
+  (classpath/make-classpath))
+
+(defn compile-java
+  ([emit-path]
+   ;; Compile java sources under the java-src-folder directory
+   (when java-src-folder
+     (javac/javac java-src-folder {;; Emit class files to the target/classes directory
+                                   :compile-path  emit-path
+                                   ;; Additional options used by the javac command
+                                   :javac-options javac-options})))
+  ([]
+   (compile-java "target/classes")))
+
+
+(defn- parse-xml
+  [^Reader rdr]
+  (let [roots (tree/seq-tree
+                event/event-element event/event-exit? event/event-node
+                (xml/event-seq rdr {:include-node? #{:element :characters :comment}}))]
+    (first (filter #(instance? Element %) (first roots)))))
+
+
+(xml/alias-uri 'ppom "http://maven.apache.org/POM/4.0.0")
+
+(defn- add-extra-stuff->pom
+  []
+  (let [pom-file (io/file "pom.xml")
+        pom      (with-open [rdr (io/reader pom-file)]
+                   (-> rdr
+                     parse-xml))
+        pom      (if artifact-url
+                   (#'badigeon.pom/xml-update pom [::ppom/url] (xml/sexp-as-element [::ppom/url artifact-url]))
+                   pom)
+        pom      (if artifact-description
+                   (#'badigeon.pom/xml-update pom [::ppom/description] (xml/sexp-as-element [::ppom/description artifact-description]))
+                   pom)
+        pom      (if artifact-scm
+                   (#'badigeon.pom/xml-update pom [::ppom/scm] (xml/sexp-as-element [::ppom/scm [::ppom/url (:url artifact-scm)]]))
+                   pom)
+        pom      (if artifact-license
+                   (#'badigeon.pom/xml-update pom [::ppom/license] (xml/sexp-as-element [::ppom/licenses
+                                                                                         [::ppom/license
+                                                                                          [::ppom/url (or (:url artifact-license) "")]
+                                                                                          [::ppom/name (or (:name artifact-license)) ""]]]))
+
+                   pom)]
+
+
+    (spit pom-file (str/replace (xml/indent-str pom) #"\n\s+\n" "\n"))
+    (spit pom-file "<!-- This file was autogenerated by build script.
+    Please do not edit it directly; instead edit deps.edn and regenerate it.
+    It should not be considered canonical data. For more information see dev/src/build.clj -->" :append true)))
+
+(defn make-pom
+  []
+  (when (.exists (io/file "pom.xml"))
+    (io/delete-file "pom.xml"))
+  (let [lib          (symbol group-artefact-id)
+        maven-coords {:mvn/version artifact-version}]
+    (pom/sync-pom lib maven-coords (-> (deps-reader/slurp-deps "deps.edn")))
+    (add-extra-stuff->pom)))
+
+(defn jar
+  []
+  (when (.exists (io/file "pom.xml"))
+    (io/delete-file "pom.xml"))
+  ;; Package the project into a jar file
+  (jar/jar group-artefact-id {:mvn/version artifact-version}
+    {;; The jar file produced.
+     :out-path                jar-name
+     ;;;; Adds a \"Main\" entry to the jar manifest with the value
+     ;;:main                    main-ns
+     ;; Additional key/value pairs to add to the jar manifest. If a value is a collection, a manifest section is built for it.
+     ;;:manifest                {"Project-awesome-level" "super-great"
+     ;;                          :my-section-1           [["MyKey1" "MyValue1"] ["MyKey2" "MyValue2"]]
+     ;;                          :my-section-2           {"MyKey3" "MyValue3" "MyKey4" "MyValue4"}}
+
+     ;; By default Badigeon add entries for all files in the directory listed in the
+     ;; :paths section of the deps.edn file. This can be overridden here.
+     ;;:paths                   ["src" "target/classes" "java-src"]
+
+     ;; The dependencies to be added to the \"dependencies\" section of the pom.xml file.
+     ;; When not specified, defaults to the :deps entry of the deps.edn file, without
+     ;; merging the user-level and system-level deps.edn files
+     ;;:deps                    '{org.clojure/clojure {:mvn/version "1.10.1"}}
+     ;; The repositories to be added to the \"repositories\" section of the pom.xml file.
+     ;; When not specified, default to nil - even if the deps.edn files contains
+     ;; a :mvn/repos entry.
+     :mvn/repos               '{"clojars" {:url "https://repo.clojars.org/"}}
+     ;; A predicate used to excludes files from beeing added to the jar.
+     ;; The predicate is a function of two parameters: The path of the directory
+     ;; beeing visited (among the :paths of the project) and the path of the file
+     ;; beeing visited under this directory.
+     :exclusion-predicate     badigeon.jar/default-exclusion-predicate
+     ;; A function to add files to the jar that would otherwise not have been added to it.
+     ;; The function must take two parameters: the path of the root directory of the
+     ;; project and the file being visited under this directory. When the function
+     ;; returns a falsy value, the file is not added to the jar. Otherwise the function
+     ;; must return a string which represents the path within the jar where the file
+     ;; is copied.
+     ;; :inclusion-path          (partial badigeon.jar/default-inclusion-path "badigeon" "badigeon")
+     ;; By default git and local dependencies are not allowed. Set allow-all-dependencies? to true to allow them
+     :allow-all-dependencies? true})
+  (add-extra-stuff->pom)
+  (println "Successfully created jar file: " jar-name))
+
+
+
+(defn install
+  []
+  ;; Install the created jar file into the local maven repository.
+  (let [local-repo (str (System/getProperty "user.home") "/.m2/repository")]
+    (install/install group-artefact-id {:mvn/version artifact-version}
+      ;; The jar file to be installed
+      jar-name
+      ;; The pom.xml file to be installed. This file is generated when creating the jar with the badigeon.jar/jar function.
+      "pom.xml"
+      {;; The local repository where the jar should be installed.
+       :local-repo local-repo})
+    (println "Successfully installed to local repo: " local-repo)))
+
+(defn deploy
+  []
+  ;; Deploy the  created jar file to a remote repository.
+  (let [;; Artifacts are maps with a required :file-path key and an optional :extension key
+        artifacts [{:file-path jar-name :extension "jar"}
+                   {:file-path "pom.xml" :extension "pom"}]
+        ;; Artifacts must be signed when deploying non-snapshot versions of artifacts.
+        artifacts (badigeon.sign/sign artifacts {;; The gpg command can be customized
+                                                 :command "gpg"})]
+    ;; The gpg key used for signing. Defaults to the first private key found in your keyring.
+    ;;:gpg-key "root@eruditorum.org"
+
+
+    ;;  default to reading the credentials from ~/.m2/settings.xml. uncomment to prompt user credentials.
+    ;;;; Prompt for a username
+    ;;username (badigeon.prompt/prompt "Username (clojars): ")
+    ;;;; Prompt for a password using the process standard input and without echoing.
+    ;;password (badigeon.prompt/prompt-password "Password (clojars): ")
+
+    (badigeon.deploy/deploy
+      group-artefact-id artifact-version
+      artifacts
+      {;; :id is used to match the repository in the ~/.m2/settings.xml for credentials when no credentials are explicitly provided.
+       :id  "clojars"
+       ;; The URL of the repository to deploy to.
+       :url "https://repo.clojars.org/"}
+      {
+       ;; Take creds from ~/.m2/settings.xml
+
+       ;; The credentials used when authenticating to the remote repository.
+       ;; When none is provided, default to reading the credentials from ~/.m2/settings.xml
+       ;;:credentials {:username username :password password
+       ;;              ;;:private-key "/path/to/private-key" :passphrase "passphrase"
+       ;;              }
+       ;; When allow-unsigned? is false, artifacts must be signed when deploying non-snapshot versions of artifacts. Default to false.
+       :allow-unsigned? false})
+    (println "Success!")))
+
+(comment
+  (def cp (make-classpath))
+  (clean)
+  (compile-java)
+  (extract-classes-from-deps)
+  (make-pom)
+  (add-extra-stuff->pom)
+  (jar)
+  (install))
+
diff --git a/dev/src/user.clj b/dev/src/user.clj
new file mode 100644
index 0000000..94ca101
--- /dev/null
+++ b/dev/src/user.clj
@@ -0,0 +1,9 @@
+(ns user)
+
+;; debug print with #p
+(require 'hashp.core)
+
+(def dev-mode true)
+(println "***************************")
+(println {:msg "dev mode" :status (if (true? dev-mode) "on" "off")})
+(println "***************************")
diff --git a/dockerfiles/CondaDockerfile b/dockerfiles/CondaDockerfile
index 385da77..bdc956b 100644
--- a/dockerfiles/CondaDockerfile
+++ b/dockerfiles/CondaDockerfile
@@ -3,6 +3,8 @@ FROM ubuntu:latest
 
 # Updating Ubuntu packages
 
+ARG CLOJURE_TOOLS_VERSION=1.10.1.507
+
 
 RUN apt-get -qq update && apt-get -qq -y install curl wget bzip2 openjdk-8-jdk-headless \
     && curl -sSL https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -o /tmp/miniconda.sh \
@@ -10,12 +12,9 @@ RUN apt-get -qq update && apt-get -qq -y install curl wget bzip2 openjdk-8-jdk-h
     && rm -rf /tmp/miniconda.sh \
     && conda install -y python=3 \
     && conda update conda \
-    && curl -O https://download.clojure.org/install/linux-install-1.10.1.492.sh \
-    && chmod +x linux-install-1.10.1.492.sh \
-    && ./linux-install-1.10.1.492.sh && rm linux-install-1.10.1.492.sh \
-    && wget https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein \
-    && chmod a+x lein \
-    && mv lein /usr/bin \
+    && curl -o install-clojure https://download.clojure.org/install/linux-install-${CLOJURE_TOOLS_VERSION}.sh \
+    && chmod +x install-clojure \
+    && ./install-clojure && rm install-clojure \
     && apt-get -qq -y autoremove \
     && apt-get autoclean \
     && rm -rf /var/lib/apt/lists/* /var/log/dpkg.log \
diff --git a/project.clj b/project.clj
deleted file mode 100644
index 12c07a3..0000000
--- a/project.clj
+++ /dev/null
@@ -1,12 +0,0 @@
-(defproject cnuernber/libpython-clj "1.34-SNAPSHOT"
-  :description "libpython bindings to the techascent ecosystem"
-  :url "http://github.com/cnuernber/libpython-clj"
-  :license {:name "EPL-2.0"
-            :url "https://www.eclipse.org/legal/epl-2.0/"}
-  :dependencies [[org.clojure/clojure "1.10.1"]
-                 [camel-snake-kebab "0.4.0"]
-                 [techascent/tech.datatype "4.72"]
-                 [org.clojure/data.json "0.2.7"]]
-  :profiles {:dev {:dependencies [[criterium "0.4.5"]]}}
-  :repl-options {:init-ns user}
-  :java-source-paths ["java"])
diff --git a/scripts/conda-repl b/scripts/conda-repl
index 17a78c8..2c68746 100755
--- a/scripts/conda-repl
+++ b/scripts/conda-repl
@@ -6,7 +6,5 @@ source activate pyclj
 ## https://github.com/conda/conda/issues/9500#issuecomment-565753807
 export LD_LIBRARY_PATH="$(python3-config --prefix)/lib"
 
+clojure -A:repl -b 0.0.0.0 -p 2222
 
-lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
-     -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
-     -- repl :headless :host localhost
diff --git a/scripts/run-conda-docker b/scripts/run-conda-docker
index 479e83e..0299e0b 100755
--- a/scripts/run-conda-docker
+++ b/scripts/run-conda-docker
@@ -3,12 +3,7 @@
 scripts/build-conda-docker
 
 docker run --rm -it -u $(id -u):$(id -g) \
-  -e LEIN_REPL_HOST="0.0.0.0" \
   -v /$HOME/.m2:/home/$USER/.m2 \
-  -v /$HOME/.lein:/home/$USER/.lein \
   -v $(pwd)/:/libpython-clj \
-  --net=host -w /libpython-clj \
+  -p 2222:2222 -w /libpython-clj \
   docker-conda scripts/conda-repl
-     # lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
-     #   -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
-     #   -- repl :headless :host localhost

From b0417a9f4f0a940e23b0916ad81460adb86aadd1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 1 Feb 2020 11:13:23 -0700
Subject: [PATCH 170/456] upgraded tech.datatype for fixed tech.parallel

---
 deps.edn | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/deps.edn b/deps.edn
index 389864a..8f34b3b 100644
--- a/deps.edn
+++ b/deps.edn
@@ -10,7 +10,7 @@
  :deps      {
              org.clojure/clojure {:mvn/version "1.10.1"}
              camel-snake-kebab {:mvn/version "0.4.0"}
-             techascent/tech.datatype {:mvn/version "4.72"}
+             techascent/tech.datatype {:mvn/version "4.73"}
              org.clojure/data.json {:mvn/version "0.2.7"}}
 
  :build     {
@@ -87,6 +87,3 @@
                                     ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
                         ;;; to supress noisy logs with logback file
                        :extra-paths ["dev/resources"]}}}
-
-
-

From 7ead006e67d2675ab4919e487cabb8b3401cba7e Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sat, 1 Feb 2020 18:05:56 -0500
Subject: [PATCH 171/456] ISSUE-72: datafy/nav extensibility for arbitrary
 Python objects (#73)

* make datafy/nav extensible

* update CHANGELOG.md

* fix tests

* fix docstring

* spacing

* no :reload true

* dispatch on symbols over strings

* dispatch on symbols over strings

* add support for datafy for more complex types

* refactor for style

* eliminate redundancy

* cleaner macro syntax

* fix url
---
 CHANGELOG.md                               |   9 +-
 src/libpython_clj/metadata.clj             |  80 +++++++--------
 src/libpython_clj/require.clj              | 109 ++++++++++++++++++++-
 test/libpython_clj/require_python_test.clj |  19 +++-
 4 files changed, 169 insertions(+), 48 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 24763ee..ba42fb1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,13 @@
 
 * [Examples are now done by gigasquid](https://github.com/gigasquid/libpython-clj-examples)
 
+* [datafy/nav](https://clojure.github.io/clojure/branch-master/clojure.datafy-api.html) are now extensible for custom Python objects. 
+  Extend `libpython-clj.require/pydafy` and `libpython-clj.require/pynav` 
+  respectively with the symbol of class you want to extend. See 
+  respective docstrings for details.
+  
+* bugfix -- python.str now loaded by `import-python`
+
 ## 1.33
 
 * Better [windows anaconda support](https://github.com/cnuernber/libpython-clj/pull/67)
@@ -44,7 +51,7 @@
   ```
   (**Note**: this is done for you by the function `libpython-clj.require/import-python`)
   
-  This fix brought to you by [jjtolten](https://github.com/jjtolton).
+  This fix brought to you by [jjtolton](https://github.com/jjtolton).
   
 
 ## 1.32
diff --git a/src/libpython_clj/metadata.clj b/src/libpython_clj/metadata.clj
index b38669f..9ee4bc0 100644
--- a/src/libpython_clj/metadata.clj
+++ b/src/libpython_clj/metadata.clj
@@ -205,48 +205,44 @@
   (or (string? att-val)
       (number? att-val)))
 
-
-(extend-type PPyObject
-  clj-proto/Datafiable
-  (datafy [item]
-    (with-meta
-      (with-gil
-        (->> (if (or (pyclass? item)
-                     (pymodule? item))
-               (-> (vars item)
-                   (py-proto/as-map))
-               (->> (py/dir item)
-                    (map (juxt identity #(get-attr item %)))))
-             (map (fn [[att-name att-val]]
-                    (when att-val
-                      (try
-                        [att-name
-                         (merge (base-pyobj-map att-val)
-                                (when (callable? att-val)
-                                  (py-fn-metadata att-name att-val {}))
-                                (when (scalar? att-val)
-                                  {:value att-val}))]
-                        (catch Throwable e
-                          (log/warnf "Metadata generation failed for %s:%s"
-                                     (.toString item)
-                                     att-name)
-                          nil)))))
-             (remove nil?)
-             (into (base-pyobj-map item))))
-      {`clj-proto/nav
-       (fn nav-pyval
-         [coll f val]
-         (if (map? val)
-           (cond
-             (= :module (:type val))
-             (as-jvm (import-module (:name val)) {})
-             (= :type (:type val))
-             (let [mod (as-jvm (import-module (:module val)) {})
-                   cls-obj (get-attr mod (:name val))]
-               cls-obj)
-             :else
-             val)
-           val))})))
+(defn datafy-module [item]
+  (with-gil
+    (->> (if (or (pyclass? item)
+                 (pymodule? item))
+           (-> (vars item)
+               (py-proto/as-map))
+           (->> (py/dir item)
+                (map (juxt identity #(get-attr item %)))))
+         (map (fn [[att-name att-val]]
+                (when att-val
+                  (try
+                    [att-name
+                     (merge (base-pyobj-map att-val)
+                            (when (callable? att-val)
+                              (py-fn-metadata att-name att-val {}))
+                            (when (scalar? att-val)
+                              {:value att-val}))]
+                    (catch Throwable e
+                      (log/warnf "Metadata generation failed for %s:%s"
+                                 (.toString item)
+                                 att-name)
+                      nil)))))
+         (remove nil?)
+         (into (base-pyobj-map item)))))
+
+(defn nav-module [coll f val]
+  (with-gil
+    (if (map? val)
+      (cond
+        (= :module (:type val))
+        (as-jvm (import-module (:name val)) {})
+        (= :type (:type val))
+        (let [mod (as-jvm (import-module (:module val)) {})
+              cls-obj (get-attr mod (:name val))]
+          cls-obj)
+        :else
+        val)
+      val)))
 
 
 (defn module-path-string
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 11399fc..0513309 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -4,11 +4,15 @@
             [libpython-clj.metadata :as pymeta]
             [clojure.datafy :refer [datafy nav]]
             ;;Binds datafy/nav to python objects
-            [libpython-clj.metadata]
-            [clojure.tools.logging :as log]))
+            [libpython-clj.metadata :as metadata]
+            [clojure.tools.logging :as log]
+            [libpython-clj.python.protocols :as py-proto]
+            [clojure.core.protocols :as clj-proto])
+  (:import [libpython_clj.python.protocols PPyObject PBridgeToJVM]))
 
 ;; for hot reloading multimethod in development
 (ns-unmap 'libpython-clj.require 'intern-ns-class)
+(ns-unmap *ns* 'pydafy)
 
 
 (defn- parse-flags
@@ -290,7 +294,106 @@
      [dict :as python.dict]
      [set :as python.set]
      [tuple :as python.tuple]
-     [frozenset :as python.frozenset])
+     [frozenset :as python.frozenset]
+     [str :as python.str])
    '[builtins :as python])
   :ok)
 
+
+(def ^:private builtins (py/import-module "builtins"))
+
+
+(def ^:private pytype   (comp symbol str (py/get-attr builtins "type")))
+
+
+(defmulti pydafy
+  "Turn a Python object into Clojure data.  Metadata of Clojure
+     data will automatically be merged with nav protocol.
+
+     Extend this method to convert a custom Python object into Clojure data.
+     Extend pynav if you would like to nav the resulting Clojure data.
+
+     Note: we don't have a way yet to use a 'python type' as a 'jvm class',
+     so you need to extend with the symbol of the object name. I know it's
+     an ugly hack. Sorry. See examples in libpython-clj.require."
+  pytype)
+
+(defmulti pynav
+  "Nav data from a Python object.
+  
+     Extend this method to nav a custom Python object into Clojure data.
+     Extend pydafy if you would like to datafy a Python object.
+
+     Note: we don't have a way yet to use a 'python type' as a 'jvm class',
+     so you need to extend with the symbol of the object name. I know it's
+     an ugly hack. Sorry. See examples in libpython-clj.require."
+  (fn [coll k v] (pytype coll)))
+
+
+(defmethod pydafy :default [x]
+  (if (metadata/pyclass? x)
+    (metadata/datafy-module x)
+    (throw (ex-info (str "datafy not implemented for " (pytype x))
+                    {:type (pytype x)}))))
+
+
+(defmethod pynav :default [x]
+  (if (metadata/pyclass? x)
+    (metadata/nav-module x)
+    (throw (ex-info (str "nav not implemented for " (pytype x))
+                    {:type (pytype x)}))))
+
+
+(defmethod pydafy 'builtins.module [m]
+  (metadata/datafy-module m))
+
+
+(defmethod pynav 'builtins.module [coll k v]
+  (metadata/nav-module coll k v))
+
+
+(defmethod pydafy 'builtins.dict [x]
+  (py/->jvm x))
+
+
+(defn ^:private py-datafy [item]
+  (let [res (pydafy item)
+        m   (meta res)]
+    (try
+      (with-meta 
+        res
+        (merge
+         {'clj-proto/nav pynav}
+         m))
+      (catch ClassCastException _
+        ;; presumably metadata doesn't work for this type
+        res))))
+
+
+(defn ^:private py-nav [coll k v]
+  (let [res (pynav coll k v)
+        m   (meta res)]
+    (try
+      (with-meta
+        res
+        (merge
+         {'clj-proto/datafy pydafy}
+         m))
+      (catch ClassCastException _
+        ;; presumably metadata doesn't work for this type
+        res))))
+
+
+(defmacro pydatafy [& types]
+  ;; credit: Tom Spoon
+  ;; https://clojurians.zulipchat.com/#narrow/stream/215609-libpython-clj-dev/topic/feature-requests/near/187056819
+  `(do ~@(for [t types]
+           `(extend-type ~t
+              clj-proto/Datafiable
+              (datafy [item#] (py-datafy item#))
+              clj-proto/Navigable
+              (nav [coll# k# v#] (py-nav coll# k# v#))))))
+
+
+(pydatafy PPyObject PBridgeToJVM)
+
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index e2c5c85..a79b39b 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -1,8 +1,10 @@
 (ns libpython-clj.require-python-test
-  (:require [libpython-clj.require :as req :refer [require-python]
+  (:require [libpython-clj.require :as req
+             :refer [require-python pydafy pynav]
              :reload true]
             [libpython-clj.python :as py]
-            [clojure.test :refer :all]))
+            [clojure.test :refer :all]
+            [clojure.datafy :refer [datafy nav]]))
 
 ;; Since this test mutates the global environment we have to accept that
 ;; it may not always work.
@@ -100,6 +102,19 @@
     (is (= (req-transform 'a '[b :as c :refer [blah] :flagA])
            '[a.b :as c :refer [blah] :flagA]))))
 
+(deftest datafy-test
+
+  (defmethod pydafy 'builtins.list [x]
+    (vec x))
+
+  (is (vector? (datafy (python/list [1 2 3]))))
+
+  (defmethod pydafy 'builtins.frozenset [x]
+    (set x))
+
+  (is (set? (datafy (python/frozenset [1 2 3])))))
+
+
 
 (deftest import-python-test
   (is (= :ok (libpython-clj.require/import-python))))

From e6be3a9e8fa24f112d0ff13b60da0fbe76f49aee Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Feb 2020 09:45:13 -0700
Subject: [PATCH 172/456] Adding back project.clj for a more complete build
 system

---
 project.clj | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 project.clj

diff --git a/project.clj b/project.clj
new file mode 100644
index 0000000..1d379fd
--- /dev/null
+++ b/project.clj
@@ -0,0 +1,11 @@
+(defproject cnuernber/libpython-clj "1.34-SNAPSHOT"
+  :description "libpython bindings to the techascent ecosystem"
+  :url "http://github.com/cnuernber/libpython-clj"
+  :license {:name "Eclipse Public License"
+            :url  "http://www.eclipse.org/legal/epl-v10.html"}
+  :plugins [[lein-tools-deps "0.4.5"]]
+  :middleware [lein-tools-deps.plugin/resolve-dependencies-with-deps-edn]
+  :lein-tools-deps/config {:config-files [:install :user :project]}
+  :profiles {:dev {:lein-tools-deps/config {:resolve-aliases [:test]}}
+             :uberjar {:aot :all}}
+  :java-source-paths ["java"])

From 13403cf6bff1e7427e89eaa7a71a53bb949b8aa1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Feb 2020 09:50:52 -0700
Subject: [PATCH 173/456] 1.34

---
 deps.edn    | 2 +-
 project.clj | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/deps.edn b/deps.edn
index 8f34b3b..2bfa4a8 100644
--- a/deps.edn
+++ b/deps.edn
@@ -5,7 +5,7 @@
  ;; don't change target/classes (do not remove it from :paths and
  ;; do not rename it, otherwise edit build.clj)
  ;; uncomment java-src if you have java sources.
- :paths     ["src" "java" "resources" "target/classes"]
+ :paths     ["src" "java"]
 
  :deps      {
              org.clojure/clojure {:mvn/version "1.10.1"}
diff --git a/project.clj b/project.clj
index 1d379fd..9d83c90 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.34-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.34"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 6f9dfde064c9d975c8fa321e4147fddba5beb533 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Feb 2020 09:51:22 -0700
Subject: [PATCH 174/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 9d83c90..4c40ea6 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.34"
+(defproject cnuernber/libpython-clj "1.35-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From e4b080bbf11eaaaab08c185823d8b39463c68073 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Feb 2020 09:52:24 -0700
Subject: [PATCH 175/456] 1.35

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 4c40ea6..0c6cbc3 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.35-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.35"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From f5c73698c139adde85fd52c33d1e4512d90eb50c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Feb 2020 09:52:31 -0700
Subject: [PATCH 176/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 0c6cbc3..9f4cda1 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.35"
+(defproject cnuernber/libpython-clj "1.36-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 70dc24f78a28cb5136511a39b4d80de927954e8f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Feb 2020 10:20:26 -0700
Subject: [PATCH 177/456] upgraded core.async to latest

---
 deps.edn | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/deps.edn b/deps.edn
index 2bfa4a8..c5c879b 100644
--- a/deps.edn
+++ b/deps.edn
@@ -5,12 +5,12 @@
  ;; don't change target/classes (do not remove it from :paths and
  ;; do not rename it, otherwise edit build.clj)
  ;; uncomment java-src if you have java sources.
- :paths     ["src" "java"]
+ :paths     ["src" "java" "resources" "target/classes"]
 
  :deps      {
              org.clojure/clojure {:mvn/version "1.10.1"}
              camel-snake-kebab {:mvn/version "0.4.0"}
-             techascent/tech.datatype {:mvn/version "4.73"}
+             techascent/tech.datatype {:mvn/version "4.74"}
              org.clojure/data.json {:mvn/version "0.2.7"}}
 
  :build     {
@@ -19,7 +19,7 @@
 
              :group-id         "cnuernber"
              :artifact-id      "libpython-clj"
-             :artifact-version "1.34-SNAPSHOT"
+             :artifact-version "1.36-SNAPSHOT"
              :description      "libpython bindings to the techascent ecosystem"
              :url              "http://github.com/cnuernber/libpython-clj"
              :scm              {:url "git@github.com:cnuernber/libpython-clj.git"}

From 9c6622a6f03d752961cea64c44a78ba0aeb86add Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Feb 2020 10:34:20 -0700
Subject: [PATCH 178/456] 1.36

---
 CHANGELOG.md | 11 ++++++++++-
 deps.edn     |  2 +-
 project.clj  |  2 +-
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ba42fb1..c37f2ad 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,11 @@
 # Time for a ChangeLog!
 
-## 1.34-SNAPSHOT
+## 1.36 
+
+* clojure.core.async upgrade
+
+
+## 1.35
 
 * [Examples are now done by gigasquid](https://github.com/gigasquid/libpython-clj-examples)
 
@@ -11,6 +16,10 @@
   
 * bugfix -- python.str now loaded by `import-python`
 
+
+## 1.34
+ * Skipped due to build system issues.
+
 ## 1.33
 
 * Better [windows anaconda support](https://github.com/cnuernber/libpython-clj/pull/67)
diff --git a/deps.edn b/deps.edn
index c5c879b..ba9d381 100644
--- a/deps.edn
+++ b/deps.edn
@@ -5,7 +5,7 @@
  ;; don't change target/classes (do not remove it from :paths and
  ;; do not rename it, otherwise edit build.clj)
  ;; uncomment java-src if you have java sources.
- :paths     ["src" "java" "resources" "target/classes"]
+ :paths     ["src" "java"]
 
  :deps      {
              org.clojure/clojure {:mvn/version "1.10.1"}
diff --git a/project.clj b/project.clj
index 9f4cda1..5325ab6 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.36-SNAPSHOT"
+(defproject cnuernber/libpython-clj "1.36"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 374284ef181f640e9dfca8bfa155dd015ce1498f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Feb 2020 10:34:51 -0700
Subject: [PATCH 179/456] snap

---
 deps.edn    | 2 +-
 project.clj | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/deps.edn b/deps.edn
index ba9d381..c5c879b 100644
--- a/deps.edn
+++ b/deps.edn
@@ -5,7 +5,7 @@
  ;; don't change target/classes (do not remove it from :paths and
  ;; do not rename it, otherwise edit build.clj)
  ;; uncomment java-src if you have java sources.
- :paths     ["src" "java"]
+ :paths     ["src" "java" "resources" "target/classes"]
 
  :deps      {
              org.clojure/clojure {:mvn/version "1.10.1"}
diff --git a/project.clj b/project.clj
index 5325ab6..fbe8e7d 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.36"
+(defproject cnuernber/libpython-clj "1.37-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 4ab6846531188d826a74b221b559351363602240 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 4 Feb 2020 07:09:24 -0700
Subject: [PATCH 180/456] Moving back to lein on main branch for now

---
 deps.edn                    |  89 ---------------
 dev/resources/logback.xml   |  11 --
 dev/src/build.clj           | 217 ------------------------------------
 dev/src/user.clj            |   9 --
 dockerfiles/CondaDockerfile |   3 +
 project.clj                 |  10 +-
 scripts/conda-repl          |   4 +-
 7 files changed, 11 insertions(+), 332 deletions(-)
 delete mode 100644 deps.edn
 delete mode 100644 dev/resources/logback.xml
 delete mode 100644 dev/src/build.clj
 delete mode 100644 dev/src/user.clj

diff --git a/deps.edn b/deps.edn
deleted file mode 100644
index c5c879b..0000000
--- a/deps.edn
+++ /dev/null
@@ -1,89 +0,0 @@
-{
- :mvn/repos {"clojars" {:url "https://repo.clojars.org/"}
-             "central" {:url "https://repo1.maven.org/maven2/"}}
-
- ;; don't change target/classes (do not remove it from :paths and
- ;; do not rename it, otherwise edit build.clj)
- ;; uncomment java-src if you have java sources.
- :paths     ["src" "java" "resources" "target/classes"]
-
- :deps      {
-             org.clojure/clojure {:mvn/version "1.10.1"}
-             camel-snake-kebab {:mvn/version "0.4.0"}
-             techascent/tech.datatype {:mvn/version "4.74"}
-             org.clojure/data.json {:mvn/version "0.2.7"}}
-
- :build     {
-             :java-source-paths "java"
-             :javac-options     ["-target" "1.8" "-source" "1.8" "-Xlint:-options"]
-
-             :group-id         "cnuernber"
-             :artifact-id      "libpython-clj"
-             :artifact-version "1.36-SNAPSHOT"
-             :description      "libpython bindings to the techascent ecosystem"
-             :url              "http://github.com/cnuernber/libpython-clj"
-             :scm              {:url "git@github.com:cnuernber/libpython-clj.git"}
-             :license          {:name "EPL-2.0"
-                                :url  "https://www.eclipse.org/legal/epl-2.0/"}}
-
-
- :aliases   {
-             ;;; clj -A:repl
-             :repl    {:extra-deps  {criterium            {:mvn/version "0.4.5"}
-                                     nrepl                {:mvn/version "0.6.0"}
-                                     healthsamurai/matcho {:mvn/version "0.3.3"}
-                                     hashp                {:mvn/version "0.1.1"}
-                                     badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
-                                                        :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
-                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
-                       :jvm-opts    ["-Duser.timezone=UTC"]
-                       :extra-paths ["dev/src" "resources" "test"]
-                       :main-opts   ["--main" "nrepl.cmdline"]}
-             ;;; clj -A:test
-             :test {:extra-paths ["test" "src/test/clojure"]
-                    :extra-deps {org.clojure/test.check {:mvn/version "RELEASE"}
-                                 com.cognitect/test-runner
-                                 {:git/url "https://github.com/cognitect-labs/test-runner"
-                                  :sha "3cb0a9daf1cb746259dc8309b218f9211ad3b33b"}}
-                    :main-opts ["-m" "cognitect.test-runner"
-                                "-d" "test"
-                                "-d" "src/test/clojure"]}
-
-             ;; clean : clj -A:clean
-             :clean   {:main-opts ["-e" "(load-file,\"dev/src/build.clj\"),(build/clean)"]
-                       :extra-deps {badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
-                                                       :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
-                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
-                       ;;; to supress noisy logs with logback file
-                       :extra-paths ["dev/resources"]}
-                          ;; build jar (compile java, clj files): clj -A:jar
-             :jar     {:main-opts ["-e" "(load-file,\"dev/src/build.clj\"),(build/clean),(build/compile-java),(build/jar)"]
-                       :extra-deps {badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
-                                                       :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
-                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
-                       ;;; to supress noisy logs with logback file
-                       :extra-paths ["dev/resources"]}
-
-             ;; compile java classes only: clj -A:javac
-             :javac   {:main-opts  ["-e" "(load-file,\"dev/src/build.clj\"),(build/compile-java)"]
-                       :extra-deps {badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
-                                                       :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
-                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
-                       ;;; to supress noisy logs with logback file
-                       :extra-paths ["dev/resources"]}
-
-             ;; install to local .m2: clj -A:install
-             :install {:main-opts  ["-e" "(load-file,\"dev/src/build.clj\"),(build/install)"]
-                       :extra-deps {badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
-                                                       :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
-                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
-                        ;;; to supress noisy logs with logback file
-                       :extra-paths ["dev/resources"]}
-
-             ;; public to clojars: clj -A:deploy
-             :deploy  {:main-opts  ["-e" "(load-file,\"dev/src/build.clj\"),(build/deploy)"]
-                       :extra-deps {badigeon/badigeon {:git/url "https://github.com/EwenG/badigeon.git"
-                                                       :sha     "c5d7d8f9c44fee2f193ef924cdf8a485aee539c5"}
-                                    ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
-                        ;;; to supress noisy logs with logback file
-                       :extra-paths ["dev/resources"]}}}
diff --git a/dev/resources/logback.xml b/dev/resources/logback.xml
deleted file mode 100644
index b70d039..0000000
--- a/dev/resources/logback.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<configuration>
-  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-    <encoder>
-      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
-    </encoder>
-  </appender>
- 
-  <root level="warn">
-    <appender-ref ref="STDOUT" />
-  </root>
-</configuration>
diff --git a/dev/src/build.clj b/dev/src/build.clj
deleted file mode 100644
index 8655466..0000000
--- a/dev/src/build.clj
+++ /dev/null
@@ -1,217 +0,0 @@
-(ns build
-  (:require [badigeon.clean :as clean]
-            [badigeon.classpath :as classpath]
-            [badigeon.javac :as javac]
-            [badigeon.jar :as jar]
-            [badigeon.install :as install]
-            [badigeon.sign :as sign]
-            [badigeon.deploy :as deploy]
-            [badigeon.pom :as pom]
-            [clojure.tools.deps.alpha.reader :as deps-reader]
-            [clojure.data.xml :as xml]
-            [clojure.string :as str]
-            [clojure.data.xml.tree :as tree]
-            [clojure.data.xml.event :as event]
-            [clojure.java.io :as io])
-  (:import (java.util.jar JarEntry JarOutputStream)
-           (java.nio.file Path Paths)
-           [java.io File Reader ByteArrayOutputStream]
-           [clojure.data.xml.node Element]
-           (java.net URI)))
-
-
-(def deps-content (deps-reader/slurp-deps "deps.edn"))
-(def java-src-folder (-> deps-content :build :java-source-paths))
-(def javac-options (-> deps-content :build :javac-options))
-(def group-id (-> deps-content :build :group-id))
-(def artifact-id (-> deps-content :build :artifact-id))
-(def group-artefact-id (symbol (str group-id "/" artifact-id)))
-(def artifact-version (-> deps-content :build :artifact-version))
-(def artifact-description (-> deps-content :build :description))
-(def artifact-url (-> deps-content :build :url))
-(def artifact-scm (-> deps-content :build :scm))
-(def artifact-license (-> deps-content :build :license))
-(def jar-name (str "target/" artifact-id "-" artifact-version ".jar"))
-
-
-(defn clean
-  []
-  (clean/clean "target"
-    {;; By default, clean does not allow deleting folders outside the target directory,
-     ;; unless :allow-outside-target? is true
-     :allow-outside-target? false}))
-
-(defn make-classpath
-  []
-  ;; Builds a classpath by using the provided deps spec or, by default, the deps.edn file of the current project.
-  ;; Returns the built classpath as a string.
-
-  (classpath/make-classpath))
-
-(defn compile-java
-  ([emit-path]
-   ;; Compile java sources under the java-src-folder directory
-   (when java-src-folder
-     (javac/javac java-src-folder {;; Emit class files to the target/classes directory
-                                   :compile-path  emit-path
-                                   ;; Additional options used by the javac command
-                                   :javac-options javac-options})))
-  ([]
-   (compile-java "target/classes")))
-
-
-(defn- parse-xml
-  [^Reader rdr]
-  (let [roots (tree/seq-tree
-                event/event-element event/event-exit? event/event-node
-                (xml/event-seq rdr {:include-node? #{:element :characters :comment}}))]
-    (first (filter #(instance? Element %) (first roots)))))
-
-
-(xml/alias-uri 'ppom "http://maven.apache.org/POM/4.0.0")
-
-(defn- add-extra-stuff->pom
-  []
-  (let [pom-file (io/file "pom.xml")
-        pom      (with-open [rdr (io/reader pom-file)]
-                   (-> rdr
-                     parse-xml))
-        pom      (if artifact-url
-                   (#'badigeon.pom/xml-update pom [::ppom/url] (xml/sexp-as-element [::ppom/url artifact-url]))
-                   pom)
-        pom      (if artifact-description
-                   (#'badigeon.pom/xml-update pom [::ppom/description] (xml/sexp-as-element [::ppom/description artifact-description]))
-                   pom)
-        pom      (if artifact-scm
-                   (#'badigeon.pom/xml-update pom [::ppom/scm] (xml/sexp-as-element [::ppom/scm [::ppom/url (:url artifact-scm)]]))
-                   pom)
-        pom      (if artifact-license
-                   (#'badigeon.pom/xml-update pom [::ppom/license] (xml/sexp-as-element [::ppom/licenses
-                                                                                         [::ppom/license
-                                                                                          [::ppom/url (or (:url artifact-license) "")]
-                                                                                          [::ppom/name (or (:name artifact-license)) ""]]]))
-
-                   pom)]
-
-
-    (spit pom-file (str/replace (xml/indent-str pom) #"\n\s+\n" "\n"))
-    (spit pom-file "<!-- This file was autogenerated by build script.
-    Please do not edit it directly; instead edit deps.edn and regenerate it.
-    It should not be considered canonical data. For more information see dev/src/build.clj -->" :append true)))
-
-(defn make-pom
-  []
-  (when (.exists (io/file "pom.xml"))
-    (io/delete-file "pom.xml"))
-  (let [lib          (symbol group-artefact-id)
-        maven-coords {:mvn/version artifact-version}]
-    (pom/sync-pom lib maven-coords (-> (deps-reader/slurp-deps "deps.edn")))
-    (add-extra-stuff->pom)))
-
-(defn jar
-  []
-  (when (.exists (io/file "pom.xml"))
-    (io/delete-file "pom.xml"))
-  ;; Package the project into a jar file
-  (jar/jar group-artefact-id {:mvn/version artifact-version}
-    {;; The jar file produced.
-     :out-path                jar-name
-     ;;;; Adds a \"Main\" entry to the jar manifest with the value
-     ;;:main                    main-ns
-     ;; Additional key/value pairs to add to the jar manifest. If a value is a collection, a manifest section is built for it.
-     ;;:manifest                {"Project-awesome-level" "super-great"
-     ;;                          :my-section-1           [["MyKey1" "MyValue1"] ["MyKey2" "MyValue2"]]
-     ;;                          :my-section-2           {"MyKey3" "MyValue3" "MyKey4" "MyValue4"}}
-
-     ;; By default Badigeon add entries for all files in the directory listed in the
-     ;; :paths section of the deps.edn file. This can be overridden here.
-     ;;:paths                   ["src" "target/classes" "java-src"]
-
-     ;; The dependencies to be added to the \"dependencies\" section of the pom.xml file.
-     ;; When not specified, defaults to the :deps entry of the deps.edn file, without
-     ;; merging the user-level and system-level deps.edn files
-     ;;:deps                    '{org.clojure/clojure {:mvn/version "1.10.1"}}
-     ;; The repositories to be added to the \"repositories\" section of the pom.xml file.
-     ;; When not specified, default to nil - even if the deps.edn files contains
-     ;; a :mvn/repos entry.
-     :mvn/repos               '{"clojars" {:url "https://repo.clojars.org/"}}
-     ;; A predicate used to excludes files from beeing added to the jar.
-     ;; The predicate is a function of two parameters: The path of the directory
-     ;; beeing visited (among the :paths of the project) and the path of the file
-     ;; beeing visited under this directory.
-     :exclusion-predicate     badigeon.jar/default-exclusion-predicate
-     ;; A function to add files to the jar that would otherwise not have been added to it.
-     ;; The function must take two parameters: the path of the root directory of the
-     ;; project and the file being visited under this directory. When the function
-     ;; returns a falsy value, the file is not added to the jar. Otherwise the function
-     ;; must return a string which represents the path within the jar where the file
-     ;; is copied.
-     ;; :inclusion-path          (partial badigeon.jar/default-inclusion-path "badigeon" "badigeon")
-     ;; By default git and local dependencies are not allowed. Set allow-all-dependencies? to true to allow them
-     :allow-all-dependencies? true})
-  (add-extra-stuff->pom)
-  (println "Successfully created jar file: " jar-name))
-
-
-
-(defn install
-  []
-  ;; Install the created jar file into the local maven repository.
-  (let [local-repo (str (System/getProperty "user.home") "/.m2/repository")]
-    (install/install group-artefact-id {:mvn/version artifact-version}
-      ;; The jar file to be installed
-      jar-name
-      ;; The pom.xml file to be installed. This file is generated when creating the jar with the badigeon.jar/jar function.
-      "pom.xml"
-      {;; The local repository where the jar should be installed.
-       :local-repo local-repo})
-    (println "Successfully installed to local repo: " local-repo)))
-
-(defn deploy
-  []
-  ;; Deploy the  created jar file to a remote repository.
-  (let [;; Artifacts are maps with a required :file-path key and an optional :extension key
-        artifacts [{:file-path jar-name :extension "jar"}
-                   {:file-path "pom.xml" :extension "pom"}]
-        ;; Artifacts must be signed when deploying non-snapshot versions of artifacts.
-        artifacts (badigeon.sign/sign artifacts {;; The gpg command can be customized
-                                                 :command "gpg"})]
-    ;; The gpg key used for signing. Defaults to the first private key found in your keyring.
-    ;;:gpg-key "root@eruditorum.org"
-
-
-    ;;  default to reading the credentials from ~/.m2/settings.xml. uncomment to prompt user credentials.
-    ;;;; Prompt for a username
-    ;;username (badigeon.prompt/prompt "Username (clojars): ")
-    ;;;; Prompt for a password using the process standard input and without echoing.
-    ;;password (badigeon.prompt/prompt-password "Password (clojars): ")
-
-    (badigeon.deploy/deploy
-      group-artefact-id artifact-version
-      artifacts
-      {;; :id is used to match the repository in the ~/.m2/settings.xml for credentials when no credentials are explicitly provided.
-       :id  "clojars"
-       ;; The URL of the repository to deploy to.
-       :url "https://repo.clojars.org/"}
-      {
-       ;; Take creds from ~/.m2/settings.xml
-
-       ;; The credentials used when authenticating to the remote repository.
-       ;; When none is provided, default to reading the credentials from ~/.m2/settings.xml
-       ;;:credentials {:username username :password password
-       ;;              ;;:private-key "/path/to/private-key" :passphrase "passphrase"
-       ;;              }
-       ;; When allow-unsigned? is false, artifacts must be signed when deploying non-snapshot versions of artifacts. Default to false.
-       :allow-unsigned? false})
-    (println "Success!")))
-
-(comment
-  (def cp (make-classpath))
-  (clean)
-  (compile-java)
-  (extract-classes-from-deps)
-  (make-pom)
-  (add-extra-stuff->pom)
-  (jar)
-  (install))
-
diff --git a/dev/src/user.clj b/dev/src/user.clj
deleted file mode 100644
index 94ca101..0000000
--- a/dev/src/user.clj
+++ /dev/null
@@ -1,9 +0,0 @@
-(ns user)
-
-;; debug print with #p
-(require 'hashp.core)
-
-(def dev-mode true)
-(println "***************************")
-(println {:msg "dev mode" :status (if (true? dev-mode) "on" "off")})
-(println "***************************")
diff --git a/dockerfiles/CondaDockerfile b/dockerfiles/CondaDockerfile
index bdc956b..aad9560 100644
--- a/dockerfiles/CondaDockerfile
+++ b/dockerfiles/CondaDockerfile
@@ -15,6 +15,9 @@ RUN apt-get -qq update && apt-get -qq -y install curl wget bzip2 openjdk-8-jdk-h
     && curl -o install-clojure https://download.clojure.org/install/linux-install-${CLOJURE_TOOLS_VERSION}.sh \
     && chmod +x install-clojure \
     && ./install-clojure && rm install-clojure \
+    && wget https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein \
+    && chmod a+x lein \
+    && mv lein /usr/bin \
     && apt-get -qq -y autoremove \
     && apt-get autoclean \
     && rm -rf /var/lib/apt/lists/* /var/log/dpkg.log \
diff --git a/project.clj b/project.clj
index fbe8e7d..a819bb7 100644
--- a/project.clj
+++ b/project.clj
@@ -3,9 +3,9 @@
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
-  :plugins [[lein-tools-deps "0.4.5"]]
-  :middleware [lein-tools-deps.plugin/resolve-dependencies-with-deps-edn]
-  :lein-tools-deps/config {:config-files [:install :user :project]}
-  :profiles {:dev {:lein-tools-deps/config {:resolve-aliases [:test]}}
-             :uberjar {:aot :all}}
+  :dependencies [[org.clojure/clojure "1.10.1"]
+                 [camel-snake-kebab "0.4.0"]
+                 [techascent/tech.datatype "4.74"]
+                 [org.clojure/data.json "0.2.7"]]
+  :profiles {:dev {:dependencies [[criterium "0.4.5"]]}}
   :java-source-paths ["java"])
diff --git a/scripts/conda-repl b/scripts/conda-repl
index 2c68746..e1af4fc 100755
--- a/scripts/conda-repl
+++ b/scripts/conda-repl
@@ -6,5 +6,7 @@ source activate pyclj
 ## https://github.com/conda/conda/issues/9500#issuecomment-565753807
 export LD_LIBRARY_PATH="$(python3-config --prefix)/lib"
 
-clojure -A:repl -b 0.0.0.0 -p 2222
+lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
+     -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
+     -- repl :headless :host localhost
 

From dfc9d446c877b72181f543247802194aad68fcdb Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 4 Feb 2020 07:13:03 -0700
Subject: [PATCH 181/456] update travis to newer leingingen

---
 .travis.yml | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 9dceeb6..ad845f9 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,17 +1,9 @@
 language: clojure
-lein: 2.8.2
+lein: 2.9.1
 before_install:
   - sudo apt-get -y install python3 python3-pip
   - sudo python3 -mpip install numpy
-  - curl -O https://download.clojure.org/install/linux-install-1.10.1.507.sh
-  - chmod +x linux-install-1.10.1.507.sh
-  - sudo ./linux-install-1.10.1.507.sh
-  - clojure -Sdescribe
 addons:
   apt:
     update: true
-install: clojure -Sdescribe
-script:
-  - clojure -A:javac
-  - clojure -A:test
 

From 2f6cef4eda51c343c20b6a35696ea8bcdeb594f2 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sat, 8 Feb 2020 14:59:37 -0500
Subject: [PATCH 182/456] ISSUE-78: clj-new template and deps.edn parallel
 support (#79)

* makefile changes

* update travis to newer leingingen

* WIP clj-new template

* wip

* fix namespace

* templates

* update changelog

* project.clj

* travis

* fix travis

* travis

* travis

* travis minimal

* revert to working, update lein

* add dev folders

* minified deps.edn

* better lein workflow

* simplified clj-new template

* fix clj-new template

* clj-new fix

* whitespace

Co-authored-by: Chris Nuernberger <cnuernber@gmail.com>
---
 .travis.yml                          |  6 +++-
 CHANGELOG.md                         | 24 +++++++++++++++
 deps.edn                             | 11 +++++++
 project.clj                          | 10 +++---
 src/clj/new/libpython_clj.clj        | 46 ++++++++++++++++++++++++++++
 src/clj/new/libpython_clj/core.clj   | 12 ++++++++
 src/clj/new/libpython_clj/deps.edn   | 11 +++++++
 src/clj/new/libpython_clj/python.clj |  9 ++++++
 8 files changed, 123 insertions(+), 6 deletions(-)
 create mode 100644 deps.edn
 create mode 100644 src/clj/new/libpython_clj.clj
 create mode 100644 src/clj/new/libpython_clj/core.clj
 create mode 100644 src/clj/new/libpython_clj/deps.edn
 create mode 100644 src/clj/new/libpython_clj/python.clj

diff --git a/.travis.yml b/.travis.yml
index ad845f9..1002412 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -3,7 +3,11 @@ lein: 2.9.1
 before_install:
   - sudo apt-get -y install python3 python3-pip
   - sudo python3 -mpip install numpy
+  - curl -O https://download.clojure.org/install/linux-install-1.10.1.507.sh
+  - chmod +x linux-install-1.10.1.507.sh
+  - sudo ./linux-install-1.10.1.507.sh
+  - clojure -Sdescribe
 addons:
   apt:
     update: true
-
+install: clojure -Sdescribe
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c37f2ad..5a6baa3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,28 @@
 # Time for a ChangeLog!
 
+## 1.37 
+
+* libpython-clj projects can now be created quickly with 
+
+```bash 
+
+    clj -A:new https://github.com/cnuernber/libpython-clj@<fill-in-sha-after-commit> <project.name>
+```
+   **NOTE**: this assumes you have `clj-new` configured in you `~/.clojure/deps.edn`
+   profile. If you do not, you can use the following:
+   
+```bash 
+clj -Sdeps '{:deps
+              {seancorfield/clj-new
+                {:mvn/version "0.8.6"}}}' \
+  -m clj-new.create \
+  https://github.com/cnuernber/libpython-clj@<fill-in-sha-after-commit> <project.name> \
+  myname/myapp
+```
+
+* `deps.edn` now supported in parallel with `project.clj`
+
+
 ## 1.36 
 
 * clojure.core.async upgrade
@@ -7,6 +30,7 @@
 
 ## 1.35
 
+
 * [Examples are now done by gigasquid](https://github.com/gigasquid/libpython-clj-examples)
 
 * [datafy/nav](https://clojure.github.io/clojure/branch-master/clojure.datafy-api.html) are now extensible for custom Python objects. 
diff --git a/deps.edn b/deps.edn
new file mode 100644
index 0000000..59e8dd5
--- /dev/null
+++ b/deps.edn
@@ -0,0 +1,11 @@
+{
+ :paths ["src"]
+
+ :deps {
+        org.clojure/clojure      {:mvn/version "1.10.1"}
+        camel-snake-kebab        {:mvn/version "0.4.0"}
+        techascent/tech.datatype {:mvn/version "4.74"}
+        org.clojure/data.json    {:mvn/version "0.2.7"}
+        seancorfield/clj-new     {:mvn/version "0.8.6"}
+        }
+ }
diff --git a/project.clj b/project.clj
index a819bb7..41c1601 100644
--- a/project.clj
+++ b/project.clj
@@ -3,9 +3,9 @@
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
-  :dependencies [[org.clojure/clojure "1.10.1"]
-                 [camel-snake-kebab "0.4.0"]
-                 [techascent/tech.datatype "4.74"]
-                 [org.clojure/data.json "0.2.7"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]]}}
-  :java-source-paths ["java"])
+  :java-source-paths ["java"]
+  :plugins [[lein-tools-deps "0.4.5"]]
+  :middleware [lein-tools-deps.plugin/resolve-dependencies-with-deps-edn]
+  :lein-tools-deps/config {:config-files [:install :user :project]})
+
diff --git a/src/clj/new/libpython_clj.clj b/src/clj/new/libpython_clj.clj
new file mode 100644
index 0000000..8b2a953
--- /dev/null
+++ b/src/clj/new/libpython_clj.clj
@@ -0,0 +1,46 @@
+(ns clj.new.libpython-clj
+  (:require [clj.new.templates :refer [renderer project-name name-to-path ->files]]))
+
+(def render (renderer "libpython_clj"))
+
+(defn file-map->files [data file-map]
+  (apply ->files data (seq file-map)))
+
+(defn libpython-clj-template! [name & {force :force? dir :dir}]
+  (let [data         {:name      (project-name name)
+                      :base      (clojure.string/replace
+                                  (project-name name)
+                                  #"(.*?)[.](.*$)"
+                                  "$1")
+                      :suffix    (clojure.string/replace
+                                  (project-name name)
+                                  #"(.*?)[.](.*$)"
+                                  "$2")
+                      :sanitized (name-to-path name)}
+        {base :base} data]
+    
+    (println (str  "Generating libpython-clj template for "
+                   (:name data) "at") (:sanitized data) ".\n\n"
+             "For the latest information, please check out "
+             "https://github.com/cnuernber/libpython-clj\n"
+             "or join us for discussion at "
+             "https://clojurians.zulipchat.com/#narrow/stream/215609-libpython-clj-dev")
+
+    (with-bindings {#'clj.new.templates/*force?* force
+                    #'clj.new.templates/*dir*    dir}
+      (file-map->files
+       data
+       {"deps.edn"                                            (render "deps.edn" data)
+        (format  "src/%s/%s.clj" (:base data) (:suffix data)) (render "core.clj" data)
+        (format  "src/%s/python.clj" (:base data))            (render "python.clj" data)}))))
+
+
+(defn libpython-clj [name]
+  (libpython-clj-template! name))
+
+(comment
+  (libpython-clj-template!
+   "mydomain.myapp"
+   :dir "/tmp/data"
+   :force? true))
+
diff --git a/src/clj/new/libpython_clj/core.clj b/src/clj/new/libpython_clj/core.clj
new file mode 100644
index 0000000..a233d2d
--- /dev/null
+++ b/src/clj/new/libpython_clj/core.clj
@@ -0,0 +1,12 @@
+(ns {{base}}.{{suffix}}
+    (:require [libpython-clj.python :as py :refer [py. py.- py.. py* py**]]
+              {{base}}.python
+              [libpython-clj.require :refer [require-python import-python]]))
+
+(import-python)
+
+(comment
+  (require-python 'os)
+  (os/getcwd))
+
+
diff --git a/src/clj/new/libpython_clj/deps.edn b/src/clj/new/libpython_clj/deps.edn
new file mode 100644
index 0000000..f7545a6
--- /dev/null
+++ b/src/clj/new/libpython_clj/deps.edn
@@ -0,0 +1,11 @@
+{
+ :mvn/repos {"clojars" {:url "https://repo.clojars.org/"}
+             "central" {:url "https://repo1.maven.org/maven2/"}}
+
+ :paths ["src" "resources"]
+
+ :deps {
+        org.clojure/clojure     {:mvn/version "1.10.1"}
+        cnuernber/libpython-clj {:mvn/version "1.36"}
+        }
+ }
diff --git a/src/clj/new/libpython_clj/python.clj b/src/clj/new/libpython_clj/python.clj
new file mode 100644
index 0000000..3f3b89d
--- /dev/null
+++ b/src/clj/new/libpython_clj/python.clj
@@ -0,0 +1,9 @@
+(ns {{base}}.python
+    (:require [libpython-clj.python :as py]))
+
+(defn initialize-python!
+  ([] (py/initialize!))
+  ([python-executable]
+   (py/initialize! :python-executable python-executable)))
+
+(initialize-python! "python3.7")

From 96f65498ec535bec794d6075df4255d61325038b Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 8 Feb 2020 13:20:21 -0700
Subject: [PATCH 183/456] Moving files to a clj-template directory to minimize
 libpy deps

---
 CHANGELOG.md                                              | 2 +-
 clj-template/deps.edn                                     | 8 ++++++++
 clj-template/project.clj                                  | 8 ++++++++
 {src => clj-template/src}/clj/new/libpython_clj.clj       | 8 ++++----
 {src => clj-template/src}/clj/new/libpython_clj/core.clj  | 0
 {src => clj-template/src}/clj/new/libpython_clj/deps.edn  | 0
 .../src}/clj/new/libpython_clj/python.clj                 | 5 +++++
 7 files changed, 26 insertions(+), 5 deletions(-)
 create mode 100644 clj-template/deps.edn
 create mode 100644 clj-template/project.clj
 rename {src => clj-template/src}/clj/new/libpython_clj.clj (97%)
 rename {src => clj-template/src}/clj/new/libpython_clj/core.clj (100%)
 rename {src => clj-template/src}/clj/new/libpython_clj/deps.edn (100%)
 rename {src => clj-template/src}/clj/new/libpython_clj/python.clj (57%)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5a6baa3..dae0d4a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,7 +2,7 @@
 
 ## 1.37 
 
-* libpython-clj projects can now be created quickly with 
+* libpython-clj projects can now be created quickly with:
 
 ```bash 
 
diff --git a/clj-template/deps.edn b/clj-template/deps.edn
new file mode 100644
index 0000000..8297390
--- /dev/null
+++ b/clj-template/deps.edn
@@ -0,0 +1,8 @@
+{
+ :paths ["src"]
+
+ :deps {
+        org.clojure/clojure      {:mvn/version "1.10.1"}
+        seancorfield/clj-new     {:mvn/version "0.8.6"}
+        }
+ }
diff --git a/clj-template/project.clj b/clj-template/project.clj
new file mode 100644
index 0000000..07ed992
--- /dev/null
+++ b/clj-template/project.clj
@@ -0,0 +1,8 @@
+(defproject libpython-clj/clj-template "1.0-SNAPSHOT"
+  :description "libpython bindings to the techascent ecosystem"
+  :url "http://github.com/cnuernber/libpython-clj"
+  :license {:name "Eclipse Public License"
+            :url  "http://www.eclipse.org/legal/epl-v10.html"}
+  :plugins [[lein-tools-deps "0.4.5"]]
+  :middleware [lein-tools-deps.plugin/resolve-dependencies-with-deps-edn]
+  :lein-tools-deps/config {:config-files [:install :user :project]})
diff --git a/src/clj/new/libpython_clj.clj b/clj-template/src/clj/new/libpython_clj.clj
similarity index 97%
rename from src/clj/new/libpython_clj.clj
rename to clj-template/src/clj/new/libpython_clj.clj
index 8b2a953..0430dbf 100644
--- a/src/clj/new/libpython_clj.clj
+++ b/clj-template/src/clj/new/libpython_clj.clj
@@ -18,7 +18,7 @@
                                   "$2")
                       :sanitized (name-to-path name)}
         {base :base} data]
-    
+
     (println (str  "Generating libpython-clj template for "
                    (:name data) "at") (:sanitized data) ".\n\n"
              "For the latest information, please check out "
@@ -41,6 +41,6 @@
 (comment
   (libpython-clj-template!
    "mydomain.myapp"
-   :dir "/tmp/data"
-   :force? true))
-
+   :dir "testdir"
+   :force? true)
+  )
diff --git a/src/clj/new/libpython_clj/core.clj b/clj-template/src/clj/new/libpython_clj/core.clj
similarity index 100%
rename from src/clj/new/libpython_clj/core.clj
rename to clj-template/src/clj/new/libpython_clj/core.clj
diff --git a/src/clj/new/libpython_clj/deps.edn b/clj-template/src/clj/new/libpython_clj/deps.edn
similarity index 100%
rename from src/clj/new/libpython_clj/deps.edn
rename to clj-template/src/clj/new/libpython_clj/deps.edn
diff --git a/src/clj/new/libpython_clj/python.clj b/clj-template/src/clj/new/libpython_clj/python.clj
similarity index 57%
rename from src/clj/new/libpython_clj/python.clj
rename to clj-template/src/clj/new/libpython_clj/python.clj
index 3f3b89d..ae532c5 100644
--- a/src/clj/new/libpython_clj/python.clj
+++ b/clj-template/src/clj/new/libpython_clj/python.clj
@@ -6,4 +6,9 @@
   ([python-executable]
    (py/initialize! :python-executable python-executable)))
 
+
+;; If you are using environments, you can specialized which python executable
+;; you bind to below.  Make sure you do this before you call 'require-python'
+;; in any file.
+
 (initialize-python! "python3.7")

From 2aacdbbe2fffbd8b95910a0ce761b4cf6039a305 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 8 Feb 2020 13:20:32 -0700
Subject: [PATCH 184/456] really minimize deps

---
 deps.edn | 1 -
 1 file changed, 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 59e8dd5..4584b1f 100644
--- a/deps.edn
+++ b/deps.edn
@@ -6,6 +6,5 @@
         camel-snake-kebab        {:mvn/version "0.4.0"}
         techascent/tech.datatype {:mvn/version "4.74"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
-        seancorfield/clj-new     {:mvn/version "0.8.6"}
         }
  }

From 721b03b0ab07f4ceed5a527b29369bdbd385edaf Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 8 Feb 2020 13:21:50 -0700
Subject: [PATCH 185/456] Attempting to keep version numbers same

---
 clj-template/project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clj-template/project.clj b/clj-template/project.clj
index 07ed992..296c472 100644
--- a/clj-template/project.clj
+++ b/clj-template/project.clj
@@ -1,4 +1,4 @@
-(defproject libpython-clj/clj-template "1.0-SNAPSHOT"
+(defproject libpython-clj/clj-template "1.36"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 2473ad60d904f87d775a7eeef8555a9b7980ec64 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 9 Feb 2020 10:42:44 -0700
Subject: [PATCH 186/456] 1.36

---
 CHANGELOG.md | 4 +++-
 project.clj  | 3 +--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dae0d4a..1b0f596 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,8 @@
 # Time for a ChangeLog!
 
-## 1.37 
+## 1.37-SNAPSHOT
+
+!! Undergoing work, potentially need a github project !!
 
 * libpython-clj projects can now be created quickly with:
 
diff --git a/project.clj b/project.clj
index 41c1601..8dc14fd 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject cnuernber/libpython-clj "1.37-SNAPSHOT"
+(defproject clj-python/libpython-clj "1.36"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
@@ -8,4 +8,3 @@
   :plugins [[lein-tools-deps "0.4.5"]]
   :middleware [lein-tools-deps.plugin/resolve-dependencies-with-deps-edn]
   :lein-tools-deps/config {:config-files [:install :user :project]})
-

From 191ca270e5b63252deb21119a95cf420ab006ae5 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 9 Feb 2020 10:43:02 -0700
Subject: [PATCH 187/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 8dc14fd..f448c11 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.36"
+(defproject clj-python/libpython-clj "1.37-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 04972161fc7b574ec9ad8c59d72039f48331ca98 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 9 Feb 2020 10:45:46 -0700
Subject: [PATCH 188/456] Updating readme and removing template

---
 README.md                                     |  4 +-
 clj-template/deps.edn                         |  8 ----
 clj-template/project.clj                      |  8 ----
 clj-template/src/clj/new/libpython_clj.clj    | 46 -------------------
 .../src/clj/new/libpython_clj/core.clj        | 12 -----
 .../src/clj/new/libpython_clj/deps.edn        | 11 -----
 .../src/clj/new/libpython_clj/python.clj      | 14 ------
 7 files changed, 2 insertions(+), 101 deletions(-)
 delete mode 100644 clj-template/deps.edn
 delete mode 100644 clj-template/project.clj
 delete mode 100644 clj-template/src/clj/new/libpython_clj.clj
 delete mode 100644 clj-template/src/clj/new/libpython_clj/core.clj
 delete mode 100644 clj-template/src/clj/new/libpython_clj/deps.edn
 delete mode 100644 clj-template/src/clj/new/libpython_clj/python.clj

diff --git a/README.md b/README.md
index d7fbb98..bab0429 100644
--- a/README.md
+++ b/README.md
@@ -2,8 +2,8 @@
 
 JNA libpython bindings to the tech ecosystem.
 
-[![Clojars Project](https://img.shields.io/clojars/v/cnuernber/libpython-clj.svg)](https://clojars.org/cnuernber/libpython-clj)
-[![travis integration](https://travis-ci.com/cnuernber/libpython-clj.svg?branch=master)](https://travis-ci.com/cnuernber/libpython-clj)
+[![Clojars Project](https://img.shields.io/clojars/v/clj-python/libpython-clj.svg)](https://clojars.org/cnuernber/libpython-clj)
+[![travis integration](https://travis-ci.com/clj-python/libpython-clj.svg?branch=master)](https://travis-ci.com/cnuernber/libpython-clj)
 
 * Bridge between JVM objects and Python objects easily; use Python in your Java and
   use some Java in your Python.
diff --git a/clj-template/deps.edn b/clj-template/deps.edn
deleted file mode 100644
index 8297390..0000000
--- a/clj-template/deps.edn
+++ /dev/null
@@ -1,8 +0,0 @@
-{
- :paths ["src"]
-
- :deps {
-        org.clojure/clojure      {:mvn/version "1.10.1"}
-        seancorfield/clj-new     {:mvn/version "0.8.6"}
-        }
- }
diff --git a/clj-template/project.clj b/clj-template/project.clj
deleted file mode 100644
index 296c472..0000000
--- a/clj-template/project.clj
+++ /dev/null
@@ -1,8 +0,0 @@
-(defproject libpython-clj/clj-template "1.36"
-  :description "libpython bindings to the techascent ecosystem"
-  :url "http://github.com/cnuernber/libpython-clj"
-  :license {:name "Eclipse Public License"
-            :url  "http://www.eclipse.org/legal/epl-v10.html"}
-  :plugins [[lein-tools-deps "0.4.5"]]
-  :middleware [lein-tools-deps.plugin/resolve-dependencies-with-deps-edn]
-  :lein-tools-deps/config {:config-files [:install :user :project]})
diff --git a/clj-template/src/clj/new/libpython_clj.clj b/clj-template/src/clj/new/libpython_clj.clj
deleted file mode 100644
index 0430dbf..0000000
--- a/clj-template/src/clj/new/libpython_clj.clj
+++ /dev/null
@@ -1,46 +0,0 @@
-(ns clj.new.libpython-clj
-  (:require [clj.new.templates :refer [renderer project-name name-to-path ->files]]))
-
-(def render (renderer "libpython_clj"))
-
-(defn file-map->files [data file-map]
-  (apply ->files data (seq file-map)))
-
-(defn libpython-clj-template! [name & {force :force? dir :dir}]
-  (let [data         {:name      (project-name name)
-                      :base      (clojure.string/replace
-                                  (project-name name)
-                                  #"(.*?)[.](.*$)"
-                                  "$1")
-                      :suffix    (clojure.string/replace
-                                  (project-name name)
-                                  #"(.*?)[.](.*$)"
-                                  "$2")
-                      :sanitized (name-to-path name)}
-        {base :base} data]
-
-    (println (str  "Generating libpython-clj template for "
-                   (:name data) "at") (:sanitized data) ".\n\n"
-             "For the latest information, please check out "
-             "https://github.com/cnuernber/libpython-clj\n"
-             "or join us for discussion at "
-             "https://clojurians.zulipchat.com/#narrow/stream/215609-libpython-clj-dev")
-
-    (with-bindings {#'clj.new.templates/*force?* force
-                    #'clj.new.templates/*dir*    dir}
-      (file-map->files
-       data
-       {"deps.edn"                                            (render "deps.edn" data)
-        (format  "src/%s/%s.clj" (:base data) (:suffix data)) (render "core.clj" data)
-        (format  "src/%s/python.clj" (:base data))            (render "python.clj" data)}))))
-
-
-(defn libpython-clj [name]
-  (libpython-clj-template! name))
-
-(comment
-  (libpython-clj-template!
-   "mydomain.myapp"
-   :dir "testdir"
-   :force? true)
-  )
diff --git a/clj-template/src/clj/new/libpython_clj/core.clj b/clj-template/src/clj/new/libpython_clj/core.clj
deleted file mode 100644
index a233d2d..0000000
--- a/clj-template/src/clj/new/libpython_clj/core.clj
+++ /dev/null
@@ -1,12 +0,0 @@
-(ns {{base}}.{{suffix}}
-    (:require [libpython-clj.python :as py :refer [py. py.- py.. py* py**]]
-              {{base}}.python
-              [libpython-clj.require :refer [require-python import-python]]))
-
-(import-python)
-
-(comment
-  (require-python 'os)
-  (os/getcwd))
-
-
diff --git a/clj-template/src/clj/new/libpython_clj/deps.edn b/clj-template/src/clj/new/libpython_clj/deps.edn
deleted file mode 100644
index f7545a6..0000000
--- a/clj-template/src/clj/new/libpython_clj/deps.edn
+++ /dev/null
@@ -1,11 +0,0 @@
-{
- :mvn/repos {"clojars" {:url "https://repo.clojars.org/"}
-             "central" {:url "https://repo1.maven.org/maven2/"}}
-
- :paths ["src" "resources"]
-
- :deps {
-        org.clojure/clojure     {:mvn/version "1.10.1"}
-        cnuernber/libpython-clj {:mvn/version "1.36"}
-        }
- }
diff --git a/clj-template/src/clj/new/libpython_clj/python.clj b/clj-template/src/clj/new/libpython_clj/python.clj
deleted file mode 100644
index ae532c5..0000000
--- a/clj-template/src/clj/new/libpython_clj/python.clj
+++ /dev/null
@@ -1,14 +0,0 @@
-(ns {{base}}.python
-    (:require [libpython-clj.python :as py]))
-
-(defn initialize-python!
-  ([] (py/initialize!))
-  ([python-executable]
-   (py/initialize! :python-executable python-executable)))
-
-
-;; If you are using environments, you can specialized which python executable
-;; you bind to below.  Make sure you do this before you call 'require-python'
-;; in any file.
-
-(initialize-python! "python3.7")

From 06a0a27a2c1320cfe3cbed89c29fb88bbdc9f19f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 9 Feb 2020 10:55:13 -0700
Subject: [PATCH 189/456] updated to reflect moved clj-template repo

---
 CHANGELOG.md | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1b0f596..fc3ad5c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,25 +3,6 @@
 ## 1.37-SNAPSHOT
 
 !! Undergoing work, potentially need a github project !!
-
-* libpython-clj projects can now be created quickly with:
-
-```bash 
-
-    clj -A:new https://github.com/cnuernber/libpython-clj@<fill-in-sha-after-commit> <project.name>
-```
-   **NOTE**: this assumes you have `clj-new` configured in you `~/.clojure/deps.edn`
-   profile. If you do not, you can use the following:
-   
-```bash 
-clj -Sdeps '{:deps
-              {seancorfield/clj-new
-                {:mvn/version "0.8.6"}}}' \
-  -m clj-new.create \
-  https://github.com/cnuernber/libpython-clj@<fill-in-sha-after-commit> <project.name> \
-  myname/myapp
-```
-
 * `deps.edn` now supported in parallel with `project.clj`
 
 

From 70c97176bc4cb5460d8f35bb7cdb70858b35b1c1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 9 Feb 2020 13:26:08 -0700
Subject: [PATCH 190/456] updating readme

---
 README.md | 55 ++-----------------------------------------------------
 1 file changed, 2 insertions(+), 53 deletions(-)

diff --git a/README.md b/README.md
index bab0429..599db8f 100644
--- a/README.md
+++ b/README.md
@@ -147,67 +147,16 @@ we have an [introductory document](docs/new-to-clojure.md).
 * [create C ptr from numpy](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.ctypes.html)
 
 
-## How to run project tasks
-This project has java sources in additon to regular clojure sources.
-The build alias have the javac built into the tasks, however for running tests or repl you would
-need to run that as a seperate step if you need to recompile the java classes.
-Example:
-
-- `clojure -A:javac`
-- `clojure -A:test`
-
-Also note, that if you have tools installed you may substitue the `clj` command for `clojure` below:
-
-- `clj -A:test`
-
-
-### Compile Java classes
-
-```bash
-$ clojure -A:javac
-```
-
-### REPL
-
-```bash
-$ clojure -A:repl
-nREPL server started on port 56785 on host localhost - nrepl://localhost:56785
-```
-
-
-### Tests
-
-```bash
-$  clojure -A:test
-```
-
-### Package jar
-
-```bash
-$ clojure -A:jar
-```
-
-### Clean target directory
-
-```bash
-$ clojure -A:clean
-```
-
-
-### Local install
-
 To install jar to local .m2 :
 
 ```bash
-$ clojure -A:install
+$ lein install
 ```
 
 ### Deploy to clojars
 
-Put your clojars.org credentials to settings.xml (or uncomment login and password prompt in dev/src/build.clj).
-
 ```bash
-$ clojure -A:deploy
+$ lein deploy clojars
 ```
 This command will sign jar before deploy, using your gpg key. (see dev/src/build.clj for signing options)
 

From c732dc65de629d9cd8a350a507795247517857e4 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 9 Feb 2020 13:27:07 -0700
Subject: [PATCH 191/456] editing

---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 599db8f..a6144b3 100644
--- a/README.md
+++ b/README.md
@@ -2,8 +2,8 @@
 
 JNA libpython bindings to the tech ecosystem.
 
-[![Clojars Project](https://img.shields.io/clojars/v/clj-python/libpython-clj.svg)](https://clojars.org/cnuernber/libpython-clj)
-[![travis integration](https://travis-ci.com/clj-python/libpython-clj.svg?branch=master)](https://travis-ci.com/cnuernber/libpython-clj)
+[![Clojars Project](https://img.shields.io/clojars/v/clj-python/libpython-clj.svg)](https://clojars.org/clj-python/libpython-clj)
+[![travis integration](https://travis-ci.com/clj-python/libpython-clj.svg?branch=master)](https://travis-ci.com/clj-python/libpython-clj)
 
 * Bridge between JVM objects and Python objects easily; use Python in your Java and
   use some Java in your Python.

From 3e500e354991f315fa9567536a4b16959a63e202 Mon Sep 17 00:00:00 2001
From: fong <FongHou@users.noreply.github.com>
Date: Thu, 20 Feb 2020 09:05:05 -0500
Subject: [PATCH 192/456] move (.get libpy-base/gil-thread-id) into (locking
 ...) because interleaving (.get ...) (== ..) (.set ...) may lead to race
 condition. (#82)

---
 src/libpython_clj/python/interpreter.clj | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index e4d7ca5..526fded 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -337,12 +337,12 @@ print(json.dumps(
   "Grab the gil and use the main interpreter using reentrant acquire-gil pathway."
   [& body]
   `(do
-     (let [interp# (ensure-interpreter)
-           ^AtomicLong bound-thread# libpy-base/gil-thread-id
-           thread-id# (libpy-base/current-thread-id)
-           previously-bound-thread-id# (.get bound-thread#)]
+     (let [interp# (ensure-interpreter)]
        (locking interp#
-         (let [gil-state# (when-not (== thread-id# previously-bound-thread-id#)
+         (let [^AtomicLong bound-thread# libpy-base/gil-thread-id
+               previously-bound-thread-id# (.get bound-thread#)
+               thread-id# (libpy-base/current-thread-id)
+               gil-state# (when-not (== thread-id# previously-bound-thread-id#)
                             (acquire-gil!))]
            (try
              ~@body

From 8cf96fbc8afdcc7a96988e3357802ab6e165438e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 20 Feb 2020 12:18:36 -0700
Subject: [PATCH 193/456] Fixes #84 (#85)

---
 src/libpython_clj/metadata.clj | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/libpython_clj/metadata.clj b/src/libpython_clj/metadata.clj
index 9ee4bc0..947f59c 100644
--- a/src/libpython_clj/metadata.clj
+++ b/src/libpython_clj/metadata.clj
@@ -209,8 +209,9 @@
   (with-gil
     (->> (if (or (pyclass? item)
                  (pymodule? item))
-           (-> (vars item)
-               (py-proto/as-map))
+           (->> (vars item)
+                (py-proto/as-map)
+                (into {}))
            (->> (py/dir item)
                 (map (juxt identity #(get-attr item %)))))
          (map (fn [[att-name att-val]]

From 1aa1d43421d3c9802ad3dca9012a8a2191abea97 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 28 Feb 2020 18:46:54 -0700
Subject: [PATCH 194/456] 1.37

---
 CHANGELOG.md | 5 +++--
 project.clj  | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fc3ad5c..cde4846 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,9 @@
 # Time for a ChangeLog!
 
-## 1.37-SNAPSHOT
+## 1.37
 
-!! Undergoing work, potentially need a github project !!
+* Fix for metadata generation of sys module that was failing.  This needs a deeper fix.
+* Race condition and stability fix.
 * `deps.edn` now supported in parallel with `project.clj`
 
 
diff --git a/project.clj b/project.clj
index f448c11..6eab293 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.37-SNAPSHOT"
+(defproject clj-python/libpython-clj "1.37"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 461e733e5e578bc3ca60ed98073a1bfc3827c3ba Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 28 Feb 2020 18:57:41 -0700
Subject: [PATCH 195/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 6eab293..d11e649 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.37"
+(defproject clj-python/libpython-clj "1.38-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From c5f4466cd1d01f4b21e0c813f57420572207bb1f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ertu=C4=9Frul=20=C3=87etin?= <ertu.ctn@gmail.com>
Date: Tue, 10 Mar 2020 20:02:01 +0300
Subject: [PATCH 196/456] added :repl-options instructions (#90)

---
 README.md | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/README.md b/README.md
index a6144b3..963f059 100644
--- a/README.md
+++ b/README.md
@@ -80,6 +80,25 @@ This code is a concrete example that generates an
 
 ## Usage
 
+#### Config namespace
+```clojure
+(ns my-py-clj.config
+  (:require [libpython-clj.python :as py]))
+
+;; When you use conda, it should look like this.
+(py/initialize! :python-executable "/opt/anaconda3/envs/my_env/bin/python3.7"
+                :library-path "/opt/anaconda3/envs/my_env/lib/libpython3.7m.dylib")
+```
+
+#### Update project.clj
+```clojure
+{...
+  ;; This namespace going to run when the REPL is up. 
+  :repl-options {:init-ns my-py-clj.config}
+...}
+```
+
+
 ```clojure
 user> (require '[libpython-clj.require :refer [require-python]])
 ...logging info....

From 96d15e7740258d7f13cceb6836abf0f075f57829 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 18 Mar 2020 15:45:24 -0600
Subject: [PATCH 197/456] upgrade to tech.datatype 4.88

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 4584b1f..c5b6c82 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "4.74"}
+        techascent/tech.datatype {:mvn/version "4.88"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
         }
  }

From a9fcc6bcc22a47927cfb0affdac2b6124cbd056c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 18 Mar 2020 15:46:45 -0600
Subject: [PATCH 198/456] 1.38

---
 CHANGELOG.md | 4 ++++
 project.clj  | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cde4846..9956718 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## 1.37
 
+* Update to tech.datatype 4.88 - much faster group-by, lots of small improvements.
+
+## 1.37
+
 * Fix for metadata generation of sys module that was failing.  This needs a deeper fix.
 * Race condition and stability fix.
 * `deps.edn` now supported in parallel with `project.clj`
diff --git a/project.clj b/project.clj
index d11e649..1fb36af 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.38-SNAPSHOT"
+(defproject clj-python/libpython-clj "1.38"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 371e466646c0ba087d6415b66909e102fb94c961 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 18 Mar 2020 15:47:13 -0600
Subject: [PATCH 199/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 1fb36af..8ec9e4c 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.38"
+(defproject clj-python/libpython-clj "1.39-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 1e828528ba482a27836275b1aa99ab437d6df1f5 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 31 Mar 2020 13:06:34 -0600
Subject: [PATCH 200/456] Upgrade datatype to 5.0

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index c5b6c82..a5b30cf 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "4.88"}
+        techascent/tech.datatype {:mvn/version "5.0-alpha-1"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
         }
  }

From 8f5efa2b2f1edbef1fcaa2271500f498f709793a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 31 Mar 2020 13:07:33 -0600
Subject: [PATCH 201/456] changelog update for latest change.

---
 CHANGELOG.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9956718..9281602 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,10 @@
 # Time for a ChangeLog!
 
+
+## 1.38-SNAPSHOT
+
+* `tech.datatype` is upgrade to 5.0 (!!).
+
 ## 1.37
 
 * Update to tech.datatype 4.88 - much faster group-by, lots of small improvements.

From bade2c477c1afe327eb432b3c226be4d33f0e518 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 31 Mar 2020 13:11:16 -0600
Subject: [PATCH 202/456] simple changes to clean up file

---
 src/libpython_clj/python/np_array.clj | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/libpython_clj/python/np_array.clj b/src/libpython_clj/python/np_array.clj
index a9076cd..8f33a27 100644
--- a/src/libpython_clj/python/np_array.clj
+++ b/src/libpython_clj/python/np_array.clj
@@ -2,14 +2,10 @@
   (:require [tech.v2.datatype.protocols :as dtype-proto]
             [tech.v2.datatype.operation-provider :as op-provider]
             [tech.v2.tensor :as dtt]
-            [tech.v2.datatype.argtypes :as argtypes]
             [libpython-clj.python.interpreter :as py-interp]
             [libpython-clj.python.protocols :as py-proto]
             [libpython-clj.python.bridge :as py-bridge]
-            [libpython-clj.python.object :as py-object]
-            [libpython-clj.python.interop :as py-interop]
-            [tech.jna :as jna]))
-
+            [libpython-clj.python.interop :as py-interop]))
 
 
 (defmethod py-proto/pyobject->jvm :ndarray

From f178642187cef8613fbad2ed1db226c1ad18ff55 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 5 Apr 2020 07:11:38 -0600
Subject: [PATCH 203/456] Fixes #88

---
 docs/slicing.md | 67 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 docs/slicing.md

diff --git a/docs/slicing.md b/docs/slicing.md
new file mode 100644
index 0000000..5516ed6
--- /dev/null
+++ b/docs/slicing.md
@@ -0,0 +1,67 @@
+# Slicing And Slices
+
+
+The way Python implements slicing is via overloading the `get-item` function call.
+This is the call the Python interpreter makes under the covers whenever you use the
+square bracket `[]` syntax.
+
+
+For quite a few objects, that function call take a tuple of arguments. The trick to
+numpy slicing is to create builtin slice objects with the appropriate arguments and
+pass them into the `get-item` call in a tuple.
+
+
+```clojure
+user> (require '[libpython-clj.python :as py])
+nil
+user> (require '[libpython-clj.require :refer [require-python]])
+... lotta logs ...
+user> (require-python '[builtins])
+WARNING: AssertionError already refers to: class java.lang.AssertionError in namespace: builtins, being replaced by: #'builtins/AssertionError
+WARNING: Exception already refers to: class java.lang.Exception in namespace: builtins, being replaced by: #'builtins/Exception
+:ok
+user> (doc builtins/slice)
+-------------------------
+builtins/slice
+[[self & [args {:as kwargs}]]]
+  slice(stop)
+slice(start, stop[, step])
+
+Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).
+nil
+user> (require-python '[numpy :as np])
+:ok
+
+user> (require-python '[numpy :as np])
+:ok
+user> (def ary (-> (np/arange 9)
+                   (np/reshape [3 3])))
+#'user/ary
+user> ary
+[[0 1 2]
+ [3 4 5]
+ [6 7 8]]
+
+user> (py/get-item ary [(builtins/slice 1 nil) (builtins/slice 1 nil)])
+[[4 5]
+ [7 8]]
+user> (py/get-item ary [(builtins/slice -1) (builtins/slice 1 nil)])
+[[1 2]
+ [4 5]]
+user> (py/get-item ary [(builtins/slice nil) (builtins/slice 1 nil)])
+[[1 2]
+ [4 5]
+ [7 8]]
+user> (py/get-item ary [(builtins/slice nil) (builtins/slice 1 2)])
+[[1]
+ [4]
+ [7]]
+user> (py/get-item ary [(builtins/slice nil) (builtins/slice 1 3)])
+[[1 2]
+ [4 5]
+ [7 8]]
+user> (py/get-item ary [(builtins/slice nil) (builtins/slice 1 4)])
+[[1 2]
+ [4 5]
+ [7 8]]
+```

From eba7aa02be63c06d8ef27c7f571e78e2e7855c22 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 18 Apr 2020 16:02:50 -0600
Subject: [PATCH 204/456] 1.39

---
 CHANGELOG.md | 43 ++++++++++++++++++++++---------------------
 deps.edn     |  2 +-
 project.clj  |  2 +-
 3 files changed, 24 insertions(+), 23 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9281602..069d8d6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,6 @@
 # Time for a ChangeLog!
-
+## 1.39
+* `tech.datatype` upgrade to version that supports datetime types.
 
 ## 1.38-SNAPSHOT
 
@@ -16,7 +17,7 @@
 * `deps.edn` now supported in parallel with `project.clj`
 
 
-## 1.36 
+## 1.36
 
 * clojure.core.async upgrade
 
@@ -26,11 +27,11 @@
 
 * [Examples are now done by gigasquid](https://github.com/gigasquid/libpython-clj-examples)
 
-* [datafy/nav](https://clojure.github.io/clojure/branch-master/clojure.datafy-api.html) are now extensible for custom Python objects. 
-  Extend `libpython-clj.require/pydafy` and `libpython-clj.require/pynav` 
-  respectively with the symbol of class you want to extend. See 
+* [datafy/nav](https://clojure.github.io/clojure/branch-master/clojure.datafy-api.html) are now extensible for custom Python objects.
+  Extend `libpython-clj.require/pydafy` and `libpython-clj.require/pynav`
+  respectively with the symbol of class you want to extend. See
   respective docstrings for details.
-  
+
 * bugfix -- python.str now loaded by `import-python`
 
 
@@ -42,33 +43,33 @@
 * Better [windows anaconda support](https://github.com/cnuernber/libpython-clj/pull/67)
   thanks to [orolle](https://github.com/orolle).
 
-* Moved to PyGILState* functions for GIL management.  This mainly due to 
+* Moved to PyGILState* functions for GIL management.  This mainly due to
   [FongHou](https://github.com/cnuernber/libpython-clj/commits?author=FongHou) in
-  PRs [here](https://github.com/cnuernber/libpython-clj/pull/64) and 
+  PRs [here](https://github.com/cnuernber/libpython-clj/pull/64) and
   [here](https://github.com/cnuernber/libpython-clj/pull/65).
 
 * **BREAKING CHANGE** `require-python` now respects prefix lists --
-  unfortunately, the previous syntax was incorrect. 
-  ```clojure 
+  unfortunately, the previous syntax was incorrect.
+  ```clojure
   ;; WRONG (syntax version < 1.33)
-  (require-python '(os math)) 
+  (require-python '(os math))
   ```
-  would be equivalent to 
-  ```clojure 
+  would be equivalent to
+  ```clojure
   ;; (do (require-python 'os) (require-python 'math))
   ```
   the correct syntax for this SHOULD have been
-  ```clojure 
+  ```clojure
   (require-python 'os 'math)
   ```
-  
-  1.33 fixes this mistake, and provides support for prefix lists, 
+
+  1.33 fixes this mistake, and provides support for prefix lists,
   for example:
-  
+
   ```clojure
-  (require-python 
+  (require-python
    '[builtins :as python]
-   '(builtins 
+   '(builtins
      [list :as python.list]
      [dict :as python.dict]
      [tuple :as python.tuple]
@@ -76,9 +77,9 @@
      [frozenset :as python.frozenset]))
   ```
   (**Note**: this is done for you by the function `libpython-clj.require/import-python`)
-  
+
   This fix brought to you by [jjtolton](https://github.com/jjtolton).
-  
+
 
 ## 1.32
 * DecRef now happens cooperatively in python thread.  We used to use separate threads
diff --git a/deps.edn b/deps.edn
index a5b30cf..64856af 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "5.0-alpha-1"}
+        techascent/tech.datatype {:mvn/version "5.0-beta-9"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
         }
  }
diff --git a/project.clj b/project.clj
index 8ec9e4c..dd87fd0 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.39-SNAPSHOT"
+(defproject clj-python/libpython-clj "1.39"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 4ca44fd9c2017efeb478f60518847c54be2b5a80 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 18 Apr 2020 16:02:59 -0600
Subject: [PATCH 205/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index dd87fd0..7b40ea2 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.39"
+(defproject clj-python/libpython-clj "1.40-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From e762878b220fb51b38defe65007b06ab575f704d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 18 Apr 2020 16:39:28 -0600
Subject: [PATCH 206/456] 1.40

---
 CHANGELOG.md | 3 +++
 deps.edn     | 2 +-
 project.clj  | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 069d8d6..2e89716 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
 # Time for a ChangeLog!
+## 1.40
+* `tech.datatype` fixed bug in argsort.
+
 ## 1.39
 * `tech.datatype` upgrade to version that supports datetime types.
 
diff --git a/deps.edn b/deps.edn
index 64856af..c835d1a 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "5.0-beta-9"}
+        techascent/tech.datatype {:mvn/version "5.0-beta-10"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
         }
  }
diff --git a/project.clj b/project.clj
index 7b40ea2..2c04c8c 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.40-SNAPSHOT"
+(defproject clj-python/libpython-clj "1.40"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 497f2f3421b79c9620110e68052b5f84693a61fc Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 18 Apr 2020 16:39:35 -0600
Subject: [PATCH 207/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 2c04c8c..d566b92 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.40"
+(defproject clj-python/libpython-clj "1.41-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 118843293d0adb4edcad1987736c6344a5d6a250 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 25 Apr 2020 12:12:07 -0600
Subject: [PATCH 208/456] 1.41

---
 CHANGELOG.md | 3 +++
 deps.edn     | 2 +-
 project.clj  | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2e89716..21dbc16 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
 # Time for a ChangeLog!
+## 1.41
+ * `tech.datatype` - latest version to work with `tech.ml.dataset`.
+
 ## 1.40
 * `tech.datatype` fixed bug in argsort.
 
diff --git a/deps.edn b/deps.edn
index c835d1a..7819577 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "5.0-beta-10"}
+        techascent/tech.datatype {:mvn/version "5.0-beta-16"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
         }
  }
diff --git a/project.clj b/project.clj
index d566b92..8b0f8a2 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.41-SNAPSHOT"
+(defproject clj-python/libpython-clj "1.41"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 49ab6e231f074e3f93dfabf867254c66145e6ff1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 25 Apr 2020 12:12:20 -0600
Subject: [PATCH 209/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 8b0f8a2..b65ac31 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.41"
+(defproject clj-python/libpython-clj "1.42-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 2f206261034a970b52f4c4002b3cf18f562375f2 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 29 Apr 2020 16:32:14 -0600
Subject: [PATCH 210/456] 1.42

---
 CHANGELOG.md | 3 +++
 deps.edn     | 2 +-
 project.clj  | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 21dbc16..bcfbee3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
 # Time for a ChangeLog!
+## 1.42
+ * `tech.datatype` - latest version to work with `tech.ml.dataset`.
+
 ## 1.41
  * `tech.datatype` - latest version to work with `tech.ml.dataset`.
 
diff --git a/deps.edn b/deps.edn
index 7819577..a601101 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "5.0-beta-16"}
+        techascent/tech.datatype {:mvn/version "5.0-beta-20"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
         }
  }
diff --git a/project.clj b/project.clj
index b65ac31..c350866 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.42-SNAPSHOT"
+(defproject clj-python/libpython-clj "1.42"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From a2cb7ba907405077e6be8eb202a9a4f32eb4431e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 29 Apr 2020 16:32:23 -0600
Subject: [PATCH 211/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index c350866..7fe5b1a 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.42"
+(defproject clj-python/libpython-clj "1.43-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From aafc20f4efa9aed2329d7bf08b2d7fbb7e04170d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 12 May 2020 12:25:50 -0600
Subject: [PATCH 212/456] 1.43

---
 CHANGELOG.md | 3 +++
 deps.edn     | 2 +-
 project.clj  | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bcfbee3..1574e41 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
 # Time for a ChangeLog!
+## 1.43
+ * `tech.datatype` - latest version to work with `tech.ml.dataset`.
+
 ## 1.42
  * `tech.datatype` - latest version to work with `tech.ml.dataset`.
 
diff --git a/deps.edn b/deps.edn
index a601101..b0b0a7d 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "5.0-beta-20"}
+        techascent/tech.datatype {:mvn/version "5.0-beta-30"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
         }
  }
diff --git a/project.clj b/project.clj
index 7fe5b1a..7e0aac6 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.43-SNAPSHOT"
+(defproject clj-python/libpython-clj "1.43"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From b12b8acb672fe22855f6c81c83b04a0d0a2d7000 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 12 May 2020 12:26:04 -0600
Subject: [PATCH 213/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 7e0aac6..4d1537b 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.43"
+(defproject clj-python/libpython-clj "1.44-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From dfd4cf58bf5311ef437b1d87194cb6a2836bfda6 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 16 May 2020 10:39:15 -0600
Subject: [PATCH 214/456] Fixes #98 - first attempt at making things really
 work for python 3.8

---
 dockerfiles/CondaDockerfile              |  3 +
 dockerfiles/Py38Dockerfile               | 32 ++++++++
 scripts/build-py38-docker                |  7 ++
 scripts/py38-repl                        |  6 ++
 scripts/run-conda-docker                 |  2 +-
 scripts/run-py38-docker                  |  9 +++
 src/libpython_clj/jna/base.clj           |  4 +-
 src/libpython_clj/python/interpreter.clj | 93 +++++++++++++++---------
 8 files changed, 119 insertions(+), 37 deletions(-)
 create mode 100644 dockerfiles/Py38Dockerfile
 create mode 100755 scripts/build-py38-docker
 create mode 100755 scripts/py38-repl
 create mode 100755 scripts/run-py38-docker

diff --git a/dockerfiles/CondaDockerfile b/dockerfiles/CondaDockerfile
index aad9560..fdba41d 100644
--- a/dockerfiles/CondaDockerfile
+++ b/dockerfiles/CondaDockerfile
@@ -39,6 +39,9 @@ USER $USERNAME
 RUN conda create -n pyclj python=3.6 && conda install -n pyclj numpy mxnet \
     && echo "source activate pyclj" > /home/$USERNAME/.bashrc
 
+## cause leiningen to install
+RUN lein -v
+
 
 ## To install pip packages into the pyclj environment do
 RUN conda run -n pyclj python3 -mpip install numpy
\ No newline at end of file
diff --git a/dockerfiles/Py38Dockerfile b/dockerfiles/Py38Dockerfile
new file mode 100644
index 0000000..41ec6a5
--- /dev/null
+++ b/dockerfiles/Py38Dockerfile
@@ -0,0 +1,32 @@
+# We will use Ubuntu for our image
+FROM ubuntu:latest
+
+# Updating Ubuntu packages
+
+ARG CLOJURE_TOOLS_VERSION=1.10.1.507
+
+
+RUN apt-get -qq update && apt-get -qq -y install curl wget bzip2 openjdk-8-jdk-headless python3.8 libpython3.8 python3-pip \
+    && curl -o install-clojure https://download.clojure.org/install/linux-install-${CLOJURE_TOOLS_VERSION}.sh \
+    && chmod +x install-clojure \
+    && ./install-clojure && rm install-clojure \
+    && wget https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein \
+    && chmod a+x lein \
+    && mv lein /usr/bin \
+    && apt-get -qq -y autoremove \
+    && apt-get autoclean \
+    && rm -rf /var/lib/apt/lists/* /var/log/dpkg.log
+
+
+ARG USERID
+ARG GROUPID
+ARG USERNAME
+
+RUN groupadd -g $GROUPID $USERNAME
+RUN useradd -u $USERID -g $GROUPID $USERNAME
+RUN mkdir /home/$USERNAME && chown $USERNAME:$USERNAME /home/$USERNAME
+USER $USERNAME
+
+# Install leiningen during build process
+RUN lein -v
+RUN python3.8 -mpip install numpy
\ No newline at end of file
diff --git a/scripts/build-py38-docker b/scripts/build-py38-docker
new file mode 100755
index 0000000..32fab3d
--- /dev/null
+++ b/scripts/build-py38-docker
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -e
+
+pushd dockerfiles
+docker build -t docker-py38 -f Py38Dockerfile --build-arg USERID=$(id -u) --build-arg GROUPID=$(id -u) --build-arg USERNAME=$USER .
+popd
diff --git a/scripts/py38-repl b/scripts/py38-repl
new file mode 100755
index 0000000..fe9624f
--- /dev/null
+++ b/scripts/py38-repl
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
+     -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
+     -- repl :headless :host localhost
+
diff --git a/scripts/run-conda-docker b/scripts/run-conda-docker
index 0299e0b..b8837a1 100755
--- a/scripts/run-conda-docker
+++ b/scripts/run-conda-docker
@@ -5,5 +5,5 @@ scripts/build-conda-docker
 docker run --rm -it -u $(id -u):$(id -g) \
   -v /$HOME/.m2:/home/$USER/.m2 \
   -v $(pwd)/:/libpython-clj \
-  -p 2222:2222 -w /libpython-clj \
+  --net=host -w /libpython-clj \
   docker-conda scripts/conda-repl
diff --git a/scripts/run-py38-docker b/scripts/run-py38-docker
new file mode 100755
index 0000000..dff5bf4
--- /dev/null
+++ b/scripts/run-py38-docker
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+scripts/build-py38-docker
+
+docker run --rm -it -u $(id -u):$(id -g) \
+  -v /$HOME/.m2:/home/$USER/.m2 \
+  -v $(pwd)/:/libpython-clj \
+  --net=host -w /libpython-clj \
+  docker-py38 scripts/py38-repl
diff --git a/src/libpython_clj/jna/base.clj b/src/libpython_clj/jna/base.clj
index 49427f5..45a9a3f 100644
--- a/src/libpython_clj/jna/base.clj
+++ b/src/libpython_clj/jna/base.clj
@@ -69,7 +69,7 @@
   (-> (Thread/currentThread)
       (.getId)))
 
-(def gil-thread-id (AtomicLong. Long/MAX_VALUE))
+(defonce gil-thread-id (AtomicLong. Long/MAX_VALUE))
 
 
 (defn set-gil-thread-id!
@@ -106,7 +106,7 @@
           `(.invoke (jna-base/to-typed-fn ~'tvm-fn) ~'fn-args)))))
 
 
-(def size-t-type (type (jna/size-t 0)))
+(defonce size-t-type (type (jna/size-t 0)))
 
 
 (defn find-pylib-symbol
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 526fded..1ecb42a 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -9,7 +9,8 @@
             [clojure.java.io :as io]
             [clojure.string :as s]
             [clojure.tools.logging :as log]
-            [clojure.data.json :as json])
+            [clojure.data.json :as json]
+            [clojure.pprint :as pp])
   (:import [libpython_clj.jna JVMBridge PyObject DirectMapped]
            [java.util.concurrent.atomic AtomicLong]
            [com.sun.jna Pointer]
@@ -91,11 +92,12 @@ print(json.dumps(
       (condp (partial =) (keyword platform)
         ;; TODO: not sure what the strings returned by
         ;;   ..: mac and windows are for sys.platform
-        :linux   "libpython%s.%sm.so$"
-        :mac     "libpython%s.%sm.dylib$"
+        :linux   "libpython%s.%sm?.so$"
+        :mac     "libpython%s.%sm?.dylib$"
         :win32   "python%s%s.dll$")
       major minor))))
 
+
 (defn python-library-paths
   "Returns vector of matching python libraries in order of:
   - virtual-env (library)
@@ -105,6 +107,7 @@ print(json.dumps(
   - installation prefix (executable)
   - default executable location"
   [system-info python-regex]
+  (println system-info)
   (transduce
    (comp
     (map io/file)
@@ -128,7 +131,7 @@ print(json.dumps(
 (comment
   ;; library paths workflow
 
-  (let [executable "python3.7"
+  (let [executable "python3.6"
         system-info (python-system-info executable)
         pyregex (python-library-regex system-info)]
     (python-library-paths system-info pyregex)))
@@ -142,13 +145,28 @@ print(json.dumps(
     (catch Throwable e nil)))
 
 
+(def default-python-executables
+  ["python3" "python3.6" "python3.7" "python3.8" "python3.9" "python"])
+
+
 (defn detect-startup-info
   [{:keys [library-path python-home python-executable]}]
   (log-info
    (str "Detecting startup-info for Python executable: "
         python-executable))
-  (let [executable                 (or python-executable "python3")
-        system-info                (python-system-info executable)
+  (let [executable-seq                (concat
+                                       (when python-executable
+                                         [python-executable])
+                                       default-python-executables)
+        system-info                (->> executable-seq
+                                        (map #(try (python-system-info %)
+                                                   (catch Throwable e
+                                                     nil)))
+                                        (remove nil?)
+                                        (first))
+        _ (when-not system-info
+            (throw (Exception. (format "Python executable was not found.  Tried: %s"
+                                       (vec executable-seq)))))
         python-home                (cond
                                      python-home
                                      python-home
@@ -165,12 +183,21 @@ print(json.dumps(
         libname                    (or library-path
                                        (when (seq lib-version)
                                          (str "python" lib-version "m")))
+        libnames                   (concat [libname]
+                                           ;;Make sure we try without the 'm' suffix
+                                           (when lib-version
+                                             [(str "python" lib-version)]))
         retval
-        {:python-home                python-home
-         :lib-version                lib-version
-         :libname                    libname
-         :java-library-path-addendum java-library-path-addendum}]
-    (log/infof "Startup info detected: %s" retval)
+        (merge
+         system-info
+         {:python-home                python-home
+          :lib-version                lib-version
+          :libname                    libname
+          :libnames                   libnames
+          :java-library-path-addendum java-library-path-addendum})]
+    (log/infof "Startup info detected:\n%s"
+               (with-out-str
+                 (pp/pprint (dissoc retval :libname))))
     retval))
 
 
@@ -185,7 +212,8 @@ print(json.dumps(
 
 ;; Main interpreter booted up during initialize!
 ;; * in the right to indicate atom
-(def main-interpreter* (atom nil))
+(defonce main-interpreter* (atom nil))
+
 (defn main-interpreter
   ^Interpreter []
   @main-interpreter*)
@@ -295,7 +323,6 @@ print(json.dumps(
   (.get ^AtomicLong libpy-base/gil-thread-id))
 
 
-
 (defn ensure-interpreter
   ^Interpreter []
   (let [retval (main-interpreter)]
@@ -355,7 +382,6 @@ print(json.dumps(
 (defonce ^:dynamic *program-name* "")
 
 
-
 (defn- find-python-lib-version
   []
   (let [{:keys [out err exit]} (ignore-shell-errors "python3" "--version")]
@@ -407,24 +433,21 @@ print(json.dumps(
 
 (defn initialize!
   [& {:keys [program-name
-             library-path
-             python-executable]
+             library-path]
       :as options}]
   (when-not (main-interpreter)
     (log-info (str "Executing python initialize with options:" options))
-    (let [{:keys [python-home libname java-library-path-addendum] :as startup-info}
+    (let [{:keys [python-home libnames java-library-path-addendum
+                  executable] :as startup-info}
           (detect-startup-info options)
-          library-names (cond
-                          library-path
-                          [library-path]
-                          libname
-                          (concat
-                           [libname]
-                           (libpy-base/library-names))
-                          :else
-                          (libpy-base/library-names))]
+          library-names (concat
+                         (when library-path
+                           [library-path])
+                         libnames
+                         (libpy-base/library-names))]
       (reset! python-home-wide-ptr* nil)
       (reset! python-path-wide-ptr* nil)
+      (log/infof "Trying python library names %s" (vec library-names))
       (when python-home
         (append-java-library-path! java-library-path-addendum)
         ;;This can never be released if load-library succeeeds
@@ -438,17 +461,19 @@ print(json.dumps(
                                                 @python-home-wide-ptr*
                                                 @python-path-wide-ptr*)))
           (recur library-names)))
-      (setup-direct-mapping!))
-    ;;Set program name
-    (when-let [program-name (or program-name *program-name* "")]
-      (pygc/with-stack-context
-       (libpy/PySys_SetArgv 0 (-> program-name
-                                  (jna/string->wide-ptr)))))
+      (setup-direct-mapping!)
+      ;;Set program name
+      (when-let [program-name (or program-name executable "")]
+        (pygc/with-stack-context
+          (libpy/PySys_SetArgv 0 (-> program-name
+                                     (jna/string->wide-ptr))))))
     (let [type-symbols (libpy/lookup-type-symbols)
           context (do
-                    (libpy-base/set-gil-thread-id! Long/MAX_VALUE (libpy-base/current-thread-id))
+                    (libpy-base/set-gil-thread-id!
+                     Long/MAX_VALUE (libpy-base/current-thread-id))
                     (let [retval (libpy/PyEval_SaveThread)]
-                      (libpy-base/set-gil-thread-id! (libpy-base/current-thread-id) Long/MAX_VALUE)
+                      (libpy-base/set-gil-thread-id!
+                       (libpy-base/current-thread-id) Long/MAX_VALUE)
                       retval))]
       (construct-main-interpreter! context type-symbols))))
 

From 62f146d86bad08bf4aa2a4d5f08e0f61192149ba Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 16 May 2020 10:45:36 -0600
Subject: [PATCH 215/456] 1.44

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 4d1537b..2186bbb 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.44-SNAPSHOT"
+(defproject clj-python/libpython-clj "1.44"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 601b04b721e0a930dae2a22aaf23c6bae487537d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 16 May 2020 10:47:39 -0600
Subject: [PATCH 216/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 2186bbb..4d1537b 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.44"
+(defproject clj-python/libpython-clj "1.44-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 22b934353bb27dcda77d6f9832ea7c9d7da23c32 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 20 May 2020 10:58:12 -0600
Subject: [PATCH 217/456] Upgrading to dtype beta-32

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index b0b0a7d..daf93eb 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "5.0-beta-30"}
+        techascent/tech.datatype {:mvn/version "5.0-beta-32"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
         }
  }

From 0fc0eefb75bbf63671037134c0e1ee3536c379d1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 13 Jun 2020 12:45:12 -0600
Subject: [PATCH 218/456] Updated to latest datatype lib.

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index daf93eb..559e174 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "5.0-beta-32"}
+        techascent/tech.datatype {:mvn/version "5.0-beta-40"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
         }
  }

From db7c7ce9b2dd67a1b015af273b004776ad49c065 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 15 Jun 2020 10:31:33 -0600
Subject: [PATCH 219/456] 1.45

---
 CHANGELOG.md | 3 +++
 deps.edn     | 2 +-
 project.clj  | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1574e41..551e384 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
 # Time for a ChangeLog!
+## 1.45
+ * tech.datatype - 5.0 release
+ 
 ## 1.43
  * `tech.datatype` - latest version to work with `tech.ml.dataset`.
 
diff --git a/deps.edn b/deps.edn
index 559e174..e1ebe25 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "5.0-beta-40"}
+        techascent/tech.datatype {:mvn/version "5.0"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
         }
  }
diff --git a/project.clj b/project.clj
index 4d1537b..8597108 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.44-SNAPSHOT"
+(defproject clj-python/libpython-clj "1.45"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From cdeb60662aadd68252be82a7930937689b93bf7f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 15 Jun 2020 10:31:41 -0600
Subject: [PATCH 220/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 8597108..1a0ea28 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.45"
+(defproject clj-python/libpython-clj "1.46-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From fbf719a2cb46390f3e410aaf0cda5e5802d3dc05 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Madis=20N=C3=B5mme?= <me@mad.is>
Date: Fri, 10 Jul 2020 15:51:32 +0300
Subject: [PATCH 221/456] Add full example on DataFrame usage & access (#100)

Add example of Python vs Clojure doing the same thing
  - import dependencies
  - create DataFrame
  - access its rows

To clarify how the `get-item` and `get-attr` work together.

After spending long time to figure out how the use the attributes vs
items access in Clojure to access DataFrame rows and columns, I thought
it would be useful to document full example how to do it Python &
Clojure side by side.
---
 docs/Usage.md | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/docs/Usage.md b/docs/Usage.md
index bc646e7..596d339 100644
--- a/docs/Usage.md
+++ b/docs/Usage.md
@@ -8,6 +8,15 @@ item access is optional and happens via the `__getitem__` and `__setitem__` attr
 This is important to realize in that the code below doesn't look like python because we are
 referencing the item and attribute systems by name and not via '.' or '[]'.
 
+This would result in the following analogous code (full example [further on](#dataframe-access-full-example)):
+
+```python
+table.loc[row_date]
+```
+
+```clojure
+(get-item (get-attr table :loc) row-date)
+```
 
 ### Installation
 
@@ -216,6 +225,31 @@ user> (att-type-map ones-ary)
 }
 ```
 
+### DataFrame access full example
+
+Here's how to create Pandas DataFrame and accessing its rows via `loc` in both Python and Clojure:
+
+```python
+# Python
+import numpy as np
+import pandas as pan
+
+dates = pan.date_range("1/1/2000", periods=8)
+table = pan.DataFrame(np.random.randn(8, 4), index=dates, columns=["A", "B", "C", "D"])
+row_date = pan.date_range(start="2000-01-01", end="2000-01-01")
+table.loc[row_date]
+```
+
+```clojure
+; Clojure
+(require-python '[numpy :as np])
+(require-python '[pandas :as pan])
+
+(def dates (pan/date_range "1/1/2000" :periods 8))
+(def table (pan/DataFrame (call-attr np/random :randn 8 4) :index dates :columns ["A" "B" "C" "D"]))
+(def row-date (pan/date_range :start "2000-01-01" :end "2000-01-01"))
+(get-item (get-attr table :loc) row-date)
+```
 
 ### Errors
 

From ab270cd95bfb5b97d790352333209b63431b828f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 10 Jul 2020 06:54:48 -0600
Subject: [PATCH 222/456] upgrade datatype.

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index e1ebe25..5b20205 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "5.0"}
+        techascent/tech.datatype {:mvn/version "5.05"}
         org.clojure/data.json    {:mvn/version "0.2.7"}
         }
  }

From b5772690a351229d5539d1dde1099f7718182e7c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 16 Jul 2020 07:29:53 -0600
Subject: [PATCH 223/456] Attempting to fix travis.

---
 .travis.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.travis.yml b/.travis.yml
index 1002412..9b592bd 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,9 @@
 language: clojure
 lein: 2.9.1
+sudo: required
 before_install:
   - sudo apt-get -y install python3 python3-pip
+  - sudo python3 -mpip install setuptools
   - sudo python3 -mpip install numpy
   - curl -O https://download.clojure.org/install/linux-install-1.10.1.507.sh
   - chmod +x linux-install-1.10.1.507.sh

From a846a4902d9b109ebfa93ea9c23eba5a2f8f8efe Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 16 Jul 2020 07:33:52 -0600
Subject: [PATCH 224/456] travis hacking...

---
 .travis.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.travis.yml b/.travis.yml
index 9b592bd..3883953 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,4 +1,5 @@
 language: clojure
+dist: bionic
 lein: 2.9.1
 sudo: required
 before_install:

From a85be74de9385ba2ef0c01c78eb0c4045b9abd42 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Mon, 7 Sep 2020 16:57:42 -0400
Subject: [PATCH 225/456] add pathing metadata; fix metatype bug (#118)

---
 src/libpython_clj/metadata.clj             | 53 +++++++++++++++-------
 src/libpython_clj/require.clj              |  4 +-
 test/libpython_clj/require_python_test.clj | 32 ++++++++++++-
 3 files changed, 70 insertions(+), 19 deletions(-)

diff --git a/src/libpython_clj/metadata.clj b/src/libpython_clj/metadata.clj
index 947f59c..4f5f7c7 100644
--- a/src/libpython_clj/metadata.clj
+++ b/src/libpython_clj/metadata.clj
@@ -17,6 +17,8 @@
 (def inspect (as-jvm (import-module "inspect") {}))
 (def argspec (get-attr inspect "getfullargspec"))
 (def py-source (get-attr inspect "getsource"))
+(def py-sourcelines (get-attr inspect "getsourcelines"))
+(def py-file (get-attr inspect "getfile"))
 (def types (import-module "types"))
 (def fn-type
   (call-attr builtins "tuple"
@@ -42,11 +44,25 @@
 (def importlib (py/import-module "importlib"))
 (def importlib_util (import-module "importlib.util"))
 (def reload-module (py/get-attr importlib "reload"))
+
 (defn findspec [x]
   (let [-findspec
         (-> importlib_util (get-attr "find_spec"))]
     (-findspec x)))
 
+
+(defn find-lineno [x]
+  (try 
+    (-> x py-sourcelines last)
+    (catch Exception _
+      nil)))
+
+(defn find-file [x]
+  (try
+    (py-file x)
+    (catch Exception _
+      nil)))
+
 (defn py-fn-argspec [f]
   (if-let [spec (try (when-not (pyclass? f)
                        (argspec f))
@@ -155,10 +171,6 @@
          (recur argspec' defaults' arglists))))))
 
 
-(defn py-class-argspec [class]
-  (let [constructor (py/get-attr class "__init__")]
-    (py-fn-argspec constructor)))
-
 
 (defn py-fn-metadata [fn-name x {:keys [no-arglists?]}]
   (let [fn-argspec (pyargspec x)
@@ -190,14 +202,18 @@
 
 (defn base-pyobj-map
   [item]
-  (merge {:type (py/python-type item)
-          :doc (doc item)
-          :str (.toString item)
-          :flags (pyobj-flags item)}
-         (when (has-attr? item "__module__")
-           {:module (get-attr item "__module__")})
-         (when (has-attr? item "__name__")
-           {:name (get-attr item "__name__")})))
+  (cond-> {:type  (py/python-type item)
+           :doc   (doc item)
+           :str   (.toString item)
+           :flags (pyobj-flags item)
+           :line  (find-lineno item)
+           :file  (find-file item)}
+    (has-attr? item "__module__")
+    (assoc :module (get-attr item "__module__"))
+    (has-attr? item "__name__")
+    (assoc :name (get-attr item "__name__"))
+    (and (find-lineno item) (find-file item))
+    (assoc :line (find-lineno item) :file (find-file item))))
 
 
 (defn scalar?
@@ -280,10 +296,15 @@
 
 (defn metadata-map->py-obj
   [metadata-map]
-  (case (:type metadata-map)
-    :module (import-module (:name metadata-map))
-    :type (-> (import-module (:module metadata-map))
-              (get-attr (:name metadata-map)))))
+  (try
+    (case  (:type metadata-map)
+      :module (import-module (:name metadata-map))
+      :type   (-> (import-module (:module metadata-map))
+                  (get-attr (:name metadata-map))))
+    (catch Exception _
+      ;; metatypes -- e.g. socket.SocketIO
+      (-> (import-module (:module metadata-map))
+          (get-attr (:name metadata-map))))))
 
 
 (defn get-or-create-namespace!
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 0513309..3cc4cca 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -127,7 +127,9 @@
                                   " to something without periods."))))        
         (intern
          (symbol (str *ns*))
-         (symbol import-name)
+         (with-meta (symbol import-name)
+           {:file (metadata/find-file pyobj)
+            :line 1})
          pyobj)))
     
     (when (or (not existing-py-ns?) reload?)
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj/require_python_test.clj
index a79b39b..42afbea 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj/require_python_test.clj
@@ -114,7 +114,35 @@
 
   (is (set? (datafy (python/frozenset [1 2 3])))))
 
-
-
 (deftest import-python-test
   (is (= :ok (libpython-clj.require/import-python))))
+
+(require-python '[socket :bind-ns true])
+(require-python 'socket.SocketIO)
+(deftest metadata-test
+  (testing "metadata generation"
+    ;; module meta
+    (let [{line :line file :file} (meta #'socket)]
+      (is (= 1 line)
+          "Modules have line numbers")
+      (is (string? file)
+          "Modules have file paths"))
+    ;; class meta
+    (let [{line :line file :file} (meta #'socket/SocketIO)]
+      (is (int? line)
+          "Classes have line numbers")
+      (is (string? file)
+          "Classes have file paths"))
+    ;; function meta
+    (let [{line :line file :file} (meta #'socket/_intenum_converter)]
+      (is (int? line)
+          "Functions have line numbers")
+      (is (string? file)
+          "Functions have file paths"))
+    ;; method meta
+    (let [{line :line file :file} (meta #'socket.SocketIO/readable)]
+      (is (int? line)
+          "Methods have line numbers")
+      (is (string? file)
+          "Methods have file paths"))))
+

From 03fab5f5d7b6a29e3975342db8c47ac1fd1a5b69 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 7 Sep 2020 15:24:04 -0600
Subject: [PATCH 226/456] Support for Python3.9 - cfunction_new ->
 cfunction_newex

---
 src/libpython_clj/jna.clj                    |  2 +-
 src/libpython_clj/jna/concrete/cfunction.clj |  5 +++--
 src/libpython_clj/python/object.clj          | 11 ++++++-----
 3 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/libpython_clj/jna.clj b/src/libpython_clj/jna.clj
index def6530..b3eee91 100644
--- a/src/libpython_clj/jna.clj
+++ b/src/libpython_clj/jna.clj
@@ -292,7 +292,7 @@
                 METH_O
                 METH_STATIC
                 METH_VARARGS
-                PyCFunction_New
+                PyCFunction_NewEx
                 PyInstanceMethod_New)
 
 
diff --git a/src/libpython_clj/jna/concrete/cfunction.clj b/src/libpython_clj/jna/concrete/cfunction.clj
index 05d9765..afa1017 100644
--- a/src/libpython_clj/jna/concrete/cfunction.clj
+++ b/src/libpython_clj/jna/concrete/cfunction.clj
@@ -51,11 +51,12 @@
 ;; #endif
 
 
-(def-pylib-fn PyCFunction_New
+(def-pylib-fn PyCFunction_NewEx
   "Create a new callable from an item."
   Pointer
   [method-def (partial jna/ensure-type PyMethodDef)]
-  [self as-pyobj])
+  [self as-pyobj]
+  [module as-pyobj])
 
 
 (def-pylib-fn PyInstanceMethod_New
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 5495ec8..d339fc1 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -444,11 +444,12 @@ Object's refcount is bad.  Crash is imminent"
     ;;This is a nice little tidbit, cfunction_new
     ;;steals the reference.
     (let [py-self (when py-self (incref (->python py-self)))]
-      (-> (libpy/PyCFunction_New (method-def-data->method-def
-                                  {:name method-name
-                                   :doc documentation
-                                   :function cfunc})
-                                 py-self)
+      (-> (libpy/PyCFunction_NewEx (method-def-data->method-def
+                                    {:name method-name
+                                     :doc documentation
+                                     :function cfunc})
+                                   py-self
+                                   nil)
           (wrap-pyobject)))))
 
 

From 466b53bd8def26ca77ba75cb33005df24b0078c4 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 7 Sep 2020 15:24:28 -0600
Subject: [PATCH 227/456] Adding a minimal pathway to test on python3.9

---
 dockerfiles/Py39Dockerfile | 35 +++++++++++++++++++++++++++++++++++
 scripts/build-py39-docker  |  7 +++++++
 scripts/run-py39-docker    |  9 +++++++++
 3 files changed, 51 insertions(+)
 create mode 100644 dockerfiles/Py39Dockerfile
 create mode 100755 scripts/build-py39-docker
 create mode 100755 scripts/run-py39-docker

diff --git a/dockerfiles/Py39Dockerfile b/dockerfiles/Py39Dockerfile
new file mode 100644
index 0000000..f071037
--- /dev/null
+++ b/dockerfiles/Py39Dockerfile
@@ -0,0 +1,35 @@
+# We will use Ubuntu for our image
+FROM ubuntu:latest
+
+# Updating Ubuntu packages
+
+ARG CLOJURE_TOOLS_VERSION=1.10.1.507
+
+RUN apt-get -qq update \
+    && apt install -y software-properties-common \
+    && add-apt-repository -y ppa:deadsnakes/ppa
+
+RUN apt-get -qq update && apt-get -qq -y install curl wget bzip2 openjdk-8-jdk-headless python3.9 libpython3.9 python3-pip python3-distutils\
+    && curl -o install-clojure https://download.clojure.org/install/linux-install-${CLOJURE_TOOLS_VERSION}.sh \
+    && chmod +x install-clojure \
+    && ./install-clojure && rm install-clojure \
+    && wget https://raw.githubusercontent.com/technomancy/leiningen/stable/bin/lein \
+    && chmod a+x lein \
+    && mv lein /usr/bin \
+    && apt-get -qq -y autoremove \
+    && apt-get autoclean \
+    && rm -rf /var/lib/apt/lists/* /var/log/dpkg.log
+
+
+ARG USERID
+ARG GROUPID
+ARG USERNAME
+
+RUN groupadd -g $GROUPID $USERNAME
+RUN useradd -u $USERID -g $GROUPID $USERNAME
+RUN mkdir /home/$USERNAME && chown $USERNAME:$USERNAME /home/$USERNAME
+USER $USERNAME
+
+# Install leiningen during build process
+RUN lein -v
+# RUN python3.9 -mpip install numpy
\ No newline at end of file
diff --git a/scripts/build-py39-docker b/scripts/build-py39-docker
new file mode 100755
index 0000000..c9b099a
--- /dev/null
+++ b/scripts/build-py39-docker
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -e
+
+pushd dockerfiles
+docker build -t docker-py39 -f Py39Dockerfile --build-arg USERID=$(id -u) --build-arg GROUPID=$(id -u) --build-arg USERNAME=$USER .
+popd
diff --git a/scripts/run-py39-docker b/scripts/run-py39-docker
new file mode 100755
index 0000000..39358ad
--- /dev/null
+++ b/scripts/run-py39-docker
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+scripts/build-py39-docker
+
+docker run --rm -it -u $(id -u):$(id -g) \
+  -v /$HOME/.m2:/home/$USER/.m2 \
+  -v $(pwd)/:/libpython-clj \
+  --net=host -w /libpython-clj \
+  docker-py39 scripts/py38-repl

From e129cf14690d1d5602016293a8a7241c36910555 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 7 Sep 2020 15:29:46 -0600
Subject: [PATCH 228/456] 1.46

---
 deps.edn    | 4 ++--
 project.clj | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/deps.edn b/deps.edn
index 5b20205..111c78b 100644
--- a/deps.edn
+++ b/deps.edn
@@ -4,7 +4,7 @@
  :deps {
         org.clojure/clojure      {:mvn/version "1.10.1"}
         camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "5.05"}
-        org.clojure/data.json    {:mvn/version "0.2.7"}
+        techascent/tech.datatype {:mvn/version "5.18"}
+        org.clojure/data.json    {:mvn/version "1.0.0"}
         }
  }
diff --git a/project.clj b/project.clj
index 1a0ea28..def8b8d 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.46-SNAPSHOT"
+(defproject clj-python/libpython-clj "1.46"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 69c4c0c11098e7352aed9d48d606ab402525af11 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 7 Sep 2020 15:29:56 -0600
Subject: [PATCH 229/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index def8b8d..857e6b9 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "1.46"
+(defproject clj-python/libpython-clj "1.47-SNAPSHOT"
   :description "libpython bindings to the techascent ecosystem"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 73f9c7fbf743f85cc69559b88174e61f82a1a27e Mon Sep 17 00:00:00 2001
From: Alan Thompson <cloojure@gmail.com>
Date: Mon, 19 Oct 2020 15:49:38 -0700
Subject: [PATCH 230/456] Added warning re outdated Clojars version (#128)

Hi - Just had some problems due to referencing the outdated `cnuernber` aritfacts on Clojars.  This name is still widely referenced in blog entries & videos and crashes when trying to run with Python 3.8, for example.  I thought a small warning on the README may help others to avoid this trap.

Thanks for a great library!

Alan
---
 README.md | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 963f059..8791f3a 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,14 @@
-# libpython-clj
+# JNA libpython bindings to the tech ecosystem.
 
-JNA libpython bindings to the tech ecosystem.
+### Version Info
 
 [![Clojars Project](https://img.shields.io/clojars/v/clj-python/libpython-clj.svg)](https://clojars.org/clj-python/libpython-clj)
 [![travis integration](https://travis-ci.com/clj-python/libpython-clj.svg?branch=master)](https://travis-ci.com/clj-python/libpython-clj)
 
+ - Note - Please avoid deprecated versions such as `[cnuernber/libpython-clj "1.36"]` (***note name change***).
+
+## libpython-clj features
+
 * Bridge between JVM objects and Python objects easily; use Python in your Java and
   use some Java in your Python.
 * Python objects are linked to the JVM GC such that when they are no longer reachable

From 0c5c7443753d29cc0ee365de0417cf66e868b800 Mon Sep 17 00:00:00 2001
From: Jay <jjtolton@gmail.com>
Date: Mon, 19 Oct 2020 20:34:00 -0400
Subject: [PATCH 231/456] fix docstring

---
 src/libpython_clj/python.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 6e113fb..e6d3970 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -163,7 +163,7 @@
 
 (defn run-simple-string
   "Run a string expression returning a map of
-  {:globals :locals :result}.
+  {:globals :locals}.
   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.

From fb6d793675ba7f3e54c2c16cc65ed923f6fd8855 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 22 Oct 2020 13:21:07 -0600
Subject: [PATCH 232/456] Dtype next support- faster loading and support for
 newest version of tech stack moving forward (#131)

* initial dtype next changes.

* Initialize! works again

* [test] Passing.

* Attempting to get API docs.

* bumping version before merge to master

* Test with latest.

Co-authored-by: Harold <hhausman@gmail.com>
---
 deps.edn                                   |  10 -
 docs/Usage.html                            | 321 ++++++++++
 docs/css/default.css                       | 649 +++++++++++++++++++++
 docs/design.html                           |  96 +++
 docs/highlight/highlight.min.js            |   2 +
 docs/highlight/solarized-light.css         |  84 +++
 docs/index.html                            |   3 +
 docs/js/jquery.min.js                      |   4 +
 docs/js/page_effects.js                    | 113 ++++
 docs/libpython-clj.python.html             |  26 +
 docs/new-to-clojure.html                   |  49 ++
 docs/scopes-and-gc.html                    |  42 ++
 docs/slicing.html                          |  58 ++
 project.clj                                |  28 +-
 src/libpython_clj/jna.clj                  |   8 +-
 src/libpython_clj/jna/concrete/bytes.clj   |   4 +-
 src/libpython_clj/jna/concrete/unicode.clj |   4 +-
 src/libpython_clj/jna/protocols/buffer.clj |   2 +-
 src/libpython_clj/python.clj               |   5 +-
 src/libpython_clj/python/bridge.clj        |  86 ++-
 src/libpython_clj/python/interop.clj       |   5 +-
 src/libpython_clj/python/np_array.clj      |  99 +---
 src/libpython_clj/python/object.clj        |  30 +-
 src/libpython_clj/python/protocols.clj     |   5 -
 test/libpython_clj/python/numpy_test.clj   |  14 +-
 test/libpython_clj/python_test.clj         |  33 +-
 {docs => topics}/Usage.md                  |   0
 {docs => topics}/design.md                 |   0
 {docs => topics}/new-to-clojure.md         |   0
 {docs => topics}/scopes-and-gc.md          |   0
 {docs => topics}/slicing.md                |   0
 31 files changed, 1578 insertions(+), 202 deletions(-)
 delete mode 100644 deps.edn
 create mode 100644 docs/Usage.html
 create mode 100644 docs/css/default.css
 create mode 100644 docs/design.html
 create mode 100644 docs/highlight/highlight.min.js
 create mode 100644 docs/highlight/solarized-light.css
 create mode 100644 docs/index.html
 create mode 100644 docs/js/jquery.min.js
 create mode 100644 docs/js/page_effects.js
 create mode 100644 docs/libpython-clj.python.html
 create mode 100644 docs/new-to-clojure.html
 create mode 100644 docs/scopes-and-gc.html
 create mode 100644 docs/slicing.html
 rename {docs => topics}/Usage.md (100%)
 rename {docs => topics}/design.md (100%)
 rename {docs => topics}/new-to-clojure.md (100%)
 rename {docs => topics}/scopes-and-gc.md (100%)
 rename {docs => topics}/slicing.md (100%)

diff --git a/deps.edn b/deps.edn
deleted file mode 100644
index 111c78b..0000000
--- a/deps.edn
+++ /dev/null
@@ -1,10 +0,0 @@
-{
- :paths ["src"]
-
- :deps {
-        org.clojure/clojure      {:mvn/version "1.10.1"}
-        camel-snake-kebab        {:mvn/version "0.4.0"}
-        techascent/tech.datatype {:mvn/version "5.18"}
-        org.clojure/data.json    {:mvn/version "1.0.0"}
-        }
- }
diff --git a/docs/Usage.html b/docs/Usage.html
new file mode 100644
index 0000000..ae328bd
--- /dev/null
+++ b/docs/Usage.html
@@ -0,0 +1,321 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
+<p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
+<pre><code class="python">table.loc[row_date]
+</code></pre>
+<pre><code class="clojure">(get-item (get-attr table :loc) row-date)
+</code></pre>
+<h3><a href="#installation" name="installation"></a>Installation</h3>
+<h4><a href="#ubuntu" name="ubuntu"></a>Ubuntu</h4>
+<pre><code class="console">sudo apt install libpython3.6
+# numpy and pandas are required for unit tests.  Numpy is required for
+# zero copy support.
+python3.6 -m pip install numpy pandas --user
+</code></pre>
+<h4><a href="#macosx" name="macosx"></a>MacOSX</h4>
+<p>Python installation instructions <a href="https://docs.python-guide.org/starting/install3/osx/">here</a>.</p>
+<h3><a href="#initialize-python" name="initialize-python"></a>Initialize python</h3>
+<pre><code class="clojure">user&gt;
+
+user&gt; (require '[libpython-clj.python
+                 :refer [as-python as-jvm
+                         -&gt;python -&gt;jvm
+                         get-attr call-attr call-attr-kw
+                         get-item att-type-map
+                         call call-kw initialize!
+                         as-numpy as-tensor -&gt;numpy
+                         run-simple-string
+                         add-module module-dict
+                         import-module
+                         python-type]])
+nil
+
+; Mac and Linux
+user&gt; (initialize!)
+Jun 30, 2019 4:47:39 PM clojure.tools.logging$eval7369$fn__7372 invoke
+INFO: executing python initialize!
+Jun 30, 2019 4:47:39 PM clojure.tools.logging$eval7369$fn__7372 invoke
+INFO: Library python3.6m found at [:system "python3.6m"]
+Jun 30, 2019 4:47:39 PM clojure.tools.logging$eval7369$fn__7372 invoke
+INFO: Reference thread starting
+:ok
+
+; Windows with Anaconda
+(initialize! ; Python executable
+             :python-executable "C:\\Users\\USER\\AppData\\Local\\Continuum\\anaconda3\\python.exe"
+             ; Python Library
+             :library-path "C:\\Users\\USER\\AppData\\Local\\Continuum\\anaconda3\\python37.dll"
+             ; Anacondas PATH environment to load native dlls of modules (numpy, etc.)
+             :windows-anaconda-activate-bat "C:\\Users\\USER\\AppData\\Local\\Continuum\\anaconda3\\Scripts\\activate.bat"
+             )
+...
+:ok
+</code></pre>
+<p>This dynamically finds the python shared library and loads it using output from the python3 executable on your system. For information about how that works, please checkout the code <a href="https://github.com/cnuernber/libpython-clj/blob/master/src/libpython_clj/python/interpreter.clj#L30">here</a>.</p>
+<h3><a href="#execute-some-python" name="execute-some-python"></a>Execute Some Python</h3>
+<p><code>*out*</code> and <code>*err*</code> capture python stdout and stderr respectively.</p>
+<pre><code class="clojure"><br />user&gt; (run-simple-string "print('hey')")
+hey
+{:globals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;},
+ :locals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;}}
+</code></pre>
+<p>The results have been ‘bridged’ into java meaning they are still python objects but there are java wrappers over the top of them. For instance, <code>Object.toString</code> forwards its implementation to the python function <code>__str__</code>.</p>
+<pre><code class="clojure">(def bridged (run-simple-string "print('hey')"))
+(instance? java.util.Map (:globals bridged))
+true
+user&gt; (:globals bridged)
+{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;}
+</code></pre>
+<p>We can get and set global variables here. If we run another string, these are in the environment. The globals map itself is the global dict of the main module:</p>
+<pre><code class="clojure">(def main-globals (-&gt; (add-module "__main__")
+                            (module-dict)))
+#'user/main-globals
+
+user&gt; main-globals
+{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;}
+user&gt; (keys main-globals)
+("__name__"
+ "__doc__"
+ "__package__"
+ "__loader__"
+ "__spec__"
+ "__annotations__"
+ "__builtins__")
+user&gt; (get main-globals "__name__")
+"__main__"
+user&gt; (.put main-globals "my_var" 200)
+nil
+
+user&gt; (run-simple-string "print('your variable is:' + str(my_var))")
+your variable is:200
+{:globals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;, 'my_var': 200},
+ :locals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;, 'my_var': 200}}
+</code></pre>
+<p>Running Python isn’t ever really necessary, however, although it may at times be convenient. You can call attributes from clojure easily:</p>
+<pre><code class="clojure">user&gt; (def np (import-module "numpy"))
+#'user/np
+user&gt; (def ones-ary (call-attr np "ones" [2 3]))
+#'user/ones-ary
+user&gt; ones-ary
+[[1. 1. 1.]
+ [1. 1. 1.]]
+user&gt; (call-attr ones-ary "__len__")
+2
+user&gt; (vec ones-ary)
+[[1. 1. 1.] [1. 1. 1.]]
+user&gt; (type (first *1))
+:pyobject
+user&gt; (get-attr ones-ary "shape")
+(2, 3)
+user&gt; (vec (get-attr ones-ary "shape"))
+[2 3]
+
+user&gt; (att-type-map ones-ary)
+{"T" :ndarray,
+ "__abs__" :method-wrapper,
+ "__add__" :method-wrapper,
+ "__and__" :method-wrapper,
+ "__array__" :builtin-function-or-method,
+ "__array_finalize__" :none-type,
+ "__array_function__" :builtin-function-or-method,
+ "__array_interface__" :dict,
+ "__array_prepare__" :builtin-function-or-method,
+ "__array_priority__" :float,
+ "__array_struct__" :py-capsule,
+ "__array_ufunc__" :builtin-function-or-method,
+ "__array_wrap__" :builtin-function-or-method,
+ "__bool__" :method-wrapper,
+ "__class__" :type,
+ "__complex__" :builtin-function-or-method,
+ "__contains__" :method-wrapper,
+ ...
+ "std" :builtin-function-or-method,
+ "strides" :tuple,
+ "sum" :builtin-function-or-method,
+ "swapaxes" :builtin-function-or-method,
+ "take" :builtin-function-or-method,
+ "tobytes" :builtin-function-or-method,
+ "tofile" :builtin-function-or-method,
+ "tolist" :builtin-function-or-method,
+ "tostring" :builtin-function-or-method,
+ "trace" :builtin-function-or-method,
+ "transpose" :builtin-function-or-method,
+ "var" :builtin-function-or-method,
+ "view" :builtin-function-or-method}
+</code></pre>
+<h3><a href="#att-type-map" name="att-type-map"></a>att-type-map</h3>
+<p>It can be extremely helpful to print out the attribute name-&gt;attribute type map:</p>
+<pre><code class="clojure">user&gt; (att-type-map ones-ary)
+{"T" :ndarray,
+ "__abs__" :method-wrapper,
+ "__add__" :method-wrapper,
+ "__and__" :method-wrapper,
+ "__array__" :builtin-function-or-method,
+ "__array_finalize__" :none-type,
+ "__array_function__" :builtin-function-or-method,
+ "__array_interface__" :dict,
+ ...
+  "real" :ndarray,
+ "repeat" :builtin-function-or-method,
+ "reshape" :builtin-function-or-method,
+ "resize" :builtin-function-or-method,
+ "round" :builtin-function-or-method,
+ "searchsorted" :builtin-function-or-method,
+ "setfield" :builtin-function-or-method,
+ "setflags" :builtin-function-or-method,
+ "shape" :tuple,
+ "size" :int,
+ "sort" :builtin-function-or-method,
+ ...
+}
+</code></pre>
+<h3><a href="#dataframe-access-full-example" name="dataframe-access-full-example"></a>DataFrame access full example</h3>
+<p>Here’s how to create Pandas DataFrame and accessing its rows via <code>loc</code> in both Python and Clojure:</p>
+<pre><code class="python"># Python
+import numpy as np
+import pandas as pan
+
+dates = pan.date_range("1/1/2000", periods=8)
+table = pan.DataFrame(np.random.randn(8, 4), index=dates, columns=["A", "B", "C", "D"])
+row_date = pan.date_range(start="2000-01-01", end="2000-01-01")
+table.loc[row_date]
+</code></pre>
+<pre><code class="clojure">; Clojure
+(require-python '[numpy :as np])
+(require-python '[pandas :as pan])
+
+(def dates (pan/date_range "1/1/2000" :periods 8))
+(def table (pan/DataFrame (call-attr np/random :randn 8 4) :index dates :columns ["A" "B" "C" "D"]))
+(def row-date (pan/date_range :start "2000-01-01" :end "2000-01-01"))
+(get-item (get-attr table :loc) row-date)
+</code></pre>
+<h3><a href="#errors" name="errors"></a>Errors</h3>
+<p>Errors are caught and an exception is thrown. The error text is saved verbatim in the exception:</p>
+<pre><code class="clojure">user&gt; (run-simple-string "print('syntax errrr")
+Execution error (ExceptionInfo) at libpython-clj.python.interpreter/check-error-throw (interpreter.clj:260).
+  File "&lt;string&gt;", line 1
+    print('syntax errrr
+                      ^
+SyntaxError: EOL while scanning string literal
+</code></pre>
+<h3><a href="#some-syntax-sugar" name="some-syntax-sugar"></a>Some Syntax Sugar</h3>
+<pre><code class="clojure">user&gt; (py/from-import numpy linspace)
+#'user/linspace
+user&gt; (linspace 2 3 :num 10)
+[2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
+ 2.66666667 2.77777778 2.88888889 3.        ]
+user&gt; (doc linspace)
+-------------------------
+user/linspace
+
+    Return evenly spaced numbers over a specified interval.
+
+    Returns `num` evenly spaced samples, calculated over the
+    interval [`start`, `stop`].
+
+</code></pre>
+<ul>
+  <li><code>from-import</code> - sugar around python <code>from a import b</code>. Takes multiple b’s.</li>
+  <li><code>import-as</code> - surgar around python <code>import a as b</code>.</li>
+  <li><code>$a</code> - call an attribute using symbol att name. Keywords map to kwargs</li>
+  <li><code>$c</code> - call an object mapping keywords to kwargs</li>
+</ul>
+<h4><a href="#experimental-sugar" name="experimental-sugar"></a>Experimental Sugar</h4>
+<p>We are trying to find the best way to handle attributes in order to shorten generic python notebook-type usage. The currently implemented direction is:</p>
+<ul>
+  <li><code>$.</code> - get an attribute. Can pass in symbol, string, or keyword</li>
+  <li><code>$..</code> - get an attribute. If more args are present, get the attribute on that result.</li>
+</ul>
+<pre><code class="clojure">user&gt; (py/$. numpy linspace)
+&lt;function linspace at 0x7fa6642766a8&gt;
+user&gt; (py/$.. numpy random shuffle)
+&lt;built-in method shuffle of numpy.random.mtrand.RandomState object at 0x7fa66410cca8&gt;
+</code></pre>
+<h5><a href="#new-sugar-fixme-" name="new-sugar-fixme-"></a>New sugar (fixme)</h5>
+<p><code>libpython-clj</code> offers syntactic forms similar to those offered by Clojure for interacting with Python classes and objects. </p>
+<p><strong>Class/object methods</strong> Where in Clojure you would use <code>(. obj method arg1 arg2 ... argN)</code>, you can use <code>(py. pyobj method arg1 arg2 ... argN)</code>. </p>
+<p>In Python, this is equivalent to <code>pyobj.method(arg1, arg2, ..., argN)</code>. Concrete examples are shown below.</p>
+<p><strong>Class/object attributes</strong> Where in Clojure you would use <code>(.- obj attr)</code>, you can use <code>(py.- pyobj attr)</code>.</p>
+<p>In Python, this is equivalent to <code>pyobj.attr</code>. Concrete examples shown below.</p>
+<p><strong>Nested attribute access</strong> To achieve a chain of method/attribute access, use the <code>py..</code> for.</p>
+<pre><code class="clojure ">(py.. (requests/get "http://www.google.com") 
+      -content
+      (decode "latin-1"))
+</code></pre>
+<p>(**Note**: requires Python <code>requests</code> module installled)</p>
+<p><strong>Examples</strong></p>
+<pre><code class="clojure ">user=&gt; (require '[libpython-clj.python :as py :refer [py. py.. py.-]])
+nil
+user=&gt; (require '[libpython-clj.require :refer [require-python]])
+
+... debug info ...
+
+user=&gt; (require-python '[builtins :as python])
+WARNING: AssertionError already refers to: class java.lang.AssertionError in namespace: builtins, being replaced by: #'builtins/AssertionError
+WARNING: Exception already refers to: class java.lang.Exception in namespace: builtins, being replaced by: #'builtins/Exception
+nil
+user=&gt; (def xs (python/list))
+#'user/xs
+user=&gt; (py. xs append 1)
+nil
+user=&gt; xs
+[1]
+user=&gt; (py. xs extend [1 2 3])
+nil
+user=&gt; xs
+[1, 1, 2, 3]
+user=&gt; (py. xs __len__)
+4
+user=&gt; ((py.- xs __len__)) ;; attribute syntax to get then call method
+4
+user=&gt; (py. xs pop)
+3
+user=&gt; (py. xs clear)
+nil
+;; requires Python requests module installed
+user=&gt; (require-python 'requests)
+nil
+user=&gt; (def requests (py/import-module "requests"))
+#'user/requests
+user=&gt; (py.. requests (get "http://www.google.com") -content (decode "latin-1"))
+"&lt;!doctype html&gt;&lt;html itemscope=\"\" ... snip ... "
+</code></pre>
+<h3><a href="#numpy" name="numpy"></a>Numpy</h3>
+<p>Speaking of numpy, you can move data between numpy and java easily.</p>
+<pre><code class="clojure">user&gt; (def tens-data (as-tensor ones-ary))
+#'user/tens-data
+user&gt; (println tens-data)
+#tech.v2.tensor&lt;float64&gt;[2 3]
+[[1.000 1.000 1.000]
+ [1.000 1.000 1.000]]
+nil
+
+
+user&gt; (require '[tech.v2.datatype :as dtype])
+nil
+user&gt; (def ignored (dtype/copy! (repeat 6 5) tens-data))
+#'user/ignored
+user&gt; (.put main-globals "ones_ary" ones_ary)
+Syntax error compiling at (*cider-repl cnuernber/libpython-clj:localhost:39019(clj)*:191:7).
+Unable to resolve symbol: ones_ary in this context
+user&gt; (.put main-globals "ones_ary" ones-ary)
+nil
+
+user&gt; (run-simple-string "print(ones_ary)")
+[[5. 5. 5.]
+ [5. 5. 5.]]
+{:globals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;, 'my_var': 200, 'ones_ary': array([[5., 5., 5.],
+       [5., 5., 5.]])},
+ :locals
+ {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;, 'my_var': 200, 'ones_ary': array([[5., 5., 5.],
+       [5., 5., 5.]])}}
+</code></pre>
+<p>So heavy data has a zero-copy route. Anything backed by a <code>:native-buffer</code> has a zero copy pathway to and from numpy. For more information on how this happens, please refer to the datatype library <a href="https://github.com/techascent/tech.datatype/tree/master/docs">documentation</a>.</p>
+<p>Just keep in mind, careless usage of zero copy is going to cause spooky action at a  distance.</p></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/css/default.css b/docs/css/default.css
new file mode 100644
index 0000000..c78d040
--- /dev/null
+++ b/docs/css/default.css
@@ -0,0 +1,649 @@
+@import url('https://fonts.googleapis.com/css?family=PT+Sans');
+
+body {
+    font-family: 'PT Sans', Helvetica, sans-serif;
+    font-size: 14px;
+}
+
+a {
+    color: #337ab7;
+    text-decoration: none;
+}
+
+a:hover {
+    color: #30426a;
+    text-decoration: underline;
+}
+
+pre, code {
+    font-family: Monaco, DejaVu Sans Mono, Consolas, monospace;
+    font-size: 9pt;
+    margin: 15px 0;
+}
+
+h1 {
+    font-weight: normal;
+    font-size: 29px;
+    margin: 10px 0 2px 0;
+    padding: 0;
+}
+
+h2 {
+    font-weight: normal;
+    font-size: 25px;
+}
+
+h3 > a:hover {
+    text-decoration: none;
+}
+
+.document h1, .namespace-index h1 {
+    font-size: 32px;
+    margin-top: 12px;
+}
+
+#header, #content, .sidebar {
+    position: fixed;
+}
+
+#header {
+    top: 0;
+    left: 0;
+    right: 0;
+    height: 22px;
+    color: #f5f5f5;
+    padding: 5px 7px;
+}
+
+#content {
+    top: 32px;
+    right: 0;
+    bottom: 0;
+    overflow: auto;
+    background: #fff;
+    color: #333;
+    padding: 0 18px;
+}
+
+.sidebar {
+    position: fixed;
+    top: 32px;
+    bottom: 0;
+    overflow: auto;
+}
+
+.sidebar.primary {
+    background: #30426a;
+    border-right: solid 1px #cccccc;
+    left: 0;
+    width: 250px;
+    color: white;
+    font-size: 110%;
+}
+
+.sidebar.secondary {
+    background: #f2f2f2;
+    border-right: solid 1px #d7d7d7;
+    left: 251px;
+    width: 200px;
+    font-size: 110%;
+}
+
+#content.namespace-index, #content.document {
+    left: 251px;
+}
+
+#content.namespace-docs {
+    left: 452px;
+}
+
+#content.document {
+    padding-bottom: 10%;
+}
+
+#header {
+    background: #2d3e63;
+    box-shadow: 0 0 8px rgba(0, 0, 0, 0.4);
+    z-index: 100;
+}
+
+#header h1 {
+    margin: 0;
+    padding: 0;
+    font-size: 18px;
+    font-weight: lighter;
+    text-shadow: -1px -1px 0px #333;
+}
+
+#header h1 .project-version {
+    font-weight: normal;
+}
+
+.project-version {
+    padding-left: 0.15em;
+}
+
+#header a, .sidebar a {
+    display: block;
+    text-decoration: none;
+}
+
+#header a {
+    color: #f5f5f5;
+}
+
+.sidebar.primary, .sidebar.primary a {
+    color: #b2bfdc;
+}
+
+.sidebar.primary a:hover {
+    color: white;
+}
+
+.sidebar.secondary, .sidebar.secondary a {
+    color: #738bc0;
+}
+
+.sidebar.secondary a:hover {
+    color: #2d3e63;
+}
+
+#header h2 {
+    float: right;
+    font-size: 9pt;
+    font-weight: normal;
+    margin: 4px 3px;
+    padding: 0;
+    color: #bbb;
+}
+
+#header h2 a {
+    display: inline;
+}
+
+.sidebar h3 {
+    margin: 0;
+    padding: 10px 13px 0 13px;
+    font-size: 19px;
+    font-weight: lighter;
+}
+
+.sidebar.primary h3.no-link {
+    text-transform: uppercase;
+    font-size: 12px;
+    color: #738bc0;
+}
+
+.sidebar.secondary h3 a {
+    text-transform: uppercase;
+    font-size: 12px;
+    color: #2d3e63;
+}
+
+.sidebar ul {
+    padding: 7px 0 6px 0;
+    margin: 0;
+}
+
+.sidebar ul.index-link {
+    padding-bottom: 4px;
+}
+
+.sidebar li {
+    display: block;
+    vertical-align: middle;
+}
+
+.sidebar li a, .sidebar li .no-link {
+    border-left: 3px solid transparent;
+    padding: 0 10px;
+    white-space: nowrap;
+}
+
+.sidebar li .inner {
+    display: inline-block;
+    padding-top: 7px;
+    height: 24px;
+}
+
+.sidebar li a, .sidebar li .tree {
+    height: 31px;
+}
+
+.depth-1 .inner { padding-left: 2px; }
+.depth-2 .inner { padding-left: 6px; }
+.depth-3 .inner { padding-left: 20px; }
+.depth-4 .inner { padding-left: 34px; }
+.depth-5 .inner { padding-left: 48px; }
+.depth-6 .inner { padding-left: 62px; }
+
+.sidebar li .tree {
+    display: block;
+    float: left;
+    position: relative;
+    top: -10px;
+    margin: 0 4px 0 0;
+    padding: 0;
+}
+
+.sidebar li.depth-1 .tree {
+    display: none;
+}
+
+.sidebar li .tree .top, .sidebar li .tree .bottom {
+    display: block;
+    margin: 0;
+    padding: 0;
+    width: 7px;
+}
+
+.sidebar li .tree .top {
+    border-left: 1px solid #aaa;
+    border-bottom: 1px solid #aaa;
+    height: 19px;
+}
+
+.sidebar li .tree .bottom {
+    height: 22px;
+}
+
+.sidebar li.branch .tree .bottom {
+    border-left: 1px solid #aaa;
+}
+
+.sidebar.primary li.current a {
+    border-left: 3px solid #e99d1a;
+    color: white;
+}
+
+.sidebar.secondary li.current a {
+    border-left: 3px solid #2d3e63;
+    color: #33a;
+}
+
+.namespace-index h2 {
+    margin: 30px 0 0 0;
+}
+
+.namespace-index h3 {
+    font-size: 16px;
+    font-weight: bold;
+    margin-bottom: 0;
+    letter-spacing: 0.05em;
+    border-bottom: solid 1px #ddd;
+    max-width: 680px;
+    background-color: #fafafa;
+    padding: 0.5em;
+}
+
+.namespace-index .topics {
+    padding-left: 30px;
+    margin: 11px 0 0 0;
+}
+
+.namespace-index .topics li {
+    padding: 5px 0;
+}
+
+.namespace-docs h3 {
+    font-size: 18px;
+    font-weight: bold;
+}
+
+.public h3 {
+    margin: 0;
+    float: left;
+}
+
+.usage {
+    clear: both;
+}
+
+.public {
+    margin: 0;
+    border-top: 1px solid #e0e0e0;
+    padding-top: 14px;
+    padding-bottom: 6px;
+}
+
+.public:last-child {
+    margin-bottom: 20%;
+}
+
+.members .public:last-child {
+    margin-bottom: 0;
+}
+
+.members {
+    margin: 15px 0;
+}
+
+.members h4 {
+    color: #555;
+    font-weight: normal;
+    font-variant: small-caps;
+    margin: 0 0 5px 0;
+}
+
+.members .inner {
+    padding-top: 5px;
+    padding-left: 12px;
+    margin-top: 2px;
+    margin-left: 7px;
+    border-left: 1px solid #bbb;
+}
+
+#content .members .inner h3 {
+    font-size: 12pt;
+}
+
+.members .public {
+    border-top: none;
+    margin-top: 0;
+    padding-top: 6px;
+    padding-bottom: 0;
+}
+
+.members .public:first-child {
+    padding-top: 0;
+}
+
+h4.type,
+h4.dynamic,
+h4.added,
+h4.deprecated {
+    float: left;
+    margin: 3px 10px 15px 0;
+    font-size: 15px;
+    font-weight: bold;
+    font-variant: small-caps;
+}
+
+.public h4.type,
+.public h4.dynamic,
+.public h4.added,
+.public h4.deprecated {
+    font-size: 13px;
+    font-weight: bold;
+    margin: 3px 0 0 10px;
+}
+
+.members h4.type,
+.members h4.added,
+.members h4.deprecated {
+    margin-top: 1px;
+}
+
+h4.type {
+    color: #717171;
+}
+
+h4.dynamic {
+    color: #9933aa;
+}
+
+h4.added {
+    color: #508820;
+}
+
+h4.deprecated {
+    color: #880000;
+}
+
+.namespace {
+    margin-bottom: 30px;
+}
+
+.namespace:last-child {
+    margin-bottom: 10%;
+}
+
+.index {
+    padding: 0;
+    font-size: 80%;
+    margin: 15px 0;
+    line-height: 1.6em;
+}
+
+.index * {
+    display: inline;
+}
+
+.index p {
+    padding-right: 3px;
+}
+
+.index li {
+    padding-right: 5px;
+}
+
+.index ul {
+    padding-left: 0;
+}
+
+.type-sig {
+    clear: both;
+    color: #088;
+}
+
+.type-sig pre {
+    padding-top: 10px;
+    margin: 0;
+}
+
+.usage code {
+    display: block;
+    color: #008;
+    margin: 2px 0;
+}
+
+.usage code:first-child {
+    padding-top: 10px;
+}
+
+p {
+    margin: 15px 0;
+}
+
+.public p:first-child, .public pre.plaintext {
+    margin-top: 12px;
+}
+
+.doc {
+    margin: 0 0 26px 0;
+    clear: both;
+}
+
+.public .doc {
+    margin: 0;
+}
+
+.namespace-index {
+  font-size: 120%;
+}
+
+.namespace-index .doc {
+    margin-bottom: 20px;
+}
+
+.namespace-index .namespace .doc {
+    margin-bottom: 10px;
+}
+
+.markdown p, .markdown li, .markdown dt, .markdown dd, .markdown td {
+    line-height: 1.6em;
+}
+
+.markdown h2 {
+    font-weight: normal;
+    font-size: 25px;
+}
+
+#content .markdown h3 {
+    font-size: 20px;
+}
+
+.markdown h4 {
+    font-size: 15px;
+}
+
+.doc, .public, .namespace .index {
+    max-width: 680px;
+    overflow-x: visible;
+}
+
+.markdown pre > code {
+    display: block;
+    padding: 10px;
+}
+
+.markdown pre > code, .src-link a {
+    border: 1px solid #e4e4e4;
+    border-radius: 2px;
+}
+
+.src-link a {
+    background: #f6f6f6;
+}
+
+.markdown code:not(.hljs) {
+    color: #c7254e;
+    background-color: #f9f2f4;
+    border-radius: 4px;
+    font-size: 90%;
+    padding: 2px 4px;
+}
+
+pre.deps {
+    display: inline-block;
+    margin: 0 10px;
+    border: 1px solid #e4e4e4;
+    border-radius: 2px;
+    padding: 10px;
+    background-color: #f6f6f6;
+}
+
+.markdown hr {
+    border-style: solid;
+    border-top: none;
+    color: #ccc;
+}
+
+.doc ul, .doc ol {
+    padding-left: 30px;
+}
+
+.doc table {
+    border-collapse: collapse;
+    margin: 0 10px;
+}
+
+.doc table td, .doc table th {
+    border: 1px solid #dddddd;
+    padding: 4px 6px;
+}
+
+.doc table th {
+    background: #f2f2f2;
+}
+
+.doc dl {
+    margin: 0 10px 20px 10px;
+}
+
+.doc dl dt {
+    font-weight: bold;
+    margin: 0;
+    padding: 3px 0;
+    border-bottom: 1px solid #ddd;
+}
+
+.doc dl dd {
+    padding: 5px 0;
+    margin: 0 0 5px 10px;
+}
+
+.doc abbr {
+    border-bottom: 1px dotted #333;
+    font-variant: none;
+    cursor: help;
+}
+
+.src-link {
+    margin-bottom: 15px;
+}
+
+.src-link a {
+    font-size: 70%;
+    padding: 1px 4px;
+    text-decoration: none;
+    color: #5555bb;
+    background-color: #f6f6f6;
+}
+
+blockquote {
+    opacity: 0.6;
+    border-left: solid 2px #ddd;
+    margin-left: 0;
+    padding-left: 1em;
+}
+
+/* Responsiveness Theme */
+
+@media (max-device-width: 480px) {
+  .sidebar {
+    display:none;
+  }
+
+  #content {
+    position: relative;
+    left: initial !important;
+    top: 110px;
+    padding: 0 1em;
+  }
+
+  #header {
+    display: flex;
+    flex-direction: column-reverse;
+    height: 100px;
+  }
+
+  #header > h1 {
+    font-size: 52px;
+  }
+
+  #header h2 {
+    float: none;
+    font-size: 20px;
+  }
+
+  .namespace-index > h1 {
+    display: none;
+  }
+
+  .public, .doc, .namespace > .index, .namespace > .doc, .namespace > h3 {
+    max-width: initial;
+  }
+
+  .doc {
+    text-align: justify;
+  }
+
+  .public {
+    padding-top: 2em;
+    padding-bottom: 2em;
+  }
+
+  .public > h3 {
+    font-size: 300%;
+  }
+
+  .public > h4.type, .public > h4.added, .public > h4.deprecated {
+    font-size: 150%;
+    margin-top: 1em;
+  }
+
+  pre > code {
+    font-size: 200%;
+  }
+}
diff --git a/docs/design.html b/docs/design.html
new file mode 100644
index 0000000..c6a2285
--- /dev/null
+++ b/docs/design.html
@@ -0,0 +1,96 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
+<h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
+<p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
+<ol>
+  <li>
+  <p>An API implementation layer which knows about things like interpreters and type  symbol tables. Users must know how to manipulate the GIL and how the two garbage  collectors work with each other to add to this layer.</p></li>
+  <li>
+  <p>A public API layer. Details like managing the GIL or messing with garbage collection  in general do not leak out to this layer.</p></li>
+</ol>
+<h3><a href="#interpreters" name="interpreters"></a>Interpreters</h3>
+<p>Interpreters are global objects. After initialize!, there is a main interpreter which is used automatically from any thread. Access to the interpreters relies on thread local variables and interpreter locking so you can do things like:</p>
+<pre><code class="clojure">(with-interpreter interpreter
+  some code)
+</code></pre>
+<p>You don’t have to do this, however. If you don’t care what context you run in you can just use the public API which under the covers simple does:</p>
+<pre><code class="clojure">(with-gil
+  some code)
+</code></pre>
+<p>This type of thing grabs the GIL if it hasn’t already been claimed by the current thread and off you go. When the code is finished, it saves the interpreter thread state back into a global atom and thus releases the GIL. Interpreters have both shared and per-interpreter state named <code>:shared-state</code> and <code>:interpreter-state</code> respectively. Shared state would be the global type symbol table. Interpreter state contains things like a map of objects to their per-interpreter python bridging class.</p>
+<p>If the interpreter isn’t specified it uses the main interpreter. The simplest way to ensure you have the gil is <code>with-gil</code>. You may also use <code>(ensure-bound-interpreter)</code> if you wish to penalize users for using a function incorrectly. This returns the interpreter currently bound to this thread or throws.</p>
+<h3><a href="#garbage-collection" name="garbage-collection"></a>Garbage Collection</h3>
+<p>The system uses the <a href="https://github.com/techascent/tech.resource">tech.resource</a> library to attach a GC hook to appropriate java object that releases the associated python object if the java object goes out of scope. Bridges use a similar technique to unregister the bridge on destruction of their python counterpart. There should be no need for manual addref/release calls in any user code aside from potentially (and damn rarely) a <code>(System/gc)</code> call.</p>
+<h3><a href="#copying-vs-bridging" name="copying-vs-bridging"></a>Copying Vs. Bridging</h3>
+<p>Objects either in python or in java may be either copied or bridged into the other ecosystem. Bridging allows sharing complex and potentially changing datastructures while copying allows a cleaner partitioning of concerns and frees both garbage collection systems to act more independently. Numeric buffers that have a direct representation as a C-ptr (the datatype native-buffer type) have a zero-copy pathway via numpy. If you want access to object functionality that object needs to be bridged; so for example if you want to call numpy functions then you need to bridge that object. Tensors are always represented in python as numpy objects using zero-copy where possible in all cases.</p>
+<h3><a href="#bridging" name="bridging"></a>Bridging</h3>
+<p>Python Callables implement <code>clojure.lang.IFn</code> along with a python specific interface so in general you can call them like any other function but you also can use keyword arguments if you know you are dealing with a python function. Python dicts implement <code>java.util.Map</code> and <code>clojure.lang.IFn</code> and lists are <code>java.util.List</code>, <code>java.util.RandomAccess</code>, and <code>clojure.lang.IFn</code>. This allows fluid manipulation of the datastructures (even mutation) from both languages.</p>
+<p>You can create a python function from a clojure function with create-function. You can create a new bridge type by implementing the <code>libpython_clj.jna.JVMBridge</code> interface:</p>
+<pre><code class="java">public interface JVMBridge extends AutoCloseable
+{
+  public Pointer getAttr(String name);
+  public void setAttr(String name, Pointer val);
+  public String[] dir();
+  public Object interpreter();
+  public Object wrappedObject();
+  // Called from python when the python mirror is deleted.
+  // This had better not throw anything.
+  public default void close() {}
+}
+</code></pre>
+<p>If all you want to do is override the attribute map that is simple. Here is the bridge for java.util.Map:</p>
+<pre><code class="clojure">(defn jvm-map-&gt;python
+  ^Pointer [^Map jvm-data]
+  (with-gil
+    (let [att-map
+          {"__contains__" (jvm-fn-&gt;python #(.containsKey jvm-data %))
+           "__eq__" (jvm-fn-&gt;python #(.equals jvm-data %))
+           "__getitem__" (jvm-fn-&gt;python #(.get jvm-data %))
+           "__setitem__" (jvm-fn-&gt;python #(.put jvm-data %1 %2))
+           "__hash__" (jvm-fn-&gt;python #(.hashCode jvm-data))
+           "__iter__" (jvm-fn-&gt;python #(.iterator ^Iterable jvm-data))
+           "__len__" (jvm-fn-&gt;python #(.size jvm-data))
+           "__str__" (jvm-fn-&gt;python #(.toString jvm-data))
+           "clear" (jvm-fn-&gt;python #(.clear jvm-data))
+           "keys" (jvm-fn-&gt;python #(seq (.keySet jvm-data)))
+           "values" (jvm-fn-&gt;python #(seq (.values jvm-data)))
+           "pop" (jvm-fn-&gt;python #(.remove jvm-data %))}]
+      (create-bridge-from-att-map jvm-data att-map))))
+</code></pre>
+<h3><a href="#io" name="io"></a>IO</h3>
+<p><code>sys.stdout</code> and <code>sys.stderr</code> are redirected to <code>*out*</code> and <code>*err*</code> respectively. This rerouting is done using a bridge that is then set as <code>sys.stdout</code> or <code>sys.stderr</code>:</p>
+<pre><code class="clojure">(defn create-var-writer
+  "Returns an unregistered bridge"
+  ^Pointer [writer-var]
+  (with-gil
+    (create-bridge-from-att-map
+     writer-var
+     {"write" (-&gt;python (fn [&amp; args]
+                          (.write ^Writer @writer-var (str (first args)))))
+      "flush" (-&gt;python (fn [&amp; args]))
+      "isatty" (-&gt;python (fn [&amp; args]
+                           (libpy/Py_False)))
+      })))
+
+(defn setup-std-writer
+  [writer-var sys-mod-attname]
+  (with-gil
+    (let [sys-module (import-module "sys")
+          std-out-writer (get-or-create-var-writer writer-var)]
+      (py-proto/set-attr! sys-module sys-mod-attname std-out-writer)
+      :ok)))
+
+
+(defn initialize!
+  [&amp; {:keys [program-name no-io-redirect?]}]
+  (when-not @pyinterp/*main-interpreter*
+    (pyinterp/initialize! program-name)
+    ;;setup bridge mechansim and io redirection
+    (pyinterop/register-bridge-type!)
+    (when-not no-io-redirect?
+      (pyinterop/setup-std-writer #'*err* "stderr")
+      (pyinterop/setup-std-writer #'*out* "stdout")))
+  :ok)
+</code></pre></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/highlight/highlight.min.js b/docs/highlight/highlight.min.js
new file mode 100644
index 0000000..6486ffd
--- /dev/null
+++ b/docs/highlight/highlight.min.js
@@ -0,0 +1,2 @@
+/*! highlight.js v9.6.0 | BSD3 License | git.io/hljslicense */
+!function(e){var n="object"==typeof window&&window||"object"==typeof self&&self;"undefined"!=typeof exports?e(exports):n&&(n.hljs=e({}),"function"==typeof define&&define.amd&&define([],function(){return n.hljs}))}(function(e){function n(e){return e.replace(/[&<>]/gm,function(e){return I[e]})}function t(e){return e.nodeName.toLowerCase()}function r(e,n){var t=e&&e.exec(n);return t&&0===t.index}function a(e){return k.test(e)}function i(e){var n,t,r,i,o=e.className+" ";if(o+=e.parentNode?e.parentNode.className:"",t=B.exec(o))return R(t[1])?t[1]:"no-highlight";for(o=o.split(/\s+/),n=0,r=o.length;r>n;n++)if(i=o[n],a(i)||R(i))return i}function o(e,n){var t,r={};for(t in e)r[t]=e[t];if(n)for(t in n)r[t]=n[t];return r}function u(e){var n=[];return function r(e,a){for(var i=e.firstChild;i;i=i.nextSibling)3===i.nodeType?a+=i.nodeValue.length:1===i.nodeType&&(n.push({event:"start",offset:a,node:i}),a=r(i,a),t(i).match(/br|hr|img|input/)||n.push({event:"stop",offset:a,node:i}));return a}(e,0),n}function c(e,r,a){function i(){return e.length&&r.length?e[0].offset!==r[0].offset?e[0].offset<r[0].offset?e:r:"start"===r[0].event?e:r:e.length?e:r}function o(e){function r(e){return" "+e.nodeName+'="'+n(e.value)+'"'}l+="<"+t(e)+w.map.call(e.attributes,r).join("")+">"}function u(e){l+="</"+t(e)+">"}function c(e){("start"===e.event?o:u)(e.node)}for(var s=0,l="",f=[];e.length||r.length;){var g=i();if(l+=n(a.substr(s,g[0].offset-s)),s=g[0].offset,g===e){f.reverse().forEach(u);do c(g.splice(0,1)[0]),g=i();while(g===e&&g.length&&g[0].offset===s);f.reverse().forEach(o)}else"start"===g[0].event?f.push(g[0].node):f.pop(),c(g.splice(0,1)[0])}return l+n(a.substr(s))}function s(e){function n(e){return e&&e.source||e}function t(t,r){return new RegExp(n(t),"m"+(e.cI?"i":"")+(r?"g":""))}function r(a,i){if(!a.compiled){if(a.compiled=!0,a.k=a.k||a.bK,a.k){var u={},c=function(n,t){e.cI&&(t=t.toLowerCase()),t.split(" ").forEach(function(e){var t=e.split("|");u[t[0]]=[n,t[1]?Number(t[1]):1]})};"string"==typeof a.k?c("keyword",a.k):E(a.k).forEach(function(e){c(e,a.k[e])}),a.k=u}a.lR=t(a.l||/\w+/,!0),i&&(a.bK&&(a.b="\\b("+a.bK.split(" ").join("|")+")\\b"),a.b||(a.b=/\B|\b/),a.bR=t(a.b),a.e||a.eW||(a.e=/\B|\b/),a.e&&(a.eR=t(a.e)),a.tE=n(a.e)||"",a.eW&&i.tE&&(a.tE+=(a.e?"|":"")+i.tE)),a.i&&(a.iR=t(a.i)),null==a.r&&(a.r=1),a.c||(a.c=[]);var s=[];a.c.forEach(function(e){e.v?e.v.forEach(function(n){s.push(o(e,n))}):s.push("self"===e?a:e)}),a.c=s,a.c.forEach(function(e){r(e,a)}),a.starts&&r(a.starts,i);var l=a.c.map(function(e){return e.bK?"\\.?("+e.b+")\\.?":e.b}).concat([a.tE,a.i]).map(n).filter(Boolean);a.t=l.length?t(l.join("|"),!0):{exec:function(){return null}}}}r(e)}function l(e,t,a,i){function o(e,n){var t,a;for(t=0,a=n.c.length;a>t;t++)if(r(n.c[t].bR,e))return n.c[t]}function u(e,n){if(r(e.eR,n)){for(;e.endsParent&&e.parent;)e=e.parent;return e}return e.eW?u(e.parent,n):void 0}function c(e,n){return!a&&r(n.iR,e)}function g(e,n){var t=N.cI?n[0].toLowerCase():n[0];return e.k.hasOwnProperty(t)&&e.k[t]}function h(e,n,t,r){var a=r?"":y.classPrefix,i='<span class="'+a,o=t?"":C;return i+=e+'">',i+n+o}function p(){var e,t,r,a;if(!E.k)return n(B);for(a="",t=0,E.lR.lastIndex=0,r=E.lR.exec(B);r;)a+=n(B.substr(t,r.index-t)),e=g(E,r),e?(M+=e[1],a+=h(e[0],n(r[0]))):a+=n(r[0]),t=E.lR.lastIndex,r=E.lR.exec(B);return a+n(B.substr(t))}function d(){var e="string"==typeof E.sL;if(e&&!x[E.sL])return n(B);var t=e?l(E.sL,B,!0,L[E.sL]):f(B,E.sL.length?E.sL:void 0);return E.r>0&&(M+=t.r),e&&(L[E.sL]=t.top),h(t.language,t.value,!1,!0)}function b(){k+=null!=E.sL?d():p(),B=""}function v(e){k+=e.cN?h(e.cN,"",!0):"",E=Object.create(e,{parent:{value:E}})}function m(e,n){if(B+=e,null==n)return b(),0;var t=o(n,E);if(t)return t.skip?B+=n:(t.eB&&(B+=n),b(),t.rB||t.eB||(B=n)),v(t,n),t.rB?0:n.length;var r=u(E,n);if(r){var a=E;a.skip?B+=n:(a.rE||a.eE||(B+=n),b(),a.eE&&(B=n));do E.cN&&(k+=C),E.skip||(M+=E.r),E=E.parent;while(E!==r.parent);return r.starts&&v(r.starts,""),a.rE?0:n.length}if(c(n,E))throw new Error('Illegal lexeme "'+n+'" for mode "'+(E.cN||"<unnamed>")+'"');return B+=n,n.length||1}var N=R(e);if(!N)throw new Error('Unknown language: "'+e+'"');s(N);var w,E=i||N,L={},k="";for(w=E;w!==N;w=w.parent)w.cN&&(k=h(w.cN,"",!0)+k);var B="",M=0;try{for(var I,j,O=0;;){if(E.t.lastIndex=O,I=E.t.exec(t),!I)break;j=m(t.substr(O,I.index-O),I[0]),O=I.index+j}for(m(t.substr(O)),w=E;w.parent;w=w.parent)w.cN&&(k+=C);return{r:M,value:k,language:e,top:E}}catch(T){if(T.message&&-1!==T.message.indexOf("Illegal"))return{r:0,value:n(t)};throw T}}function f(e,t){t=t||y.languages||E(x);var r={r:0,value:n(e)},a=r;return t.filter(R).forEach(function(n){var t=l(n,e,!1);t.language=n,t.r>a.r&&(a=t),t.r>r.r&&(a=r,r=t)}),a.language&&(r.second_best=a),r}function g(e){return y.tabReplace||y.useBR?e.replace(M,function(e,n){return y.useBR&&"\n"===e?"<br>":y.tabReplace?n.replace(/\t/g,y.tabReplace):void 0}):e}function h(e,n,t){var r=n?L[n]:t,a=[e.trim()];return e.match(/\bhljs\b/)||a.push("hljs"),-1===e.indexOf(r)&&a.push(r),a.join(" ").trim()}function p(e){var n,t,r,o,s,p=i(e);a(p)||(y.useBR?(n=document.createElementNS("http://www.w3.org/1999/xhtml","div"),n.innerHTML=e.innerHTML.replace(/\n/g,"").replace(/<br[ \/]*>/g,"\n")):n=e,s=n.textContent,r=p?l(p,s,!0):f(s),t=u(n),t.length&&(o=document.createElementNS("http://www.w3.org/1999/xhtml","div"),o.innerHTML=r.value,r.value=c(t,u(o),s)),r.value=g(r.value),e.innerHTML=r.value,e.className=h(e.className,p,r.language),e.result={language:r.language,re:r.r},r.second_best&&(e.second_best={language:r.second_best.language,re:r.second_best.r}))}function d(e){y=o(y,e)}function b(){if(!b.called){b.called=!0;var e=document.querySelectorAll("pre code");w.forEach.call(e,p)}}function v(){addEventListener("DOMContentLoaded",b,!1),addEventListener("load",b,!1)}function m(n,t){var r=x[n]=t(e);r.aliases&&r.aliases.forEach(function(e){L[e]=n})}function N(){return E(x)}function R(e){return e=(e||"").toLowerCase(),x[e]||x[L[e]]}var w=[],E=Object.keys,x={},L={},k=/^(no-?highlight|plain|text)$/i,B=/\blang(?:uage)?-([\w-]+)\b/i,M=/((^(<[^>]+>|\t|)+|(?:\n)))/gm,C="</span>",y={classPrefix:"hljs-",tabReplace:null,useBR:!1,languages:void 0},I={"&":"&amp;","<":"&lt;",">":"&gt;"};return e.highlight=l,e.highlightAuto=f,e.fixMarkup=g,e.highlightBlock=p,e.configure=d,e.initHighlighting=b,e.initHighlightingOnLoad=v,e.registerLanguage=m,e.listLanguages=N,e.getLanguage=R,e.inherit=o,e.IR="[a-zA-Z]\\w*",e.UIR="[a-zA-Z_]\\w*",e.NR="\\b\\d+(\\.\\d+)?",e.CNR="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",e.BNR="\\b(0b[01]+)",e.RSR="!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",e.BE={b:"\\\\[\\s\\S]",r:0},e.ASM={cN:"string",b:"'",e:"'",i:"\\n",c:[e.BE]},e.QSM={cN:"string",b:'"',e:'"',i:"\\n",c:[e.BE]},e.PWM={b:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|like)\b/},e.C=function(n,t,r){var a=e.inherit({cN:"comment",b:n,e:t,c:[]},r||{});return a.c.push(e.PWM),a.c.push({cN:"doctag",b:"(?:TODO|FIXME|NOTE|BUG|XXX):",r:0}),a},e.CLCM=e.C("//","$"),e.CBCM=e.C("/\\*","\\*/"),e.HCM=e.C("#","$"),e.NM={cN:"number",b:e.NR,r:0},e.CNM={cN:"number",b:e.CNR,r:0},e.BNM={cN:"number",b:e.BNR,r:0},e.CSSNM={cN:"number",b:e.NR+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",r:0},e.RM={cN:"regexp",b:/\//,e:/\/[gimuy]*/,i:/\n/,c:[e.BE,{b:/\[/,e:/\]/,r:0,c:[e.BE]}]},e.TM={cN:"title",b:e.IR,r:0},e.UTM={cN:"title",b:e.UIR,r:0},e.METHOD_GUARD={b:"\\.\\s*"+e.UIR,r:0},e});hljs.registerLanguage("clojure",function(e){var t={"builtin-name":"def defonce cond apply if-not if-let if not not= = < > <= >= == + / * - rem quot neg? pos? delay? symbol? keyword? true? false? integer? empty? coll? list? set? ifn? fn? associative? sequential? sorted? counted? reversible? number? decimal? class? distinct? isa? float? rational? reduced? ratio? odd? even? char? seq? vector? string? map? nil? contains? zero? instance? not-every? not-any? libspec? -> ->> .. . inc compare do dotimes mapcat take remove take-while drop letfn drop-last take-last drop-while while intern condp case reduced cycle split-at split-with repeat replicate iterate range merge zipmap declare line-seq sort comparator sort-by dorun doall nthnext nthrest partition eval doseq await await-for let agent atom send send-off release-pending-sends add-watch mapv filterv remove-watch agent-error restart-agent set-error-handler error-handler set-error-mode! error-mode shutdown-agents quote var fn loop recur throw try monitor-enter monitor-exit defmacro defn defn- macroexpand macroexpand-1 for dosync and or when when-not when-let comp juxt partial sequence memoize constantly complement identity assert peek pop doto proxy defstruct first rest cons defprotocol cast coll deftype defrecord last butlast sigs reify second ffirst fnext nfirst nnext defmulti defmethod meta with-meta ns in-ns create-ns import refer keys select-keys vals key val rseq name namespace promise into transient persistent! conj! assoc! dissoc! pop! disj! use class type num float double short byte boolean bigint biginteger bigdec print-method print-dup throw-if printf format load compile get-in update-in pr pr-on newline flush read slurp read-line subvec with-open memfn time re-find re-groups rand-int rand mod locking assert-valid-fdecl alias resolve ref deref refset swap! reset! set-validator! compare-and-set! alter-meta! reset-meta! commute get-validator alter ref-set ref-history-count ref-min-history ref-max-history ensure sync io! new next conj set! to-array future future-call into-array aset gen-class reduce map filter find empty hash-map hash-set sorted-map sorted-map-by sorted-set sorted-set-by vec vector seq flatten reverse assoc dissoc list disj get union difference intersection extend extend-type extend-protocol int nth delay count concat chunk chunk-buffer chunk-append chunk-first chunk-rest max min dec unchecked-inc-int unchecked-inc unchecked-dec-inc unchecked-dec unchecked-negate unchecked-add-int unchecked-add unchecked-subtract-int unchecked-subtract chunk-next chunk-cons chunked-seq? prn vary-meta lazy-seq spread list* str find-keyword keyword symbol gensym force rationalize"},r="a-zA-Z_\\-!.?+*=<>&#'",n="["+r+"]["+r+"0-9/;:]*",a="[-+]?\\d+(\\.\\d+)?",o={b:n,r:0},s={cN:"number",b:a,r:0},i=e.inherit(e.QSM,{i:null}),c=e.C(";","$",{r:0}),d={cN:"literal",b:/\b(true|false|nil)\b/},l={b:"[\\[\\{]",e:"[\\]\\}]"},m={cN:"comment",b:"\\^"+n},p=e.C("\\^\\{","\\}"),u={cN:"symbol",b:"[:]{1,2}"+n},f={b:"\\(",e:"\\)"},h={eW:!0,r:0},y={k:t,l:n,cN:"name",b:n,starts:h},b=[f,i,m,p,c,u,l,s,d,o];return f.c=[e.C("comment",""),y,h],h.c=b,l.c=b,{aliases:["clj"],i:/\S/,c:[f,i,m,p,c,u,l,s,d]}});hljs.registerLanguage("clojure-repl",function(e){return{c:[{cN:"meta",b:/^([\w.-]+|\s*#_)=>/,starts:{e:/$/,sL:"clojure"}}]}});
\ No newline at end of file
diff --git a/docs/highlight/solarized-light.css b/docs/highlight/solarized-light.css
new file mode 100644
index 0000000..fdcfcc7
--- /dev/null
+++ b/docs/highlight/solarized-light.css
@@ -0,0 +1,84 @@
+/*
+
+Orginal Style from ethanschoonover.com/solarized (c) Jeremy Hull <sourdrums@gmail.com>
+
+*/
+
+.hljs {
+  display: block;
+  overflow-x: auto;
+  padding: 0.5em;
+  background: #fdf6e3;
+  color: #657b83;
+}
+
+.hljs-comment,
+.hljs-quote {
+  color: #93a1a1;
+}
+
+/* Solarized Green */
+.hljs-keyword,
+.hljs-selector-tag,
+.hljs-addition {
+  color: #859900;
+}
+
+/* Solarized Cyan */
+.hljs-number,
+.hljs-string,
+.hljs-meta .hljs-meta-string,
+.hljs-literal,
+.hljs-doctag,
+.hljs-regexp {
+  color: #2aa198;
+}
+
+/* Solarized Blue */
+.hljs-title,
+.hljs-section,
+.hljs-name,
+.hljs-selector-id,
+.hljs-selector-class {
+  color: #268bd2;
+}
+
+/* Solarized Yellow */
+.hljs-attribute,
+.hljs-attr,
+.hljs-variable,
+.hljs-template-variable,
+.hljs-class .hljs-title,
+.hljs-type {
+  color: #b58900;
+}
+
+/* Solarized Orange */
+.hljs-symbol,
+.hljs-bullet,
+.hljs-subst,
+.hljs-meta,
+.hljs-meta .hljs-keyword,
+.hljs-selector-attr,
+.hljs-selector-pseudo,
+.hljs-link {
+  color: #cb4b16;
+}
+
+/* Solarized Red */
+.hljs-built_in,
+.hljs-deletion {
+  color: #dc322f;
+}
+
+.hljs-formula {
+  background: #eee8d5;
+}
+
+.hljs-emphasis {
+  font-style: italic;
+}
+
+.hljs-strong {
+  font-weight: bold;
+}
diff --git a/docs/index.html b/docs/index.html
new file mode 100644
index 0000000..eb81ef0
--- /dev/null
+++ b/docs/index.html
@@ -0,0 +1,3 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>tech.ml.dataset 1.47-SNAPSHOT</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "1.47-SNAPSHOT"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/js/jquery.min.js b/docs/js/jquery.min.js
new file mode 100644
index 0000000..73f33fb
--- /dev/null
+++ b/docs/js/jquery.min.js
@@ -0,0 +1,4 @@
+/*! jQuery v1.11.0 | (c) 2005, 2014 jQuery Foundation, Inc. | jquery.org/license */
+!function(a,b){"object"==typeof module&&"object"==typeof module.exports?module.exports=a.document?b(a,!0):function(a){if(!a.document)throw new Error("jQuery requires a window with a document");return b(a)}:b(a)}("undefined"!=typeof window?window:this,function(a,b){var c=[],d=c.slice,e=c.concat,f=c.push,g=c.indexOf,h={},i=h.toString,j=h.hasOwnProperty,k="".trim,l={},m="1.11.0",n=function(a,b){return new n.fn.init(a,b)},o=/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,p=/^-ms-/,q=/-([\da-z])/gi,r=function(a,b){return b.toUpperCase()};n.fn=n.prototype={jquery:m,constructor:n,selector:"",length:0,toArray:function(){return d.call(this)},get:function(a){return null!=a?0>a?this[a+this.length]:this[a]:d.call(this)},pushStack:function(a){var b=n.merge(this.constructor(),a);return b.prevObject=this,b.context=this.context,b},each:function(a,b){return n.each(this,a,b)},map:function(a){return this.pushStack(n.map(this,function(b,c){return a.call(b,c,b)}))},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(a){var b=this.length,c=+a+(0>a?b:0);return this.pushStack(c>=0&&b>c?[this[c]]:[])},end:function(){return this.prevObject||this.constructor(null)},push:f,sort:c.sort,splice:c.splice},n.extend=n.fn.extend=function(){var a,b,c,d,e,f,g=arguments[0]||{},h=1,i=arguments.length,j=!1;for("boolean"==typeof g&&(j=g,g=arguments[h]||{},h++),"object"==typeof g||n.isFunction(g)||(g={}),h===i&&(g=this,h--);i>h;h++)if(null!=(e=arguments[h]))for(d in e)a=g[d],c=e[d],g!==c&&(j&&c&&(n.isPlainObject(c)||(b=n.isArray(c)))?(b?(b=!1,f=a&&n.isArray(a)?a:[]):f=a&&n.isPlainObject(a)?a:{},g[d]=n.extend(j,f,c)):void 0!==c&&(g[d]=c));return g},n.extend({expando:"jQuery"+(m+Math.random()).replace(/\D/g,""),isReady:!0,error:function(a){throw new Error(a)},noop:function(){},isFunction:function(a){return"function"===n.type(a)},isArray:Array.isArray||function(a){return"array"===n.type(a)},isWindow:function(a){return null!=a&&a==a.window},isNumeric:function(a){return a-parseFloat(a)>=0},isEmptyObject:function(a){var b;for(b in a)return!1;return!0},isPlainObject:function(a){var b;if(!a||"object"!==n.type(a)||a.nodeType||n.isWindow(a))return!1;try{if(a.constructor&&!j.call(a,"constructor")&&!j.call(a.constructor.prototype,"isPrototypeOf"))return!1}catch(c){return!1}if(l.ownLast)for(b in a)return j.call(a,b);for(b in a);return void 0===b||j.call(a,b)},type:function(a){return null==a?a+"":"object"==typeof a||"function"==typeof a?h[i.call(a)]||"object":typeof a},globalEval:function(b){b&&n.trim(b)&&(a.execScript||function(b){a.eval.call(a,b)})(b)},camelCase:function(a){return a.replace(p,"ms-").replace(q,r)},nodeName:function(a,b){return a.nodeName&&a.nodeName.toLowerCase()===b.toLowerCase()},each:function(a,b,c){var d,e=0,f=a.length,g=s(a);if(c){if(g){for(;f>e;e++)if(d=b.apply(a[e],c),d===!1)break}else for(e in a)if(d=b.apply(a[e],c),d===!1)break}else if(g){for(;f>e;e++)if(d=b.call(a[e],e,a[e]),d===!1)break}else for(e in a)if(d=b.call(a[e],e,a[e]),d===!1)break;return a},trim:k&&!k.call("\ufeff\xa0")?function(a){return null==a?"":k.call(a)}:function(a){return null==a?"":(a+"").replace(o,"")},makeArray:function(a,b){var c=b||[];return null!=a&&(s(Object(a))?n.merge(c,"string"==typeof a?[a]:a):f.call(c,a)),c},inArray:function(a,b,c){var d;if(b){if(g)return g.call(b,a,c);for(d=b.length,c=c?0>c?Math.max(0,d+c):c:0;d>c;c++)if(c in b&&b[c]===a)return c}return-1},merge:function(a,b){var c=+b.length,d=0,e=a.length;while(c>d)a[e++]=b[d++];if(c!==c)while(void 0!==b[d])a[e++]=b[d++];return a.length=e,a},grep:function(a,b,c){for(var d,e=[],f=0,g=a.length,h=!c;g>f;f++)d=!b(a[f],f),d!==h&&e.push(a[f]);return e},map:function(a,b,c){var d,f=0,g=a.length,h=s(a),i=[];if(h)for(;g>f;f++)d=b(a[f],f,c),null!=d&&i.push(d);else for(f in a)d=b(a[f],f,c),null!=d&&i.push(d);return e.apply([],i)},guid:1,proxy:function(a,b){var c,e,f;return"string"==typeof b&&(f=a[b],b=a,a=f),n.isFunction(a)?(c=d.call(arguments,2),e=function(){return a.apply(b||this,c.concat(d.call(arguments)))},e.guid=a.guid=a.guid||n.guid++,e):void 0},now:function(){return+new Date},support:l}),n.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(a,b){h["[object "+b+"]"]=b.toLowerCase()});function s(a){var b=a.length,c=n.type(a);return"function"===c||n.isWindow(a)?!1:1===a.nodeType&&b?!0:"array"===c||0===b||"number"==typeof b&&b>0&&b-1 in a}var t=function(a){var b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s="sizzle"+-new Date,t=a.document,u=0,v=0,w=eb(),x=eb(),y=eb(),z=function(a,b){return a===b&&(j=!0),0},A="undefined",B=1<<31,C={}.hasOwnProperty,D=[],E=D.pop,F=D.push,G=D.push,H=D.slice,I=D.indexOf||function(a){for(var b=0,c=this.length;c>b;b++)if(this[b]===a)return b;return-1},J="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",K="[\\x20\\t\\r\\n\\f]",L="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",M=L.replace("w","w#"),N="\\["+K+"*("+L+")"+K+"*(?:([*^$|!~]?=)"+K+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+M+")|)|)"+K+"*\\]",O=":("+L+")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|"+N.replace(3,8)+")*)|.*)\\)|)",P=new RegExp("^"+K+"+|((?:^|[^\\\\])(?:\\\\.)*)"+K+"+$","g"),Q=new RegExp("^"+K+"*,"+K+"*"),R=new RegExp("^"+K+"*([>+~]|"+K+")"+K+"*"),S=new RegExp("="+K+"*([^\\]'\"]*?)"+K+"*\\]","g"),T=new RegExp(O),U=new RegExp("^"+M+"$"),V={ID:new RegExp("^#("+L+")"),CLASS:new RegExp("^\\.("+L+")"),TAG:new RegExp("^("+L.replace("w","w*")+")"),ATTR:new RegExp("^"+N),PSEUDO:new RegExp("^"+O),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+K+"*(even|odd|(([+-]|)(\\d*)n|)"+K+"*(?:([+-]|)"+K+"*(\\d+)|))"+K+"*\\)|)","i"),bool:new RegExp("^(?:"+J+")$","i"),needsContext:new RegExp("^"+K+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+K+"*((?:-\\d)?\\d*)"+K+"*\\)|)(?=[^-]|$)","i")},W=/^(?:input|select|textarea|button)$/i,X=/^h\d$/i,Y=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,$=/[+~]/,_=/'|\\/g,ab=new RegExp("\\\\([\\da-f]{1,6}"+K+"?|("+K+")|.)","ig"),bb=function(a,b,c){var d="0x"+b-65536;return d!==d||c?b:0>d?String.fromCharCode(d+65536):String.fromCharCode(d>>10|55296,1023&d|56320)};try{G.apply(D=H.call(t.childNodes),t.childNodes),D[t.childNodes.length].nodeType}catch(cb){G={apply:D.length?function(a,b){F.apply(a,H.call(b))}:function(a,b){var c=a.length,d=0;while(a[c++]=b[d++]);a.length=c-1}}}function db(a,b,d,e){var f,g,h,i,j,m,p,q,u,v;if((b?b.ownerDocument||b:t)!==l&&k(b),b=b||l,d=d||[],!a||"string"!=typeof a)return d;if(1!==(i=b.nodeType)&&9!==i)return[];if(n&&!e){if(f=Z.exec(a))if(h=f[1]){if(9===i){if(g=b.getElementById(h),!g||!g.parentNode)return d;if(g.id===h)return d.push(g),d}else if(b.ownerDocument&&(g=b.ownerDocument.getElementById(h))&&r(b,g)&&g.id===h)return d.push(g),d}else{if(f[2])return G.apply(d,b.getElementsByTagName(a)),d;if((h=f[3])&&c.getElementsByClassName&&b.getElementsByClassName)return G.apply(d,b.getElementsByClassName(h)),d}if(c.qsa&&(!o||!o.test(a))){if(q=p=s,u=b,v=9===i&&a,1===i&&"object"!==b.nodeName.toLowerCase()){m=ob(a),(p=b.getAttribute("id"))?q=p.replace(_,"\\$&"):b.setAttribute("id",q),q="[id='"+q+"'] ",j=m.length;while(j--)m[j]=q+pb(m[j]);u=$.test(a)&&mb(b.parentNode)||b,v=m.join(",")}if(v)try{return G.apply(d,u.querySelectorAll(v)),d}catch(w){}finally{p||b.removeAttribute("id")}}}return xb(a.replace(P,"$1"),b,d,e)}function eb(){var a=[];function b(c,e){return a.push(c+" ")>d.cacheLength&&delete b[a.shift()],b[c+" "]=e}return b}function fb(a){return a[s]=!0,a}function gb(a){var b=l.createElement("div");try{return!!a(b)}catch(c){return!1}finally{b.parentNode&&b.parentNode.removeChild(b),b=null}}function hb(a,b){var c=a.split("|"),e=a.length;while(e--)d.attrHandle[c[e]]=b}function ib(a,b){var c=b&&a,d=c&&1===a.nodeType&&1===b.nodeType&&(~b.sourceIndex||B)-(~a.sourceIndex||B);if(d)return d;if(c)while(c=c.nextSibling)if(c===b)return-1;return a?1:-1}function jb(a){return function(b){var c=b.nodeName.toLowerCase();return"input"===c&&b.type===a}}function kb(a){return function(b){var c=b.nodeName.toLowerCase();return("input"===c||"button"===c)&&b.type===a}}function lb(a){return fb(function(b){return b=+b,fb(function(c,d){var e,f=a([],c.length,b),g=f.length;while(g--)c[e=f[g]]&&(c[e]=!(d[e]=c[e]))})})}function mb(a){return a&&typeof a.getElementsByTagName!==A&&a}c=db.support={},f=db.isXML=function(a){var b=a&&(a.ownerDocument||a).documentElement;return b?"HTML"!==b.nodeName:!1},k=db.setDocument=function(a){var b,e=a?a.ownerDocument||a:t,g=e.defaultView;return e!==l&&9===e.nodeType&&e.documentElement?(l=e,m=e.documentElement,n=!f(e),g&&g!==g.top&&(g.addEventListener?g.addEventListener("unload",function(){k()},!1):g.attachEvent&&g.attachEvent("onunload",function(){k()})),c.attributes=gb(function(a){return a.className="i",!a.getAttribute("className")}),c.getElementsByTagName=gb(function(a){return a.appendChild(e.createComment("")),!a.getElementsByTagName("*").length}),c.getElementsByClassName=Y.test(e.getElementsByClassName)&&gb(function(a){return a.innerHTML="<div class='a'></div><div class='a i'></div>",a.firstChild.className="i",2===a.getElementsByClassName("i").length}),c.getById=gb(function(a){return m.appendChild(a).id=s,!e.getElementsByName||!e.getElementsByName(s).length}),c.getById?(d.find.ID=function(a,b){if(typeof b.getElementById!==A&&n){var c=b.getElementById(a);return c&&c.parentNode?[c]:[]}},d.filter.ID=function(a){var b=a.replace(ab,bb);return function(a){return a.getAttribute("id")===b}}):(delete d.find.ID,d.filter.ID=function(a){var b=a.replace(ab,bb);return function(a){var c=typeof a.getAttributeNode!==A&&a.getAttributeNode("id");return c&&c.value===b}}),d.find.TAG=c.getElementsByTagName?function(a,b){return typeof b.getElementsByTagName!==A?b.getElementsByTagName(a):void 0}:function(a,b){var c,d=[],e=0,f=b.getElementsByTagName(a);if("*"===a){while(c=f[e++])1===c.nodeType&&d.push(c);return d}return f},d.find.CLASS=c.getElementsByClassName&&function(a,b){return typeof b.getElementsByClassName!==A&&n?b.getElementsByClassName(a):void 0},p=[],o=[],(c.qsa=Y.test(e.querySelectorAll))&&(gb(function(a){a.innerHTML="<select t=''><option selected=''></option></select>",a.querySelectorAll("[t^='']").length&&o.push("[*^$]="+K+"*(?:''|\"\")"),a.querySelectorAll("[selected]").length||o.push("\\["+K+"*(?:value|"+J+")"),a.querySelectorAll(":checked").length||o.push(":checked")}),gb(function(a){var b=e.createElement("input");b.setAttribute("type","hidden"),a.appendChild(b).setAttribute("name","D"),a.querySelectorAll("[name=d]").length&&o.push("name"+K+"*[*^$|!~]?="),a.querySelectorAll(":enabled").length||o.push(":enabled",":disabled"),a.querySelectorAll("*,:x"),o.push(",.*:")})),(c.matchesSelector=Y.test(q=m.webkitMatchesSelector||m.mozMatchesSelector||m.oMatchesSelector||m.msMatchesSelector))&&gb(function(a){c.disconnectedMatch=q.call(a,"div"),q.call(a,"[s!='']:x"),p.push("!=",O)}),o=o.length&&new RegExp(o.join("|")),p=p.length&&new RegExp(p.join("|")),b=Y.test(m.compareDocumentPosition),r=b||Y.test(m.contains)?function(a,b){var c=9===a.nodeType?a.documentElement:a,d=b&&b.parentNode;return a===d||!(!d||1!==d.nodeType||!(c.contains?c.contains(d):a.compareDocumentPosition&&16&a.compareDocumentPosition(d)))}:function(a,b){if(b)while(b=b.parentNode)if(b===a)return!0;return!1},z=b?function(a,b){if(a===b)return j=!0,0;var d=!a.compareDocumentPosition-!b.compareDocumentPosition;return d?d:(d=(a.ownerDocument||a)===(b.ownerDocument||b)?a.compareDocumentPosition(b):1,1&d||!c.sortDetached&&b.compareDocumentPosition(a)===d?a===e||a.ownerDocument===t&&r(t,a)?-1:b===e||b.ownerDocument===t&&r(t,b)?1:i?I.call(i,a)-I.call(i,b):0:4&d?-1:1)}:function(a,b){if(a===b)return j=!0,0;var c,d=0,f=a.parentNode,g=b.parentNode,h=[a],k=[b];if(!f||!g)return a===e?-1:b===e?1:f?-1:g?1:i?I.call(i,a)-I.call(i,b):0;if(f===g)return ib(a,b);c=a;while(c=c.parentNode)h.unshift(c);c=b;while(c=c.parentNode)k.unshift(c);while(h[d]===k[d])d++;return d?ib(h[d],k[d]):h[d]===t?-1:k[d]===t?1:0},e):l},db.matches=function(a,b){return db(a,null,null,b)},db.matchesSelector=function(a,b){if((a.ownerDocument||a)!==l&&k(a),b=b.replace(S,"='$1']"),!(!c.matchesSelector||!n||p&&p.test(b)||o&&o.test(b)))try{var d=q.call(a,b);if(d||c.disconnectedMatch||a.document&&11!==a.document.nodeType)return d}catch(e){}return db(b,l,null,[a]).length>0},db.contains=function(a,b){return(a.ownerDocument||a)!==l&&k(a),r(a,b)},db.attr=function(a,b){(a.ownerDocument||a)!==l&&k(a);var e=d.attrHandle[b.toLowerCase()],f=e&&C.call(d.attrHandle,b.toLowerCase())?e(a,b,!n):void 0;return void 0!==f?f:c.attributes||!n?a.getAttribute(b):(f=a.getAttributeNode(b))&&f.specified?f.value:null},db.error=function(a){throw new Error("Syntax error, unrecognized expression: "+a)},db.uniqueSort=function(a){var b,d=[],e=0,f=0;if(j=!c.detectDuplicates,i=!c.sortStable&&a.slice(0),a.sort(z),j){while(b=a[f++])b===a[f]&&(e=d.push(f));while(e--)a.splice(d[e],1)}return i=null,a},e=db.getText=function(a){var b,c="",d=0,f=a.nodeType;if(f){if(1===f||9===f||11===f){if("string"==typeof a.textContent)return a.textContent;for(a=a.firstChild;a;a=a.nextSibling)c+=e(a)}else if(3===f||4===f)return a.nodeValue}else while(b=a[d++])c+=e(b);return c},d=db.selectors={cacheLength:50,createPseudo:fb,match:V,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(a){return a[1]=a[1].replace(ab,bb),a[3]=(a[4]||a[5]||"").replace(ab,bb),"~="===a[2]&&(a[3]=" "+a[3]+" "),a.slice(0,4)},CHILD:function(a){return a[1]=a[1].toLowerCase(),"nth"===a[1].slice(0,3)?(a[3]||db.error(a[0]),a[4]=+(a[4]?a[5]+(a[6]||1):2*("even"===a[3]||"odd"===a[3])),a[5]=+(a[7]+a[8]||"odd"===a[3])):a[3]&&db.error(a[0]),a},PSEUDO:function(a){var b,c=!a[5]&&a[2];return V.CHILD.test(a[0])?null:(a[3]&&void 0!==a[4]?a[2]=a[4]:c&&T.test(c)&&(b=ob(c,!0))&&(b=c.indexOf(")",c.length-b)-c.length)&&(a[0]=a[0].slice(0,b),a[2]=c.slice(0,b)),a.slice(0,3))}},filter:{TAG:function(a){var b=a.replace(ab,bb).toLowerCase();return"*"===a?function(){return!0}:function(a){return a.nodeName&&a.nodeName.toLowerCase()===b}},CLASS:function(a){var b=w[a+" "];return b||(b=new RegExp("(^|"+K+")"+a+"("+K+"|$)"))&&w(a,function(a){return b.test("string"==typeof a.className&&a.className||typeof a.getAttribute!==A&&a.getAttribute("class")||"")})},ATTR:function(a,b,c){return function(d){var e=db.attr(d,a);return null==e?"!="===b:b?(e+="","="===b?e===c:"!="===b?e!==c:"^="===b?c&&0===e.indexOf(c):"*="===b?c&&e.indexOf(c)>-1:"$="===b?c&&e.slice(-c.length)===c:"~="===b?(" "+e+" ").indexOf(c)>-1:"|="===b?e===c||e.slice(0,c.length+1)===c+"-":!1):!0}},CHILD:function(a,b,c,d,e){var f="nth"!==a.slice(0,3),g="last"!==a.slice(-4),h="of-type"===b;return 1===d&&0===e?function(a){return!!a.parentNode}:function(b,c,i){var j,k,l,m,n,o,p=f!==g?"nextSibling":"previousSibling",q=b.parentNode,r=h&&b.nodeName.toLowerCase(),t=!i&&!h;if(q){if(f){while(p){l=b;while(l=l[p])if(h?l.nodeName.toLowerCase()===r:1===l.nodeType)return!1;o=p="only"===a&&!o&&"nextSibling"}return!0}if(o=[g?q.firstChild:q.lastChild],g&&t){k=q[s]||(q[s]={}),j=k[a]||[],n=j[0]===u&&j[1],m=j[0]===u&&j[2],l=n&&q.childNodes[n];while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if(1===l.nodeType&&++m&&l===b){k[a]=[u,n,m];break}}else if(t&&(j=(b[s]||(b[s]={}))[a])&&j[0]===u)m=j[1];else while(l=++n&&l&&l[p]||(m=n=0)||o.pop())if((h?l.nodeName.toLowerCase()===r:1===l.nodeType)&&++m&&(t&&((l[s]||(l[s]={}))[a]=[u,m]),l===b))break;return m-=e,m===d||m%d===0&&m/d>=0}}},PSEUDO:function(a,b){var c,e=d.pseudos[a]||d.setFilters[a.toLowerCase()]||db.error("unsupported pseudo: "+a);return e[s]?e(b):e.length>1?(c=[a,a,"",b],d.setFilters.hasOwnProperty(a.toLowerCase())?fb(function(a,c){var d,f=e(a,b),g=f.length;while(g--)d=I.call(a,f[g]),a[d]=!(c[d]=f[g])}):function(a){return e(a,0,c)}):e}},pseudos:{not:fb(function(a){var b=[],c=[],d=g(a.replace(P,"$1"));return d[s]?fb(function(a,b,c,e){var f,g=d(a,null,e,[]),h=a.length;while(h--)(f=g[h])&&(a[h]=!(b[h]=f))}):function(a,e,f){return b[0]=a,d(b,null,f,c),!c.pop()}}),has:fb(function(a){return function(b){return db(a,b).length>0}}),contains:fb(function(a){return function(b){return(b.textContent||b.innerText||e(b)).indexOf(a)>-1}}),lang:fb(function(a){return U.test(a||"")||db.error("unsupported lang: "+a),a=a.replace(ab,bb).toLowerCase(),function(b){var c;do if(c=n?b.lang:b.getAttribute("xml:lang")||b.getAttribute("lang"))return c=c.toLowerCase(),c===a||0===c.indexOf(a+"-");while((b=b.parentNode)&&1===b.nodeType);return!1}}),target:function(b){var c=a.location&&a.location.hash;return c&&c.slice(1)===b.id},root:function(a){return a===m},focus:function(a){return a===l.activeElement&&(!l.hasFocus||l.hasFocus())&&!!(a.type||a.href||~a.tabIndex)},enabled:function(a){return a.disabled===!1},disabled:function(a){return a.disabled===!0},checked:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&!!a.checked||"option"===b&&!!a.selected},selected:function(a){return a.parentNode&&a.parentNode.selectedIndex,a.selected===!0},empty:function(a){for(a=a.firstChild;a;a=a.nextSibling)if(a.nodeType<6)return!1;return!0},parent:function(a){return!d.pseudos.empty(a)},header:function(a){return X.test(a.nodeName)},input:function(a){return W.test(a.nodeName)},button:function(a){var b=a.nodeName.toLowerCase();return"input"===b&&"button"===a.type||"button"===b},text:function(a){var b;return"input"===a.nodeName.toLowerCase()&&"text"===a.type&&(null==(b=a.getAttribute("type"))||"text"===b.toLowerCase())},first:lb(function(){return[0]}),last:lb(function(a,b){return[b-1]}),eq:lb(function(a,b,c){return[0>c?c+b:c]}),even:lb(function(a,b){for(var c=0;b>c;c+=2)a.push(c);return a}),odd:lb(function(a,b){for(var c=1;b>c;c+=2)a.push(c);return a}),lt:lb(function(a,b,c){for(var d=0>c?c+b:c;--d>=0;)a.push(d);return a}),gt:lb(function(a,b,c){for(var d=0>c?c+b:c;++d<b;)a.push(d);return a})}},d.pseudos.nth=d.pseudos.eq;for(b in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})d.pseudos[b]=jb(b);for(b in{submit:!0,reset:!0})d.pseudos[b]=kb(b);function nb(){}nb.prototype=d.filters=d.pseudos,d.setFilters=new nb;function ob(a,b){var c,e,f,g,h,i,j,k=x[a+" "];if(k)return b?0:k.slice(0);h=a,i=[],j=d.preFilter;while(h){(!c||(e=Q.exec(h)))&&(e&&(h=h.slice(e[0].length)||h),i.push(f=[])),c=!1,(e=R.exec(h))&&(c=e.shift(),f.push({value:c,type:e[0].replace(P," ")}),h=h.slice(c.length));for(g in d.filter)!(e=V[g].exec(h))||j[g]&&!(e=j[g](e))||(c=e.shift(),f.push({value:c,type:g,matches:e}),h=h.slice(c.length));if(!c)break}return b?h.length:h?db.error(a):x(a,i).slice(0)}function pb(a){for(var b=0,c=a.length,d="";c>b;b++)d+=a[b].value;return d}function qb(a,b,c){var d=b.dir,e=c&&"parentNode"===d,f=v++;return b.first?function(b,c,f){while(b=b[d])if(1===b.nodeType||e)return a(b,c,f)}:function(b,c,g){var h,i,j=[u,f];if(g){while(b=b[d])if((1===b.nodeType||e)&&a(b,c,g))return!0}else while(b=b[d])if(1===b.nodeType||e){if(i=b[s]||(b[s]={}),(h=i[d])&&h[0]===u&&h[1]===f)return j[2]=h[2];if(i[d]=j,j[2]=a(b,c,g))return!0}}}function rb(a){return a.length>1?function(b,c,d){var e=a.length;while(e--)if(!a[e](b,c,d))return!1;return!0}:a[0]}function sb(a,b,c,d,e){for(var f,g=[],h=0,i=a.length,j=null!=b;i>h;h++)(f=a[h])&&(!c||c(f,d,e))&&(g.push(f),j&&b.push(h));return g}function tb(a,b,c,d,e,f){return d&&!d[s]&&(d=tb(d)),e&&!e[s]&&(e=tb(e,f)),fb(function(f,g,h,i){var j,k,l,m=[],n=[],o=g.length,p=f||wb(b||"*",h.nodeType?[h]:h,[]),q=!a||!f&&b?p:sb(p,m,a,h,i),r=c?e||(f?a:o||d)?[]:g:q;if(c&&c(q,r,h,i),d){j=sb(r,n),d(j,[],h,i),k=j.length;while(k--)(l=j[k])&&(r[n[k]]=!(q[n[k]]=l))}if(f){if(e||a){if(e){j=[],k=r.length;while(k--)(l=r[k])&&j.push(q[k]=l);e(null,r=[],j,i)}k=r.length;while(k--)(l=r[k])&&(j=e?I.call(f,l):m[k])>-1&&(f[j]=!(g[j]=l))}}else r=sb(r===g?r.splice(o,r.length):r),e?e(null,g,r,i):G.apply(g,r)})}function ub(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],i=g||d.relative[" "],j=g?1:0,k=qb(function(a){return a===b},i,!0),l=qb(function(a){return I.call(b,a)>-1},i,!0),m=[function(a,c,d){return!g&&(d||c!==h)||((b=c).nodeType?k(a,c,d):l(a,c,d))}];f>j;j++)if(c=d.relative[a[j].type])m=[qb(rb(m),c)];else{if(c=d.filter[a[j].type].apply(null,a[j].matches),c[s]){for(e=++j;f>e;e++)if(d.relative[a[e].type])break;return tb(j>1&&rb(m),j>1&&pb(a.slice(0,j-1).concat({value:" "===a[j-2].type?"*":""})).replace(P,"$1"),c,e>j&&ub(a.slice(j,e)),f>e&&ub(a=a.slice(e)),f>e&&pb(a))}m.push(c)}return rb(m)}function vb(a,b){var c=b.length>0,e=a.length>0,f=function(f,g,i,j,k){var m,n,o,p=0,q="0",r=f&&[],s=[],t=h,v=f||e&&d.find.TAG("*",k),w=u+=null==t?1:Math.random()||.1,x=v.length;for(k&&(h=g!==l&&g);q!==x&&null!=(m=v[q]);q++){if(e&&m){n=0;while(o=a[n++])if(o(m,g,i)){j.push(m);break}k&&(u=w)}c&&((m=!o&&m)&&p--,f&&r.push(m))}if(p+=q,c&&q!==p){n=0;while(o=b[n++])o(r,s,g,i);if(f){if(p>0)while(q--)r[q]||s[q]||(s[q]=E.call(j));s=sb(s)}G.apply(j,s),k&&!f&&s.length>0&&p+b.length>1&&db.uniqueSort(j)}return k&&(u=w,h=t),r};return c?fb(f):f}g=db.compile=function(a,b){var c,d=[],e=[],f=y[a+" "];if(!f){b||(b=ob(a)),c=b.length;while(c--)f=ub(b[c]),f[s]?d.push(f):e.push(f);f=y(a,vb(e,d))}return f};function wb(a,b,c){for(var d=0,e=b.length;e>d;d++)db(a,b[d],c);return c}function xb(a,b,e,f){var h,i,j,k,l,m=ob(a);if(!f&&1===m.length){if(i=m[0]=m[0].slice(0),i.length>2&&"ID"===(j=i[0]).type&&c.getById&&9===b.nodeType&&n&&d.relative[i[1].type]){if(b=(d.find.ID(j.matches[0].replace(ab,bb),b)||[])[0],!b)return e;a=a.slice(i.shift().value.length)}h=V.needsContext.test(a)?0:i.length;while(h--){if(j=i[h],d.relative[k=j.type])break;if((l=d.find[k])&&(f=l(j.matches[0].replace(ab,bb),$.test(i[0].type)&&mb(b.parentNode)||b))){if(i.splice(h,1),a=f.length&&pb(i),!a)return G.apply(e,f),e;break}}}return g(a,m)(f,b,!n,e,$.test(a)&&mb(b.parentNode)||b),e}return c.sortStable=s.split("").sort(z).join("")===s,c.detectDuplicates=!!j,k(),c.sortDetached=gb(function(a){return 1&a.compareDocumentPosition(l.createElement("div"))}),gb(function(a){return a.innerHTML="<a href='#'></a>","#"===a.firstChild.getAttribute("href")})||hb("type|href|height|width",function(a,b,c){return c?void 0:a.getAttribute(b,"type"===b.toLowerCase()?1:2)}),c.attributes&&gb(function(a){return a.innerHTML="<input/>",a.firstChild.setAttribute("value",""),""===a.firstChild.getAttribute("value")})||hb("value",function(a,b,c){return c||"input"!==a.nodeName.toLowerCase()?void 0:a.defaultValue}),gb(function(a){return null==a.getAttribute("disabled")})||hb(J,function(a,b,c){var d;return c?void 0:a[b]===!0?b.toLowerCase():(d=a.getAttributeNode(b))&&d.specified?d.value:null}),db}(a);n.find=t,n.expr=t.selectors,n.expr[":"]=n.expr.pseudos,n.unique=t.uniqueSort,n.text=t.getText,n.isXMLDoc=t.isXML,n.contains=t.contains;var u=n.expr.match.needsContext,v=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,w=/^.[^:#\[\.,]*$/;function x(a,b,c){if(n.isFunction(b))return n.grep(a,function(a,d){return!!b.call(a,d,a)!==c});if(b.nodeType)return n.grep(a,function(a){return a===b!==c});if("string"==typeof b){if(w.test(b))return n.filter(b,a,c);b=n.filter(b,a)}return n.grep(a,function(a){return n.inArray(a,b)>=0!==c})}n.filter=function(a,b,c){var d=b[0];return c&&(a=":not("+a+")"),1===b.length&&1===d.nodeType?n.find.matchesSelector(d,a)?[d]:[]:n.find.matches(a,n.grep(b,function(a){return 1===a.nodeType}))},n.fn.extend({find:function(a){var b,c=[],d=this,e=d.length;if("string"!=typeof a)return this.pushStack(n(a).filter(function(){for(b=0;e>b;b++)if(n.contains(d[b],this))return!0}));for(b=0;e>b;b++)n.find(a,d[b],c);return c=this.pushStack(e>1?n.unique(c):c),c.selector=this.selector?this.selector+" "+a:a,c},filter:function(a){return this.pushStack(x(this,a||[],!1))},not:function(a){return this.pushStack(x(this,a||[],!0))},is:function(a){return!!x(this,"string"==typeof a&&u.test(a)?n(a):a||[],!1).length}});var y,z=a.document,A=/^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,B=n.fn.init=function(a,b){var c,d;if(!a)return this;if("string"==typeof a){if(c="<"===a.charAt(0)&&">"===a.charAt(a.length-1)&&a.length>=3?[null,a,null]:A.exec(a),!c||!c[1]&&b)return!b||b.jquery?(b||y).find(a):this.constructor(b).find(a);if(c[1]){if(b=b instanceof n?b[0]:b,n.merge(this,n.parseHTML(c[1],b&&b.nodeType?b.ownerDocument||b:z,!0)),v.test(c[1])&&n.isPlainObject(b))for(c in b)n.isFunction(this[c])?this[c](b[c]):this.attr(c,b[c]);return this}if(d=z.getElementById(c[2]),d&&d.parentNode){if(d.id!==c[2])return y.find(a);this.length=1,this[0]=d}return this.context=z,this.selector=a,this}return a.nodeType?(this.context=this[0]=a,this.length=1,this):n.isFunction(a)?"undefined"!=typeof y.ready?y.ready(a):a(n):(void 0!==a.selector&&(this.selector=a.selector,this.context=a.context),n.makeArray(a,this))};B.prototype=n.fn,y=n(z);var C=/^(?:parents|prev(?:Until|All))/,D={children:!0,contents:!0,next:!0,prev:!0};n.extend({dir:function(a,b,c){var d=[],e=a[b];while(e&&9!==e.nodeType&&(void 0===c||1!==e.nodeType||!n(e).is(c)))1===e.nodeType&&d.push(e),e=e[b];return d},sibling:function(a,b){for(var c=[];a;a=a.nextSibling)1===a.nodeType&&a!==b&&c.push(a);return c}}),n.fn.extend({has:function(a){var b,c=n(a,this),d=c.length;return this.filter(function(){for(b=0;d>b;b++)if(n.contains(this,c[b]))return!0})},closest:function(a,b){for(var c,d=0,e=this.length,f=[],g=u.test(a)||"string"!=typeof a?n(a,b||this.context):0;e>d;d++)for(c=this[d];c&&c!==b;c=c.parentNode)if(c.nodeType<11&&(g?g.index(c)>-1:1===c.nodeType&&n.find.matchesSelector(c,a))){f.push(c);break}return this.pushStack(f.length>1?n.unique(f):f)},index:function(a){return a?"string"==typeof a?n.inArray(this[0],n(a)):n.inArray(a.jquery?a[0]:a,this):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(a,b){return this.pushStack(n.unique(n.merge(this.get(),n(a,b))))},addBack:function(a){return this.add(null==a?this.prevObject:this.prevObject.filter(a))}});function E(a,b){do a=a[b];while(a&&1!==a.nodeType);return a}n.each({parent:function(a){var b=a.parentNode;return b&&11!==b.nodeType?b:null},parents:function(a){return n.dir(a,"parentNode")},parentsUntil:function(a,b,c){return n.dir(a,"parentNode",c)},next:function(a){return E(a,"nextSibling")},prev:function(a){return E(a,"previousSibling")},nextAll:function(a){return n.dir(a,"nextSibling")},prevAll:function(a){return n.dir(a,"previousSibling")},nextUntil:function(a,b,c){return n.dir(a,"nextSibling",c)},prevUntil:function(a,b,c){return n.dir(a,"previousSibling",c)},siblings:function(a){return n.sibling((a.parentNode||{}).firstChild,a)},children:function(a){return n.sibling(a.firstChild)},contents:function(a){return n.nodeName(a,"iframe")?a.contentDocument||a.contentWindow.document:n.merge([],a.childNodes)}},function(a,b){n.fn[a]=function(c,d){var e=n.map(this,b,c);return"Until"!==a.slice(-5)&&(d=c),d&&"string"==typeof d&&(e=n.filter(d,e)),this.length>1&&(D[a]||(e=n.unique(e)),C.test(a)&&(e=e.reverse())),this.pushStack(e)}});var F=/\S+/g,G={};function H(a){var b=G[a]={};return n.each(a.match(F)||[],function(a,c){b[c]=!0}),b}n.Callbacks=function(a){a="string"==typeof a?G[a]||H(a):n.extend({},a);var b,c,d,e,f,g,h=[],i=!a.once&&[],j=function(l){for(c=a.memory&&l,d=!0,f=g||0,g=0,e=h.length,b=!0;h&&e>f;f++)if(h[f].apply(l[0],l[1])===!1&&a.stopOnFalse){c=!1;break}b=!1,h&&(i?i.length&&j(i.shift()):c?h=[]:k.disable())},k={add:function(){if(h){var d=h.length;!function f(b){n.each(b,function(b,c){var d=n.type(c);"function"===d?a.unique&&k.has(c)||h.push(c):c&&c.length&&"string"!==d&&f(c)})}(arguments),b?e=h.length:c&&(g=d,j(c))}return this},remove:function(){return h&&n.each(arguments,function(a,c){var d;while((d=n.inArray(c,h,d))>-1)h.splice(d,1),b&&(e>=d&&e--,f>=d&&f--)}),this},has:function(a){return a?n.inArray(a,h)>-1:!(!h||!h.length)},empty:function(){return h=[],e=0,this},disable:function(){return h=i=c=void 0,this},disabled:function(){return!h},lock:function(){return i=void 0,c||k.disable(),this},locked:function(){return!i},fireWith:function(a,c){return!h||d&&!i||(c=c||[],c=[a,c.slice?c.slice():c],b?i.push(c):j(c)),this},fire:function(){return k.fireWith(this,arguments),this},fired:function(){return!!d}};return k},n.extend({Deferred:function(a){var b=[["resolve","done",n.Callbacks("once memory"),"resolved"],["reject","fail",n.Callbacks("once memory"),"rejected"],["notify","progress",n.Callbacks("memory")]],c="pending",d={state:function(){return c},always:function(){return e.done(arguments).fail(arguments),this},then:function(){var a=arguments;return n.Deferred(function(c){n.each(b,function(b,f){var g=n.isFunction(a[b])&&a[b];e[f[1]](function(){var a=g&&g.apply(this,arguments);a&&n.isFunction(a.promise)?a.promise().done(c.resolve).fail(c.reject).progress(c.notify):c[f[0]+"With"](this===d?c.promise():this,g?[a]:arguments)})}),a=null}).promise()},promise:function(a){return null!=a?n.extend(a,d):d}},e={};return d.pipe=d.then,n.each(b,function(a,f){var g=f[2],h=f[3];d[f[1]]=g.add,h&&g.add(function(){c=h},b[1^a][2].disable,b[2][2].lock),e[f[0]]=function(){return e[f[0]+"With"](this===e?d:this,arguments),this},e[f[0]+"With"]=g.fireWith}),d.promise(e),a&&a.call(e,e),e},when:function(a){var b=0,c=d.call(arguments),e=c.length,f=1!==e||a&&n.isFunction(a.promise)?e:0,g=1===f?a:n.Deferred(),h=function(a,b,c){return function(e){b[a]=this,c[a]=arguments.length>1?d.call(arguments):e,c===i?g.notifyWith(b,c):--f||g.resolveWith(b,c)}},i,j,k;if(e>1)for(i=new Array(e),j=new Array(e),k=new Array(e);e>b;b++)c[b]&&n.isFunction(c[b].promise)?c[b].promise().done(h(b,k,c)).fail(g.reject).progress(h(b,j,i)):--f;return f||g.resolveWith(k,c),g.promise()}});var I;n.fn.ready=function(a){return n.ready.promise().done(a),this},n.extend({isReady:!1,readyWait:1,holdReady:function(a){a?n.readyWait++:n.ready(!0)},ready:function(a){if(a===!0?!--n.readyWait:!n.isReady){if(!z.body)return setTimeout(n.ready);n.isReady=!0,a!==!0&&--n.readyWait>0||(I.resolveWith(z,[n]),n.fn.trigger&&n(z).trigger("ready").off("ready"))}}});function J(){z.addEventListener?(z.removeEventListener("DOMContentLoaded",K,!1),a.removeEventListener("load",K,!1)):(z.detachEvent("onreadystatechange",K),a.detachEvent("onload",K))}function K(){(z.addEventListener||"load"===event.type||"complete"===z.readyState)&&(J(),n.ready())}n.ready.promise=function(b){if(!I)if(I=n.Deferred(),"complete"===z.readyState)setTimeout(n.ready);else if(z.addEventListener)z.addEventListener("DOMContentLoaded",K,!1),a.addEventListener("load",K,!1);else{z.attachEvent("onreadystatechange",K),a.attachEvent("onload",K);var c=!1;try{c=null==a.frameElement&&z.documentElement}catch(d){}c&&c.doScroll&&!function e(){if(!n.isReady){try{c.doScroll("left")}catch(a){return setTimeout(e,50)}J(),n.ready()}}()}return I.promise(b)};var L="undefined",M;for(M in n(l))break;l.ownLast="0"!==M,l.inlineBlockNeedsLayout=!1,n(function(){var a,b,c=z.getElementsByTagName("body")[0];c&&(a=z.createElement("div"),a.style.cssText="border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px",b=z.createElement("div"),c.appendChild(a).appendChild(b),typeof b.style.zoom!==L&&(b.style.cssText="border:0;margin:0;width:1px;padding:1px;display:inline;zoom:1",(l.inlineBlockNeedsLayout=3===b.offsetWidth)&&(c.style.zoom=1)),c.removeChild(a),a=b=null)}),function(){var a=z.createElement("div");if(null==l.deleteExpando){l.deleteExpando=!0;try{delete a.test}catch(b){l.deleteExpando=!1}}a=null}(),n.acceptData=function(a){var b=n.noData[(a.nodeName+" ").toLowerCase()],c=+a.nodeType||1;return 1!==c&&9!==c?!1:!b||b!==!0&&a.getAttribute("classid")===b};var N=/^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,O=/([A-Z])/g;function P(a,b,c){if(void 0===c&&1===a.nodeType){var d="data-"+b.replace(O,"-$1").toLowerCase();if(c=a.getAttribute(d),"string"==typeof c){try{c="true"===c?!0:"false"===c?!1:"null"===c?null:+c+""===c?+c:N.test(c)?n.parseJSON(c):c}catch(e){}n.data(a,b,c)}else c=void 0}return c}function Q(a){var b;for(b in a)if(("data"!==b||!n.isEmptyObject(a[b]))&&"toJSON"!==b)return!1;return!0}function R(a,b,d,e){if(n.acceptData(a)){var f,g,h=n.expando,i=a.nodeType,j=i?n.cache:a,k=i?a[h]:a[h]&&h;if(k&&j[k]&&(e||j[k].data)||void 0!==d||"string"!=typeof b)return k||(k=i?a[h]=c.pop()||n.guid++:h),j[k]||(j[k]=i?{}:{toJSON:n.noop}),("object"==typeof b||"function"==typeof b)&&(e?j[k]=n.extend(j[k],b):j[k].data=n.extend(j[k].data,b)),g=j[k],e||(g.data||(g.data={}),g=g.data),void 0!==d&&(g[n.camelCase(b)]=d),"string"==typeof b?(f=g[b],null==f&&(f=g[n.camelCase(b)])):f=g,f
+}}function S(a,b,c){if(n.acceptData(a)){var d,e,f=a.nodeType,g=f?n.cache:a,h=f?a[n.expando]:n.expando;if(g[h]){if(b&&(d=c?g[h]:g[h].data)){n.isArray(b)?b=b.concat(n.map(b,n.camelCase)):b in d?b=[b]:(b=n.camelCase(b),b=b in d?[b]:b.split(" ")),e=b.length;while(e--)delete d[b[e]];if(c?!Q(d):!n.isEmptyObject(d))return}(c||(delete g[h].data,Q(g[h])))&&(f?n.cleanData([a],!0):l.deleteExpando||g!=g.window?delete g[h]:g[h]=null)}}}n.extend({cache:{},noData:{"applet ":!0,"embed ":!0,"object ":"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"},hasData:function(a){return a=a.nodeType?n.cache[a[n.expando]]:a[n.expando],!!a&&!Q(a)},data:function(a,b,c){return R(a,b,c)},removeData:function(a,b){return S(a,b)},_data:function(a,b,c){return R(a,b,c,!0)},_removeData:function(a,b){return S(a,b,!0)}}),n.fn.extend({data:function(a,b){var c,d,e,f=this[0],g=f&&f.attributes;if(void 0===a){if(this.length&&(e=n.data(f),1===f.nodeType&&!n._data(f,"parsedAttrs"))){c=g.length;while(c--)d=g[c].name,0===d.indexOf("data-")&&(d=n.camelCase(d.slice(5)),P(f,d,e[d]));n._data(f,"parsedAttrs",!0)}return e}return"object"==typeof a?this.each(function(){n.data(this,a)}):arguments.length>1?this.each(function(){n.data(this,a,b)}):f?P(f,a,n.data(f,a)):void 0},removeData:function(a){return this.each(function(){n.removeData(this,a)})}}),n.extend({queue:function(a,b,c){var d;return a?(b=(b||"fx")+"queue",d=n._data(a,b),c&&(!d||n.isArray(c)?d=n._data(a,b,n.makeArray(c)):d.push(c)),d||[]):void 0},dequeue:function(a,b){b=b||"fx";var c=n.queue(a,b),d=c.length,e=c.shift(),f=n._queueHooks(a,b),g=function(){n.dequeue(a,b)};"inprogress"===e&&(e=c.shift(),d--),e&&("fx"===b&&c.unshift("inprogress"),delete f.stop,e.call(a,g,f)),!d&&f&&f.empty.fire()},_queueHooks:function(a,b){var c=b+"queueHooks";return n._data(a,c)||n._data(a,c,{empty:n.Callbacks("once memory").add(function(){n._removeData(a,b+"queue"),n._removeData(a,c)})})}}),n.fn.extend({queue:function(a,b){var c=2;return"string"!=typeof a&&(b=a,a="fx",c--),arguments.length<c?n.queue(this[0],a):void 0===b?this:this.each(function(){var c=n.queue(this,a,b);n._queueHooks(this,a),"fx"===a&&"inprogress"!==c[0]&&n.dequeue(this,a)})},dequeue:function(a){return this.each(function(){n.dequeue(this,a)})},clearQueue:function(a){return this.queue(a||"fx",[])},promise:function(a,b){var c,d=1,e=n.Deferred(),f=this,g=this.length,h=function(){--d||e.resolveWith(f,[f])};"string"!=typeof a&&(b=a,a=void 0),a=a||"fx";while(g--)c=n._data(f[g],a+"queueHooks"),c&&c.empty&&(d++,c.empty.add(h));return h(),e.promise(b)}});var T=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,U=["Top","Right","Bottom","Left"],V=function(a,b){return a=b||a,"none"===n.css(a,"display")||!n.contains(a.ownerDocument,a)},W=n.access=function(a,b,c,d,e,f,g){var h=0,i=a.length,j=null==c;if("object"===n.type(c)){e=!0;for(h in c)n.access(a,b,h,c[h],!0,f,g)}else if(void 0!==d&&(e=!0,n.isFunction(d)||(g=!0),j&&(g?(b.call(a,d),b=null):(j=b,b=function(a,b,c){return j.call(n(a),c)})),b))for(;i>h;h++)b(a[h],c,g?d:d.call(a[h],h,b(a[h],c)));return e?a:j?b.call(a):i?b(a[0],c):f},X=/^(?:checkbox|radio)$/i;!function(){var a=z.createDocumentFragment(),b=z.createElement("div"),c=z.createElement("input");if(b.setAttribute("className","t"),b.innerHTML="  <link/><table></table><a href='/a'>a</a>",l.leadingWhitespace=3===b.firstChild.nodeType,l.tbody=!b.getElementsByTagName("tbody").length,l.htmlSerialize=!!b.getElementsByTagName("link").length,l.html5Clone="<:nav></:nav>"!==z.createElement("nav").cloneNode(!0).outerHTML,c.type="checkbox",c.checked=!0,a.appendChild(c),l.appendChecked=c.checked,b.innerHTML="<textarea>x</textarea>",l.noCloneChecked=!!b.cloneNode(!0).lastChild.defaultValue,a.appendChild(b),b.innerHTML="<input type='radio' checked='checked' name='t'/>",l.checkClone=b.cloneNode(!0).cloneNode(!0).lastChild.checked,l.noCloneEvent=!0,b.attachEvent&&(b.attachEvent("onclick",function(){l.noCloneEvent=!1}),b.cloneNode(!0).click()),null==l.deleteExpando){l.deleteExpando=!0;try{delete b.test}catch(d){l.deleteExpando=!1}}a=b=c=null}(),function(){var b,c,d=z.createElement("div");for(b in{submit:!0,change:!0,focusin:!0})c="on"+b,(l[b+"Bubbles"]=c in a)||(d.setAttribute(c,"t"),l[b+"Bubbles"]=d.attributes[c].expando===!1);d=null}();var Y=/^(?:input|select|textarea)$/i,Z=/^key/,$=/^(?:mouse|contextmenu)|click/,_=/^(?:focusinfocus|focusoutblur)$/,ab=/^([^.]*)(?:\.(.+)|)$/;function bb(){return!0}function cb(){return!1}function db(){try{return z.activeElement}catch(a){}}n.event={global:{},add:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=n._data(a);if(r){c.handler&&(i=c,c=i.handler,e=i.selector),c.guid||(c.guid=n.guid++),(g=r.events)||(g=r.events={}),(k=r.handle)||(k=r.handle=function(a){return typeof n===L||a&&n.event.triggered===a.type?void 0:n.event.dispatch.apply(k.elem,arguments)},k.elem=a),b=(b||"").match(F)||[""],h=b.length;while(h--)f=ab.exec(b[h])||[],o=q=f[1],p=(f[2]||"").split(".").sort(),o&&(j=n.event.special[o]||{},o=(e?j.delegateType:j.bindType)||o,j=n.event.special[o]||{},l=n.extend({type:o,origType:q,data:d,handler:c,guid:c.guid,selector:e,needsContext:e&&n.expr.match.needsContext.test(e),namespace:p.join(".")},i),(m=g[o])||(m=g[o]=[],m.delegateCount=0,j.setup&&j.setup.call(a,d,p,k)!==!1||(a.addEventListener?a.addEventListener(o,k,!1):a.attachEvent&&a.attachEvent("on"+o,k))),j.add&&(j.add.call(a,l),l.handler.guid||(l.handler.guid=c.guid)),e?m.splice(m.delegateCount++,0,l):m.push(l),n.event.global[o]=!0);a=null}},remove:function(a,b,c,d,e){var f,g,h,i,j,k,l,m,o,p,q,r=n.hasData(a)&&n._data(a);if(r&&(k=r.events)){b=(b||"").match(F)||[""],j=b.length;while(j--)if(h=ab.exec(b[j])||[],o=q=h[1],p=(h[2]||"").split(".").sort(),o){l=n.event.special[o]||{},o=(d?l.delegateType:l.bindType)||o,m=k[o]||[],h=h[2]&&new RegExp("(^|\\.)"+p.join("\\.(?:.*\\.|)")+"(\\.|$)"),i=f=m.length;while(f--)g=m[f],!e&&q!==g.origType||c&&c.guid!==g.guid||h&&!h.test(g.namespace)||d&&d!==g.selector&&("**"!==d||!g.selector)||(m.splice(f,1),g.selector&&m.delegateCount--,l.remove&&l.remove.call(a,g));i&&!m.length&&(l.teardown&&l.teardown.call(a,p,r.handle)!==!1||n.removeEvent(a,o,r.handle),delete k[o])}else for(o in k)n.event.remove(a,o+b[j],c,d,!0);n.isEmptyObject(k)&&(delete r.handle,n._removeData(a,"events"))}},trigger:function(b,c,d,e){var f,g,h,i,k,l,m,o=[d||z],p=j.call(b,"type")?b.type:b,q=j.call(b,"namespace")?b.namespace.split("."):[];if(h=l=d=d||z,3!==d.nodeType&&8!==d.nodeType&&!_.test(p+n.event.triggered)&&(p.indexOf(".")>=0&&(q=p.split("."),p=q.shift(),q.sort()),g=p.indexOf(":")<0&&"on"+p,b=b[n.expando]?b:new n.Event(p,"object"==typeof b&&b),b.isTrigger=e?2:3,b.namespace=q.join("."),b.namespace_re=b.namespace?new RegExp("(^|\\.)"+q.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,b.result=void 0,b.target||(b.target=d),c=null==c?[b]:n.makeArray(c,[b]),k=n.event.special[p]||{},e||!k.trigger||k.trigger.apply(d,c)!==!1)){if(!e&&!k.noBubble&&!n.isWindow(d)){for(i=k.delegateType||p,_.test(i+p)||(h=h.parentNode);h;h=h.parentNode)o.push(h),l=h;l===(d.ownerDocument||z)&&o.push(l.defaultView||l.parentWindow||a)}m=0;while((h=o[m++])&&!b.isPropagationStopped())b.type=m>1?i:k.bindType||p,f=(n._data(h,"events")||{})[b.type]&&n._data(h,"handle"),f&&f.apply(h,c),f=g&&h[g],f&&f.apply&&n.acceptData(h)&&(b.result=f.apply(h,c),b.result===!1&&b.preventDefault());if(b.type=p,!e&&!b.isDefaultPrevented()&&(!k._default||k._default.apply(o.pop(),c)===!1)&&n.acceptData(d)&&g&&d[p]&&!n.isWindow(d)){l=d[g],l&&(d[g]=null),n.event.triggered=p;try{d[p]()}catch(r){}n.event.triggered=void 0,l&&(d[g]=l)}return b.result}},dispatch:function(a){a=n.event.fix(a);var b,c,e,f,g,h=[],i=d.call(arguments),j=(n._data(this,"events")||{})[a.type]||[],k=n.event.special[a.type]||{};if(i[0]=a,a.delegateTarget=this,!k.preDispatch||k.preDispatch.call(this,a)!==!1){h=n.event.handlers.call(this,a,j),b=0;while((f=h[b++])&&!a.isPropagationStopped()){a.currentTarget=f.elem,g=0;while((e=f.handlers[g++])&&!a.isImmediatePropagationStopped())(!a.namespace_re||a.namespace_re.test(e.namespace))&&(a.handleObj=e,a.data=e.data,c=((n.event.special[e.origType]||{}).handle||e.handler).apply(f.elem,i),void 0!==c&&(a.result=c)===!1&&(a.preventDefault(),a.stopPropagation()))}return k.postDispatch&&k.postDispatch.call(this,a),a.result}},handlers:function(a,b){var c,d,e,f,g=[],h=b.delegateCount,i=a.target;if(h&&i.nodeType&&(!a.button||"click"!==a.type))for(;i!=this;i=i.parentNode||this)if(1===i.nodeType&&(i.disabled!==!0||"click"!==a.type)){for(e=[],f=0;h>f;f++)d=b[f],c=d.selector+" ",void 0===e[c]&&(e[c]=d.needsContext?n(c,this).index(i)>=0:n.find(c,this,null,[i]).length),e[c]&&e.push(d);e.length&&g.push({elem:i,handlers:e})}return h<b.length&&g.push({elem:this,handlers:b.slice(h)}),g},fix:function(a){if(a[n.expando])return a;var b,c,d,e=a.type,f=a,g=this.fixHooks[e];g||(this.fixHooks[e]=g=$.test(e)?this.mouseHooks:Z.test(e)?this.keyHooks:{}),d=g.props?this.props.concat(g.props):this.props,a=new n.Event(f),b=d.length;while(b--)c=d[b],a[c]=f[c];return a.target||(a.target=f.srcElement||z),3===a.target.nodeType&&(a.target=a.target.parentNode),a.metaKey=!!a.metaKey,g.filter?g.filter(a,f):a},props:"altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(a,b){return null==a.which&&(a.which=null!=b.charCode?b.charCode:b.keyCode),a}},mouseHooks:{props:"button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(a,b){var c,d,e,f=b.button,g=b.fromElement;return null==a.pageX&&null!=b.clientX&&(d=a.target.ownerDocument||z,e=d.documentElement,c=d.body,a.pageX=b.clientX+(e&&e.scrollLeft||c&&c.scrollLeft||0)-(e&&e.clientLeft||c&&c.clientLeft||0),a.pageY=b.clientY+(e&&e.scrollTop||c&&c.scrollTop||0)-(e&&e.clientTop||c&&c.clientTop||0)),!a.relatedTarget&&g&&(a.relatedTarget=g===a.target?b.toElement:g),a.which||void 0===f||(a.which=1&f?1:2&f?3:4&f?2:0),a}},special:{load:{noBubble:!0},focus:{trigger:function(){if(this!==db()&&this.focus)try{return this.focus(),!1}catch(a){}},delegateType:"focusin"},blur:{trigger:function(){return this===db()&&this.blur?(this.blur(),!1):void 0},delegateType:"focusout"},click:{trigger:function(){return n.nodeName(this,"input")&&"checkbox"===this.type&&this.click?(this.click(),!1):void 0},_default:function(a){return n.nodeName(a.target,"a")}},beforeunload:{postDispatch:function(a){void 0!==a.result&&(a.originalEvent.returnValue=a.result)}}},simulate:function(a,b,c,d){var e=n.extend(new n.Event,c,{type:a,isSimulated:!0,originalEvent:{}});d?n.event.trigger(e,null,b):n.event.dispatch.call(b,e),e.isDefaultPrevented()&&c.preventDefault()}},n.removeEvent=z.removeEventListener?function(a,b,c){a.removeEventListener&&a.removeEventListener(b,c,!1)}:function(a,b,c){var d="on"+b;a.detachEvent&&(typeof a[d]===L&&(a[d]=null),a.detachEvent(d,c))},n.Event=function(a,b){return this instanceof n.Event?(a&&a.type?(this.originalEvent=a,this.type=a.type,this.isDefaultPrevented=a.defaultPrevented||void 0===a.defaultPrevented&&(a.returnValue===!1||a.getPreventDefault&&a.getPreventDefault())?bb:cb):this.type=a,b&&n.extend(this,b),this.timeStamp=a&&a.timeStamp||n.now(),void(this[n.expando]=!0)):new n.Event(a,b)},n.Event.prototype={isDefaultPrevented:cb,isPropagationStopped:cb,isImmediatePropagationStopped:cb,preventDefault:function(){var a=this.originalEvent;this.isDefaultPrevented=bb,a&&(a.preventDefault?a.preventDefault():a.returnValue=!1)},stopPropagation:function(){var a=this.originalEvent;this.isPropagationStopped=bb,a&&(a.stopPropagation&&a.stopPropagation(),a.cancelBubble=!0)},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=bb,this.stopPropagation()}},n.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){n.event.special[a]={delegateType:b,bindType:b,handle:function(a){var c,d=this,e=a.relatedTarget,f=a.handleObj;return(!e||e!==d&&!n.contains(d,e))&&(a.type=f.origType,c=f.handler.apply(this,arguments),a.type=b),c}}}),l.submitBubbles||(n.event.special.submit={setup:function(){return n.nodeName(this,"form")?!1:void n.event.add(this,"click._submit keypress._submit",function(a){var b=a.target,c=n.nodeName(b,"input")||n.nodeName(b,"button")?b.form:void 0;c&&!n._data(c,"submitBubbles")&&(n.event.add(c,"submit._submit",function(a){a._submit_bubble=!0}),n._data(c,"submitBubbles",!0))})},postDispatch:function(a){a._submit_bubble&&(delete a._submit_bubble,this.parentNode&&!a.isTrigger&&n.event.simulate("submit",this.parentNode,a,!0))},teardown:function(){return n.nodeName(this,"form")?!1:void n.event.remove(this,"._submit")}}),l.changeBubbles||(n.event.special.change={setup:function(){return Y.test(this.nodeName)?(("checkbox"===this.type||"radio"===this.type)&&(n.event.add(this,"propertychange._change",function(a){"checked"===a.originalEvent.propertyName&&(this._just_changed=!0)}),n.event.add(this,"click._change",function(a){this._just_changed&&!a.isTrigger&&(this._just_changed=!1),n.event.simulate("change",this,a,!0)})),!1):void n.event.add(this,"beforeactivate._change",function(a){var b=a.target;Y.test(b.nodeName)&&!n._data(b,"changeBubbles")&&(n.event.add(b,"change._change",function(a){!this.parentNode||a.isSimulated||a.isTrigger||n.event.simulate("change",this.parentNode,a,!0)}),n._data(b,"changeBubbles",!0))})},handle:function(a){var b=a.target;return this!==b||a.isSimulated||a.isTrigger||"radio"!==b.type&&"checkbox"!==b.type?a.handleObj.handler.apply(this,arguments):void 0},teardown:function(){return n.event.remove(this,"._change"),!Y.test(this.nodeName)}}),l.focusinBubbles||n.each({focus:"focusin",blur:"focusout"},function(a,b){var c=function(a){n.event.simulate(b,a.target,n.event.fix(a),!0)};n.event.special[b]={setup:function(){var d=this.ownerDocument||this,e=n._data(d,b);e||d.addEventListener(a,c,!0),n._data(d,b,(e||0)+1)},teardown:function(){var d=this.ownerDocument||this,e=n._data(d,b)-1;e?n._data(d,b,e):(d.removeEventListener(a,c,!0),n._removeData(d,b))}}}),n.fn.extend({on:function(a,b,c,d,e){var f,g;if("object"==typeof a){"string"!=typeof b&&(c=c||b,b=void 0);for(f in a)this.on(f,b,c,a[f],e);return this}if(null==c&&null==d?(d=b,c=b=void 0):null==d&&("string"==typeof b?(d=c,c=void 0):(d=c,c=b,b=void 0)),d===!1)d=cb;else if(!d)return this;return 1===e&&(g=d,d=function(a){return n().off(a),g.apply(this,arguments)},d.guid=g.guid||(g.guid=n.guid++)),this.each(function(){n.event.add(this,a,d,c,b)})},one:function(a,b,c,d){return this.on(a,b,c,d,1)},off:function(a,b,c){var d,e;if(a&&a.preventDefault&&a.handleObj)return d=a.handleObj,n(a.delegateTarget).off(d.namespace?d.origType+"."+d.namespace:d.origType,d.selector,d.handler),this;if("object"==typeof a){for(e in a)this.off(e,b,a[e]);return this}return(b===!1||"function"==typeof b)&&(c=b,b=void 0),c===!1&&(c=cb),this.each(function(){n.event.remove(this,a,c,b)})},trigger:function(a,b){return this.each(function(){n.event.trigger(a,b,this)})},triggerHandler:function(a,b){var c=this[0];return c?n.event.trigger(a,b,c,!0):void 0}});function eb(a){var b=fb.split("|"),c=a.createDocumentFragment();if(c.createElement)while(b.length)c.createElement(b.pop());return c}var fb="abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",gb=/ jQuery\d+="(?:null|\d+)"/g,hb=new RegExp("<(?:"+fb+")[\\s/>]","i"),ib=/^\s+/,jb=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,kb=/<([\w:]+)/,lb=/<tbody/i,mb=/<|&#?\w+;/,nb=/<(?:script|style|link)/i,ob=/checked\s*(?:[^=]|=\s*.checked.)/i,pb=/^$|\/(?:java|ecma)script/i,qb=/^true\/(.*)/,rb=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,sb={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],area:[1,"<map>","</map>"],param:[1,"<object>","</object>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:l.htmlSerialize?[0,"",""]:[1,"X<div>","</div>"]},tb=eb(z),ub=tb.appendChild(z.createElement("div"));sb.optgroup=sb.option,sb.tbody=sb.tfoot=sb.colgroup=sb.caption=sb.thead,sb.th=sb.td;function vb(a,b){var c,d,e=0,f=typeof a.getElementsByTagName!==L?a.getElementsByTagName(b||"*"):typeof a.querySelectorAll!==L?a.querySelectorAll(b||"*"):void 0;if(!f)for(f=[],c=a.childNodes||a;null!=(d=c[e]);e++)!b||n.nodeName(d,b)?f.push(d):n.merge(f,vb(d,b));return void 0===b||b&&n.nodeName(a,b)?n.merge([a],f):f}function wb(a){X.test(a.type)&&(a.defaultChecked=a.checked)}function xb(a,b){return n.nodeName(a,"table")&&n.nodeName(11!==b.nodeType?b:b.firstChild,"tr")?a.getElementsByTagName("tbody")[0]||a.appendChild(a.ownerDocument.createElement("tbody")):a}function yb(a){return a.type=(null!==n.find.attr(a,"type"))+"/"+a.type,a}function zb(a){var b=qb.exec(a.type);return b?a.type=b[1]:a.removeAttribute("type"),a}function Ab(a,b){for(var c,d=0;null!=(c=a[d]);d++)n._data(c,"globalEval",!b||n._data(b[d],"globalEval"))}function Bb(a,b){if(1===b.nodeType&&n.hasData(a)){var c,d,e,f=n._data(a),g=n._data(b,f),h=f.events;if(h){delete g.handle,g.events={};for(c in h)for(d=0,e=h[c].length;e>d;d++)n.event.add(b,c,h[c][d])}g.data&&(g.data=n.extend({},g.data))}}function Cb(a,b){var c,d,e;if(1===b.nodeType){if(c=b.nodeName.toLowerCase(),!l.noCloneEvent&&b[n.expando]){e=n._data(b);for(d in e.events)n.removeEvent(b,d,e.handle);b.removeAttribute(n.expando)}"script"===c&&b.text!==a.text?(yb(b).text=a.text,zb(b)):"object"===c?(b.parentNode&&(b.outerHTML=a.outerHTML),l.html5Clone&&a.innerHTML&&!n.trim(b.innerHTML)&&(b.innerHTML=a.innerHTML)):"input"===c&&X.test(a.type)?(b.defaultChecked=b.checked=a.checked,b.value!==a.value&&(b.value=a.value)):"option"===c?b.defaultSelected=b.selected=a.defaultSelected:("input"===c||"textarea"===c)&&(b.defaultValue=a.defaultValue)}}n.extend({clone:function(a,b,c){var d,e,f,g,h,i=n.contains(a.ownerDocument,a);if(l.html5Clone||n.isXMLDoc(a)||!hb.test("<"+a.nodeName+">")?f=a.cloneNode(!0):(ub.innerHTML=a.outerHTML,ub.removeChild(f=ub.firstChild)),!(l.noCloneEvent&&l.noCloneChecked||1!==a.nodeType&&11!==a.nodeType||n.isXMLDoc(a)))for(d=vb(f),h=vb(a),g=0;null!=(e=h[g]);++g)d[g]&&Cb(e,d[g]);if(b)if(c)for(h=h||vb(a),d=d||vb(f),g=0;null!=(e=h[g]);g++)Bb(e,d[g]);else Bb(a,f);return d=vb(f,"script"),d.length>0&&Ab(d,!i&&vb(a,"script")),d=h=e=null,f},buildFragment:function(a,b,c,d){for(var e,f,g,h,i,j,k,m=a.length,o=eb(b),p=[],q=0;m>q;q++)if(f=a[q],f||0===f)if("object"===n.type(f))n.merge(p,f.nodeType?[f]:f);else if(mb.test(f)){h=h||o.appendChild(b.createElement("div")),i=(kb.exec(f)||["",""])[1].toLowerCase(),k=sb[i]||sb._default,h.innerHTML=k[1]+f.replace(jb,"<$1></$2>")+k[2],e=k[0];while(e--)h=h.lastChild;if(!l.leadingWhitespace&&ib.test(f)&&p.push(b.createTextNode(ib.exec(f)[0])),!l.tbody){f="table"!==i||lb.test(f)?"<table>"!==k[1]||lb.test(f)?0:h:h.firstChild,e=f&&f.childNodes.length;while(e--)n.nodeName(j=f.childNodes[e],"tbody")&&!j.childNodes.length&&f.removeChild(j)}n.merge(p,h.childNodes),h.textContent="";while(h.firstChild)h.removeChild(h.firstChild);h=o.lastChild}else p.push(b.createTextNode(f));h&&o.removeChild(h),l.appendChecked||n.grep(vb(p,"input"),wb),q=0;while(f=p[q++])if((!d||-1===n.inArray(f,d))&&(g=n.contains(f.ownerDocument,f),h=vb(o.appendChild(f),"script"),g&&Ab(h),c)){e=0;while(f=h[e++])pb.test(f.type||"")&&c.push(f)}return h=null,o},cleanData:function(a,b){for(var d,e,f,g,h=0,i=n.expando,j=n.cache,k=l.deleteExpando,m=n.event.special;null!=(d=a[h]);h++)if((b||n.acceptData(d))&&(f=d[i],g=f&&j[f])){if(g.events)for(e in g.events)m[e]?n.event.remove(d,e):n.removeEvent(d,e,g.handle);j[f]&&(delete j[f],k?delete d[i]:typeof d.removeAttribute!==L?d.removeAttribute(i):d[i]=null,c.push(f))}}}),n.fn.extend({text:function(a){return W(this,function(a){return void 0===a?n.text(this):this.empty().append((this[0]&&this[0].ownerDocument||z).createTextNode(a))},null,a,arguments.length)},append:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=xb(this,a);b.appendChild(a)}})},prepend:function(){return this.domManip(arguments,function(a){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var b=xb(this,a);b.insertBefore(a,b.firstChild)}})},before:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this)})},after:function(){return this.domManip(arguments,function(a){this.parentNode&&this.parentNode.insertBefore(a,this.nextSibling)})},remove:function(a,b){for(var c,d=a?n.filter(a,this):this,e=0;null!=(c=d[e]);e++)b||1!==c.nodeType||n.cleanData(vb(c)),c.parentNode&&(b&&n.contains(c.ownerDocument,c)&&Ab(vb(c,"script")),c.parentNode.removeChild(c));return this},empty:function(){for(var a,b=0;null!=(a=this[b]);b++){1===a.nodeType&&n.cleanData(vb(a,!1));while(a.firstChild)a.removeChild(a.firstChild);a.options&&n.nodeName(a,"select")&&(a.options.length=0)}return this},clone:function(a,b){return a=null==a?!1:a,b=null==b?a:b,this.map(function(){return n.clone(this,a,b)})},html:function(a){return W(this,function(a){var b=this[0]||{},c=0,d=this.length;if(void 0===a)return 1===b.nodeType?b.innerHTML.replace(gb,""):void 0;if(!("string"!=typeof a||nb.test(a)||!l.htmlSerialize&&hb.test(a)||!l.leadingWhitespace&&ib.test(a)||sb[(kb.exec(a)||["",""])[1].toLowerCase()])){a=a.replace(jb,"<$1></$2>");try{for(;d>c;c++)b=this[c]||{},1===b.nodeType&&(n.cleanData(vb(b,!1)),b.innerHTML=a);b=0}catch(e){}}b&&this.empty().append(a)},null,a,arguments.length)},replaceWith:function(){var a=arguments[0];return this.domManip(arguments,function(b){a=this.parentNode,n.cleanData(vb(this)),a&&a.replaceChild(b,this)}),a&&(a.length||a.nodeType)?this:this.remove()},detach:function(a){return this.remove(a,!0)},domManip:function(a,b){a=e.apply([],a);var c,d,f,g,h,i,j=0,k=this.length,m=this,o=k-1,p=a[0],q=n.isFunction(p);if(q||k>1&&"string"==typeof p&&!l.checkClone&&ob.test(p))return this.each(function(c){var d=m.eq(c);q&&(a[0]=p.call(this,c,d.html())),d.domManip(a,b)});if(k&&(i=n.buildFragment(a,this[0].ownerDocument,!1,this),c=i.firstChild,1===i.childNodes.length&&(i=c),c)){for(g=n.map(vb(i,"script"),yb),f=g.length;k>j;j++)d=i,j!==o&&(d=n.clone(d,!0,!0),f&&n.merge(g,vb(d,"script"))),b.call(this[j],d,j);if(f)for(h=g[g.length-1].ownerDocument,n.map(g,zb),j=0;f>j;j++)d=g[j],pb.test(d.type||"")&&!n._data(d,"globalEval")&&n.contains(h,d)&&(d.src?n._evalUrl&&n._evalUrl(d.src):n.globalEval((d.text||d.textContent||d.innerHTML||"").replace(rb,"")));i=c=null}return this}}),n.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){n.fn[a]=function(a){for(var c,d=0,e=[],g=n(a),h=g.length-1;h>=d;d++)c=d===h?this:this.clone(!0),n(g[d])[b](c),f.apply(e,c.get());return this.pushStack(e)}});var Db,Eb={};function Fb(b,c){var d=n(c.createElement(b)).appendTo(c.body),e=a.getDefaultComputedStyle?a.getDefaultComputedStyle(d[0]).display:n.css(d[0],"display");return d.detach(),e}function Gb(a){var b=z,c=Eb[a];return c||(c=Fb(a,b),"none"!==c&&c||(Db=(Db||n("<iframe frameborder='0' width='0' height='0'/>")).appendTo(b.documentElement),b=(Db[0].contentWindow||Db[0].contentDocument).document,b.write(),b.close(),c=Fb(a,b),Db.detach()),Eb[a]=c),c}!function(){var a,b,c=z.createElement("div"),d="-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;padding:0;margin:0;border:0";c.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",a=c.getElementsByTagName("a")[0],a.style.cssText="float:left;opacity:.5",l.opacity=/^0.5/.test(a.style.opacity),l.cssFloat=!!a.style.cssFloat,c.style.backgroundClip="content-box",c.cloneNode(!0).style.backgroundClip="",l.clearCloneStyle="content-box"===c.style.backgroundClip,a=c=null,l.shrinkWrapBlocks=function(){var a,c,e,f;if(null==b){if(a=z.getElementsByTagName("body")[0],!a)return;f="border:0;width:0;height:0;position:absolute;top:0;left:-9999px",c=z.createElement("div"),e=z.createElement("div"),a.appendChild(c).appendChild(e),b=!1,typeof e.style.zoom!==L&&(e.style.cssText=d+";width:1px;padding:1px;zoom:1",e.innerHTML="<div></div>",e.firstChild.style.width="5px",b=3!==e.offsetWidth),a.removeChild(c),a=c=e=null}return b}}();var Hb=/^margin/,Ib=new RegExp("^("+T+")(?!px)[a-z%]+$","i"),Jb,Kb,Lb=/^(top|right|bottom|left)$/;a.getComputedStyle?(Jb=function(a){return a.ownerDocument.defaultView.getComputedStyle(a,null)},Kb=function(a,b,c){var d,e,f,g,h=a.style;return c=c||Jb(a),g=c?c.getPropertyValue(b)||c[b]:void 0,c&&(""!==g||n.contains(a.ownerDocument,a)||(g=n.style(a,b)),Ib.test(g)&&Hb.test(b)&&(d=h.width,e=h.minWidth,f=h.maxWidth,h.minWidth=h.maxWidth=h.width=g,g=c.width,h.width=d,h.minWidth=e,h.maxWidth=f)),void 0===g?g:g+""}):z.documentElement.currentStyle&&(Jb=function(a){return a.currentStyle},Kb=function(a,b,c){var d,e,f,g,h=a.style;return c=c||Jb(a),g=c?c[b]:void 0,null==g&&h&&h[b]&&(g=h[b]),Ib.test(g)&&!Lb.test(b)&&(d=h.left,e=a.runtimeStyle,f=e&&e.left,f&&(e.left=a.currentStyle.left),h.left="fontSize"===b?"1em":g,g=h.pixelLeft+"px",h.left=d,f&&(e.left=f)),void 0===g?g:g+""||"auto"});function Mb(a,b){return{get:function(){var c=a();if(null!=c)return c?void delete this.get:(this.get=b).apply(this,arguments)}}}!function(){var b,c,d,e,f,g,h=z.createElement("div"),i="border:0;width:0;height:0;position:absolute;top:0;left:-9999px",j="-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;padding:0;margin:0;border:0";h.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",b=h.getElementsByTagName("a")[0],b.style.cssText="float:left;opacity:.5",l.opacity=/^0.5/.test(b.style.opacity),l.cssFloat=!!b.style.cssFloat,h.style.backgroundClip="content-box",h.cloneNode(!0).style.backgroundClip="",l.clearCloneStyle="content-box"===h.style.backgroundClip,b=h=null,n.extend(l,{reliableHiddenOffsets:function(){if(null!=c)return c;var a,b,d,e=z.createElement("div"),f=z.getElementsByTagName("body")[0];if(f)return e.setAttribute("className","t"),e.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",a=z.createElement("div"),a.style.cssText=i,f.appendChild(a).appendChild(e),e.innerHTML="<table><tr><td></td><td>t</td></tr></table>",b=e.getElementsByTagName("td"),b[0].style.cssText="padding:0;margin:0;border:0;display:none",d=0===b[0].offsetHeight,b[0].style.display="",b[1].style.display="none",c=d&&0===b[0].offsetHeight,f.removeChild(a),e=f=null,c},boxSizing:function(){return null==d&&k(),d},boxSizingReliable:function(){return null==e&&k(),e},pixelPosition:function(){return null==f&&k(),f},reliableMarginRight:function(){var b,c,d,e;if(null==g&&a.getComputedStyle){if(b=z.getElementsByTagName("body")[0],!b)return;c=z.createElement("div"),d=z.createElement("div"),c.style.cssText=i,b.appendChild(c).appendChild(d),e=d.appendChild(z.createElement("div")),e.style.cssText=d.style.cssText=j,e.style.marginRight=e.style.width="0",d.style.width="1px",g=!parseFloat((a.getComputedStyle(e,null)||{}).marginRight),b.removeChild(c)}return g}});function k(){var b,c,h=z.getElementsByTagName("body")[0];h&&(b=z.createElement("div"),c=z.createElement("div"),b.style.cssText=i,h.appendChild(b).appendChild(c),c.style.cssText="-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;position:absolute;display:block;padding:1px;border:1px;width:4px;margin-top:1%;top:1%",n.swap(h,null!=h.style.zoom?{zoom:1}:{},function(){d=4===c.offsetWidth}),e=!0,f=!1,g=!0,a.getComputedStyle&&(f="1%"!==(a.getComputedStyle(c,null)||{}).top,e="4px"===(a.getComputedStyle(c,null)||{width:"4px"}).width),h.removeChild(b),c=h=null)}}(),n.swap=function(a,b,c,d){var e,f,g={};for(f in b)g[f]=a.style[f],a.style[f]=b[f];e=c.apply(a,d||[]);for(f in b)a.style[f]=g[f];return e};var Nb=/alpha\([^)]*\)/i,Ob=/opacity\s*=\s*([^)]*)/,Pb=/^(none|table(?!-c[ea]).+)/,Qb=new RegExp("^("+T+")(.*)$","i"),Rb=new RegExp("^([+-])=("+T+")","i"),Sb={position:"absolute",visibility:"hidden",display:"block"},Tb={letterSpacing:0,fontWeight:400},Ub=["Webkit","O","Moz","ms"];function Vb(a,b){if(b in a)return b;var c=b.charAt(0).toUpperCase()+b.slice(1),d=b,e=Ub.length;while(e--)if(b=Ub[e]+c,b in a)return b;return d}function Wb(a,b){for(var c,d,e,f=[],g=0,h=a.length;h>g;g++)d=a[g],d.style&&(f[g]=n._data(d,"olddisplay"),c=d.style.display,b?(f[g]||"none"!==c||(d.style.display=""),""===d.style.display&&V(d)&&(f[g]=n._data(d,"olddisplay",Gb(d.nodeName)))):f[g]||(e=V(d),(c&&"none"!==c||!e)&&n._data(d,"olddisplay",e?c:n.css(d,"display"))));for(g=0;h>g;g++)d=a[g],d.style&&(b&&"none"!==d.style.display&&""!==d.style.display||(d.style.display=b?f[g]||"":"none"));return a}function Xb(a,b,c){var d=Qb.exec(b);return d?Math.max(0,d[1]-(c||0))+(d[2]||"px"):b}function Yb(a,b,c,d,e){for(var f=c===(d?"border":"content")?4:"width"===b?1:0,g=0;4>f;f+=2)"margin"===c&&(g+=n.css(a,c+U[f],!0,e)),d?("content"===c&&(g-=n.css(a,"padding"+U[f],!0,e)),"margin"!==c&&(g-=n.css(a,"border"+U[f]+"Width",!0,e))):(g+=n.css(a,"padding"+U[f],!0,e),"padding"!==c&&(g+=n.css(a,"border"+U[f]+"Width",!0,e)));return g}function Zb(a,b,c){var d=!0,e="width"===b?a.offsetWidth:a.offsetHeight,f=Jb(a),g=l.boxSizing()&&"border-box"===n.css(a,"boxSizing",!1,f);if(0>=e||null==e){if(e=Kb(a,b,f),(0>e||null==e)&&(e=a.style[b]),Ib.test(e))return e;d=g&&(l.boxSizingReliable()||e===a.style[b]),e=parseFloat(e)||0}return e+Yb(a,b,c||(g?"border":"content"),d,f)+"px"}n.extend({cssHooks:{opacity:{get:function(a,b){if(b){var c=Kb(a,"opacity");return""===c?"1":c}}}},cssNumber:{columnCount:!0,fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":l.cssFloat?"cssFloat":"styleFloat"},style:function(a,b,c,d){if(a&&3!==a.nodeType&&8!==a.nodeType&&a.style){var e,f,g,h=n.camelCase(b),i=a.style;if(b=n.cssProps[h]||(n.cssProps[h]=Vb(i,h)),g=n.cssHooks[b]||n.cssHooks[h],void 0===c)return g&&"get"in g&&void 0!==(e=g.get(a,!1,d))?e:i[b];if(f=typeof c,"string"===f&&(e=Rb.exec(c))&&(c=(e[1]+1)*e[2]+parseFloat(n.css(a,b)),f="number"),null!=c&&c===c&&("number"!==f||n.cssNumber[h]||(c+="px"),l.clearCloneStyle||""!==c||0!==b.indexOf("background")||(i[b]="inherit"),!(g&&"set"in g&&void 0===(c=g.set(a,c,d)))))try{i[b]="",i[b]=c}catch(j){}}},css:function(a,b,c,d){var e,f,g,h=n.camelCase(b);return b=n.cssProps[h]||(n.cssProps[h]=Vb(a.style,h)),g=n.cssHooks[b]||n.cssHooks[h],g&&"get"in g&&(f=g.get(a,!0,c)),void 0===f&&(f=Kb(a,b,d)),"normal"===f&&b in Tb&&(f=Tb[b]),""===c||c?(e=parseFloat(f),c===!0||n.isNumeric(e)?e||0:f):f}}),n.each(["height","width"],function(a,b){n.cssHooks[b]={get:function(a,c,d){return c?0===a.offsetWidth&&Pb.test(n.css(a,"display"))?n.swap(a,Sb,function(){return Zb(a,b,d)}):Zb(a,b,d):void 0},set:function(a,c,d){var e=d&&Jb(a);return Xb(a,c,d?Yb(a,b,d,l.boxSizing()&&"border-box"===n.css(a,"boxSizing",!1,e),e):0)}}}),l.opacity||(n.cssHooks.opacity={get:function(a,b){return Ob.test((b&&a.currentStyle?a.currentStyle.filter:a.style.filter)||"")?.01*parseFloat(RegExp.$1)+"":b?"1":""},set:function(a,b){var c=a.style,d=a.currentStyle,e=n.isNumeric(b)?"alpha(opacity="+100*b+")":"",f=d&&d.filter||c.filter||"";c.zoom=1,(b>=1||""===b)&&""===n.trim(f.replace(Nb,""))&&c.removeAttribute&&(c.removeAttribute("filter"),""===b||d&&!d.filter)||(c.filter=Nb.test(f)?f.replace(Nb,e):f+" "+e)}}),n.cssHooks.marginRight=Mb(l.reliableMarginRight,function(a,b){return b?n.swap(a,{display:"inline-block"},Kb,[a,"marginRight"]):void 0}),n.each({margin:"",padding:"",border:"Width"},function(a,b){n.cssHooks[a+b]={expand:function(c){for(var d=0,e={},f="string"==typeof c?c.split(" "):[c];4>d;d++)e[a+U[d]+b]=f[d]||f[d-2]||f[0];return e}},Hb.test(a)||(n.cssHooks[a+b].set=Xb)}),n.fn.extend({css:function(a,b){return W(this,function(a,b,c){var d,e,f={},g=0;if(n.isArray(b)){for(d=Jb(a),e=b.length;e>g;g++)f[b[g]]=n.css(a,b[g],!1,d);return f}return void 0!==c?n.style(a,b,c):n.css(a,b)
+},a,b,arguments.length>1)},show:function(){return Wb(this,!0)},hide:function(){return Wb(this)},toggle:function(a){return"boolean"==typeof a?a?this.show():this.hide():this.each(function(){V(this)?n(this).show():n(this).hide()})}});function $b(a,b,c,d,e){return new $b.prototype.init(a,b,c,d,e)}n.Tween=$b,$b.prototype={constructor:$b,init:function(a,b,c,d,e,f){this.elem=a,this.prop=c,this.easing=e||"swing",this.options=b,this.start=this.now=this.cur(),this.end=d,this.unit=f||(n.cssNumber[c]?"":"px")},cur:function(){var a=$b.propHooks[this.prop];return a&&a.get?a.get(this):$b.propHooks._default.get(this)},run:function(a){var b,c=$b.propHooks[this.prop];return this.pos=b=this.options.duration?n.easing[this.easing](a,this.options.duration*a,0,1,this.options.duration):a,this.now=(this.end-this.start)*b+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),c&&c.set?c.set(this):$b.propHooks._default.set(this),this}},$b.prototype.init.prototype=$b.prototype,$b.propHooks={_default:{get:function(a){var b;return null==a.elem[a.prop]||a.elem.style&&null!=a.elem.style[a.prop]?(b=n.css(a.elem,a.prop,""),b&&"auto"!==b?b:0):a.elem[a.prop]},set:function(a){n.fx.step[a.prop]?n.fx.step[a.prop](a):a.elem.style&&(null!=a.elem.style[n.cssProps[a.prop]]||n.cssHooks[a.prop])?n.style(a.elem,a.prop,a.now+a.unit):a.elem[a.prop]=a.now}}},$b.propHooks.scrollTop=$b.propHooks.scrollLeft={set:function(a){a.elem.nodeType&&a.elem.parentNode&&(a.elem[a.prop]=a.now)}},n.easing={linear:function(a){return a},swing:function(a){return.5-Math.cos(a*Math.PI)/2}},n.fx=$b.prototype.init,n.fx.step={};var _b,ac,bc=/^(?:toggle|show|hide)$/,cc=new RegExp("^(?:([+-])=|)("+T+")([a-z%]*)$","i"),dc=/queueHooks$/,ec=[jc],fc={"*":[function(a,b){var c=this.createTween(a,b),d=c.cur(),e=cc.exec(b),f=e&&e[3]||(n.cssNumber[a]?"":"px"),g=(n.cssNumber[a]||"px"!==f&&+d)&&cc.exec(n.css(c.elem,a)),h=1,i=20;if(g&&g[3]!==f){f=f||g[3],e=e||[],g=+d||1;do h=h||".5",g/=h,n.style(c.elem,a,g+f);while(h!==(h=c.cur()/d)&&1!==h&&--i)}return e&&(g=c.start=+g||+d||0,c.unit=f,c.end=e[1]?g+(e[1]+1)*e[2]:+e[2]),c}]};function gc(){return setTimeout(function(){_b=void 0}),_b=n.now()}function hc(a,b){var c,d={height:a},e=0;for(b=b?1:0;4>e;e+=2-b)c=U[e],d["margin"+c]=d["padding"+c]=a;return b&&(d.opacity=d.width=a),d}function ic(a,b,c){for(var d,e=(fc[b]||[]).concat(fc["*"]),f=0,g=e.length;g>f;f++)if(d=e[f].call(c,b,a))return d}function jc(a,b,c){var d,e,f,g,h,i,j,k,m=this,o={},p=a.style,q=a.nodeType&&V(a),r=n._data(a,"fxshow");c.queue||(h=n._queueHooks(a,"fx"),null==h.unqueued&&(h.unqueued=0,i=h.empty.fire,h.empty.fire=function(){h.unqueued||i()}),h.unqueued++,m.always(function(){m.always(function(){h.unqueued--,n.queue(a,"fx").length||h.empty.fire()})})),1===a.nodeType&&("height"in b||"width"in b)&&(c.overflow=[p.overflow,p.overflowX,p.overflowY],j=n.css(a,"display"),k=Gb(a.nodeName),"none"===j&&(j=k),"inline"===j&&"none"===n.css(a,"float")&&(l.inlineBlockNeedsLayout&&"inline"!==k?p.zoom=1:p.display="inline-block")),c.overflow&&(p.overflow="hidden",l.shrinkWrapBlocks()||m.always(function(){p.overflow=c.overflow[0],p.overflowX=c.overflow[1],p.overflowY=c.overflow[2]}));for(d in b)if(e=b[d],bc.exec(e)){if(delete b[d],f=f||"toggle"===e,e===(q?"hide":"show")){if("show"!==e||!r||void 0===r[d])continue;q=!0}o[d]=r&&r[d]||n.style(a,d)}if(!n.isEmptyObject(o)){r?"hidden"in r&&(q=r.hidden):r=n._data(a,"fxshow",{}),f&&(r.hidden=!q),q?n(a).show():m.done(function(){n(a).hide()}),m.done(function(){var b;n._removeData(a,"fxshow");for(b in o)n.style(a,b,o[b])});for(d in o)g=ic(q?r[d]:0,d,m),d in r||(r[d]=g.start,q&&(g.end=g.start,g.start="width"===d||"height"===d?1:0))}}function kc(a,b){var c,d,e,f,g;for(c in a)if(d=n.camelCase(c),e=b[d],f=a[c],n.isArray(f)&&(e=f[1],f=a[c]=f[0]),c!==d&&(a[d]=f,delete a[c]),g=n.cssHooks[d],g&&"expand"in g){f=g.expand(f),delete a[d];for(c in f)c in a||(a[c]=f[c],b[c]=e)}else b[d]=e}function lc(a,b,c){var d,e,f=0,g=ec.length,h=n.Deferred().always(function(){delete i.elem}),i=function(){if(e)return!1;for(var b=_b||gc(),c=Math.max(0,j.startTime+j.duration-b),d=c/j.duration||0,f=1-d,g=0,i=j.tweens.length;i>g;g++)j.tweens[g].run(f);return h.notifyWith(a,[j,f,c]),1>f&&i?c:(h.resolveWith(a,[j]),!1)},j=h.promise({elem:a,props:n.extend({},b),opts:n.extend(!0,{specialEasing:{}},c),originalProperties:b,originalOptions:c,startTime:_b||gc(),duration:c.duration,tweens:[],createTween:function(b,c){var d=n.Tween(a,j.opts,b,c,j.opts.specialEasing[b]||j.opts.easing);return j.tweens.push(d),d},stop:function(b){var c=0,d=b?j.tweens.length:0;if(e)return this;for(e=!0;d>c;c++)j.tweens[c].run(1);return b?h.resolveWith(a,[j,b]):h.rejectWith(a,[j,b]),this}}),k=j.props;for(kc(k,j.opts.specialEasing);g>f;f++)if(d=ec[f].call(j,a,k,j.opts))return d;return n.map(k,ic,j),n.isFunction(j.opts.start)&&j.opts.start.call(a,j),n.fx.timer(n.extend(i,{elem:a,anim:j,queue:j.opts.queue})),j.progress(j.opts.progress).done(j.opts.done,j.opts.complete).fail(j.opts.fail).always(j.opts.always)}n.Animation=n.extend(lc,{tweener:function(a,b){n.isFunction(a)?(b=a,a=["*"]):a=a.split(" ");for(var c,d=0,e=a.length;e>d;d++)c=a[d],fc[c]=fc[c]||[],fc[c].unshift(b)},prefilter:function(a,b){b?ec.unshift(a):ec.push(a)}}),n.speed=function(a,b,c){var d=a&&"object"==typeof a?n.extend({},a):{complete:c||!c&&b||n.isFunction(a)&&a,duration:a,easing:c&&b||b&&!n.isFunction(b)&&b};return d.duration=n.fx.off?0:"number"==typeof d.duration?d.duration:d.duration in n.fx.speeds?n.fx.speeds[d.duration]:n.fx.speeds._default,(null==d.queue||d.queue===!0)&&(d.queue="fx"),d.old=d.complete,d.complete=function(){n.isFunction(d.old)&&d.old.call(this),d.queue&&n.dequeue(this,d.queue)},d},n.fn.extend({fadeTo:function(a,b,c,d){return this.filter(V).css("opacity",0).show().end().animate({opacity:b},a,c,d)},animate:function(a,b,c,d){var e=n.isEmptyObject(a),f=n.speed(b,c,d),g=function(){var b=lc(this,n.extend({},a),f);(e||n._data(this,"finish"))&&b.stop(!0)};return g.finish=g,e||f.queue===!1?this.each(g):this.queue(f.queue,g)},stop:function(a,b,c){var d=function(a){var b=a.stop;delete a.stop,b(c)};return"string"!=typeof a&&(c=b,b=a,a=void 0),b&&a!==!1&&this.queue(a||"fx",[]),this.each(function(){var b=!0,e=null!=a&&a+"queueHooks",f=n.timers,g=n._data(this);if(e)g[e]&&g[e].stop&&d(g[e]);else for(e in g)g[e]&&g[e].stop&&dc.test(e)&&d(g[e]);for(e=f.length;e--;)f[e].elem!==this||null!=a&&f[e].queue!==a||(f[e].anim.stop(c),b=!1,f.splice(e,1));(b||!c)&&n.dequeue(this,a)})},finish:function(a){return a!==!1&&(a=a||"fx"),this.each(function(){var b,c=n._data(this),d=c[a+"queue"],e=c[a+"queueHooks"],f=n.timers,g=d?d.length:0;for(c.finish=!0,n.queue(this,a,[]),e&&e.stop&&e.stop.call(this,!0),b=f.length;b--;)f[b].elem===this&&f[b].queue===a&&(f[b].anim.stop(!0),f.splice(b,1));for(b=0;g>b;b++)d[b]&&d[b].finish&&d[b].finish.call(this);delete c.finish})}}),n.each(["toggle","show","hide"],function(a,b){var c=n.fn[b];n.fn[b]=function(a,d,e){return null==a||"boolean"==typeof a?c.apply(this,arguments):this.animate(hc(b,!0),a,d,e)}}),n.each({slideDown:hc("show"),slideUp:hc("hide"),slideToggle:hc("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(a,b){n.fn[a]=function(a,c,d){return this.animate(b,a,c,d)}}),n.timers=[],n.fx.tick=function(){var a,b=n.timers,c=0;for(_b=n.now();c<b.length;c++)a=b[c],a()||b[c]!==a||b.splice(c--,1);b.length||n.fx.stop(),_b=void 0},n.fx.timer=function(a){n.timers.push(a),a()?n.fx.start():n.timers.pop()},n.fx.interval=13,n.fx.start=function(){ac||(ac=setInterval(n.fx.tick,n.fx.interval))},n.fx.stop=function(){clearInterval(ac),ac=null},n.fx.speeds={slow:600,fast:200,_default:400},n.fn.delay=function(a,b){return a=n.fx?n.fx.speeds[a]||a:a,b=b||"fx",this.queue(b,function(b,c){var d=setTimeout(b,a);c.stop=function(){clearTimeout(d)}})},function(){var a,b,c,d,e=z.createElement("div");e.setAttribute("className","t"),e.innerHTML="  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>",a=e.getElementsByTagName("a")[0],c=z.createElement("select"),d=c.appendChild(z.createElement("option")),b=e.getElementsByTagName("input")[0],a.style.cssText="top:1px",l.getSetAttribute="t"!==e.className,l.style=/top/.test(a.getAttribute("style")),l.hrefNormalized="/a"===a.getAttribute("href"),l.checkOn=!!b.value,l.optSelected=d.selected,l.enctype=!!z.createElement("form").enctype,c.disabled=!0,l.optDisabled=!d.disabled,b=z.createElement("input"),b.setAttribute("value",""),l.input=""===b.getAttribute("value"),b.value="t",b.setAttribute("type","radio"),l.radioValue="t"===b.value,a=b=c=d=e=null}();var mc=/\r/g;n.fn.extend({val:function(a){var b,c,d,e=this[0];{if(arguments.length)return d=n.isFunction(a),this.each(function(c){var e;1===this.nodeType&&(e=d?a.call(this,c,n(this).val()):a,null==e?e="":"number"==typeof e?e+="":n.isArray(e)&&(e=n.map(e,function(a){return null==a?"":a+""})),b=n.valHooks[this.type]||n.valHooks[this.nodeName.toLowerCase()],b&&"set"in b&&void 0!==b.set(this,e,"value")||(this.value=e))});if(e)return b=n.valHooks[e.type]||n.valHooks[e.nodeName.toLowerCase()],b&&"get"in b&&void 0!==(c=b.get(e,"value"))?c:(c=e.value,"string"==typeof c?c.replace(mc,""):null==c?"":c)}}}),n.extend({valHooks:{option:{get:function(a){var b=n.find.attr(a,"value");return null!=b?b:n.text(a)}},select:{get:function(a){for(var b,c,d=a.options,e=a.selectedIndex,f="select-one"===a.type||0>e,g=f?null:[],h=f?e+1:d.length,i=0>e?h:f?e:0;h>i;i++)if(c=d[i],!(!c.selected&&i!==e||(l.optDisabled?c.disabled:null!==c.getAttribute("disabled"))||c.parentNode.disabled&&n.nodeName(c.parentNode,"optgroup"))){if(b=n(c).val(),f)return b;g.push(b)}return g},set:function(a,b){var c,d,e=a.options,f=n.makeArray(b),g=e.length;while(g--)if(d=e[g],n.inArray(n.valHooks.option.get(d),f)>=0)try{d.selected=c=!0}catch(h){d.scrollHeight}else d.selected=!1;return c||(a.selectedIndex=-1),e}}}}),n.each(["radio","checkbox"],function(){n.valHooks[this]={set:function(a,b){return n.isArray(b)?a.checked=n.inArray(n(a).val(),b)>=0:void 0}},l.checkOn||(n.valHooks[this].get=function(a){return null===a.getAttribute("value")?"on":a.value})});var nc,oc,pc=n.expr.attrHandle,qc=/^(?:checked|selected)$/i,rc=l.getSetAttribute,sc=l.input;n.fn.extend({attr:function(a,b){return W(this,n.attr,a,b,arguments.length>1)},removeAttr:function(a){return this.each(function(){n.removeAttr(this,a)})}}),n.extend({attr:function(a,b,c){var d,e,f=a.nodeType;if(a&&3!==f&&8!==f&&2!==f)return typeof a.getAttribute===L?n.prop(a,b,c):(1===f&&n.isXMLDoc(a)||(b=b.toLowerCase(),d=n.attrHooks[b]||(n.expr.match.bool.test(b)?oc:nc)),void 0===c?d&&"get"in d&&null!==(e=d.get(a,b))?e:(e=n.find.attr(a,b),null==e?void 0:e):null!==c?d&&"set"in d&&void 0!==(e=d.set(a,c,b))?e:(a.setAttribute(b,c+""),c):void n.removeAttr(a,b))},removeAttr:function(a,b){var c,d,e=0,f=b&&b.match(F);if(f&&1===a.nodeType)while(c=f[e++])d=n.propFix[c]||c,n.expr.match.bool.test(c)?sc&&rc||!qc.test(c)?a[d]=!1:a[n.camelCase("default-"+c)]=a[d]=!1:n.attr(a,c,""),a.removeAttribute(rc?c:d)},attrHooks:{type:{set:function(a,b){if(!l.radioValue&&"radio"===b&&n.nodeName(a,"input")){var c=a.value;return a.setAttribute("type",b),c&&(a.value=c),b}}}}}),oc={set:function(a,b,c){return b===!1?n.removeAttr(a,c):sc&&rc||!qc.test(c)?a.setAttribute(!rc&&n.propFix[c]||c,c):a[n.camelCase("default-"+c)]=a[c]=!0,c}},n.each(n.expr.match.bool.source.match(/\w+/g),function(a,b){var c=pc[b]||n.find.attr;pc[b]=sc&&rc||!qc.test(b)?function(a,b,d){var e,f;return d||(f=pc[b],pc[b]=e,e=null!=c(a,b,d)?b.toLowerCase():null,pc[b]=f),e}:function(a,b,c){return c?void 0:a[n.camelCase("default-"+b)]?b.toLowerCase():null}}),sc&&rc||(n.attrHooks.value={set:function(a,b,c){return n.nodeName(a,"input")?void(a.defaultValue=b):nc&&nc.set(a,b,c)}}),rc||(nc={set:function(a,b,c){var d=a.getAttributeNode(c);return d||a.setAttributeNode(d=a.ownerDocument.createAttribute(c)),d.value=b+="","value"===c||b===a.getAttribute(c)?b:void 0}},pc.id=pc.name=pc.coords=function(a,b,c){var d;return c?void 0:(d=a.getAttributeNode(b))&&""!==d.value?d.value:null},n.valHooks.button={get:function(a,b){var c=a.getAttributeNode(b);return c&&c.specified?c.value:void 0},set:nc.set},n.attrHooks.contenteditable={set:function(a,b,c){nc.set(a,""===b?!1:b,c)}},n.each(["width","height"],function(a,b){n.attrHooks[b]={set:function(a,c){return""===c?(a.setAttribute(b,"auto"),c):void 0}}})),l.style||(n.attrHooks.style={get:function(a){return a.style.cssText||void 0},set:function(a,b){return a.style.cssText=b+""}});var tc=/^(?:input|select|textarea|button|object)$/i,uc=/^(?:a|area)$/i;n.fn.extend({prop:function(a,b){return W(this,n.prop,a,b,arguments.length>1)},removeProp:function(a){return a=n.propFix[a]||a,this.each(function(){try{this[a]=void 0,delete this[a]}catch(b){}})}}),n.extend({propFix:{"for":"htmlFor","class":"className"},prop:function(a,b,c){var d,e,f,g=a.nodeType;if(a&&3!==g&&8!==g&&2!==g)return f=1!==g||!n.isXMLDoc(a),f&&(b=n.propFix[b]||b,e=n.propHooks[b]),void 0!==c?e&&"set"in e&&void 0!==(d=e.set(a,c,b))?d:a[b]=c:e&&"get"in e&&null!==(d=e.get(a,b))?d:a[b]},propHooks:{tabIndex:{get:function(a){var b=n.find.attr(a,"tabindex");return b?parseInt(b,10):tc.test(a.nodeName)||uc.test(a.nodeName)&&a.href?0:-1}}}}),l.hrefNormalized||n.each(["href","src"],function(a,b){n.propHooks[b]={get:function(a){return a.getAttribute(b,4)}}}),l.optSelected||(n.propHooks.selected={get:function(a){var b=a.parentNode;return b&&(b.selectedIndex,b.parentNode&&b.parentNode.selectedIndex),null}}),n.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){n.propFix[this.toLowerCase()]=this}),l.enctype||(n.propFix.enctype="encoding");var vc=/[\t\r\n\f]/g;n.fn.extend({addClass:function(a){var b,c,d,e,f,g,h=0,i=this.length,j="string"==typeof a&&a;if(n.isFunction(a))return this.each(function(b){n(this).addClass(a.call(this,b,this.className))});if(j)for(b=(a||"").match(F)||[];i>h;h++)if(c=this[h],d=1===c.nodeType&&(c.className?(" "+c.className+" ").replace(vc," "):" ")){f=0;while(e=b[f++])d.indexOf(" "+e+" ")<0&&(d+=e+" ");g=n.trim(d),c.className!==g&&(c.className=g)}return this},removeClass:function(a){var b,c,d,e,f,g,h=0,i=this.length,j=0===arguments.length||"string"==typeof a&&a;if(n.isFunction(a))return this.each(function(b){n(this).removeClass(a.call(this,b,this.className))});if(j)for(b=(a||"").match(F)||[];i>h;h++)if(c=this[h],d=1===c.nodeType&&(c.className?(" "+c.className+" ").replace(vc," "):"")){f=0;while(e=b[f++])while(d.indexOf(" "+e+" ")>=0)d=d.replace(" "+e+" "," ");g=a?n.trim(d):"",c.className!==g&&(c.className=g)}return this},toggleClass:function(a,b){var c=typeof a;return"boolean"==typeof b&&"string"===c?b?this.addClass(a):this.removeClass(a):this.each(n.isFunction(a)?function(c){n(this).toggleClass(a.call(this,c,this.className,b),b)}:function(){if("string"===c){var b,d=0,e=n(this),f=a.match(F)||[];while(b=f[d++])e.hasClass(b)?e.removeClass(b):e.addClass(b)}else(c===L||"boolean"===c)&&(this.className&&n._data(this,"__className__",this.className),this.className=this.className||a===!1?"":n._data(this,"__className__")||"")})},hasClass:function(a){for(var b=" "+a+" ",c=0,d=this.length;d>c;c++)if(1===this[c].nodeType&&(" "+this[c].className+" ").replace(vc," ").indexOf(b)>=0)return!0;return!1}}),n.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(a,b){n.fn[b]=function(a,c){return arguments.length>0?this.on(b,null,a,c):this.trigger(b)}}),n.fn.extend({hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)},bind:function(a,b,c){return this.on(a,null,b,c)},unbind:function(a,b){return this.off(a,null,b)},delegate:function(a,b,c,d){return this.on(b,a,c,d)},undelegate:function(a,b,c){return 1===arguments.length?this.off(a,"**"):this.off(b,a||"**",c)}});var wc=n.now(),xc=/\?/,yc=/(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g;n.parseJSON=function(b){if(a.JSON&&a.JSON.parse)return a.JSON.parse(b+"");var c,d=null,e=n.trim(b+"");return e&&!n.trim(e.replace(yc,function(a,b,e,f){return c&&b&&(d=0),0===d?a:(c=e||b,d+=!f-!e,"")}))?Function("return "+e)():n.error("Invalid JSON: "+b)},n.parseXML=function(b){var c,d;if(!b||"string"!=typeof b)return null;try{a.DOMParser?(d=new DOMParser,c=d.parseFromString(b,"text/xml")):(c=new ActiveXObject("Microsoft.XMLDOM"),c.async="false",c.loadXML(b))}catch(e){c=void 0}return c&&c.documentElement&&!c.getElementsByTagName("parsererror").length||n.error("Invalid XML: "+b),c};var zc,Ac,Bc=/#.*$/,Cc=/([?&])_=[^&]*/,Dc=/^(.*?):[ \t]*([^\r\n]*)\r?$/gm,Ec=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Fc=/^(?:GET|HEAD)$/,Gc=/^\/\//,Hc=/^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,Ic={},Jc={},Kc="*/".concat("*");try{Ac=location.href}catch(Lc){Ac=z.createElement("a"),Ac.href="",Ac=Ac.href}zc=Hc.exec(Ac.toLowerCase())||[];function Mc(a){return function(b,c){"string"!=typeof b&&(c=b,b="*");var d,e=0,f=b.toLowerCase().match(F)||[];if(n.isFunction(c))while(d=f[e++])"+"===d.charAt(0)?(d=d.slice(1)||"*",(a[d]=a[d]||[]).unshift(c)):(a[d]=a[d]||[]).push(c)}}function Nc(a,b,c,d){var e={},f=a===Jc;function g(h){var i;return e[h]=!0,n.each(a[h]||[],function(a,h){var j=h(b,c,d);return"string"!=typeof j||f||e[j]?f?!(i=j):void 0:(b.dataTypes.unshift(j),g(j),!1)}),i}return g(b.dataTypes[0])||!e["*"]&&g("*")}function Oc(a,b){var c,d,e=n.ajaxSettings.flatOptions||{};for(d in b)void 0!==b[d]&&((e[d]?a:c||(c={}))[d]=b[d]);return c&&n.extend(!0,a,c),a}function Pc(a,b,c){var d,e,f,g,h=a.contents,i=a.dataTypes;while("*"===i[0])i.shift(),void 0===e&&(e=a.mimeType||b.getResponseHeader("Content-Type"));if(e)for(g in h)if(h[g]&&h[g].test(e)){i.unshift(g);break}if(i[0]in c)f=i[0];else{for(g in c){if(!i[0]||a.converters[g+" "+i[0]]){f=g;break}d||(d=g)}f=f||d}return f?(f!==i[0]&&i.unshift(f),c[f]):void 0}function Qc(a,b,c,d){var e,f,g,h,i,j={},k=a.dataTypes.slice();if(k[1])for(g in a.converters)j[g.toLowerCase()]=a.converters[g];f=k.shift();while(f)if(a.responseFields[f]&&(c[a.responseFields[f]]=b),!i&&d&&a.dataFilter&&(b=a.dataFilter(b,a.dataType)),i=f,f=k.shift())if("*"===f)f=i;else if("*"!==i&&i!==f){if(g=j[i+" "+f]||j["* "+f],!g)for(e in j)if(h=e.split(" "),h[1]===f&&(g=j[i+" "+h[0]]||j["* "+h[0]])){g===!0?g=j[e]:j[e]!==!0&&(f=h[0],k.unshift(h[1]));break}if(g!==!0)if(g&&a["throws"])b=g(b);else try{b=g(b)}catch(l){return{state:"parsererror",error:g?l:"No conversion from "+i+" to "+f}}}return{state:"success",data:b}}n.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Ac,type:"GET",isLocal:Ec.test(zc[1]),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":Kc,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":n.parseJSON,"text xml":n.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(a,b){return b?Oc(Oc(a,n.ajaxSettings),b):Oc(n.ajaxSettings,a)},ajaxPrefilter:Mc(Ic),ajaxTransport:Mc(Jc),ajax:function(a,b){"object"==typeof a&&(b=a,a=void 0),b=b||{};var c,d,e,f,g,h,i,j,k=n.ajaxSetup({},b),l=k.context||k,m=k.context&&(l.nodeType||l.jquery)?n(l):n.event,o=n.Deferred(),p=n.Callbacks("once memory"),q=k.statusCode||{},r={},s={},t=0,u="canceled",v={readyState:0,getResponseHeader:function(a){var b;if(2===t){if(!j){j={};while(b=Dc.exec(f))j[b[1].toLowerCase()]=b[2]}b=j[a.toLowerCase()]}return null==b?null:b},getAllResponseHeaders:function(){return 2===t?f:null},setRequestHeader:function(a,b){var c=a.toLowerCase();return t||(a=s[c]=s[c]||a,r[a]=b),this},overrideMimeType:function(a){return t||(k.mimeType=a),this},statusCode:function(a){var b;if(a)if(2>t)for(b in a)q[b]=[q[b],a[b]];else v.always(a[v.status]);return this},abort:function(a){var b=a||u;return i&&i.abort(b),x(0,b),this}};if(o.promise(v).complete=p.add,v.success=v.done,v.error=v.fail,k.url=((a||k.url||Ac)+"").replace(Bc,"").replace(Gc,zc[1]+"//"),k.type=b.method||b.type||k.method||k.type,k.dataTypes=n.trim(k.dataType||"*").toLowerCase().match(F)||[""],null==k.crossDomain&&(c=Hc.exec(k.url.toLowerCase()),k.crossDomain=!(!c||c[1]===zc[1]&&c[2]===zc[2]&&(c[3]||("http:"===c[1]?"80":"443"))===(zc[3]||("http:"===zc[1]?"80":"443")))),k.data&&k.processData&&"string"!=typeof k.data&&(k.data=n.param(k.data,k.traditional)),Nc(Ic,k,b,v),2===t)return v;h=k.global,h&&0===n.active++&&n.event.trigger("ajaxStart"),k.type=k.type.toUpperCase(),k.hasContent=!Fc.test(k.type),e=k.url,k.hasContent||(k.data&&(e=k.url+=(xc.test(e)?"&":"?")+k.data,delete k.data),k.cache===!1&&(k.url=Cc.test(e)?e.replace(Cc,"$1_="+wc++):e+(xc.test(e)?"&":"?")+"_="+wc++)),k.ifModified&&(n.lastModified[e]&&v.setRequestHeader("If-Modified-Since",n.lastModified[e]),n.etag[e]&&v.setRequestHeader("If-None-Match",n.etag[e])),(k.data&&k.hasContent&&k.contentType!==!1||b.contentType)&&v.setRequestHeader("Content-Type",k.contentType),v.setRequestHeader("Accept",k.dataTypes[0]&&k.accepts[k.dataTypes[0]]?k.accepts[k.dataTypes[0]]+("*"!==k.dataTypes[0]?", "+Kc+"; q=0.01":""):k.accepts["*"]);for(d in k.headers)v.setRequestHeader(d,k.headers[d]);if(k.beforeSend&&(k.beforeSend.call(l,v,k)===!1||2===t))return v.abort();u="abort";for(d in{success:1,error:1,complete:1})v[d](k[d]);if(i=Nc(Jc,k,b,v)){v.readyState=1,h&&m.trigger("ajaxSend",[v,k]),k.async&&k.timeout>0&&(g=setTimeout(function(){v.abort("timeout")},k.timeout));try{t=1,i.send(r,x)}catch(w){if(!(2>t))throw w;x(-1,w)}}else x(-1,"No Transport");function x(a,b,c,d){var j,r,s,u,w,x=b;2!==t&&(t=2,g&&clearTimeout(g),i=void 0,f=d||"",v.readyState=a>0?4:0,j=a>=200&&300>a||304===a,c&&(u=Pc(k,v,c)),u=Qc(k,u,v,j),j?(k.ifModified&&(w=v.getResponseHeader("Last-Modified"),w&&(n.lastModified[e]=w),w=v.getResponseHeader("etag"),w&&(n.etag[e]=w)),204===a||"HEAD"===k.type?x="nocontent":304===a?x="notmodified":(x=u.state,r=u.data,s=u.error,j=!s)):(s=x,(a||!x)&&(x="error",0>a&&(a=0))),v.status=a,v.statusText=(b||x)+"",j?o.resolveWith(l,[r,x,v]):o.rejectWith(l,[v,x,s]),v.statusCode(q),q=void 0,h&&m.trigger(j?"ajaxSuccess":"ajaxError",[v,k,j?r:s]),p.fireWith(l,[v,x]),h&&(m.trigger("ajaxComplete",[v,k]),--n.active||n.event.trigger("ajaxStop")))}return v},getJSON:function(a,b,c){return n.get(a,b,c,"json")},getScript:function(a,b){return n.get(a,void 0,b,"script")}}),n.each(["get","post"],function(a,b){n[b]=function(a,c,d,e){return n.isFunction(c)&&(e=e||d,d=c,c=void 0),n.ajax({url:a,type:b,dataType:e,data:c,success:d})}}),n.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(a,b){n.fn[b]=function(a){return this.on(b,a)}}),n._evalUrl=function(a){return n.ajax({url:a,type:"GET",dataType:"script",async:!1,global:!1,"throws":!0})},n.fn.extend({wrapAll:function(a){if(n.isFunction(a))return this.each(function(b){n(this).wrapAll(a.call(this,b))});if(this[0]){var b=n(a,this[0].ownerDocument).eq(0).clone(!0);this[0].parentNode&&b.insertBefore(this[0]),b.map(function(){var a=this;while(a.firstChild&&1===a.firstChild.nodeType)a=a.firstChild;return a}).append(this)}return this},wrapInner:function(a){return this.each(n.isFunction(a)?function(b){n(this).wrapInner(a.call(this,b))}:function(){var b=n(this),c=b.contents();c.length?c.wrapAll(a):b.append(a)})},wrap:function(a){var b=n.isFunction(a);return this.each(function(c){n(this).wrapAll(b?a.call(this,c):a)})},unwrap:function(){return this.parent().each(function(){n.nodeName(this,"body")||n(this).replaceWith(this.childNodes)}).end()}}),n.expr.filters.hidden=function(a){return a.offsetWidth<=0&&a.offsetHeight<=0||!l.reliableHiddenOffsets()&&"none"===(a.style&&a.style.display||n.css(a,"display"))},n.expr.filters.visible=function(a){return!n.expr.filters.hidden(a)};var Rc=/%20/g,Sc=/\[\]$/,Tc=/\r?\n/g,Uc=/^(?:submit|button|image|reset|file)$/i,Vc=/^(?:input|select|textarea|keygen)/i;function Wc(a,b,c,d){var e;if(n.isArray(b))n.each(b,function(b,e){c||Sc.test(a)?d(a,e):Wc(a+"["+("object"==typeof e?b:"")+"]",e,c,d)});else if(c||"object"!==n.type(b))d(a,b);else for(e in b)Wc(a+"["+e+"]",b[e],c,d)}n.param=function(a,b){var c,d=[],e=function(a,b){b=n.isFunction(b)?b():null==b?"":b,d[d.length]=encodeURIComponent(a)+"="+encodeURIComponent(b)};if(void 0===b&&(b=n.ajaxSettings&&n.ajaxSettings.traditional),n.isArray(a)||a.jquery&&!n.isPlainObject(a))n.each(a,function(){e(this.name,this.value)});else for(c in a)Wc(c,a[c],b,e);return d.join("&").replace(Rc,"+")},n.fn.extend({serialize:function(){return n.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var a=n.prop(this,"elements");return a?n.makeArray(a):this}).filter(function(){var a=this.type;return this.name&&!n(this).is(":disabled")&&Vc.test(this.nodeName)&&!Uc.test(a)&&(this.checked||!X.test(a))}).map(function(a,b){var c=n(this).val();return null==c?null:n.isArray(c)?n.map(c,function(a){return{name:b.name,value:a.replace(Tc,"\r\n")}}):{name:b.name,value:c.replace(Tc,"\r\n")}}).get()}}),n.ajaxSettings.xhr=void 0!==a.ActiveXObject?function(){return!this.isLocal&&/^(get|post|head|put|delete|options)$/i.test(this.type)&&$c()||_c()}:$c;var Xc=0,Yc={},Zc=n.ajaxSettings.xhr();a.ActiveXObject&&n(a).on("unload",function(){for(var a in Yc)Yc[a](void 0,!0)}),l.cors=!!Zc&&"withCredentials"in Zc,Zc=l.ajax=!!Zc,Zc&&n.ajaxTransport(function(a){if(!a.crossDomain||l.cors){var b;return{send:function(c,d){var e,f=a.xhr(),g=++Xc;if(f.open(a.type,a.url,a.async,a.username,a.password),a.xhrFields)for(e in a.xhrFields)f[e]=a.xhrFields[e];a.mimeType&&f.overrideMimeType&&f.overrideMimeType(a.mimeType),a.crossDomain||c["X-Requested-With"]||(c["X-Requested-With"]="XMLHttpRequest");for(e in c)void 0!==c[e]&&f.setRequestHeader(e,c[e]+"");f.send(a.hasContent&&a.data||null),b=function(c,e){var h,i,j;if(b&&(e||4===f.readyState))if(delete Yc[g],b=void 0,f.onreadystatechange=n.noop,e)4!==f.readyState&&f.abort();else{j={},h=f.status,"string"==typeof f.responseText&&(j.text=f.responseText);try{i=f.statusText}catch(k){i=""}h||!a.isLocal||a.crossDomain?1223===h&&(h=204):h=j.text?200:404}j&&d(h,i,j,f.getAllResponseHeaders())},a.async?4===f.readyState?setTimeout(b):f.onreadystatechange=Yc[g]=b:b()},abort:function(){b&&b(void 0,!0)}}}});function $c(){try{return new a.XMLHttpRequest}catch(b){}}function _c(){try{return new a.ActiveXObject("Microsoft.XMLHTTP")}catch(b){}}n.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/(?:java|ecma)script/},converters:{"text script":function(a){return n.globalEval(a),a}}}),n.ajaxPrefilter("script",function(a){void 0===a.cache&&(a.cache=!1),a.crossDomain&&(a.type="GET",a.global=!1)}),n.ajaxTransport("script",function(a){if(a.crossDomain){var b,c=z.head||n("head")[0]||z.documentElement;return{send:function(d,e){b=z.createElement("script"),b.async=!0,a.scriptCharset&&(b.charset=a.scriptCharset),b.src=a.url,b.onload=b.onreadystatechange=function(a,c){(c||!b.readyState||/loaded|complete/.test(b.readyState))&&(b.onload=b.onreadystatechange=null,b.parentNode&&b.parentNode.removeChild(b),b=null,c||e(200,"success"))},c.insertBefore(b,c.firstChild)},abort:function(){b&&b.onload(void 0,!0)}}}});var ad=[],bd=/(=)\?(?=&|$)|\?\?/;n.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var a=ad.pop()||n.expando+"_"+wc++;return this[a]=!0,a}}),n.ajaxPrefilter("json jsonp",function(b,c,d){var e,f,g,h=b.jsonp!==!1&&(bd.test(b.url)?"url":"string"==typeof b.data&&!(b.contentType||"").indexOf("application/x-www-form-urlencoded")&&bd.test(b.data)&&"data");return h||"jsonp"===b.dataTypes[0]?(e=b.jsonpCallback=n.isFunction(b.jsonpCallback)?b.jsonpCallback():b.jsonpCallback,h?b[h]=b[h].replace(bd,"$1"+e):b.jsonp!==!1&&(b.url+=(xc.test(b.url)?"&":"?")+b.jsonp+"="+e),b.converters["script json"]=function(){return g||n.error(e+" was not called"),g[0]},b.dataTypes[0]="json",f=a[e],a[e]=function(){g=arguments},d.always(function(){a[e]=f,b[e]&&(b.jsonpCallback=c.jsonpCallback,ad.push(e)),g&&n.isFunction(f)&&f(g[0]),g=f=void 0}),"script"):void 0}),n.parseHTML=function(a,b,c){if(!a||"string"!=typeof a)return null;"boolean"==typeof b&&(c=b,b=!1),b=b||z;var d=v.exec(a),e=!c&&[];return d?[b.createElement(d[1])]:(d=n.buildFragment([a],b,e),e&&e.length&&n(e).remove(),n.merge([],d.childNodes))};var cd=n.fn.load;n.fn.load=function(a,b,c){if("string"!=typeof a&&cd)return cd.apply(this,arguments);var d,e,f,g=this,h=a.indexOf(" ");return h>=0&&(d=a.slice(h,a.length),a=a.slice(0,h)),n.isFunction(b)?(c=b,b=void 0):b&&"object"==typeof b&&(f="POST"),g.length>0&&n.ajax({url:a,type:f,dataType:"html",data:b}).done(function(a){e=arguments,g.html(d?n("<div>").append(n.parseHTML(a)).find(d):a)}).complete(c&&function(a,b){g.each(c,e||[a.responseText,b,a])}),this},n.expr.filters.animated=function(a){return n.grep(n.timers,function(b){return a===b.elem}).length};var dd=a.document.documentElement;function ed(a){return n.isWindow(a)?a:9===a.nodeType?a.defaultView||a.parentWindow:!1}n.offset={setOffset:function(a,b,c){var d,e,f,g,h,i,j,k=n.css(a,"position"),l=n(a),m={};"static"===k&&(a.style.position="relative"),h=l.offset(),f=n.css(a,"top"),i=n.css(a,"left"),j=("absolute"===k||"fixed"===k)&&n.inArray("auto",[f,i])>-1,j?(d=l.position(),g=d.top,e=d.left):(g=parseFloat(f)||0,e=parseFloat(i)||0),n.isFunction(b)&&(b=b.call(a,c,h)),null!=b.top&&(m.top=b.top-h.top+g),null!=b.left&&(m.left=b.left-h.left+e),"using"in b?b.using.call(a,m):l.css(m)}},n.fn.extend({offset:function(a){if(arguments.length)return void 0===a?this:this.each(function(b){n.offset.setOffset(this,a,b)});var b,c,d={top:0,left:0},e=this[0],f=e&&e.ownerDocument;if(f)return b=f.documentElement,n.contains(b,e)?(typeof e.getBoundingClientRect!==L&&(d=e.getBoundingClientRect()),c=ed(f),{top:d.top+(c.pageYOffset||b.scrollTop)-(b.clientTop||0),left:d.left+(c.pageXOffset||b.scrollLeft)-(b.clientLeft||0)}):d},position:function(){if(this[0]){var a,b,c={top:0,left:0},d=this[0];return"fixed"===n.css(d,"position")?b=d.getBoundingClientRect():(a=this.offsetParent(),b=this.offset(),n.nodeName(a[0],"html")||(c=a.offset()),c.top+=n.css(a[0],"borderTopWidth",!0),c.left+=n.css(a[0],"borderLeftWidth",!0)),{top:b.top-c.top-n.css(d,"marginTop",!0),left:b.left-c.left-n.css(d,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var a=this.offsetParent||dd;while(a&&!n.nodeName(a,"html")&&"static"===n.css(a,"position"))a=a.offsetParent;return a||dd})}}),n.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(a,b){var c=/Y/.test(b);n.fn[a]=function(d){return W(this,function(a,d,e){var f=ed(a);return void 0===e?f?b in f?f[b]:f.document.documentElement[d]:a[d]:void(f?f.scrollTo(c?n(f).scrollLeft():e,c?e:n(f).scrollTop()):a[d]=e)},a,d,arguments.length,null)}}),n.each(["top","left"],function(a,b){n.cssHooks[b]=Mb(l.pixelPosition,function(a,c){return c?(c=Kb(a,b),Ib.test(c)?n(a).position()[b]+"px":c):void 0})}),n.each({Height:"height",Width:"width"},function(a,b){n.each({padding:"inner"+a,content:b,"":"outer"+a},function(c,d){n.fn[d]=function(d,e){var f=arguments.length&&(c||"boolean"!=typeof d),g=c||(d===!0||e===!0?"margin":"border");return W(this,function(b,c,d){var e;return n.isWindow(b)?b.document.documentElement["client"+a]:9===b.nodeType?(e=b.documentElement,Math.max(b.body["scroll"+a],e["scroll"+a],b.body["offset"+a],e["offset"+a],e["client"+a])):void 0===d?n.css(b,c,g):n.style(b,c,d,g)},b,f?d:void 0,f,null)}})}),n.fn.size=function(){return this.length},n.fn.andSelf=n.fn.addBack,"function"==typeof define&&define.amd&&define("jquery",[],function(){return n});var fd=a.jQuery,gd=a.$;return n.noConflict=function(b){return a.$===n&&(a.$=gd),b&&a.jQuery===n&&(a.jQuery=fd),n},typeof b===L&&(a.jQuery=a.$=n),n});
diff --git a/docs/js/page_effects.js b/docs/js/page_effects.js
new file mode 100644
index 0000000..7ba93bf
--- /dev/null
+++ b/docs/js/page_effects.js
@@ -0,0 +1,113 @@
+function visibleInParent(element) {
+    var position = $(element).position().top
+    return position > -50 && position < ($(element).offsetParent().height() - 50)
+}
+
+function hasFragment(link, fragment) {
+    return $(link).attr("href").indexOf("#" + fragment) != -1
+}
+
+function findLinkByFragment(elements, fragment) {
+    return $(elements).filter(function(i, e) { return hasFragment(e, fragment)}).first()
+}
+
+function scrollToCurrentVarLink(elements) {
+    var elements = $(elements);
+    var parent   = elements.offsetParent();
+
+    if (elements.length == 0) return;
+
+    var top    = elements.first().position().top;
+    var bottom = elements.last().position().top + elements.last().height();
+
+    if (top >= 0 && bottom <= parent.height()) return;
+
+    if (top < 0) {
+        parent.scrollTop(parent.scrollTop() + top);
+    }
+    else if (bottom > parent.height()) {
+        parent.scrollTop(parent.scrollTop() + bottom - parent.height());
+    }
+}
+
+function setCurrentVarLink() {
+    $('.secondary a').parent().removeClass('current')
+    $('.anchor').
+        filter(function(index) { return visibleInParent(this) }).
+        each(function(index, element) {
+            findLinkByFragment(".secondary a", element.id).
+                parent().
+                addClass('current')
+        });
+    scrollToCurrentVarLink('.secondary .current');
+}
+
+var hasStorage = (function() { try { return localStorage.getItem } catch(e) {} }())
+
+function scrollPositionId(element) {
+    var directory = window.location.href.replace(/[^\/]+\.html$/, '')
+    return 'scroll::' + $(element).attr('id') + '::' + directory
+}
+
+function storeScrollPosition(element) {
+    if (!hasStorage) return;
+    localStorage.setItem(scrollPositionId(element) + "::x", $(element).scrollLeft())
+    localStorage.setItem(scrollPositionId(element) + "::y", $(element).scrollTop())
+}
+
+function recallScrollPosition(element) {
+    if (!hasStorage) return;
+    $(element).scrollLeft(localStorage.getItem(scrollPositionId(element) + "::x"))
+    $(element).scrollTop(localStorage.getItem(scrollPositionId(element) + "::y"))
+}
+
+function persistScrollPosition(element) {
+    recallScrollPosition(element)
+    $(element).scroll(function() { storeScrollPosition(element) })
+}
+
+function sidebarContentWidth(element) {
+    var widths = $(element).find('.inner').map(function() { return $(this).innerWidth() })
+    return Math.max.apply(Math, widths)
+}
+
+function calculateSize(width, snap, margin, minimum) {
+    if (width == 0) {
+        return 0
+    }
+    else {
+        return Math.max(minimum, (Math.ceil(width / snap) * snap) + (margin * 2))
+    }
+}
+
+function resizeSidebars() {
+    var primaryWidth   = sidebarContentWidth('.primary')
+    var secondaryWidth = 0
+
+    if ($('.secondary').length != 0) {
+        secondaryWidth = sidebarContentWidth('.secondary')
+    }
+
+    // snap to grid
+    primaryWidth   = calculateSize(primaryWidth, 32, 13, 160)
+    secondaryWidth = calculateSize(secondaryWidth, 32, 13, 160)
+
+    $('.primary').css('width', primaryWidth)
+    $('.secondary').css('width', secondaryWidth).css('left', primaryWidth + 1)
+
+    if (secondaryWidth > 0) {
+        $('#content').css('left', primaryWidth + secondaryWidth + 2)
+    }
+    else {
+        $('#content').css('left', primaryWidth + 1)
+    }
+}
+
+$(window).ready(resizeSidebars)
+$(window).ready(setCurrentVarLink)
+$(window).ready(function() { persistScrollPosition('.primary')})
+$(window).ready(function() {
+    $('#content').scroll(setCurrentVarLink)
+    $(window).resize(setCurrentVarLink)
+    $(window).resize(resizeSidebars)
+})
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
new file mode 100644
index 0000000..5f29f49
--- /dev/null
+++ b/docs/libpython-clj.python.html
@@ -0,0 +1,26 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 current"><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L394">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L400">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L376">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L385">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L133">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L154">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L140">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L147">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L350">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L214">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L608">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L553">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L105">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1126">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L118">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L727">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
+<p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L363">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L583">view source</a></div></div><div class="public anchor" id="var-create-bridge-from-att-map"><h3>create-bridge-from-att-map</h3><div class="usage"><code>(create-bridge-from-att-map src-item att-map)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/interop.clj#L377">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap will be presented as instance methods. Things in the cls hashmap had better be either atoms or already converted python objects. You may get surprised otherwise; you have been warned. See the classes-test file in test/libpython-clj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L573">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir item)</code></div><div class="doc"><div class="markdown"><p>Get sorted list of all attribute names.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-equals.3F"><h3>equals?</h3><div class="usage"><code>(equals? lhs rhs)</code></div><div class="doc"><div class="markdown"><p>Returns true of the python equals operator returns 1.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1127">view source</a></div></div><div class="public anchor" id="var-finalize.21"><h3>finalize!</h3><div class="usage"><code>(finalize!)</code></div><div class="doc"><div class="markdown"><p>Finalize the interpreter. You probably shouldn’t call this as it destroys the global interpreter and reinitialization is unsupported cpython.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L262">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L419">view source</a></div></div><div class="public anchor" id="var-gc.21"><h3>gc!</h3><div class="usage"><code>(gc!)</code></div><div class="doc"><div class="markdown"><p>Run the system garbage collection facility and then call the cooperative ‘cleanup python objects’ queue</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L340">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr item item-name)</code></div><div class="doc"><div class="markdown"><p>Get attribute from object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item item item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item of a given name from an object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? item item-name)</code></div><div class="doc"><div class="markdown"><p>Return true of object has attribute</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? item item-name)</code></div><div class="doc"><div class="markdown"><p>Return true of object has item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-hash-code"><h3>hash-code</h3><div class="usage"><code>(hash-code py-inst)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1121">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L410">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L207">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [program-name library-path python-home no-io-redirect? python-executable windows-anaconda-activate-bat]})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is provided, then the python :library-path Library path of the python library to use. :program-name - optional but will show up in error messages from python. :no-io-redirect - there if you don’t want python stdout and stderr redirection  to <em>out</em> and <em>err</em>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-type)</code></div><div class="doc"><div class="markdown"><p>Returns true if inst is an instance of type. False otherwise.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1111">view source</a></div></div><div class="public anchor" id="var-len"><h3>len</h3><div class="usage"><code>(len item)</code></div><div class="doc"><div class="markdown"><p>Call the <strong>len</strong> attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-libpython-clj-module-name"><h3>libpython-clj-module-name</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Module name of the libpython-clj python model. Used to find binding-level objects such as the type used for actual jvm bridging objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/interop.clj#L69">view source</a></div></div><div class="public anchor" id="var-make-tuple-fn"><h3>make-tuple-fn</h3><div class="usage"><code>(make-tuple-fn fn-obj &amp; {:keys [arg-converter result-converter], :or {arg-converter -&gt;jvm, result-converter -&gt;python-incref}, :as options})</code></div><div class="doc"><div class="markdown"><p>Given a clojure function, create a python tuple function. arg-convert is applied to arguments before the clojure function gets them and result-converter is applied to the outbound result. Exceptions are caught, logged, and propagated to python.</p>
+<p>arg-converter: A function to be called on arguments before they get to  clojure. Defaults to -&gt;jvm. result-converter: A function to be called on the return value before it  makes it back to python. Defaults to -&gt;python-incref. method-name: Name of function exposed to python. documentation: Documentation of function exposed to python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L484">view source</a></div></div><div class="public anchor" id="var-make-tuple-instance-fn"><h3>make-tuple-instance-fn</h3><div class="usage"><code>(make-tuple-instance-fn clj-fn &amp; {:keys [arg-converter], :as options})</code></div><div class="doc"><div class="markdown"><p>Make an instance function. In this case the default behavior is to pass raw python object ptr args to the clojure function without marshalling as that can add confusion and unnecessary overhead. Self will be the first argument. Callers can change this behavior by setting the ‘arg-converter’ option as in ‘make-tuple-fn’. Options are the same as make-tuple-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L553">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict module)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary. Returns bridge.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L221">view source</a></div></div><div class="public anchor" id="var-ptr-refcnt"><h3>ptr-refcnt</h3><div class="usage"><code>(ptr-refcnt item)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L255">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+<p>Usage:</p>
+<p>(py* obj method args kwargs)</p>
+<p>Example:</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L446">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L467">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L440">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L433">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
+<p>is equivalent to Python’s</p>
+<p>import sys sys.path.append(‘/home/user/bin’)</p>
+<p>SPECIAL SYNTAX for programmatic *args and **kwargs</p>
+<p>Special syntax is provided to meet the needs required by Python’s *args and **kwargs syntax programmatically.</p>
+<p>(= (py.. obj (*method args))  (py* obj methods args))</p>
+<p>(= (py.. obj (*methods args kwargs))  (py* obj method args kwargs))</p>
+<p>(= (py.. obj (**method kwargs))  (py** obj kwargs))</p>
+<p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L502">view source</a></div></div><div class="public anchor" id="var-python-pyerr-fetch-error-handler"><h3>python-pyerr-fetch-error-handler</h3><div class="usage"><code>(python-pyerr-fetch-error-handler)</code></div><div class="doc"><div class="markdown"><p>Utility code used in with macro</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L269">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type item)</code></div><div class="doc"><div class="markdown"><p>Return a keyword that describes the python datatype of this object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L26">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
+<p>Globals, locals may be provided but are not necessary.</p>
+<p>Implemented in cpython as:</p>
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L163">view source</a></div></div><div class="public anchor" id="var-run-string"><h3>run-string</h3><div class="usage"><code>(run-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L196">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! item item-name item-value)</code></div><div class="doc"><div class="markdown"><p>Set attribute on object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! item att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L97">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! item item-name item-value)</code></div><div class="doc"><div class="markdown"><p>Set an item of to a value</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! item item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L107">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L61">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L316">view source</a></div></div><div class="public anchor" id="var-with-exit-error-handler"><h3>with-exit-error-handler</h3><div class="usage"><code>(with-exit-error-handler with-var error)</code></div><div class="doc"><div class="markdown"><p>Utility code used in with macro</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L289">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L74">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L83">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
new file mode 100644
index 0000000..e04e687
--- /dev/null
+++ b/docs/new-to-clojure.html
@@ -0,0 +1,49 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
+<p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
+<p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
+<p>My perspective is closer to <a href="http://blog.cleancoder.com/uncle-bob/2019/08/22/WhyClojure.html">Uncle Bob’s</a>. </p>
+<p>To address the parenthesis, we need to talk about <a href="https://en.wikipedia.org/wiki/Homoiconicity">homoiconicity</a>. LISPs are part of a subset of languages that build themselves out of their own data structures so that when you type symbols into a file or repl, you get back a data structure of the language itself. This means that several parts of the programmers toolbox can be simpler and you can load a file as data, transform it, and then execute some portion of it all without leaving the language. This isn’t something you will really need to understand today, but the point is that the look and structure of the language is a sweet spot to make it more of middle ground between what a human and a machine can understand.</p>
+<p>The fallout from having a language that is both a language and a data structure is that you can extend the language without needing to change the compiler. For example, the very first standardized ‘object oriented programming’ system was <a href="https://en.wikipedia.org/wiki/Common_Lisp_Object_System">CLOS</a>, or Common Lisp Object System. This was implemented on top of Common Lisp with no updates to the compiler whatsoever. In Clojure, we have been able to add things like an <a href="https://github.com/clojure/core.async">async library</a> or <a href="https://clojure.org/reference/refs">software transactional memory</a> without changing the compiler itself because we can extend or change the language quite substantially at compile time.</p>
+<p>Clojure is a deeply functional language with pragmatic pathways built for mutation. All of the basic data structures of Clojure are immutable. Learning to program in a functional manner will mean learning things like <code>map</code> and <code>reduce</code> and basically re-wiring how you think about problems. I believe it is this re-wiring that is most beneficial in the long term regardless of whether you become some functional programming God or just dabble for a while.</p>
+<p>Many systems, regardless of language, are designed in a functional manner because properties like <a href="https://en.wikipedia.org/wiki/Idempotence">idempotency</a> and <a href="https://en.wikipedia.org/wiki/Referential_transparency">referential transparency</a> make it easier to reason about code that you didn’t write. That being said, Clojure doesn’t force you to write functional code all the time as it is mainly a pragmatic language. You can easily write mutable code if you like.</p>
+<p>For the web, Clojure has a <a href="https://clojurescript.org/">version</a> that compiles to JavaScript so that you can write one language both server and front end side. Many Clojure projects are just one repository and one artifact that when run produces both the server and client side of the equation. Another important usage of the Clojurescript is mobile application development using frameworks like <a href="https://www.upwork.com/blog/2018/11/developing-react-native-applications-in-clojurescript/">React Native</a>. Clojurescript is truly one of Clojure’s greatest strengths and one that the Clojure community has strongly embraced.</p>
+<p>No talk about Clojure would be complete without giving major credit to its excellent REPL support. One important aspect of the Clojure REPL is that you can see all of complex nested datastructures easily without needing to write <code>toString</code> or <code>__str__</code> methods. Because of this visibility advantage a common way to use Clojure is to model your problem as a transformation from datastructure to datastructure, testing each stage of this transformation in the repl and just letting the REPL printing show you the next move. Programming with data is often just easier than programming with objects and debugging data transformations is far, far easier than debugging a complex object graph.</p>
+<h2><a href="#learning-clojure" name="learning-clojure"></a>Learning Clojure</h2>
+<p>There are in fact many resources to learn Clojure and here are some the community recommends:</p>
+<h3><a href="#books-courses" name="books-courses"></a>Books/Courses</h3>
+<ol>
+  <li><a href="https://www.braveclojure.com/clojure-for-the-brave-and-true/">Clojure for the Brave and True</a></li>
+  <li><a href="https://practicalli.github.io/clojure/">Practicalli</a></li>
+  <li><a href="https://www.amazon.it/dp/B00YSILGWG/ref=dp-kindle-redirect?_encoding=UTF8&amp;btkr=1">Clojure for Data Science</a></li>
+  <li><a href="https://www.amazon.it/dp/B00HUEG8KK/ref=dp-kindle-redirect?_encoding=UTF8&amp;btkr=1">Functional Programming in Scala and Clojure</a></li>
+</ol>
+<p>Practicalli has a page devoted purely to resources on learning Clojure at whatever level you are so if these recommendations do not speak to you please review their <a href="https://practicalli.github.io/clojure/reference/books.html">books page</a>.</p>
+<h3><a href="#learn-by-writing-code" name="learn-by-writing-code"></a>Learn by Writing Code</h3>
+<ol>
+  <li><a href="https://github.com/functional-koans/clojure-koans">Clojure Koans</a></li>
+  <li><a href="https://github.com/lspector/clojinc">clojinc</a></li>
+  <li><a href="http://clojurescriptkoans.com/">Clojurescript Koans</a></li>
+  <li><a href="http://www.4clojure.com/">4Clojure</a></li>
+</ol>
+<h3><a href="#ides-editors" name="ides-editors"></a>IDEs/Editors</h3>
+<p>There are many more IDEs available than listed here; these ones are just very popular:</p>
+<ol>
+  <li><a href="https://marketplace.visualstudio.com/items?itemName=betterthantomorrow.calva">Calva</a></li>
+  <li><a href="https://cursive-ide.com/">Cursive</a></li>
+  <li><a href="https://medium.com/@jacekschae/slick-clojure-editor-setup-with-atom-a3c1b528b722">Atom</a></li>
+  <li><a href="https://cider.mx/">emacs + cider</a></li>
+  <li><a href="https://www.vim.org/scripts/script.php?script_id=4978">vim + fireplace</a></li>
+</ol>
+<p>One thing to be sure of, regardless of IDE, is to use some form of <a href="https://shaunlebron.github.io/parinfer/">structural editing</a>. All the better IDEs have it; all the IDEs listed here have it, and I personally really struggle without it. When I have a form of <a href="https://wikemacs.org/wiki/Paredit-mode">structure editing</a>, however, I can move code around much faster than I can in Java, Python, or C++. This is another benefit of the homoiconicity that we spoke earlier in that we can transform the program easily because it is just a data structure and this includes editor level transformations and analysis.</p>
+<h2><a href="#off-we-go-" name="off-we-go-"></a>Off We Go!</h2>
+<p>Clojure is an amazing language. It is really rewarding on a personal level because it is tailored towards extremely high individual and small group productivity. But this power comes with some caveats and one of those is that learning Clojure takes time and patience. The community is here to support you, however, so check us out:</p>
+<ul>
+  <li><a href="https://clojurians.slack.com">Clojurians Slack</a></li>
+  <li><a href="https://clojurians.zulipchat.com/">Clojurians Zulip</a></li>
+  <li><a href="https://www.reddit.com/r/Clojure/">r/Clojure reddit</a></li>
+  <li><a href="https://www.reddit.com/r/Clojurescript/">r/Clojurescript reddit</a></li>
+  <li><a href="https://clojureverse.org/">Clojureverse</a></li>
+</ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
new file mode 100644
index 0000000..9f8db2f
--- /dev/null
+++ b/docs/scopes-and-gc.html
@@ -0,0 +1,42 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
+<p>Using the stack-based scoping looks like:</p>
+<pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
+nil
+user&gt; (py/initialize!)
+... (logging elided)
+:ok
+user&gt; (py/stack-resource-context
+       (-&gt; (py/-&gt;py-dict {:a 1 :b 2})
+           ;;Note - Without this call you guarantee a crash.
+           (py/-&gt;jvm)))
+{"a" 1, "b" 2}
+</code></pre>
+<p>You must either call -&gt;jvm or return a keyword at the end of your scope.</p>
+<p>In the case where you are processing a batch of items (which we recommend for perf reasons), you can also grab the GIL at the top of your thing:</p>
+<pre><code class="clojure">user&gt; (def dict-seq (py/as-jvm (py/-&gt;py-list (repeat 1000 (py/-&gt;py-dict {:a 1 :b 2})))))
+#'user/dict-seq
+
+
+user&gt; (def ignored (time (mapv py/-&gt;jvm dict-seq)))
+"Elapsed time: 2200.556506 msecs"
+#'user/ignored
+user&gt; (def ignored (time (py/with-gil (mapv py/-&gt;jvm dict-seq))))
+"Elapsed time: 2095.815518 msecs"
+#'user/ignored
+</code></pre>
+<p>The hidden thing above, regardless of if you grab the gil or not is that you are actually holding onto a lot of python objects that could be released. Hence if you aren’t disciplined about calling System/gc or if the jvm gc just decides not to run you could be allocating a lot of native-heap objects. Plus what you don’t see is that if you call System/gc the resource thread dedicated to releasing things will have a lot of work to do.</p>
+<p>For production use cases where you need a bit more assurance that things get released, please consider both grabbing the gil <em>and</em> opening a resource context:</p>
+<pre><code class="clojure">user&gt; (def ignored (time (py/with-gil-stack-rc-context
+                           (-&gt;&gt; (repeatedly 1000 #(py/-&gt;py-dict {:a 1 :b 2}))
+                                (py/-&gt;py-list)
+                                (py/as-jvm)
+                                (mapv py/-&gt;jvm)))))
+
+"Elapsed time: 3246.847595 msecs"
+#'user/ignored
+</code></pre>
+<p>This took a second longer! But, you <em>know</em> that all python objects allocated within that scope are released. Before, you would be in essence hoping that things would be released soon enough.</p>
+<p>Again, for production contexts we recommend batch processing objects <em>and</em> using the <code>with-gil-stack-rc-context</code> function call that correctly grabs the gil, opens a resource context and then releases anything allocated within that context.</p></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/slicing.html b/docs/slicing.html
new file mode 100644
index 0000000..fd98dac
--- /dev/null
+++ b/docs/slicing.html
@@ -0,0 +1,58 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
+<p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
+<pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
+nil
+user&gt; (require '[libpython-clj.require :refer [require-python]])
+... lotta logs ...
+user&gt; (require-python '[builtins])
+WARNING: AssertionError already refers to: class java.lang.AssertionError in namespace: builtins, being replaced by: #'builtins/AssertionError
+WARNING: Exception already refers to: class java.lang.Exception in namespace: builtins, being replaced by: #'builtins/Exception
+:ok
+user&gt; (doc builtins/slice)
+-------------------------
+builtins/slice
+[[self &amp; [args {:as kwargs}]]]
+  slice(stop)
+slice(start, stop[, step])
+
+Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).
+nil
+user&gt; (require-python '[numpy :as np])
+:ok
+
+user&gt; (require-python '[numpy :as np])
+:ok
+user&gt; (def ary (-&gt; (np/arange 9)
+                   (np/reshape [3 3])))
+#'user/ary
+user&gt; ary
+[[0 1 2]
+ [3 4 5]
+ [6 7 8]]
+
+user&gt; (py/get-item ary [(builtins/slice 1 nil) (builtins/slice 1 nil)])
+[[4 5]
+ [7 8]]
+user&gt; (py/get-item ary [(builtins/slice -1) (builtins/slice 1 nil)])
+[[1 2]
+ [4 5]]
+user&gt; (py/get-item ary [(builtins/slice nil) (builtins/slice 1 nil)])
+[[1 2]
+ [4 5]
+ [7 8]]
+user&gt; (py/get-item ary [(builtins/slice nil) (builtins/slice 1 2)])
+[[1]
+ [4]
+ [7]]
+user&gt; (py/get-item ary [(builtins/slice nil) (builtins/slice 1 3)])
+[[1 2]
+ [4 5]
+ [7 8]]
+user&gt; (py/get-item ary [(builtins/slice nil) (builtins/slice 1 4)])
+[[1 2]
+ [4 5]
+ [7 8]]
+</code></pre></div></div></div></body></html>
\ No newline at end of file
diff --git a/project.clj b/project.clj
index 857e6b9..465969e 100644
--- a/project.clj
+++ b/project.clj
@@ -1,10 +1,26 @@
-(defproject clj-python/libpython-clj "1.47-SNAPSHOT"
-  :description "libpython bindings to the techascent ecosystem"
+(defproject clj-python/libpython-clj "2.00-SNAPSHOT"
+  :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
-  :profiles {:dev {:dependencies [[criterium "0.4.5"]]}}
+  :dependencies [[org.clojure/clojure    "1.10.2-alpha2"]
+                 [camel-snake-kebab      "0.4.0"]
+                 [cnuernber/dtype-next   "6.00-alpha-9"]
+                 [techascent/tech.jna    "3.24"]
+                 [org.clojure/data.json  "1.0.0"]]
+  :profiles {:dev {:dependencies [[criterium "0.4.5"]]}
+             :codox
+             {:dependencies [[codox-theme-rdash "0.1.2"]]
+              :plugins [[lein-codox "0.10.7"]]
+              :codox {:project {:name "tech.ml.dataset"}
+                      :metadata {:doc/format :markdown}
+                      :themes [:rdash]
+                      :source-paths ["src"]
+                      :output-path "docs"
+                      :doc-paths ["topics"]
+                      :source-uri "https://github.com/clj-python/libpython-clj/blob/master/{filepath}#L{line}"
+                      :namespaces [libpython-clj.python]}}}
   :java-source-paths ["java"]
-  :plugins [[lein-tools-deps "0.4.5"]]
-  :middleware [lein-tools-deps.plugin/resolve-dependencies-with-deps-edn]
-  :lein-tools-deps/config {:config-files [:install :user :project]})
+  :aliases {"codox" ["with-profile" "codox,dev" "codox"]}
+
+  )
diff --git a/src/libpython_clj/jna.clj b/src/libpython_clj/jna.clj
index b3eee91..241ce7b 100644
--- a/src/libpython_clj/jna.clj
+++ b/src/libpython_clj/jna.clj
@@ -1,12 +1,6 @@
 (ns libpython-clj.jna
-  (:require [tech.v2.datatype :as dtype]
-            [tech.jna :as jna]
-            [tech.jna.base :as jna-base]
-            [tech.v2.datatype.typecast :as typecast]
-            [camel-snake-kebab.core :refer [->kebab-case]]
-            [tech.parallel.utils :refer [export-symbols]]
+  (:require [tech.v3.datatype.export-symbols :refer [export-symbols]]
             [libpython-clj.jna.base :as libpy-base]
-            [libpython-clj.jna.base]
             [libpython-clj.jna.interpreter :as jnainterp]
             [libpython-clj.jna.protocols.object]
             [libpython-clj.jna.protocols.iterator]
diff --git a/src/libpython_clj/jna/concrete/bytes.clj b/src/libpython_clj/jna/concrete/bytes.clj
index 2c510ef..7d982a8 100644
--- a/src/libpython_clj/jna/concrete/bytes.clj
+++ b/src/libpython_clj/jna/concrete/bytes.clj
@@ -8,7 +8,7 @@
                      size-t-type
                      *python-library*]
              :as libpy-base]
-            [tech.v2.datatype :as dtype]
+            [tech.v3.datatype :as dtype]
             [tech.jna :as jna])
   (:import [com.sun.jna Pointer]))
 
@@ -45,7 +45,7 @@
    success, and NULL on failure. If v is NULL, the contents of the bytes object are
    uninitialized."
   Pointer
-  [v dtype/as-nio-buffer]
+  [v dtype/->nio-buffer]
   [len jna/size-t])
 
 
diff --git a/src/libpython_clj/jna/concrete/unicode.clj b/src/libpython_clj/jna/concrete/unicode.clj
index 7a22d1f..683b84c 100644
--- a/src/libpython_clj/jna/concrete/unicode.clj
+++ b/src/libpython_clj/jna/concrete/unicode.clj
@@ -8,7 +8,7 @@
                      *python-library*]
              :as libpy-base]
             [tech.jna :as jna]
-            [tech.v2.datatype :as dtype])
+            [tech.v3.datatype :as dtype])
   (:import [com.sun.jna Pointer]
            [com.sun.jna.ptr PointerByReference
             LongByReference IntByReference]
@@ -27,7 +27,7 @@
   Signature:
   PyObject* (const char *s, Py_ssize_t size, const char *encoding, const char *errors)"
   ^Pointer [s size encoding errors]
-  (DirectMapped/PyUnicode_Decode (dtype/as-nio-buffer s)
+  (DirectMapped/PyUnicode_Decode (dtype/->nio-buffer s)
                                  (jna/size-t size)
                                  (str encoding)
                                  (str errors)))
diff --git a/src/libpython_clj/jna/protocols/buffer.clj b/src/libpython_clj/jna/protocols/buffer.clj
index 06696e5..835e6e8 100644
--- a/src/libpython_clj/jna/protocols/buffer.clj
+++ b/src/libpython_clj/jna/protocols/buffer.clj
@@ -8,7 +8,7 @@
                      *python-library*]
              :as libpy-base]
             [tech.jna :as jna]
-            [tech.v2.datatype :as dtype])
+            [tech.v3.datatype :as dtype])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyBuffer]))
 
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index e6d3970..3d94959 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -1,5 +1,5 @@
 (ns libpython-clj.python
-  (:require [tech.parallel.utils :refer [export-symbols]]
+  (:require [tech.v3.datatype.export-symbols :refer [export-symbols]]
             [libpython-clj.python.interop :as pyinterop]
             [libpython-clj.python.interpreter :as pyinterp]
             [libpython-clj.python.object :as pyobj]
@@ -39,8 +39,7 @@
                 call-attr-kw
                 len
                 as-map
-                as-list
-                as-tensor)
+                as-list)
 
 
 (export-symbols libpython-clj.python.object
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index 5668a1d..bfef85a 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -43,20 +43,21 @@
             [libpython-clj.python.gc :as pygc]
             [clojure.stacktrace :as st]
             [tech.jna :as jna]
-            [tech.v2.tensor :as dtt]
-            [tech.v2.datatype.casting :as casting]
-            [tech.v2.datatype.functional :as dtype-fn]
-            [tech.v2.datatype :as dtype]
+            [tech.v3.tensor :as dtt]
+            [tech.v3.datatype.protocols :as dtype-proto]
+            [tech.v3.datatype.casting :as casting]
+            [tech.v3.datatype.functional :as dtype-fn]
+            [tech.v3.datatype.argops :as argops]
+            [tech.v3.datatype :as dtype]
             [clojure.set :as c-set]
             [clojure.tools.logging :as log])
   (:import [java.util Map RandomAccess List Map$Entry Iterator UUID]
            [java.util.concurrent ConcurrentHashMap ConcurrentLinkedQueue]
            [clojure.lang IFn Symbol Keyword Seqable
             Fn MapEntry Range LongRange]
-           [tech.v2.datatype ObjectReader ObjectWriter ObjectMutable
-            ObjectIter MutableRemove]
-           [tech.v2.datatype.typed_buffer TypedBuffer]
-           [tech.v2.tensor.protocols PTensor]
+           [tech.v3.datatype NDBuffer ObjectBuffer]
+           [tech.v3.datatype.array_buffer ArrayBuffer]
+           [tech.v3.datatype.native_buffer NativeBuffer]
            [com.sun.jna Pointer]
            [tech.resource GCReference]
            [java.io Writer]
@@ -440,28 +441,23 @@
       (bridge-pyobject
        pyobj
        interpreter
-       ObjectReader
+       ObjectBuffer
        (lsize [reader]
               (long (py-call "__len__")))
-       (read [reader idx]
+       (readObject [reader idx]
              (py-call "__getitem__" idx))
        (sort [reader obj-com]
              (when-not (= nil obj-com)
                (throw (ex-info "Python lists do not support comparators" {})))
              (py-call "sort"))
-       ObjectWriter
-       (write [writer idx value]
+       (writeObject [writer idx value]
               (py-call "__setitem__" idx value))
        (remove [writer ^int idx]
                (py-call "__delitem__" idx))
-       ObjectMutable
-       (insert [mutable idx value]
-               (py-call "insert" idx value))
-       (append [mutable value]
-               (py-call "append" value))
-       MutableRemove
-       (mremove [mutable idx]
-                (py-call "__delitem__" idx))))))
+       (add [mutable idx value]
+            (py-call "insert" idx value))
+       (add [mutable value]
+            (.add mutable (.size mutable) value))))))
 
 
 
@@ -535,16 +531,16 @@
                     (as-list)
                     vec)
           strides (-> (get-attr ctypes "strides")
-                    (as-list)
-                    vec)
+                      (as-list)
+                      vec)
           long-addr (get-attr ctypes "data")
           hash-ary {:ctypes-map ctypes}
-          ptr-val (-> (Pointer. long-addr)
-                      (pygc/track #(get hash-ary :ctypes-map)))]
-      {:ptr ptr-val
-       :datatype np-dtype
-       :shape shape
-       :strides strides})))
+          ptr-val long-addr]
+      (-> {:ptr ptr-val
+           :elemwise-datatype np-dtype
+           :shape shape
+           :strides strides}
+          (pygc/track #(get hash-ary :ctypes-map))))))
 
 
 (defmethod py-proto/python-obj-iterator :default
@@ -706,10 +702,10 @@
            py-proto/PPyObjectBridgeToList
            (as-list [item]
                     (generic-python-as-list pyobj))
-           py-proto/PPyObjectBridgeToTensor
+           dtype-proto/PToTensor
            (as-tensor [item]
                       (-> (numpy->desc item)
-                          dtt/buffer-descriptor->tensor))))))))
+                          dtt/nd-buffer-descriptor->tensor))))))))
 
 
 (defmethod pyobject-as-jvm :default
@@ -1041,12 +1037,12 @@
       (jvm-list-as-python item)
       :else
       (jvm-iterable-as-python item)))
-  TypedBuffer
-  (as-python [item options]
-    (py-proto/as-numpy item options))
-  PTensor
-  (as-python [item options]
-    (py-proto/as-numpy item options))
+  NDBuffer
+  (as-python [item options] (py-proto/as-numpy item options))
+  ArrayBuffer
+  (as-python [item options] (py-proto/as-numpy item options))
+  NativeBuffer
+  (as-python [item options] (py-proto/as-numpy item options))
   Iterator
   (as-python [item options]
     (jvm-iterator-as-python item))
@@ -1076,7 +1072,7 @@
 
 
 (defn descriptor->numpy
-  [{:keys [ptr shape strides datatype] :as buffer-desc}]
+  [{:keys [ptr shape strides elemwise-datatype] :as buffer-desc}]
   (with-gil
     (let [stride-tricks (-> (pyinterop/import-module "numpy.lib.stride_tricks")
                             as-jvm)
@@ -1084,19 +1080,19 @@
                      as-jvm)
           np-ctypes (-> (pyinterop/import-module "numpy.ctypeslib")
                         as-jvm)
-          dtype-size (casting/numeric-byte-width datatype)
-          max-stride-idx (dtype-fn/argmax strides)
+          dtype-size (casting/numeric-byte-width elemwise-datatype)
+          max-stride-idx (argops/argmax strides)
           buffer-len (* (long (dtype/get-value shape max-stride-idx))
                         (long (dtype/get-value strides max-stride-idx)))
           n-elems (quot buffer-len dtype-size)
-          lvalue (Pointer/nativeValue ^Pointer ptr)
+          lvalue (long ptr)
           void-p (call-attr ctypes "c_void_p" lvalue)
           actual-ptr (call-attr
                       ctypes "cast" void-p
                       (call-attr
                        ctypes "POINTER"
                        (py-proto/get-attr ctypes
-                                          (datatype->ptr-type-name datatype))))
+                                          (datatype->ptr-type-name elemwise-datatype))))
 
           initial-buffer (call-attr
                           np-ctypes "as_array"
@@ -1112,13 +1108,13 @@
 (extend-type Object
   py-proto/PJvmToNumpy
   (->numpy [item options]
-    (-> (dtt/ensure-buffer-descriptor item)
+    (-> (dtt/ensure-nd-buffer-descriptor item)
         descriptor->numpy))
   py-proto/PJvmToNumpyBridge
   (as-numpy [item options]
-    (when-let [desc (-> (dtt/ensure-tensor item)
-                        dtype/as-buffer-descriptor)]
-      (descriptor->numpy desc))))
+    (when (dtype-proto/convertible-to-native-buffer? item)
+      (when-let [desc (dtt/ensure-nd-buffer-descriptor item)]
+        (descriptor->numpy desc)))))
 
 
 (defn ->numpy
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
index 3cad57f..d1b4eb0 100644
--- a/src/libpython_clj/python/interop.clj
+++ b/src/libpython_clj/python/interop.clj
@@ -4,7 +4,6 @@
   type or function, something that requires knowledge of the C structures behind
   everything that knowledge should be encoded in this file."
   (:require [libpython-clj.jna :as libpy]
-            [libpython-clj.jna.base :as libpy-base]
             [libpython-clj.python.logging
              :refer [log-error log-warn log-info]]
             [libpython-clj.python.interpreter
@@ -22,7 +21,7 @@
             [clojure.stacktrace :as st]
             [tech.jna :as jna]
             ;;need memset
-            [tech.v2.datatype.nio-buffer :as nio-buf]
+            [tech.v3.datatype.native-buffer :as native-buffer]
             [tech.resource :as resource]
             [libpython-clj.python.object
              :refer [wrap-pyobject incref-wrap-pyobject
@@ -225,7 +224,7 @@
          ;;We allocate our memory manually here else the system will gc the
          ;;type object memory when the type goes out of scope.
          new-mem (jna/malloc-untracked type-obj-size)
-         _ (nio-buf/memset new-mem 0 type-obj-size)
+         _ (.setMemory (native-buffer/unsafe) (Pointer/nativeValue new-mem) type-obj-size (unchecked-byte 0))
          new-type (PyTypeObject. new-mem)]
      (set! (.tp_name new-type) type-name-ptr)
      (set! (.tp_init new-type) tp_init)
diff --git a/src/libpython_clj/python/np_array.clj b/src/libpython_clj/python/np_array.clj
index 8f33a27..0c75564 100644
--- a/src/libpython_clj/python/np_array.clj
+++ b/src/libpython_clj/python/np_array.clj
@@ -1,7 +1,6 @@
 (ns libpython-clj.python.np-array
-  (:require [tech.v2.datatype.protocols :as dtype-proto]
-            [tech.v2.datatype.operation-provider :as op-provider]
-            [tech.v2.tensor :as dtt]
+  (:require [tech.v3.datatype.protocols :as dtype-proto]
+            [tech.v3.tensor :as dtt]
             [libpython-clj.python.interpreter :as py-interp]
             [libpython-clj.python.protocols :as py-proto]
             [libpython-clj.python.bridge :as py-bridge]
@@ -11,7 +10,7 @@
 (defmethod py-proto/pyobject->jvm :ndarray
   [pyobj]
   (-> (py-bridge/numpy->desc pyobj)
-      (dtt/buffer-descriptor->tensor)
+      (dtt/nd-buffer-descriptor->tensor)
       (dtt/clone)))
 
 
@@ -31,24 +30,19 @@
        py-proto/PPyObjectBridgeToList
        (as-list [item]
                 (py-bridge/generic-python-as-list pyobj))
-       py-proto/PPyObjectBridgeToTensor
+       dtype-proto/PToTensor
        (as-tensor [item]
                   (-> (py-bridge/numpy->desc item)
-                      dtt/buffer-descriptor->tensor))
-       dtype-proto/PDatatype
-       (get-datatype
+                      dtt/nd-buffer-descriptor->tensor))
+       dtype-proto/PElemwiseDatatype
+       (elemwise-datatype
         [this]
         (-> (py-proto/get-attr pyobj "dtype")
             (py-proto/as-jvm {})
             (py-bridge/obj-dtype->dtype)))
 
 
-       dtype-proto/POperationType
-       (operation-type
-        [this]
-        :numpy-array)
-
-       dtype-proto/PCountable
+       dtype-proto/PECount
        (ecount [this] (apply * (dtype-proto/shape this)))
 
        dtype-proto/PShape
@@ -57,44 +51,24 @@
         (-> (py-proto/get-attr pyobj "shape")
             (py-proto/->jvm {})))
 
-       dtype-proto/PToNioBuffer
-       (convertible-to-nio-buffer? [item] true)
-       (->buffer-backing-store
+       dtype-proto/PToNativeBuffer
+       (convertible-to-native-buffer? [item] true)
+       (->native-buffer
         [item]
-        (-> (py-proto/as-tensor item)
-            (dtype-proto/->buffer-backing-store)))
+        (dtype-proto/->native-buffer
+         (dtype-proto/as-tensor item)))
 
-       dtype-proto/PToJNAPointer
-       (convertible-to-data-ptr? [item] true)
-       (->jna-ptr
-        [item]
-        (:ptr (py-bridge/numpy->desc item)))
-
-       dtype-proto/PBuffer
+       dtype-proto/PSubBuffer
        (sub-buffer
         [buffer offset length]
-        (-> (py-proto/as-tensor buffer)
+        (-> (dtype-proto/as-tensor buffer)
             (dtype-proto/sub-buffer offset length)))
 
-       dtype-proto/PToBufferDesc
-       (convertible-to-buffer-desc? [item] true)
-       (->buffer-descriptor
+       dtype-proto/PToNDBufferDesc
+       (convertible-to-nd-buffer-desc? [item] true)
+       (->nd-buffer-descriptor
         [item]
-        (py-bridge/numpy->desc item))
-
-       dtype-proto/PToReader
-       (convertible-to-reader? [item] true)
-       (->reader
-        [item options]
-        (-> (py-proto/as-tensor item)
-            (dtype-proto/->reader options)))
-
-       dtype-proto/PToWriter
-       (convertible-to-writer? [item] true)
-       (->writer
-        [item options]
-        (-> (py-proto/as-tensor item)
-            (dtype-proto/->writer options)))))))
+        (py-bridge/numpy->desc item))))))
 
 
 (def np-mod
@@ -112,16 +86,6 @@
     (throw (Exception. "Unimplemented"))))
 
 
-(defmethod op-provider/half-dispatch-unary-op :numpy-array
-  [op lhs options]
-  (dispatch-unary-op op lhs options))
-
-
-(defmethod op-provider/half-dispatch-boolean-unary-op :numpy-array
-  [op lhs options]
-  (dispatch-unary-op op lhs options))
-
-
 (defn- dispatch-binary-op
   [op lhs rhs options]
   (case op
@@ -149,28 +113,3 @@
     :eq (py-proto/call-attr @np-mod "equal" lhs rhs)
     :> (py-proto/call-attr @np-mod "greater" lhs rhs)
     :>= (py-proto/call-attr @np-mod "greater_equal" lhs rhs)))
-
-
-(def binary-op-dispatch-table
-  [[:numpy-array :scalar]
-   [:scalar :numpy-array]
-   [:numpy-array :numpy-array]])
-
-
-(defmacro implement-binary-ops
-  []
-  `(do
-     ~@(for [targets binary-op-dispatch-table]
-         `(do
-            (defmethod op-provider/half-dispatch-binary-op
-              ~targets
-              [op# lhs# rhs# options#]
-              (dispatch-binary-op op# lhs# rhs# options#))
-            (defmethod op-provider/half-dispatch-boolean-binary-op
-              ~targets
-              [op# lhs# rhs# options#]
-              (dispatch-binary-op op# lhs# rhs# options#))
-            ))))
-
-
-(implement-binary-ops)
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index d339fc1..4d32869 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -36,11 +36,9 @@
             [libpython-clj.python.gc :as pygc]
             [clojure.stacktrace :as st]
             [tech.jna :as jna]
-            [tech.v2.datatype :as dtype]
-            [tech.v2.datatype.protocols :as dtype-proto]
-            [tech.v2.datatype.casting :as casting]
-            [tech.resource :as resource]
-            [tech.v2.tensor]
+            [tech.v3.datatype :as dtype]
+            [tech.v3.datatype.protocols :as dtype-proto]
+            [tech.v3.datatype.casting :as casting]
             [clojure.tools.logging :as log])
   (:import [com.sun.jna Pointer CallbackReference]
            [com.sun.jna.ptr PointerByReference]
@@ -52,10 +50,10 @@
             CFunction$NoArgFunction
             PyMethodDef]
            [java.nio.charset StandardCharsets]
-           [tech.v2.datatype ObjectIter ObjectReader]
-           [tech.v2.datatype.typed_buffer TypedBuffer]
-           [tech.v2.tensor.protocols PTensor]
            [java.util RandomAccess Map Set Map$Entry]
+           [tech.v3.datatype ObjectReader NDBuffer Buffer]
+           [tech.v3.datatype.array_buffer ArrayBuffer]
+           [tech.v3.datatype.native_buffer NativeBuffer]
            [clojure.lang Symbol Keyword
             IPersistentMap
             IPersistentVector
@@ -464,7 +462,7 @@ Object's refcount is bad.  Crash is imminent"
           n-items (long (libpy/PyObject_Length tuple))]
       (reify ObjectReader
         (lsize [_] n-items)
-        (read [_ idx]
+        (readObject [_ idx]
           (with-gil
             (libpy/PyTuple_GetItem tuple idx)))))))
 
@@ -660,9 +658,11 @@ Object's refcount is bad.  Crash is imminent"
   (->python [item options] item)
   PyObject
   (->python [item options] (.getPointer item))
-  PTensor
+  NDBuffer
   (->python [item options] (py-proto/as-numpy item options))
-  TypedBuffer
+  ArrayBuffer
+  (->python [item options] (py-proto/as-numpy item options))
+  NativeBuffer
   (->python [item options] (py-proto/as-numpy item options))
   Object
   (->python [item options]
@@ -911,17 +911,17 @@ Object's refcount is bad.  Crash is imminent"
                                item-conversion-fn
                                item-conversion-fn)]))))
             cur-item-store (atom (next-fn nil))]
-        (reify ObjectIter
+        (reify
           jna/PToPtr
           (is-jna-ptr-convertible? [item] true)
           (->ptr-backing-store [item] py-iter)
+
+          java.util.Iterator
           (hasNext [obj-iter]
             (not (nil? @cur-item-store)))
           (next [obj-iter]
             (-> (swap-vals! cur-item-store next-fn)
-                ffirst))
-          (current [obj-iter]
-            (first @cur-item-store)))))))
+                ffirst)))))))
 
 
 (defn python->jvm-iterable
diff --git a/src/libpython_clj/python/protocols.clj b/src/libpython_clj/python/protocols.clj
index b4b72ab..2f36bf1 100644
--- a/src/libpython_clj/python/protocols.clj
+++ b/src/libpython_clj/python/protocols.clj
@@ -165,11 +165,6 @@ incomplete especially if the object has no 'keys' attribute."))
     "Never return nil.  Copy or otherwise, numpy or bust."))
 
 
-(defprotocol PPyObjectBridgeToTensor
-  (as-tensor [item]
-    "Return a tech.v2.tensor object from the item that shares the data backing store."))
-
-
 (defmulti pyobject->jvm
   (fn [pyobj]
     (python-type pyobj)))
diff --git a/test/libpython_clj/python/numpy_test.clj b/test/libpython_clj/python/numpy_test.clj
index 0d98463..f6856ae 100644
--- a/test/libpython_clj/python/numpy_test.clj
+++ b/test/libpython_clj/python/numpy_test.clj
@@ -1,9 +1,10 @@
 (ns libpython-clj.python.numpy-test
-  (:require [libpython-clj.python :as py]
-            [tech.v2.datatype :as dtype]
-            [tech.v2.datatype.functional :as dfn]
-            [tech.v2.tensor :as dtt]
-            [clojure.test :refer :all]))
+  (:require [clojure.test :refer [deftest is]]
+            [libpython-clj.python :as py]
+            [tech.v3.datatype :as dtype]
+            [tech.v3.datatype.functional :as dfn]
+            [tech.v3.tensor :as dtt])
+  (:import [com.sun.jna Pointer]))
 
 (py/initialize!)
 
@@ -15,7 +16,6 @@
   (let [test-data [[1 2] [3 4]]
         np-ary (py/$a np-mod array test-data)
         tens (dtt/->tensor test-data)]
-    (is (dfn/equals (dfn/- np-ary 4)
-                    (dfn/- tens 4)))
+    (is (dfn/equals (dtt/ensure-tensor np-ary) tens))
     (is (dfn/equals [1 2 3 4]
                     (dtype/make-container :java-array :int64 np-ary)))))
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index 3d9a499..ca4edfd 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -1,9 +1,9 @@
 (ns libpython-clj.python-test
   (:require [libpython-clj.python :as py :refer [py. py.. py.- py* py**]]
             [libpython-clj.jna :as libpy]
-            [tech.v2.datatype :as dtype]
-            [tech.v2.datatype.functional :as dfn]
-            [tech.v2.tensor :as dtt]
+            [tech.v3.datatype :as dtype]
+            [tech.v3.datatype.functional :as dfn]
+            [tech.v3.tensor :as dtt]
             [tech.jna :as jna]
             [clojure.test :refer :all])
   (:import [java.io StringWriter]
@@ -69,27 +69,28 @@
 
 (deftest numpy-and-back
   (let [jvm-tens (dtt/->tensor (->> (range 9)
-                                    (partition 3)))]
+                                    (partition 3))
+                               :datatype :float64)]
     ;;zero-copy can't work on jvm datastructures with current JNA tech.
     ;;IT would require 'pinning' which isn't yet available.
     (is (nil? (py/as-numpy jvm-tens)))
     (let [py-tens (py/->numpy jvm-tens)]
       (is (= [[0.0 1.0 2.0] [3.0 4.0 5.0] [6.0 7.0 8.0]]
-             (-> (py/as-tensor py-tens)
+             (-> (dtt/as-tensor py-tens)
                  dtt/->jvm)))
       ;;This operation is in-place
       (let [py-trans (py/call-attr py-tens "transpose" [1 0])]
         (is (= [[0.0 1.0 2.0] [3.0 4.0 5.0] [6.0 7.0 8.0]]
-               (-> (py/as-tensor py-tens)
+               (-> (dtt/as-tensor py-tens)
                    dtt/->jvm)))
         (is (= [[0.0 3.0 6.0] [1.0 4.0 7.0] [2.0 5.0 8.0]]
-               (-> (py/as-tensor py-trans)
+               (-> (dtt/as-tensor py-trans)
                    dtt/->jvm)))
         ;;But they are sharing backing store, so mutation will travel both
         ;;ways.  Creepy action at a distance indeed
-        (dtype/copy! [5 6 7] (py/as-tensor py-trans))
+        (dtype/copy! [5 6 7] (nth (dtt/as-tensor py-trans) 0))
         (is (= [[5.0 1.0 2.0] [6.0 4.0 5.0] [7.0 7.0 8.0]]
-               (-> (py/as-tensor py-tens)
+               (-> (dtt/as-tensor py-tens)
                    dtt/->jvm))))
       (let [main-module (py/add-module "__main__")
             ^Map globals (-> (py/module-dict main-module)
@@ -100,7 +101,7 @@
                ;;zero copy almost always works the other way, however.  So there is
                ;;py/->tensor available.  Copying the numpy object will allow the
                ;;zero copy pathway to work.
-               (-> (py/as-tensor py-tens)
+               (-> (dtt/as-tensor py-tens)
                    dtt/->jvm)))))))
 
 (deftest numpy-scalars
@@ -128,7 +129,7 @@
 
 (deftest simple-print-crashed
   (let [numpy (py/import-module "numpy")]
-    (println (py/as-tensor (py/call-attr numpy "ones" [3 3])))))
+    (println (dtt/as-tensor (py/call-attr numpy "ones" [3 3])))))
 
 (deftest true-false-list
   (is (= [false true]
@@ -237,11 +238,11 @@
         linspace (py/$. np linspace)]
 
     (is (dfn/equals [2.000 2.250 2.500 2.750 3.000]
-                    (py/as-tensor (linspace 2 3 :num 5))))
+                    (dtt/as-tensor (linspace 2 3 :num 5))))
     (is (dfn/equals [2.000 2.250 2.500 2.750 3.000]
-                    (py/as-tensor (py/c$ linspace 2 3 :num 5))))
+                    (dtt/as-tensor (py/c$ linspace 2 3 :num 5))))
     (is (dfn/equals [2.000 2.250 2.500 2.750 3.000]
-                    (py/as-tensor (py/a$ np linspace 2 3 :num 5))))))
+                    (dtt/as-tensor (py/a$ np linspace 2 3 :num 5))))))
 
 (deftest syntax-sugar
   (py/initialize!)
@@ -356,7 +357,7 @@ class Foo:
                                      [4 5 6]]))]
       (is (dfn/equals (dtt/->tensor [[1 2 3]
                                      [4 5 6]])
-                      (py/as-tensor ary-data))))))
+                      (dtt/as-tensor ary-data))))))
 
 (deftest python-tuple-equals
   (testing "Python tuples have nice equal semantics."
@@ -374,7 +375,7 @@ class Foo:
   (let [ary-data (-> (py/import-module "numpy")
                      (py/$a array (range 10)))]
     (is (dfn/equals (dtt/->tensor (range 10))
-                    (py/as-tensor ary-data)))))
+                    (dtt/as-tensor ary-data)))))
 
 (deftest false-is-always-py-false
   (let [py-false (libpy/Py_False)
diff --git a/docs/Usage.md b/topics/Usage.md
similarity index 100%
rename from docs/Usage.md
rename to topics/Usage.md
diff --git a/docs/design.md b/topics/design.md
similarity index 100%
rename from docs/design.md
rename to topics/design.md
diff --git a/docs/new-to-clojure.md b/topics/new-to-clojure.md
similarity index 100%
rename from docs/new-to-clojure.md
rename to topics/new-to-clojure.md
diff --git a/docs/scopes-and-gc.md b/topics/scopes-and-gc.md
similarity index 100%
rename from docs/scopes-and-gc.md
rename to topics/scopes-and-gc.md
diff --git a/docs/slicing.md b/topics/slicing.md
similarity index 100%
rename from docs/slicing.md
rename to topics/slicing.md

From f8e1e1affffd429b54bb18c04d3899e700c20401 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 22 Oct 2020 13:26:47 -0600
Subject: [PATCH 233/456] 2.00-alpha-1

---
 CHANGELOG.md                   | 7 +++++++
 README.md                      | 2 ++
 docs/Usage.html                | 2 +-
 docs/design.html               | 2 +-
 docs/index.html                | 2 +-
 docs/libpython-clj.python.html | 2 +-
 docs/new-to-clojure.html       | 2 +-
 docs/scopes-and-gc.html        | 2 +-
 docs/slicing.html              | 2 +-
 project.clj                    | 2 +-
 10 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 551e384..9156885 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,11 @@
 # Time for a ChangeLog!
+
+## 2.00
+* Major upgrade of tech system - moved to dtype-next.  This release is only compatible with
+  tech.ml.dataset versions 5.+.  There are many changes but there should be very few user visible
+  ones.  Please see [cnuernber/dtype-next](https://cnuernber.github.io/dtype-next/) for more
+  information.
+
 ## 1.45
  * tech.datatype - 5.0 release
  
diff --git a/README.md b/README.md
index 8791f3a..64542be 100644
--- a/README.md
+++ b/README.md
@@ -6,6 +6,8 @@
 [![travis integration](https://travis-ci.com/clj-python/libpython-clj.svg?branch=master)](https://travis-ci.com/clj-python/libpython-clj)
 
  - Note - Please avoid deprecated versions such as `[cnuernber/libpython-clj "1.36"]` (***note name change***).
+ 
+ * [API Documentation](https://clj-python.github.io/libpython-clj/)
 
 ## libpython-clj features
 
diff --git a/docs/Usage.html b/docs/Usage.html
index ae328bd..a4118ed 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index c6a2285..c8b19c5 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index eb81ef0..52af5b6 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>tech.ml.dataset 1.47-SNAPSHOT</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "1.47-SNAPSHOT"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>tech.ml.dataset 2.00-alpha-1</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-1"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
index 5f29f49..1b3de48 100644
--- a/docs/libpython-clj.python.html
+++ b/docs/libpython-clj.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 current"><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L394">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L400">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L376">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L385">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L133">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L154">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L140">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L147">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 current"><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L394">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L400">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L376">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L385">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L133">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L154">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L140">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L147">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
 <p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L350">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L214">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L608">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L553">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L105">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1126">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L118">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L727">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
 <p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L363">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index e04e687..4a85447 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 9f8db2f..2c06e53 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index fd98dac..43ee9ef 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">1.47-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 465969e..3f6a468 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-alpha-1"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From a4d23c14167845dde746373285b397a89d98b031 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 22 Oct 2020 13:26:59 -0600
Subject: [PATCH 234/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 3f6a468..5faf5e4 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-alpha-1"
+(defproject clj-python/libpython-clj "2.00-alpha-2-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 7ba2d9c992813503e946710930726d7152defdb0 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 22 Oct 2020 13:28:33 -0600
Subject: [PATCH 235/456] docs

---
 docs/Usage.html                | 2 +-
 docs/design.html               | 2 +-
 docs/index.html                | 2 +-
 docs/libpython-clj.python.html | 2 +-
 docs/new-to-clojure.html       | 2 +-
 docs/scopes-and-gc.html        | 2 +-
 docs/slicing.html              | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index a4118ed..af9b2bb 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index c8b19c5..55ed60d 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index 52af5b6..dfbf1b2 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>tech.ml.dataset 2.00-alpha-1</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-1"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-1</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-1"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
index 1b3de48..3ccfac0 100644
--- a/docs/libpython-clj.python.html
+++ b/docs/libpython-clj.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 current"><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L394">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L400">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L376">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L385">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L133">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L154">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L140">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L147">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 current"><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L394">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L400">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L376">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L385">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L133">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L154">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L140">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L147">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
 <p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L350">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L214">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L608">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L553">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L105">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1126">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L118">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L727">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
 <p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L363">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 4a85447..6346d23 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 2c06e53..433ff0e 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 43ee9ef..cd5b48e 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From c7c6c05e99d0037cc7641b16f69558acb8abb43c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 22 Oct 2020 13:42:42 -0600
Subject: [PATCH 236/456] docs

---
 docs/Usage.html                         |  2 +-
 docs/design.html                        |  2 +-
 docs/index.html                         |  2 +-
 docs/libpython-clj.python.html          | 18 +++---
 docs/libpython-clj.python.np-array.html |  3 +
 docs/libpython-clj.require.html         | 32 +++++++++++
 docs/new-to-clojure.html                |  2 +-
 docs/scopes-and-gc.html                 |  2 +-
 docs/slicing.html                       |  2 +-
 src/libpython_clj/python.clj            |  2 +
 src/libpython_clj/python/np_array.clj   | 73 ++++++++++++-------------
 src/libpython_clj/require.clj           | 25 +++++----
 12 files changed, 101 insertions(+), 64 deletions(-)
 create mode 100644 docs/libpython-clj.python.np-array.html
 create mode 100644 docs/libpython-clj.require.html

diff --git a/docs/Usage.html b/docs/Usage.html
index af9b2bb..75a8da8 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 55ed60d..4a096e5 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index dfbf1b2..305f083 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-1</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-1"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>tech.ml.dataset 2.00-alpha-1</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-1"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
index 3ccfac0..5ca85c7 100644
--- a/docs/libpython-clj.python.html
+++ b/docs/libpython-clj.python.html
@@ -1,15 +1,15 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 current"><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L394">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L400">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L376">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L385">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L133">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L154">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L140">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L147">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
-<p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L350">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L214">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L608">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L553">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L105">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1126">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L118">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L727">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
-<p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L363">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L583">view source</a></div></div><div class="public anchor" id="var-create-bridge-from-att-map"><h3>create-bridge-from-att-map</h3><div class="usage"><code>(create-bridge-from-att-map src-item att-map)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/interop.clj#L377">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap will be presented as instance methods. Things in the cls hashmap had better be either atoms or already converted python objects. You may get surprised otherwise; you have been warned. See the classes-test file in test/libpython-clj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L573">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir item)</code></div><div class="doc"><div class="markdown"><p>Get sorted list of all attribute names.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-equals.3F"><h3>equals?</h3><div class="usage"><code>(equals? lhs rhs)</code></div><div class="doc"><div class="markdown"><p>Returns true of the python equals operator returns 1.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1127">view source</a></div></div><div class="public anchor" id="var-finalize.21"><h3>finalize!</h3><div class="usage"><code>(finalize!)</code></div><div class="doc"><div class="markdown"><p>Finalize the interpreter. You probably shouldn’t call this as it destroys the global interpreter and reinitialization is unsupported cpython.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L262">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L419">view source</a></div></div><div class="public anchor" id="var-gc.21"><h3>gc!</h3><div class="usage"><code>(gc!)</code></div><div class="doc"><div class="markdown"><p>Run the system garbage collection facility and then call the cooperative ‘cleanup python objects’ queue</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L340">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr item item-name)</code></div><div class="doc"><div class="markdown"><p>Get attribute from object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item item item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item of a given name from an object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? item item-name)</code></div><div class="doc"><div class="markdown"><p>Return true of object has attribute</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? item item-name)</code></div><div class="doc"><div class="markdown"><p>Return true of object has item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-hash-code"><h3>hash-code</h3><div class="usage"><code>(hash-code py-inst)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1121">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L410">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L207">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [program-name library-path python-home no-io-redirect? python-executable windows-anaconda-activate-bat]})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is provided, then the python :library-path Library path of the python library to use. :program-name - optional but will show up in error messages from python. :no-io-redirect - there if you don’t want python stdout and stderr redirection  to <em>out</em> and <em>err</em>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-type)</code></div><div class="doc"><div class="markdown"><p>Returns true if inst is an instance of type. False otherwise.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1111">view source</a></div></div><div class="public anchor" id="var-len"><h3>len</h3><div class="usage"><code>(len item)</code></div><div class="doc"><div class="markdown"><p>Call the <strong>len</strong> attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-libpython-clj-module-name"><h3>libpython-clj-module-name</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Module name of the libpython-clj python model. Used to find binding-level objects such as the type used for actual jvm bridging objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/interop.clj#L69">view source</a></div></div><div class="public anchor" id="var-make-tuple-fn"><h3>make-tuple-fn</h3><div class="usage"><code>(make-tuple-fn fn-obj &amp; {:keys [arg-converter result-converter], :or {arg-converter -&gt;jvm, result-converter -&gt;python-incref}, :as options})</code></div><div class="doc"><div class="markdown"><p>Given a clojure function, create a python tuple function. arg-convert is applied to arguments before the clojure function gets them and result-converter is applied to the outbound result. Exceptions are caught, logged, and propagated to python.</p>
-<p>arg-converter: A function to be called on arguments before they get to  clojure. Defaults to -&gt;jvm. result-converter: A function to be called on the return value before it  makes it back to python. Defaults to -&gt;python-incref. method-name: Name of function exposed to python. documentation: Documentation of function exposed to python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L484">view source</a></div></div><div class="public anchor" id="var-make-tuple-instance-fn"><h3>make-tuple-instance-fn</h3><div class="usage"><code>(make-tuple-instance-fn clj-fn &amp; {:keys [arg-converter], :as options})</code></div><div class="doc"><div class="markdown"><p>Make an instance function. In this case the default behavior is to pass raw python object ptr args to the clojure function without marshalling as that can add confusion and unnecessary overhead. Self will be the first argument. Callers can change this behavior by setting the ‘arg-converter’ option as in ‘make-tuple-fn’. Options are the same as make-tuple-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L553">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict module)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary. Returns bridge.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L221">view source</a></div></div><div class="public anchor" id="var-ptr-refcnt"><h3>ptr-refcnt</h3><div class="usage"><code>(ptr-refcnt item)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L255">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L352">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L608">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L553">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L105">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1126">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L118">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L727">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
+<p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L365">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L583">view source</a></div></div><div class="public anchor" id="var-create-bridge-from-att-map"><h3>create-bridge-from-att-map</h3><div class="usage"><code>(create-bridge-from-att-map src-item att-map)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/interop.clj#L377">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap will be presented as instance methods. Things in the cls hashmap had better be either atoms or already converted python objects. You may get surprised otherwise; you have been warned. See the classes-test file in test/libpython-clj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L573">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir item)</code></div><div class="doc"><div class="markdown"><p>Get sorted list of all attribute names.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-equals.3F"><h3>equals?</h3><div class="usage"><code>(equals? lhs rhs)</code></div><div class="doc"><div class="markdown"><p>Returns true of the python equals operator returns 1.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1127">view source</a></div></div><div class="public anchor" id="var-finalize.21"><h3>finalize!</h3><div class="usage"><code>(finalize!)</code></div><div class="doc"><div class="markdown"><p>Finalize the interpreter. You probably shouldn’t call this as it destroys the global interpreter and reinitialization is unsupported cpython.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L264">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L421">view source</a></div></div><div class="public anchor" id="var-gc.21"><h3>gc!</h3><div class="usage"><code>(gc!)</code></div><div class="doc"><div class="markdown"><p>Run the system garbage collection facility and then call the cooperative ‘cleanup python objects’ queue</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L342">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr item item-name)</code></div><div class="doc"><div class="markdown"><p>Get attribute from object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item item item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item of a given name from an object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? item item-name)</code></div><div class="doc"><div class="markdown"><p>Return true of object has attribute</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? item item-name)</code></div><div class="doc"><div class="markdown"><p>Return true of object has item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-hash-code"><h3>hash-code</h3><div class="usage"><code>(hash-code py-inst)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1121">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L412">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L209">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [program-name library-path python-home no-io-redirect? python-executable windows-anaconda-activate-bat]})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is provided, then the python :library-path Library path of the python library to use. :program-name - optional but will show up in error messages from python. :no-io-redirect - there if you don’t want python stdout and stderr redirection  to <em>out</em> and <em>err</em>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-type)</code></div><div class="doc"><div class="markdown"><p>Returns true if inst is an instance of type. False otherwise.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1111">view source</a></div></div><div class="public anchor" id="var-len"><h3>len</h3><div class="usage"><code>(len item)</code></div><div class="doc"><div class="markdown"><p>Call the <strong>len</strong> attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-libpython-clj-module-name"><h3>libpython-clj-module-name</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Module name of the libpython-clj python model. Used to find binding-level objects such as the type used for actual jvm bridging objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/interop.clj#L69">view source</a></div></div><div class="public anchor" id="var-make-tuple-fn"><h3>make-tuple-fn</h3><div class="usage"><code>(make-tuple-fn fn-obj &amp; {:keys [arg-converter result-converter], :or {arg-converter -&gt;jvm, result-converter -&gt;python-incref}, :as options})</code></div><div class="doc"><div class="markdown"><p>Given a clojure function, create a python tuple function. arg-convert is applied to arguments before the clojure function gets them and result-converter is applied to the outbound result. Exceptions are caught, logged, and propagated to python.</p>
+<p>arg-converter: A function to be called on arguments before they get to  clojure. Defaults to -&gt;jvm. result-converter: A function to be called on the return value before it  makes it back to python. Defaults to -&gt;python-incref. method-name: Name of function exposed to python. documentation: Documentation of function exposed to python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L484">view source</a></div></div><div class="public anchor" id="var-make-tuple-instance-fn"><h3>make-tuple-instance-fn</h3><div class="usage"><code>(make-tuple-instance-fn clj-fn &amp; {:keys [arg-converter], :as options})</code></div><div class="doc"><div class="markdown"><p>Make an instance function. In this case the default behavior is to pass raw python object ptr args to the clojure function without marshalling as that can add confusion and unnecessary overhead. Self will be the first argument. Callers can change this behavior by setting the ‘arg-converter’ option as in ‘make-tuple-fn’. Options are the same as make-tuple-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L553">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict module)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary. Returns bridge.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-ptr-refcnt"><h3>ptr-refcnt</h3><div class="usage"><code>(ptr-refcnt item)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L257">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L446">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L467">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L440">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L433">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L448">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L469">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L442">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L435">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -19,8 +19,8 @@
 <p>(= (py.. obj (*methods args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L502">view source</a></div></div><div class="public anchor" id="var-python-pyerr-fetch-error-handler"><h3>python-pyerr-fetch-error-handler</h3><div class="usage"><code>(python-pyerr-fetch-error-handler)</code></div><div class="doc"><div class="markdown"><p>Utility code used in with macro</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L269">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type item)</code></div><div class="doc"><div class="markdown"><p>Return a keyword that describes the python datatype of this object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L26">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L504">view source</a></div></div><div class="public anchor" id="var-python-pyerr-fetch-error-handler"><h3>python-pyerr-fetch-error-handler</h3><div class="usage"><code>(python-pyerr-fetch-error-handler)</code></div><div class="doc"><div class="markdown"><p>Utility code used in with macro</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L271">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type item)</code></div><div class="doc"><div class="markdown"><p>Return a keyword that describes the python datatype of this object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L26">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L163">view source</a></div></div><div class="public anchor" id="var-run-string"><h3>run-string</h3><div class="usage"><code>(run-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L196">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! item item-name item-value)</code></div><div class="doc"><div class="markdown"><p>Set attribute on object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! item att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L97">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! item item-name item-value)</code></div><div class="doc"><div class="markdown"><p>Set an item of to a value</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L25">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! item item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L107">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L61">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L316">view source</a></div></div><div class="public anchor" id="var-with-exit-error-handler"><h3>with-exit-error-handler</h3><div class="usage"><code>(with-exit-error-handler with-var error)</code></div><div class="doc"><div class="markdown"><p>Utility code used in with macro</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L289">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L74">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L83">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L165">view source</a></div></div><div class="public anchor" id="var-run-string"><h3>run-string</h3><div class="usage"><code>(run-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L198">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! item item-name item-value)</code></div><div class="doc"><div class="markdown"><p>Set attribute on object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! item att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L99">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! item item-name item-value)</code></div><div class="doc"><div class="markdown"><p>Set an item of to a value</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! item item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L109">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L63">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L318">view source</a></div></div><div class="public anchor" id="var-with-exit-error-handler"><h3>with-exit-error-handler</h3><div class="usage"><code>(with-exit-error-handler with-var error)</code></div><div class="doc"><div class="markdown"><p>Utility code used in with macro</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L291">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L76">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L85">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.np-array.html b/docs/libpython-clj.python.np-array.html
new file mode 100644
index 0000000..71de3e1
--- /dev/null
+++ b/docs/libpython-clj.python.np-array.html
@@ -0,0 +1,3 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.require.html b/docs/libpython-clj.require.html
new file mode 100644
index 0000000..de7dc40
--- /dev/null
+++ b/docs/libpython-clj.require.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
+<p>(require-python ’[math :as maaaath])</p>
+<p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
+<p>(require-python ‘math ‘csv) (require-python ’[math :as pymath] ‘csv)) (require-python ’[math :as pymath] ’[csv :as py-csv]) (require-python ‘concurrent.futures) (require-python ’[concurrent.futures :as fs]) (require-python ’(concurrent [futures :as fs]))</p>
+<p>(require-python ’[requests :refer [get post]])</p>
+<p>(requests/get “https//www.google.com”) ;;=&gt; &lt;Response [200]&gt; (get “https//www.google.com”) ;;=&gt; &lt;Response [200]&gt;</p>
+<p>In some cases we may generate invalid arglists metadata for the clojure compiler. In those cases we have a flag, :no-arglists that will disable adding arglists to the generated metadata for the vars. Use the reload flag below if you need to force reload a namespace where invalid arglists have been generated.</p>
+<p>(require-python ’[numpy :refer [linspace] :no-arglists :as np])</p>
+<p>If you would like to bind the Python module to the namespace, use the :bind-ns flag.</p>
+<p>(require-python ‘[requests :bind-ns true]) or (require-python ’[requests :bind-ns])</p>
+<h2><a href="#use-with-custom-modules" name="use-with-custom-modules"></a>Use with custom modules</h2>
+<p>For use with a custom namespace foo.py while developing, you can use:</p>
+<p>(require-python ’[foo :reload])</p>
+<p>NOTE: unless you specify the :reload flag,  ..: the module will NOT reload. If the :reload flag is set,  ..: the behavior mimics importlib.reload</p>
+<h2><a href="#setting-up-classpath-for-custom-modules" name="setting-up-classpath-for-custom-modules"></a>Setting up classpath for custom modules</h2>
+<p>Note: you may need to setup your PYTHONPATH correctly. One technique to do this is, if your foo.py lives at /path/to/foodir/foo.py:</p>
+<p>(require-python ’sys) (py/call-attr (py/get-attr sys “path”)  “append”  “/path/to/foodir”)</p>
+<p>Another option is</p>
+<p>(require-python ’os) (os/chdir “/path/to/foodir”)</p>
+<h2><a href="#prefix-lists" name="prefix-lists"></a>prefix lists</h2>
+<p>For convenience, if you are loading multiple Python modules with the same prefix, you can use the following notation:</p>
+<p>(require-python ’(a b c)) is equivalent to (require-python ’a.b ’a.c)</p>
+<p>(require-python ‘(foo [bar :as baz :refer [qux]])) is equivalent to (require-python ’[foo.bar :as baz :refer [qux]])</p>
+<p>(require-python ‘(foo [bar :as baz :refer [qux]] buster)) (require-python ’[foo.bar :as baz :refer [qux]] ’foo.buster))</p>
+<h2><a href="#for-library-developers" name="for-library-developers"></a>For library developers</h2>
+<p>If you want to intern all symbols to your current namespace, you can do the following –</p>
+<p>(require-python ’[math :refer :all])</p>
+<p>However, if you only want to use those things designated by the module under the <strong>all</strong> attribute, you can do</p>
+<p>(require-python ’[operators :refer :*])</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L181">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 6346d23..dd6c48b 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 433ff0e..5a33426 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index cd5b48e..360a61c 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 3d94959..338ab16 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -1,4 +1,6 @@
 (ns libpython-clj.python
+  "Base low-level namespace for accessing Python via Clojure.  Higher level interfaces
+   are found in libpython-clj.require specifically require-python and import-python."
   (:require [tech.v3.datatype.export-symbols :refer [export-symbols]]
             [libpython-clj.python.interop :as pyinterop]
             [libpython-clj.python.interpreter :as pyinterp]
diff --git a/src/libpython_clj/python/np_array.clj b/src/libpython_clj/python/np_array.clj
index 0c75564..38998e0 100644
--- a/src/libpython_clj/python/np_array.clj
+++ b/src/libpython_clj/python/np_array.clj
@@ -1,4 +1,7 @@
 (ns libpython-clj.python.np-array
+  "Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This allows somewhat more
+  seamless usage of numpy arrays in datatype and tensor functionality such as enabling
+  the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible)."
   (:require [tech.v3.datatype.protocols :as dtype-proto]
             [tech.v3.tensor :as dtt]
             [libpython-clj.python.interpreter :as py-interp]
@@ -71,45 +74,41 @@
         (py-bridge/numpy->desc item))))))
 
 
-(def np-mod
+(def np-mod*
+  "Delay that dereferences to the python numpy module"
   (py-bridge/pydelay
    (-> (py-interop/import-module "numpy")
        (py-proto/as-jvm {}))))
 
 
-(defn- dispatch-unary-op
-  [op lhs options]
-  (if (keyword? op)
-    (if (= op :-)
-      (py-proto/call-attr lhs "__neg__")
-      (py-proto/call-attr @np-mod (name op) lhs))
-    (throw (Exception. "Unimplemented"))))
-
-
-(defn- dispatch-binary-op
-  [op lhs rhs options]
-  (case op
-    :max (py-proto/call-attr @np-mod "max" lhs rhs)
-    :min (py-proto/call-attr @np-mod "min" lhs rhs)
-    :+ (py-proto/call-attr @np-mod "add" lhs rhs)
-    :- (py-proto/call-attr @np-mod "subtract" lhs rhs)
-    :div (py-proto/call-attr @np-mod "divide" lhs rhs)
-    :* (py-proto/call-attr @np-mod "multiply" lhs rhs)
-    :pow (py-proto/call-attr @np-mod "power" lhs rhs)
-    :quot (py-proto/call-attr @np-mod "floor_divide" lhs rhs)
-    :rem (py-proto/call-attr @np-mod "mod" lhs rhs)
-    :bit-and (py-proto/call-attr @np-mod "bitwise_and" lhs rhs)
-    :bit-flip (py-proto/call-attr @np-mod "bitwise_not" lhs rhs)
-    :bit-or (py-proto/call-attr @np-mod "bitwise_or" lhs rhs)
-    :bit-xor (py-proto/call-attr @np-mod "bitwise_xor" lhs rhs)
-    :bit-shift-left (py-proto/call-attr @np-mod "left_shift" lhs rhs)
-    :bit-shift-right (py-proto/call-attr @np-mod "right_shift" lhs rhs)
-    :and (py-proto/call-attr @np-mod "logical_and" lhs rhs)
-    :or (py-proto/call-attr @np-mod "logical_or" lhs rhs)
-    :not (py-proto/call-attr @np-mod "logical_not" lhs rhs)
-    :xor (py-proto/call-attr @np-mod "logical_xor" lhs rhs)
-    :< (py-proto/call-attr @np-mod "less" lhs rhs)
-    :<= (py-proto/call-attr @np-mod "less_equal" lhs rhs)
-    :eq (py-proto/call-attr @np-mod "equal" lhs rhs)
-    :> (py-proto/call-attr @np-mod "greater" lhs rhs)
-    :>= (py-proto/call-attr @np-mod "greater_equal" lhs rhs)))
+(comment
+
+  ;;Dispatch table for what tech.v3.datatype.functional methods are found in the numpy module.
+
+  (defn- dispatch-binary-op
+    [op lhs rhs options]
+    (case op
+      :max (py-proto/call-attr @np-mod "max" lhs rhs)
+      :min (py-proto/call-attr @np-mod "min" lhs rhs)
+      :+ (py-proto/call-attr @np-mod "add" lhs rhs)
+      :- (py-proto/call-attr @np-mod "subtract" lhs rhs)
+      :div (py-proto/call-attr @np-mod "divide" lhs rhs)
+      :* (py-proto/call-attr @np-mod "multiply" lhs rhs)
+      :pow (py-proto/call-attr @np-mod "power" lhs rhs)
+      :quot (py-proto/call-attr @np-mod "floor_divide" lhs rhs)
+      :rem (py-proto/call-attr @np-mod "mod" lhs rhs)
+      :bit-and (py-proto/call-attr @np-mod "bitwise_and" lhs rhs)
+      :bit-flip (py-proto/call-attr @np-mod "bitwise_not" lhs rhs)
+      :bit-or (py-proto/call-attr @np-mod "bitwise_or" lhs rhs)
+      :bit-xor (py-proto/call-attr @np-mod "bitwise_xor" lhs rhs)
+      :bit-shift-left (py-proto/call-attr @np-mod "left_shift" lhs rhs)
+      :bit-shift-right (py-proto/call-attr @np-mod "right_shift" lhs rhs)
+      :and (py-proto/call-attr @np-mod "logical_and" lhs rhs)
+      :or (py-proto/call-attr @np-mod "logical_or" lhs rhs)
+      :not (py-proto/call-attr @np-mod "logical_not" lhs rhs)
+      :xor (py-proto/call-attr @np-mod "logical_xor" lhs rhs)
+      :< (py-proto/call-attr @np-mod "less" lhs rhs)
+      :<= (py-proto/call-attr @np-mod "less_equal" lhs rhs)
+      :eq (py-proto/call-attr @np-mod "equal" lhs rhs)
+      :> (py-proto/call-attr @np-mod "greater" lhs rhs)
+      :>= (py-proto/call-attr @np-mod "greater_equal" lhs rhs))))
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj/require.clj
index 3cc4cca..606dc86 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj/require.clj
@@ -1,4 +1,6 @@
 (ns libpython-clj.require
+  "Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  scanning the module for metadata and dynamically building the Clojure namespace."
   (:refer-clojure :exclude [fn? doc])
   (:require [libpython-clj.python :as py]
             [libpython-clj.metadata :as pymeta]
@@ -124,14 +126,14 @@
           (throw (Exception. (str "Cannot have periods in module/class"
                                   "name. Please :alias "
                                   import-name
-                                  " to something without periods."))))        
+                                  " to something without periods."))))
         (intern
          (symbol (str *ns*))
          (with-meta (symbol import-name)
            {:file (metadata/find-file pyobj)
             :line 1})
          pyobj)))
-    
+
     (when (or (not existing-py-ns?) reload?)
       (pymeta/apply-static-metadata-to-namespace! module-name (datafy pyobj)
                                                   :no-arglists? no-arglists?))
@@ -152,7 +154,7 @@
      (let [base (first req)
            reqs (rest req)]
        (map (partial req-transform base) reqs))))
-  ([prefix req] 
+  ([prefix req]
    (cond
      (and  (symbol? req)
            (clojure.string/includes? (name req) ".") )
@@ -185,7 +187,7 @@
    (require-python '[math :as maaaath])
 
    (maaaath/sin 1.0) ;;=> 0.8414709848078965
-  
+
    (require-python 'math 'csv)
    (require-python '[math :as pymath] 'csv))
    (require-python '[math :as pymath] '[csv :as py-csv])
@@ -254,7 +256,7 @@
 
    (require-python '(foo [bar :as baz :refer [qux]] buster))
    (require-python '[foo.bar :as baz :refer [qux]] 'foo.buster))
-  
+
    ## For library developers ##
 
    If you want to intern all symbols to your current namespace,
@@ -272,7 +274,7 @@
      (list? req) ;; prefix list
      (let [prefix-lists (req-transform req)]
        (doseq [req prefix-lists] (require-python req)))
-     (symbol? req) 
+     (symbol? req)
      (require-python (vector req))
      (vector? req)
      (do-require-python req)
@@ -308,7 +310,7 @@
 (def ^:private pytype   (comp symbol str (py/get-attr builtins "type")))
 
 
-(defmulti pydafy
+(defmulti ^:no-doc pydafy
   "Turn a Python object into Clojure data.  Metadata of Clojure
      data will automatically be merged with nav protocol.
 
@@ -320,9 +322,9 @@
      an ugly hack. Sorry. See examples in libpython-clj.require."
   pytype)
 
-(defmulti pynav
+(defmulti ^:no-doc pynav
   "Nav data from a Python object.
-  
+
      Extend this method to nav a custom Python object into Clojure data.
      Extend pydafy if you would like to datafy a Python object.
 
@@ -362,7 +364,7 @@
   (let [res (pydafy item)
         m   (meta res)]
     (try
-      (with-meta 
+      (with-meta
         res
         (merge
          {'clj-proto/nav pynav}
@@ -386,7 +388,7 @@
         res))))
 
 
-(defmacro pydatafy [& types]
+(defmacro ^:no-doc pydatafy [& types]
   ;; credit: Tom Spoon
   ;; https://clojurians.zulipchat.com/#narrow/stream/215609-libpython-clj-dev/topic/feature-requests/near/187056819
   `(do ~@(for [t types]
@@ -398,4 +400,3 @@
 
 
 (pydatafy PPyObject PBridgeToJVM)
-

From 68040ceef82757dac4c2c294611c732521bb26b8 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 22 Oct 2020 13:58:38 -0600
Subject: [PATCH 237/456] 5.00-alpha-2

---
 docs/Usage.html                | 2 +-
 docs/design.html               | 2 +-
 docs/index.html                | 2 +-
 docs/libpython-clj.python.html | 2 +-
 docs/new-to-clojure.html       | 2 +-
 docs/scopes-and-gc.html        | 2 +-
 docs/slicing.html              | 2 +-
 project.clj                    | 4 ++--
 8 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index 75a8da8..d5a1757 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 4a096e5..abdb175 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index 305f083..31db0bb 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>tech.ml.dataset 2.00-alpha-1</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-1"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>tech.ml.dataset 2.00-alpha-2</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-2"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
index 5ca85c7..6179bda 100644
--- a/docs/libpython-clj.python.html
+++ b/docs/libpython-clj.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 current"><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
 <p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L352">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L608">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L553">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L105">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1126">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L118">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L727">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
 <p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L365">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index dd6c48b..a3f9f31 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 5a33426..30e02d2 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 360a61c..9197804 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 5faf5e4..522dc63 100644
--- a/project.clj
+++ b/project.clj
@@ -1,11 +1,11 @@
-(defproject clj-python/libpython-clj "2.00-alpha-2-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-alpha-2"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2-alpha2"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.00-alpha-9"]
+                 [cnuernber/dtype-next   "6.00-alpha-10"]
                  [techascent/tech.jna    "3.24"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]]}

From a15c6c0542a72ca281cefc1bf0f33926b3dacdda Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 22 Oct 2020 13:58:47 -0600
Subject: [PATCH 238/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 522dc63..87562cd 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-alpha-2"
+(defproject clj-python/libpython-clj "2.00-alpha-3-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 8e877a3fa966a4d1d95581dda6b1c0472a99da02 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 22 Oct 2020 14:01:16 -0600
Subject: [PATCH 239/456] docs

---
 docs/Usage.html                         | 2 +-
 docs/design.html                        | 2 +-
 docs/index.html                         | 2 +-
 docs/libpython-clj.python.html          | 2 +-
 docs/libpython-clj.python.np-array.html | 2 +-
 docs/libpython-clj.require.html         | 2 +-
 docs/new-to-clojure.html                | 2 +-
 docs/scopes-and-gc.html                 | 2 +-
 docs/slicing.html                       | 2 +-
 project.clj                             | 4 +++-
 10 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index d5a1757..988a1b7 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index abdb175..5dedfa3 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index 31db0bb..9c7b05f 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>tech.ml.dataset 2.00-alpha-2</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-2"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>tech.ml.dataset 2.00-alpha-2</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-2"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
index 6179bda..5993f50 100644
--- a/docs/libpython-clj.python.html
+++ b/docs/libpython-clj.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 current"><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
 <p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L352">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L608">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L553">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L105">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1126">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L118">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L727">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
 <p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L365">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
diff --git a/docs/libpython-clj.python.np-array.html b/docs/libpython-clj.python.np-array.html
index 71de3e1..af4142f 100644
--- a/docs/libpython-clj.python.np-array.html
+++ b/docs/libpython-clj.python.np-array.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.require.html b/docs/libpython-clj.require.html
index de7dc40..fd06855 100644
--- a/docs/libpython-clj.require.html
+++ b/docs/libpython-clj.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index a3f9f31..c779680 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 30e02d2..c218c32 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 9197804..b90982d 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1 "><a href="libpython-clj.python.html"><div class="inner"><span>libpython-clj.python</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 87562cd..3267a21 100644
--- a/project.clj
+++ b/project.clj
@@ -19,7 +19,9 @@
                       :output-path "docs"
                       :doc-paths ["topics"]
                       :source-uri "https://github.com/clj-python/libpython-clj/blob/master/{filepath}#L{line}"
-                      :namespaces [libpython-clj.python]}}}
+                      :namespaces [libpython-clj.python
+                                   libpython-clj.require
+                                   libpython-clj.python.np-array]}}}
   :java-source-paths ["java"]
   :aliases {"codox" ["with-profile" "codox,dev" "codox"]}
 

From c4d0c2cb6476d053013224cf8b441f1f55241eee Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 22 Oct 2020 14:03:34 -0600
Subject: [PATCH 240/456] docs

---
 docs/Usage.html                         | 2 +-
 docs/design.html                        | 2 +-
 docs/index.html                         | 2 +-
 docs/libpython-clj.python.html          | 2 +-
 docs/libpython-clj.python.np-array.html | 2 +-
 docs/libpython-clj.require.html         | 2 +-
 docs/new-to-clojure.html                | 2 +-
 docs/scopes-and-gc.html                 | 2 +-
 docs/slicing.html                       | 2 +-
 project.clj                             | 2 +-
 10 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index 988a1b7..f69b4ea 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 5dedfa3..6710c14 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index 9c7b05f..d944bec 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>tech.ml.dataset 2.00-alpha-2</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-2"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-2</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-2"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
index 5993f50..60911a2 100644
--- a/docs/libpython-clj.python.html
+++ b/docs/libpython-clj.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
 <p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L352">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L608">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L553">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L105">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1126">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L118">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L727">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
 <p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L365">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
diff --git a/docs/libpython-clj.python.np-array.html b/docs/libpython-clj.python.np-array.html
index af4142f..d861e14 100644
--- a/docs/libpython-clj.python.np-array.html
+++ b/docs/libpython-clj.python.np-array.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.require.html b/docs/libpython-clj.require.html
index fd06855..0c85385 100644
--- a/docs/libpython-clj.require.html
+++ b/docs/libpython-clj.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index c779680..cc97df8 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index c218c32..ab2438c 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index b90982d..eed107b 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">tech.ml.dataset</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 3267a21..5f1c323 100644
--- a/project.clj
+++ b/project.clj
@@ -12,7 +12,7 @@
              :codox
              {:dependencies [[codox-theme-rdash "0.1.2"]]
               :plugins [[lein-codox "0.10.7"]]
-              :codox {:project {:name "tech.ml.dataset"}
+              :codox {:project {:name "libpython-clj"}
                       :metadata {:doc/format :markdown}
                       :themes [:rdash]
                       :source-paths ["src"]

From 06298ff1e645005994b9e0cab22fd51807a5f0b9 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 24 Oct 2020 14:09:19 -0600
Subject: [PATCH 241/456] Tech.resource 5.x (#132)

* Another large change, needs some careful consideration.

* Moved to tech.v3.jna as an issue in tech.resource was found.

* removed unused requires.

* Updating readme.
---
 README.md                                          | 5 +++++
 project.clj                                        | 4 ++--
 src/libpython_clj/jna/base.clj                     | 6 +++---
 src/libpython_clj/jna/concrete/cfunction.clj       | 2 +-
 src/libpython_clj/jna/concrete/dict.clj            | 2 +-
 src/libpython_clj/jna/concrete/err.clj             | 4 +++-
 src/libpython_clj/jna/concrete/import.clj          | 3 +--
 src/libpython_clj/jna/concrete/list.clj            | 2 +-
 src/libpython_clj/jna/concrete/module.clj          | 2 +-
 src/libpython_clj/jna/concrete/numeric/boolean.clj | 3 +--
 src/libpython_clj/jna/concrete/numeric/complex.clj | 2 +-
 src/libpython_clj/jna/concrete/numeric/float.clj   | 3 +--
 src/libpython_clj/jna/concrete/numeric/integer.clj | 2 +-
 src/libpython_clj/jna/concrete/set.clj             | 3 +--
 src/libpython_clj/jna/concrete/tuple.clj           | 2 +-
 src/libpython_clj/jna/concrete/type.clj            | 2 +-
 src/libpython_clj/jna/concrete/unicode.clj         | 7 ++++---
 src/libpython_clj/jna/interpreter.clj              | 5 ++---
 src/libpython_clj/jna/protocols/buffer.clj         | 6 +++---
 src/libpython_clj/jna/protocols/iterator.clj       | 3 +--
 src/libpython_clj/jna/protocols/mapping.clj        | 3 +--
 src/libpython_clj/jna/protocols/object.clj         | 2 --
 src/libpython_clj/jna/protocols/sequence.clj       | 2 +-
 src/libpython_clj/python.clj                       | 2 +-
 src/libpython_clj/python/bridge.clj                | 3 +--
 src/libpython_clj/python/interop.clj               | 4 ++--
 src/libpython_clj/python/interpreter.clj           | 7 +++----
 src/libpython_clj/python/object.clj                | 2 +-
 test/libpython_clj/classes_test.clj                | 2 --
 test/libpython_clj/python_test.clj                 | 2 +-
 test/libpython_clj/stress_test.clj                 | 2 --
 31 files changed, 46 insertions(+), 53 deletions(-)

diff --git a/README.md b/README.md
index 64542be..9c9308a 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,11 @@
  - Note - Please avoid deprecated versions such as `[cnuernber/libpython-clj "1.36"]` (***note name change***).
  
  * [API Documentation](https://clj-python.github.io/libpython-clj/)
+ * This library, which has received the efforts of many excellent people, is built mainly upon
+   [cnuernber/dtype-next](https://github.com/cnuernber/dtype-next/) and 
+   [techascent/tech.jna](https://github.com/techascent/tech.jna).  It supports zerocopy transfer
+   of data to/from numpy, dynamically creating Clojure namespaces from Python modules, and has
+   a deep intergration with the Clojure language.
 
 ## libpython-clj features
 
diff --git a/project.clj b/project.clj
index 5f1c323..0a737d1 100644
--- a/project.clj
+++ b/project.clj
@@ -5,8 +5,8 @@
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2-alpha2"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.00-alpha-10"]
-                 [techascent/tech.jna    "3.24"]
+                 [cnuernber/dtype-next   "6.00-alpha-11"]
+                 [techascent/tech.jna    "4.02"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]]}
              :codox
diff --git a/src/libpython_clj/jna/base.clj b/src/libpython_clj/jna/base.clj
index 45a9a3f..1011fa9 100644
--- a/src/libpython_clj/jna/base.clj
+++ b/src/libpython_clj/jna/base.clj
@@ -1,6 +1,6 @@
 (ns libpython-clj.jna.base
-  (:require [tech.jna :as jna]
-            [tech.jna.base :as jna-base])
+  (:require [tech.v3.jna :as jna]
+            [tech.v3.jna.base :as jna-base])
   (:import [com.sun.jna Pointer NativeLibrary]
            [libpython_clj.jna PyObject]
            [java.util.concurrent.atomic AtomicLong]))
@@ -110,6 +110,6 @@
 
 
 (defn find-pylib-symbol
-  [sym-name]
+  ^Pointer [sym-name]
   (.getGlobalVariableAddress ^NativeLibrary (jna-base/load-library *python-library*)
                              sym-name))
diff --git a/src/libpython_clj/jna/concrete/cfunction.clj b/src/libpython_clj/jna/concrete/cfunction.clj
index afa1017..70f9057 100644
--- a/src/libpython_clj/jna/concrete/cfunction.clj
+++ b/src/libpython_clj/jna/concrete/cfunction.clj
@@ -8,7 +8,7 @@
                      size-t-type
                      *python-library*]
              :as libpy-base]
-            [tech.jna :as jna])
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna CallbackReference Pointer Callback]
            [libpython_clj.jna
             CFunction$KeyWordFunction
diff --git a/src/libpython_clj/jna/concrete/dict.clj b/src/libpython_clj/jna/concrete/dict.clj
index b194f6a..50690d1 100644
--- a/src/libpython_clj/jna/concrete/dict.clj
+++ b/src/libpython_clj/jna/concrete/dict.clj
@@ -7,7 +7,7 @@
                      size-t-type
                      *python-library*]
              :as libpy-base]
-            [tech.jna :as jna])
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject DirectMapped]))
 
diff --git a/src/libpython_clj/jna/concrete/err.clj b/src/libpython_clj/jna/concrete/err.clj
index 7df5a24..54b7c2b 100644
--- a/src/libpython_clj/jna/concrete/err.clj
+++ b/src/libpython_clj/jna/concrete/err.clj
@@ -8,10 +8,12 @@
                      find-pylib-symbol
                      *python-library*]
              :as libpy-base]
-            [tech.jna :as jna])
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject PyTypeObject DirectMapped]))
 
+(set! *warn-on-reflection* true)
+
 
 (defn PyErr_Occurred
   "Check if the error indicator is set.  If so, return the exception type."
diff --git a/src/libpython_clj/jna/concrete/import.clj b/src/libpython_clj/jna/concrete/import.clj
index bca342d..34a16cf 100644
--- a/src/libpython_clj/jna/concrete/import.clj
+++ b/src/libpython_clj/jna/concrete/import.clj
@@ -6,8 +6,7 @@
                      ensure-pydict
                      size-t-type
                      *python-library*]
-             :as libpy-base]
-            [tech.jna :as jna])
+             :as libpy-base])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject]))
 
diff --git a/src/libpython_clj/jna/concrete/list.clj b/src/libpython_clj/jna/concrete/list.clj
index 3e91c5e..7922b72 100644
--- a/src/libpython_clj/jna/concrete/list.clj
+++ b/src/libpython_clj/jna/concrete/list.clj
@@ -7,7 +7,7 @@
                      size-t-type
                      *python-library*]
              :as libpy-base]
-            [tech.jna :as jna])
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject]))
 
diff --git a/src/libpython_clj/jna/concrete/module.clj b/src/libpython_clj/jna/concrete/module.clj
index 63196e5..10b2018 100644
--- a/src/libpython_clj/jna/concrete/module.clj
+++ b/src/libpython_clj/jna/concrete/module.clj
@@ -7,7 +7,7 @@
                      size-t-type
                      *python-library*]
              :as libpy-base]
-            [tech.jna :as jna])
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyModuleDef PyMethodDef PyObject]))
 
diff --git a/src/libpython_clj/jna/concrete/numeric/boolean.clj b/src/libpython_clj/jna/concrete/numeric/boolean.clj
index 2536e98..3350159 100644
--- a/src/libpython_clj/jna/concrete/numeric/boolean.clj
+++ b/src/libpython_clj/jna/concrete/numeric/boolean.clj
@@ -5,8 +5,7 @@
                      ensure-pytuple
                      ensure-pydict
                      find-pylib-symbol]
-             :as libpy-base]
-            [tech.jna :as jna])
+             :as libpy-base])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject]))
 
diff --git a/src/libpython_clj/jna/concrete/numeric/complex.clj b/src/libpython_clj/jna/concrete/numeric/complex.clj
index ac34501..215e97f 100644
--- a/src/libpython_clj/jna/concrete/numeric/complex.clj
+++ b/src/libpython_clj/jna/concrete/numeric/complex.clj
@@ -6,7 +6,7 @@
                      ensure-pydict
                      find-pylib-symbol]
              :as libpy-base]
-            [tech.jna :as jna])
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyComplex PyComplex$ByValue
             PyObject]))
diff --git a/src/libpython_clj/jna/concrete/numeric/float.clj b/src/libpython_clj/jna/concrete/numeric/float.clj
index dee3276..14ed289 100644
--- a/src/libpython_clj/jna/concrete/numeric/float.clj
+++ b/src/libpython_clj/jna/concrete/numeric/float.clj
@@ -5,8 +5,7 @@
                      ensure-pytuple
                      ensure-pydict
                      *python-library*]
-             :as libpy-base]
-            [tech.jna :as jna])
+             :as libpy-base])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject DirectMapped]))
 
diff --git a/src/libpython_clj/jna/concrete/numeric/integer.clj b/src/libpython_clj/jna/concrete/numeric/integer.clj
index 3c8af96..2b80db4 100644
--- a/src/libpython_clj/jna/concrete/numeric/integer.clj
+++ b/src/libpython_clj/jna/concrete/numeric/integer.clj
@@ -6,7 +6,7 @@
                      ensure-pydict
                      *python-library*]
              :as libpy-base]
-            [tech.jna :as jna])
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject DirectMapped]))
 
diff --git a/src/libpython_clj/jna/concrete/set.clj b/src/libpython_clj/jna/concrete/set.clj
index aa7655f..1370c9f 100644
--- a/src/libpython_clj/jna/concrete/set.clj
+++ b/src/libpython_clj/jna/concrete/set.clj
@@ -6,8 +6,7 @@
                      ensure-pydict
                      size-t-type
                      *python-library*]
-             :as libpy-base]
-            [tech.jna :as jna])
+             :as libpy-base])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject]))
 
diff --git a/src/libpython_clj/jna/concrete/tuple.clj b/src/libpython_clj/jna/concrete/tuple.clj
index df726a3..5b44e04 100644
--- a/src/libpython_clj/jna/concrete/tuple.clj
+++ b/src/libpython_clj/jna/concrete/tuple.clj
@@ -7,7 +7,7 @@
                      size-t-type
                      *python-library*]
              :as libpy-base]
-            [tech.jna :as jna])
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject DirectMapped]))
 
diff --git a/src/libpython_clj/jna/concrete/type.clj b/src/libpython_clj/jna/concrete/type.clj
index 323a906..52db927 100644
--- a/src/libpython_clj/jna/concrete/type.clj
+++ b/src/libpython_clj/jna/concrete/type.clj
@@ -7,7 +7,7 @@
                      size-t-type
                      *python-library*]
              :as libpy-base]
-            [tech.jna :as jna])
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyMethodDef PyTypeObject PyObject]))
 
diff --git a/src/libpython_clj/jna/concrete/unicode.clj b/src/libpython_clj/jna/concrete/unicode.clj
index 683b84c..e44000c 100644
--- a/src/libpython_clj/jna/concrete/unicode.clj
+++ b/src/libpython_clj/jna/concrete/unicode.clj
@@ -7,8 +7,9 @@
                      find-pylib-symbol
                      *python-library*]
              :as libpy-base]
-            [tech.jna :as jna]
-            [tech.v3.datatype :as dtype])
+            [tech.v3.jna :as jna]
+            [tech.v3.datatype :as dtype]
+            [tech.v3.datatype.nio-buffer :as nio-buffer])
   (:import [com.sun.jna Pointer]
            [com.sun.jna.ptr PointerByReference
             LongByReference IntByReference]
@@ -27,7 +28,7 @@
   Signature:
   PyObject* (const char *s, Py_ssize_t size, const char *encoding, const char *errors)"
   ^Pointer [s size encoding errors]
-  (DirectMapped/PyUnicode_Decode (dtype/->nio-buffer s)
+  (DirectMapped/PyUnicode_Decode (nio-buffer/->nio-buffer s)
                                  (jna/size-t size)
                                  (str encoding)
                                  (str errors)))
diff --git a/src/libpython_clj/jna/interpreter.clj b/src/libpython_clj/jna/interpreter.clj
index 9f58c3a..7cdb26b 100644
--- a/src/libpython_clj/jna/interpreter.clj
+++ b/src/libpython_clj/jna/interpreter.clj
@@ -9,8 +9,7 @@
                      find-pylib-symbol
                      *python-library*]
              :as libpy-base]
-            [tech.jna.base :as jna-base]
-            [tech.jna :as jna]
+            [tech.v3.jna :as jna]
             [libpython-clj.jna.protocols.object :as pyobj]
             [libpython-clj.jna.concrete.unicode :as pyuni]
             [camel-snake-kebab.core :refer [->kebab-case]]
@@ -273,7 +272,7 @@
    the Py_BEGIN_ALLOW_THREADS and Py_END_ALLOW_THREADS macros is acceptable.
 
    The return value is an opaque “handle” to the thread state when PyGILState_Ensure()
-   was called, and must be passed to PyGILState_Release() to ensure Python is left in 
+   was called, and must be passed to PyGILState_Release() to ensure Python is left in
    the same state. Even though recursive calls are allowed, these handles cannot be shared -
    each unique call to PyGILState_Ensure() must save the handle for its call to PyGILState_Release().
 
diff --git a/src/libpython_clj/jna/protocols/buffer.clj b/src/libpython_clj/jna/protocols/buffer.clj
index 835e6e8..66d94f3 100644
--- a/src/libpython_clj/jna/protocols/buffer.clj
+++ b/src/libpython_clj/jna/protocols/buffer.clj
@@ -7,8 +7,8 @@
                      size-t-type
                      *python-library*]
              :as libpy-base]
-            [tech.jna :as jna]
-            [tech.v3.datatype :as dtype])
+            [tech.v3.jna :as jna]
+            [tech.v3.datatype.nio-buffer :as nio-buffer])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyBuffer]))
 
@@ -102,7 +102,7 @@
 
    This function fails if len != src->len."
   Integer
-  [buf dtype/as-nio-buffer]
+  [buf nio-buffer/as-nio-buffer]
   [src (partial jna/ensure-type PyBuffer)]
   [len jna/size-t]
   [order byte])
diff --git a/src/libpython_clj/jna/protocols/iterator.clj b/src/libpython_clj/jna/protocols/iterator.clj
index 2e73fa8..c28c8a7 100644
--- a/src/libpython_clj/jna/protocols/iterator.clj
+++ b/src/libpython_clj/jna/protocols/iterator.clj
@@ -6,8 +6,7 @@
                      ensure-pydict
                      size-t-type
                      *python-library*]
-             :as libpy-base]
-            [tech.jna :as jna])
+             :as libpy-base])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject]))
 
diff --git a/src/libpython_clj/jna/protocols/mapping.clj b/src/libpython_clj/jna/protocols/mapping.clj
index d97fc98..ff9ebcc 100644
--- a/src/libpython_clj/jna/protocols/mapping.clj
+++ b/src/libpython_clj/jna/protocols/mapping.clj
@@ -6,8 +6,7 @@
                      ensure-pydict
                      size-t-type
                      *python-library*]
-             :as libpy-base]
-            [tech.jna :as jna])
+             :as libpy-base])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject]))
 
diff --git a/src/libpython_clj/jna/protocols/object.clj b/src/libpython_clj/jna/protocols/object.clj
index 061b949..3ad78aa 100644
--- a/src/libpython_clj/jna/protocols/object.clj
+++ b/src/libpython_clj/jna/protocols/object.clj
@@ -8,8 +8,6 @@
                      size-t-type
                      *python-library*]
              :as libpy-base]
-            [tech.jna.base :as jna-base]
-            [tech.jna :as jna]
             [camel-snake-kebab.core :refer [->kebab-case]])
   (:import [com.sun.jna Pointer Native NativeLibrary]
            [com.sun.jna.ptr PointerByReference]
diff --git a/src/libpython_clj/jna/protocols/sequence.clj b/src/libpython_clj/jna/protocols/sequence.clj
index b3d67b9..8a77b8f 100644
--- a/src/libpython_clj/jna/protocols/sequence.clj
+++ b/src/libpython_clj/jna/protocols/sequence.clj
@@ -7,7 +7,7 @@
                      size-t-type
                      *python-library*]
              :as libpy-base]
-            [tech.jna :as jna])
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna Pointer]
            [libpython_clj.jna PyObject DirectMapped]))
 
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
index 338ab16..c5b21f1 100644
--- a/src/libpython_clj/python.clj
+++ b/src/libpython_clj/python.clj
@@ -10,7 +10,7 @@
             [libpython-clj.jna :as libpy]
             ;;Protocol implementations purely for nd-ness
             [libpython-clj.python.np-array]
-            [tech.jna :as jna])
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna Pointer]
            [com.sun.jna.ptr PointerByReference]
            [java.lang.reflect Field]
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
index bfef85a..fecf9c1 100644
--- a/src/libpython_clj/python/bridge.clj
+++ b/src/libpython_clj/python/bridge.clj
@@ -42,11 +42,10 @@
               create-bridge-from-att-map]]
             [libpython-clj.python.gc :as pygc]
             [clojure.stacktrace :as st]
-            [tech.jna :as jna]
+            [tech.v3.jna :as jna]
             [tech.v3.tensor :as dtt]
             [tech.v3.datatype.protocols :as dtype-proto]
             [tech.v3.datatype.casting :as casting]
-            [tech.v3.datatype.functional :as dtype-fn]
             [tech.v3.datatype.argops :as argops]
             [tech.v3.datatype :as dtype]
             [clojure.set :as c-set]
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
index d1b4eb0..9e9990a 100644
--- a/src/libpython_clj/python/interop.clj
+++ b/src/libpython_clj/python/interop.clj
@@ -19,10 +19,10 @@
               conj-forever!]
              :as pyinterp]
             [clojure.stacktrace :as st]
-            [tech.jna :as jna]
+            [tech.v3.jna :as jna]
             ;;need memset
             [tech.v3.datatype.native-buffer :as native-buffer]
-            [tech.resource :as resource]
+            [tech.v3.resource :as resource]
             [libpython-clj.python.object
              :refer [wrap-pyobject incref-wrap-pyobject
                      incref
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 1ecb42a..7306a9c 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -4,7 +4,7 @@
             [libpython-clj.python.gc :as pygc]
             [libpython-clj.python.logging
              :refer [log-error log-warn log-info]]
-            [tech.jna :as jna]
+            [tech.v3.jna :as jna]
             [clojure.java.shell :refer [sh]]
             [clojure.java.io :as io]
             [clojure.string :as s]
@@ -464,9 +464,8 @@ print(json.dumps(
       (setup-direct-mapping!)
       ;;Set program name
       (when-let [program-name (or program-name executable "")]
-        (pygc/with-stack-context
-          (libpy/PySys_SetArgv 0 (-> program-name
-                                     (jna/string->wide-ptr))))))
+        (libpy/PySys_SetArgv 0 (-> program-name
+                                   (jna/string->wide-ptr)))))
     (let [type-symbols (libpy/lookup-type-symbols)
           context (do
                     (libpy-base/set-gil-thread-id!
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
index 4d32869..352ec97 100644
--- a/src/libpython_clj/python/object.clj
+++ b/src/libpython_clj/python/object.clj
@@ -35,7 +35,7 @@
             [libpython-clj.jna :as libpy]
             [libpython-clj.python.gc :as pygc]
             [clojure.stacktrace :as st]
-            [tech.jna :as jna]
+            [tech.v3.jna :as jna]
             [tech.v3.datatype :as dtype]
             [tech.v3.datatype.protocols :as dtype-proto]
             [tech.v3.datatype.casting :as casting]
diff --git a/test/libpython_clj/classes_test.clj b/test/libpython_clj/classes_test.clj
index e68d7cc..9ce4a32 100644
--- a/test/libpython_clj/classes_test.clj
+++ b/test/libpython_clj/classes_test.clj
@@ -1,8 +1,6 @@
 (ns libpython-clj.classes-test
   (:require [libpython-clj.python :as py]
-            [libpython-clj.jna :as pylib]
             [clojure.test :refer :all]
-            [clojure.pprint :as pp]
             [clojure.edn :as edn]))
 
 
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj/python_test.clj
index ca4edfd..6a4cb0a 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj/python_test.clj
@@ -4,7 +4,7 @@
             [tech.v3.datatype :as dtype]
             [tech.v3.datatype.functional :as dfn]
             [tech.v3.tensor :as dtt]
-            [tech.jna :as jna]
+            [tech.v3.jna :as jna]
             [clojure.test :refer :all])
   (:import [java.io StringWriter]
            [java.util Map List]
diff --git a/test/libpython_clj/stress_test.clj b/test/libpython_clj/stress_test.clj
index 615c709..73b5356 100644
--- a/test/libpython_clj/stress_test.clj
+++ b/test/libpython_clj/stress_test.clj
@@ -60,8 +60,6 @@ def getmultidata():
 ;;related things causes immediate failure.  Unless you feel like being pedantic,
 ;;this isn't necessary.  The python library automatically switches to normal gc-only
 ;;mode if a resource context is open.
-(alter-var-root #'tech.resource.stack/*resource-context*
-                (constantly nil))
 
 (deftest forever-test
   (doseq [items (take 10 (partition 999 (get-data)))]

From 0d22c1f487bff54fbc2f71317780dfb933b7857d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 24 Oct 2020 14:21:43 -0600
Subject: [PATCH 242/456] 2.00-alpha-3

---
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj.python.html           | 6 +++---
 docs/libpython-clj.python.np-array.html  | 2 +-
 docs/libpython-clj.require.html          | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 project.clj                              | 2 +-
 src/libpython_clj/jna/concrete/bytes.clj | 6 +++---
 11 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index f69b4ea..487bd9f 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 6710c14..f9a7acb 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index d944bec..ee7f63b 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-2</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-2"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-3</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-3"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
index 60911a2..8b848b2 100644
--- a/docs/libpython-clj.python.html
+++ b/docs/libpython-clj.python.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1120">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1119">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
 <p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L352">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L608">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L553">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L105">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1126">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L118">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L727">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L607">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L552">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L104">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1125">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L117">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L726">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
 <p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L365">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L583">view source</a></div></div><div class="public anchor" id="var-create-bridge-from-att-map"><h3>create-bridge-from-att-map</h3><div class="usage"><code>(create-bridge-from-att-map src-item att-map)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/interop.clj#L377">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap will be presented as instance methods. Things in the cls hashmap had better be either atoms or already converted python objects. You may get surprised otherwise; you have been warned. See the classes-test file in test/libpython-clj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L573">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir item)</code></div><div class="doc"><div class="markdown"><p>Get sorted list of all attribute names.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-equals.3F"><h3>equals?</h3><div class="usage"><code>(equals? lhs rhs)</code></div><div class="doc"><div class="markdown"><p>Returns true of the python equals operator returns 1.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1127">view source</a></div></div><div class="public anchor" id="var-finalize.21"><h3>finalize!</h3><div class="usage"><code>(finalize!)</code></div><div class="doc"><div class="markdown"><p>Finalize the interpreter. You probably shouldn’t call this as it destroys the global interpreter and reinitialization is unsupported cpython.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L264">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L421">view source</a></div></div><div class="public anchor" id="var-gc.21"><h3>gc!</h3><div class="usage"><code>(gc!)</code></div><div class="doc"><div class="markdown"><p>Run the system garbage collection facility and then call the cooperative ‘cleanup python objects’ queue</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L342">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr item item-name)</code></div><div class="doc"><div class="markdown"><p>Get attribute from object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item item item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item of a given name from an object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? item item-name)</code></div><div class="doc"><div class="markdown"><p>Return true of object has attribute</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? item item-name)</code></div><div class="doc"><div class="markdown"><p>Return true of object has item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-hash-code"><h3>hash-code</h3><div class="usage"><code>(hash-code py-inst)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1121">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L412">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L209">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [program-name library-path python-home no-io-redirect? python-executable windows-anaconda-activate-bat]})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is provided, then the python :library-path Library path of the python library to use. :program-name - optional but will show up in error messages from python. :no-io-redirect - there if you don’t want python stdout and stderr redirection  to <em>out</em> and <em>err</em>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-type)</code></div><div class="doc"><div class="markdown"><p>Returns true if inst is an instance of type. False otherwise.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1111">view source</a></div></div><div class="public anchor" id="var-len"><h3>len</h3><div class="usage"><code>(len item)</code></div><div class="doc"><div class="markdown"><p>Call the <strong>len</strong> attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-libpython-clj-module-name"><h3>libpython-clj-module-name</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Module name of the libpython-clj python model. Used to find binding-level objects such as the type used for actual jvm bridging objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/interop.clj#L69">view source</a></div></div><div class="public anchor" id="var-make-tuple-fn"><h3>make-tuple-fn</h3><div class="usage"><code>(make-tuple-fn fn-obj &amp; {:keys [arg-converter result-converter], :or {arg-converter -&gt;jvm, result-converter -&gt;python-incref}, :as options})</code></div><div class="doc"><div class="markdown"><p>Given a clojure function, create a python tuple function. arg-convert is applied to arguments before the clojure function gets them and result-converter is applied to the outbound result. Exceptions are caught, logged, and propagated to python.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L582">view source</a></div></div><div class="public anchor" id="var-create-bridge-from-att-map"><h3>create-bridge-from-att-map</h3><div class="usage"><code>(create-bridge-from-att-map src-item att-map)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/interop.clj#L377">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap will be presented as instance methods. Things in the cls hashmap had better be either atoms or already converted python objects. You may get surprised otherwise; you have been warned. See the classes-test file in test/libpython-clj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L573">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir item)</code></div><div class="doc"><div class="markdown"><p>Get sorted list of all attribute names.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-equals.3F"><h3>equals?</h3><div class="usage"><code>(equals? lhs rhs)</code></div><div class="doc"><div class="markdown"><p>Returns true of the python equals operator returns 1.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1127">view source</a></div></div><div class="public anchor" id="var-finalize.21"><h3>finalize!</h3><div class="usage"><code>(finalize!)</code></div><div class="doc"><div class="markdown"><p>Finalize the interpreter. You probably shouldn’t call this as it destroys the global interpreter and reinitialization is unsupported cpython.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L264">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L421">view source</a></div></div><div class="public anchor" id="var-gc.21"><h3>gc!</h3><div class="usage"><code>(gc!)</code></div><div class="doc"><div class="markdown"><p>Run the system garbage collection facility and then call the cooperative ‘cleanup python objects’ queue</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L342">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr item item-name)</code></div><div class="doc"><div class="markdown"><p>Get attribute from object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item item item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item of a given name from an object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? item item-name)</code></div><div class="doc"><div class="markdown"><p>Return true of object has attribute</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? item item-name)</code></div><div class="doc"><div class="markdown"><p>Return true of object has item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-hash-code"><h3>hash-code</h3><div class="usage"><code>(hash-code py-inst)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1121">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L412">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L209">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [program-name library-path python-home no-io-redirect? python-executable windows-anaconda-activate-bat]})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is provided, then the python :library-path Library path of the python library to use. :program-name - optional but will show up in error messages from python. :no-io-redirect - there if you don’t want python stdout and stderr redirection  to <em>out</em> and <em>err</em>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-type)</code></div><div class="doc"><div class="markdown"><p>Returns true if inst is an instance of type. False otherwise.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L1111">view source</a></div></div><div class="public anchor" id="var-len"><h3>len</h3><div class="usage"><code>(len item)</code></div><div class="doc"><div class="markdown"><p>Call the <strong>len</strong> attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-libpython-clj-module-name"><h3>libpython-clj-module-name</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Module name of the libpython-clj python model. Used to find binding-level objects such as the type used for actual jvm bridging objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/interop.clj#L69">view source</a></div></div><div class="public anchor" id="var-make-tuple-fn"><h3>make-tuple-fn</h3><div class="usage"><code>(make-tuple-fn fn-obj &amp; {:keys [arg-converter result-converter], :or {arg-converter -&gt;jvm, result-converter -&gt;python-incref}, :as options})</code></div><div class="doc"><div class="markdown"><p>Given a clojure function, create a python tuple function. arg-convert is applied to arguments before the clojure function gets them and result-converter is applied to the outbound result. Exceptions are caught, logged, and propagated to python.</p>
 <p>arg-converter: A function to be called on arguments before they get to  clojure. Defaults to -&gt;jvm. result-converter: A function to be called on the return value before it  makes it back to python. Defaults to -&gt;python-incref. method-name: Name of function exposed to python. documentation: Documentation of function exposed to python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L484">view source</a></div></div><div class="public anchor" id="var-make-tuple-instance-fn"><h3>make-tuple-instance-fn</h3><div class="usage"><code>(make-tuple-instance-fn clj-fn &amp; {:keys [arg-converter], :as options})</code></div><div class="doc"><div class="markdown"><p>Make an instance function. In this case the default behavior is to pass raw python object ptr args to the clojure function without marshalling as that can add confusion and unnecessary overhead. Self will be the first argument. Callers can change this behavior by setting the ‘arg-converter’ option as in ‘make-tuple-fn’. Options are the same as make-tuple-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L553">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict module)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary. Returns bridge.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-ptr-refcnt"><h3>ptr-refcnt</h3><div class="usage"><code>(ptr-refcnt item)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L257">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
diff --git a/docs/libpython-clj.python.np-array.html b/docs/libpython-clj.python.np-array.html
index d861e14..5a6b925 100644
--- a/docs/libpython-clj.python.np-array.html
+++ b/docs/libpython-clj.python.np-array.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.require.html b/docs/libpython-clj.require.html
index 0c85385..1ddcbc1 100644
--- a/docs/libpython-clj.require.html
+++ b/docs/libpython-clj.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index cc97df8..784ad65 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index ab2438c..079f9d2 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index eed107b..f85c877 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 0a737d1..04ae774 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-alpha-3-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-alpha-3"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
diff --git a/src/libpython_clj/jna/concrete/bytes.clj b/src/libpython_clj/jna/concrete/bytes.clj
index 7d982a8..d091821 100644
--- a/src/libpython_clj/jna/concrete/bytes.clj
+++ b/src/libpython_clj/jna/concrete/bytes.clj
@@ -8,8 +8,8 @@
                      size-t-type
                      *python-library*]
              :as libpy-base]
-            [tech.v3.datatype :as dtype]
-            [tech.jna :as jna])
+            [tech.v3.datatype.nio-buffer :as nio-buffer]
+            [tech.v3.jna :as jna])
   (:import [com.sun.jna Pointer]))
 
 
@@ -45,7 +45,7 @@
    success, and NULL on failure. If v is NULL, the contents of the bytes object are
    uninitialized."
   Pointer
-  [v dtype/->nio-buffer]
+  [v nio-buffer/->nio-buffer]
   [len jna/size-t])
 
 

From cd8ad34b8b9b36d471aa64ee9e5d0580ec0404e3 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 24 Oct 2020 14:21:53 -0600
Subject: [PATCH 243/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 04ae774..8bbb639 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-alpha-3"
+(defproject clj-python/libpython-clj "2.00-alpha-4-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From ff8bc4179f8b1b7962f0c83fd8586e6fc75fa7d4 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 25 Oct 2020 09:29:34 -0600
Subject: [PATCH 244/456] 2.00-alpha-4

---
 docs/Usage.html                         | 2 +-
 docs/design.html                        | 2 +-
 docs/index.html                         | 2 +-
 docs/libpython-clj.python.html          | 2 +-
 docs/libpython-clj.python.np-array.html | 2 +-
 docs/libpython-clj.require.html         | 2 +-
 docs/new-to-clojure.html                | 2 +-
 docs/scopes-and-gc.html                 | 2 +-
 docs/slicing.html                       | 2 +-
 project.clj                             | 4 ++--
 10 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index 487bd9f..7cbf489 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index f9a7acb..4a2a42d 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index ee7f63b..afc0134 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-3</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-3"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-4</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-4"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
index 8b848b2..4eec3ed 100644
--- a/docs/libpython-clj.python.html
+++ b/docs/libpython-clj.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1119">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1119">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
 <p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L352">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L607">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L552">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L104">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1125">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L117">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L726">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
 <p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L365">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
diff --git a/docs/libpython-clj.python.np-array.html b/docs/libpython-clj.python.np-array.html
index 5a6b925..bfbac05 100644
--- a/docs/libpython-clj.python.np-array.html
+++ b/docs/libpython-clj.python.np-array.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.require.html b/docs/libpython-clj.require.html
index 1ddcbc1..e248807 100644
--- a/docs/libpython-clj.require.html
+++ b/docs/libpython-clj.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 784ad65..1dcd3b3 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 079f9d2..ceae5d7 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index f85c877..d84bdd7 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 8bbb639..b0fe5bb 100644
--- a/project.clj
+++ b/project.clj
@@ -1,11 +1,11 @@
-(defproject clj-python/libpython-clj "2.00-alpha-4-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-alpha-4"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2-alpha2"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.00-alpha-11"]
+                 [cnuernber/dtype-next   "6.00-alpha-12"]
                  [techascent/tech.jna    "4.02"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]]}

From e1a7f037bcdc0d9fa392d039cf54b16b4bbfa343 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 25 Oct 2020 09:29:46 -0600
Subject: [PATCH 245/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index b0fe5bb..9cfb0a3 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-alpha-4"
+(defproject clj-python/libpython-clj "2.00-alpha-5-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From d08d0a4c77601cdd2e3604ff21d70aa82c88a4ef Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 25 Oct 2020 09:41:18 -0600
Subject: [PATCH 246/456] 2.00-alpha-5

---
 docs/Usage.html                         | 2 +-
 docs/design.html                        | 2 +-
 docs/index.html                         | 2 +-
 docs/libpython-clj.python.html          | 2 +-
 docs/libpython-clj.python.np-array.html | 2 +-
 docs/libpython-clj.require.html         | 2 +-
 docs/new-to-clojure.html                | 2 +-
 docs/scopes-and-gc.html                 | 2 +-
 docs/slicing.html                       | 2 +-
 project.clj                             | 4 ++--
 10 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index 7cbf489..9c3dfac 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 4a2a42d..c6c3b46 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index afc0134..f2880f2 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-4</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-4"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-5</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-5"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
index 4eec3ed..9b1bb43 100644
--- a/docs/libpython-clj.python.html
+++ b/docs/libpython-clj.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1119">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1119">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
 <p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L352">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L607">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L552">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L104">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1125">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L117">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L726">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
 <p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L365">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
diff --git a/docs/libpython-clj.python.np-array.html b/docs/libpython-clj.python.np-array.html
index bfbac05..6aaafdb 100644
--- a/docs/libpython-clj.python.np-array.html
+++ b/docs/libpython-clj.python.np-array.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.require.html b/docs/libpython-clj.require.html
index e248807..99563d4 100644
--- a/docs/libpython-clj.require.html
+++ b/docs/libpython-clj.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 1dcd3b3..0a12f5c 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index ceae5d7..26eaa29 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index d84bdd7..a7f639d 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 9cfb0a3..81963b6 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-alpha-5-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-alpha-5"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
@@ -6,7 +6,7 @@
   :dependencies [[org.clojure/clojure    "1.10.2-alpha2"]
                  [camel-snake-kebab      "0.4.0"]
                  [cnuernber/dtype-next   "6.00-alpha-12"]
-                 [techascent/tech.jna    "4.02"]
+                 [techascent/tech.jna    "4.04"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]]}
              :codox

From b217de6bdbe2c3d590acade1f23cb82c98031beb Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 25 Oct 2020 09:41:25 -0600
Subject: [PATCH 247/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 81963b6..104552f 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-alpha-5"
+(defproject clj-python/libpython-clj "2.00-alpha-6-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 91f58f7802e473c122fd7c8e6370a734f5edd90e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 25 Oct 2020 13:51:20 -0600
Subject: [PATCH 248/456] upgrade dtype and test

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 104552f..82e344e 100644
--- a/project.clj
+++ b/project.clj
@@ -5,7 +5,7 @@
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2-alpha2"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.00-alpha-12"]
+                 [cnuernber/dtype-next   "6.00-alpha-13"]
                  [techascent/tech.jna    "4.04"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]]}

From dbb0e36a5211cfbfac9a34c4eb5d973f55d2c61c Mon Sep 17 00:00:00 2001
From: sogaiu <983021772@users.noreply.github.com>
Date: Sat, 7 Nov 2020 10:32:34 +0900
Subject: [PATCH 249/456] Add clj-kondo hooks

---
 .../clj-python/libpython-clj/config.edn       | 13 +++
 .../libpython_clj/jna/base/def_pylib_fn.clj   | 83 +++++++++++++++++++
 .../libpython_clj/require/import_python.clj   | 75 +++++++++++++++++
 3 files changed, 171 insertions(+)
 create mode 100644 resources/clj-kondo.exports/clj-python/libpython-clj/config.edn
 create mode 100644 resources/clj-kondo.exports/clj-python/libpython-clj/hooks/libpython_clj/jna/base/def_pylib_fn.clj
 create mode 100644 resources/clj-kondo.exports/clj-python/libpython-clj/hooks/libpython_clj/require/import_python.clj

diff --git a/resources/clj-kondo.exports/clj-python/libpython-clj/config.edn b/resources/clj-kondo.exports/clj-python/libpython-clj/config.edn
new file mode 100644
index 0000000..cab3e49
--- /dev/null
+++ b/resources/clj-kondo.exports/clj-python/libpython-clj/config.edn
@@ -0,0 +1,13 @@
+{:hooks
+ {:analyze-call {libpython-clj.jna.base/def-pylib-fn
+                 hooks.libpython-clj.jna.base.def-pylib-fn/def-pylib-fn
+                 libpython-clj.require/import-python
+                 hooks.libpython-clj.require.import-python/import-python}}
+  :linters {:unused-namespace {:exclude [builtins.list
+                                         builtins.dict
+                                         builtins.set
+                                         builtins.tuple
+                                         builtins.frozenset
+                                         builtins.str
+                                         builtins]}}
+}
diff --git a/resources/clj-kondo.exports/clj-python/libpython-clj/hooks/libpython_clj/jna/base/def_pylib_fn.clj b/resources/clj-kondo.exports/clj-python/libpython-clj/hooks/libpython_clj/jna/base/def_pylib_fn.clj
new file mode 100644
index 0000000..bac1e09
--- /dev/null
+++ b/resources/clj-kondo.exports/clj-python/libpython-clj/hooks/libpython_clj/jna/base/def_pylib_fn.clj
@@ -0,0 +1,83 @@
+;; XXX: work on export-symbols from tech.parallel.utils?
+(ns hooks.libpython-clj.jna.base.def-pylib-fn
+  "The def-pylib-fn macro from libpython-clj/jna/base.clj"
+  (:require [clj-kondo.hooks-api :as api]))
+
+;; from: libpython-clj/jna/base.clj
+
+;; (defmacro def-pylib-fn
+;;   [fn-name docstring rettype & argpairs]
+;;   `(defn ~fn-name
+;;      ~docstring
+;;      ~(mapv first argpairs)
+;;      (when-not (== (current-thread-id) (.get ^AtomicLong gil-thread-id))
+;;        (throw (Exception. "Failure to capture gil when calling into libpython")))
+;;      (let [~'tvm-fn (jna/find-function ~(str fn-name) *python-library*)
+;;            ~'fn-args (object-array
+;;                       ~(mapv (fn [[arg-symbol arg-coersion]]
+;;                                (when (= arg-symbol arg-coersion)
+;;                                  (throw (ex-info (format "Argument symbol (%s) cannot match coersion (%s)"
+;;                                                          arg-symbol arg-coersion)
+;;                                                  {})))
+;;                                `(~arg-coersion ~arg-symbol))
+;;                              argpairs))]
+;;        ~(if rettype
+;;           `(.invoke (jna-base/to-typed-fn ~'tvm-fn) ~rettype ~'fn-args)
+;;           `(.invoke (jna-base/to-typed-fn ~'tvm-fn) ~'fn-args)))))
+
+;; called like:
+
+;; (def-pylib-fn PyImport_AddModule
+;;  "Return value: Borrowed reference.
+;;
+;;   Similar to PyImport_AddModuleObject(), but the name is a UTF-8 encoded string instead
+;;   of a Unicode object."
+;;  Pointer
+;;  [name str])
+
+(defn def-pylib-fn
+  "Macro in libpython-clj/jna/base.clj.
+
+  Example call:
+
+    (def-pylib-fn PyImport_AddModule
+      \"Return value: Borrowed reference.
+
+       Similar to PyImport_AddModuleObject(), but the name is a UTF-8 ...
+       of a Unicode object.\"
+      Pointer
+      [name str])
+
+  This has the form:
+
+    (def-pylib-fn fn-name docstring rettype & argpairs)
+
+  May be treating it as:
+
+    (defn fn-name
+      [arg1 arg2 ,,, argn]
+      [arg1 arg2 ,,, argn]) ; fake usage of args?
+
+  where arg1, ..., argn are extracted from argpairs is acceptable.
+
+  XXX: using the second elements of argpairs might be worth doing
+       to avoid unused warnings.
+
+  "
+  [{:keys [:node]}]
+  (let [[_ fn-name _ _ & argpairs] (:children node)
+        pairs (map (fn [vec-node]
+                     (let [[an-arg a-type] (:children vec-node)]
+                       [an-arg a-type]))
+                   argpairs)
+        new-node (with-meta (api/list-node
+                               (apply concat
+                                      [(api/token-node 'defn)
+                                       fn-name
+                                       (api/vector-node (map first pairs))]
+                                      pairs))
+                     (meta node))]
+    ;; XXX: uncomment following and run clj-kondo on cl_format.clj to debug
+    ;;(prn (api/sexpr node))
+    ;;(prn (api/sexpr new-node))
+    {:node new-node}))
diff --git a/resources/clj-kondo.exports/clj-python/libpython-clj/hooks/libpython_clj/require/import_python.clj b/resources/clj-kondo.exports/clj-python/libpython-clj/hooks/libpython_clj/require/import_python.clj
new file mode 100644
index 0000000..c6089d3
--- /dev/null
+++ b/resources/clj-kondo.exports/clj-python/libpython-clj/hooks/libpython_clj/require/import_python.clj
@@ -0,0 +1,75 @@
+(ns hooks.libpython-clj.require.import-python
+  "The import-python macro from libpython-clj/require.clj"
+  (:require [clj-kondo.hooks-api :as api]))
+
+;; from: libpython-clj/require.clj
+
+;; (defn import-python
+;;   "Loads python, python.list, python.dict, python.set, python.tuple,
+;;   and python.frozenset."
+;;   []
+;;   (require-python
+;;    '(builtins
+;;      [list :as python.list]
+;;      [dict :as python.dict]
+;;      [set :as python.set]
+;;      [tuple :as python.tuple]
+;;      [frozenset :as python.frozenset]
+;;      [str :as python.str])
+;;    '[builtins :as python])
+;;   :ok)
+
+;; alternative:
+;;
+;; (require
+;;   (quote [builtins.list :as python.list])
+;;   (quote [builtins.dict :as python.dict])
+;;   (quote [builtins.set :as python.set])
+;;   (quote [builtins.tuple :as python.tuple])
+;;   (quote [builtins.frozenset :as python.frozenset])
+;;   (quote [builtins.str :as python.str])
+;;   (quote [builtins :as python]))
+
+(defn make-require
+  [ns-sym alias-sym]
+  (api/list-node
+   [(api/token-node 'require)
+    (api/list-node
+     [(api/token-node 'quote)
+      (api/vector-node
+       [(api/token-node ns-sym)
+        (api/keyword-node :as)
+        (api/token-node alias-sym)])])]))
+
+(defn import-python
+  "Macro in libpython-clj/require.clj.
+
+  Example call:
+
+    (import-python)
+
+  May be treating it as:
+
+   (do
+     (require (quote [builtins.list :as python.list]))
+     (require (quote [builtins.dict :as python.dict]))
+     ,,,
+     )
+
+  "
+  [{:keys [:node]}]
+  (let [new-node
+        (with-meta (api/list-node
+                    [(api/token-node 'do)
+                     (make-require 'builtins.list 'python.list)
+                     (make-require 'builtins.dict 'python.dict)
+                     (make-require 'builtins.set 'python.set)
+                     (make-require 'builtins.tuple 'python.tuple)
+                     (make-require 'builtins.frozenset 'python.frozenset)
+                     (make-require 'builtins.str 'python.str)
+                     (make-require 'builtins 'python)])
+                   (meta node))]
+    ;; XXX: uncomment following and run clj-kondo on cl_format.clj to debug
+    ;;(prn (api/sexpr node))
+    ;;(prn (api/sexpr new-node))
+    {:node new-node}))

From c2aaed604cad70831154bce28b488d8a5702e43f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 14 Nov 2020 16:01:43 -0700
Subject: [PATCH 250/456] Upgrade to latest dtype.

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 82e344e..39d505e 100644
--- a/project.clj
+++ b/project.clj
@@ -5,7 +5,7 @@
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2-alpha2"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.00-alpha-13"]
+                 [cnuernber/dtype-next   "6.00-beta-1"]
                  [techascent/tech.jna    "4.04"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]]}

From 417cc6e6a4e02cfb4de1bc2f9ddb2d75bfaf97c2 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 24 Nov 2020 06:34:21 -0700
Subject: [PATCH 251/456] Fixes #137

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 9c9308a..320f88e 100644
--- a/README.md
+++ b/README.md
@@ -123,7 +123,7 @@ user> test-ary
  [3 4]]
 ```
 
-We have a [document](docs/Usage.md) on all the features but beginning usage is
+We have a [document](topics/Usage.md) on all the features but beginning usage is
 pretty simple.  Import your modules, use the things from Clojure.  We have put
 effort into making sure things like sequences and ranges transfer between the two
 languages.
@@ -152,8 +152,8 @@ our test [docker containers](dockerfiles/CondaDockerfile).
 * Clojure Conj 2019 [video](https://www.youtube.com/watch?v=vQPW16_jixs) and
   [slides](https://docs.google.com/presentation/d/1uegYhpS6P2AtEfhpg6PlgBmTSIPqCXvFTWcGYG_Qk2o/edit?usp=sharing).
 * [development discussion forum](https://clojurians.zulipchat.com/#narrow/stream/215609-libpython-clj-dev)
-* [design documentation](docs/design.md)
-* [scope and garbage collection docs](https://github.com/cnuernber/libpython-clj/blob/master/docs/scopes-and-gc.md)
+* [design documentation](topics/design.md)
+* [scope and garbage collection docs](topics/scopes-and-gc.md)
 * [examples](https://github.com/gigasquid/libpython-clj-examples)
 * [docker setup](https://github.com/scicloj/docker-hub)
 * [pandas bindings (!!)](https://github.com/alanmarazzi/panthera)
@@ -167,7 +167,7 @@ our test [docker containers](dockerfiles/CondaDockerfile).
 
 New to Clojure or the JVM?  Try remixing the nextjournal entry and playing around
 there.  For more resources on learning and getting more comfortable with Clojure,
-we have an [introductory document](docs/new-to-clojure.md).
+we have an [introductory document](topics/new-to-clojure.md).
 
 
 ## Resources

From 11a0bcf3c12adecca14258604d609470613604d2 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 24 Nov 2020 06:36:42 -0700
Subject: [PATCH 252/456] docs->topics

---
 README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 9c9308a..f9a4fce 100644
--- a/README.md
+++ b/README.md
@@ -20,7 +20,7 @@
   use some Java in your Python.
 * Python objects are linked to the JVM GC such that when they are no longer reachable
   from the JVM their references are released.  Scope based resource contexts are
-  [also available](https://github.com/cnuernber/libpython-clj/blob/master/docs/scopes-and-gc.md).
+  [also available](topics/scopes-and-gc.md).
 * Finding the python libraries is done dynamically allowing one system to run on multiple versions
   of python.
 * REPL oriented design means fast, smooth, iterative development.
@@ -123,7 +123,7 @@ user> test-ary
  [3 4]]
 ```
 
-We have a [document](docs/Usage.md) on all the features but beginning usage is
+We have a [document](topics/Usage.md) on all the features but beginning usage is
 pretty simple.  Import your modules, use the things from Clojure.  We have put
 effort into making sure things like sequences and ranges transfer between the two
 languages.
@@ -152,8 +152,8 @@ our test [docker containers](dockerfiles/CondaDockerfile).
 * Clojure Conj 2019 [video](https://www.youtube.com/watch?v=vQPW16_jixs) and
   [slides](https://docs.google.com/presentation/d/1uegYhpS6P2AtEfhpg6PlgBmTSIPqCXvFTWcGYG_Qk2o/edit?usp=sharing).
 * [development discussion forum](https://clojurians.zulipchat.com/#narrow/stream/215609-libpython-clj-dev)
-* [design documentation](docs/design.md)
-* [scope and garbage collection docs](https://github.com/cnuernber/libpython-clj/blob/master/docs/scopes-and-gc.md)
+* [design documentation](topics/design.md)
+* [scope and garbage collection docs](topics/scopes-and-gc.md)
 * [examples](https://github.com/gigasquid/libpython-clj-examples)
 * [docker setup](https://github.com/scicloj/docker-hub)
 * [pandas bindings (!!)](https://github.com/alanmarazzi/panthera)
@@ -167,7 +167,7 @@ our test [docker containers](dockerfiles/CondaDockerfile).
 
 New to Clojure or the JVM?  Try remixing the nextjournal entry and playing around
 there.  For more resources on learning and getting more comfortable with Clojure,
-we have an [introductory document](docs/new-to-clojure.md).
+we have an [introductory document](topics/new-to-clojure.md).
 
 
 ## Resources

From dce96f5371e80a5e0a9b20051fcc151ddfbb2c0f Mon Sep 17 00:00:00 2001
From: vijay edwin <vedwin.dev@gmail.com>
Date: Fri, 27 Nov 2020 07:43:04 -0800
Subject: [PATCH 253/456] 
 https://github.com/clj-python/libpython-clj/issues/138 (#139)

Co-authored-by: Vijay Edwin <vedwin@Vijays-MacBook-Pro.local>
---
 src/libpython_clj/python/interpreter.clj | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 7306a9c..210666f 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -94,6 +94,7 @@ print(json.dumps(
         ;;   ..: mac and windows are for sys.platform
         :linux   "libpython%s.%sm?.so$"
         :mac     "libpython%s.%sm?.dylib$"
+        :darwin  "libpython%s.%sm?.dylib$"
         :win32   "python%s%s.dll$")
       major minor))))
 

From 40e64a885e655d49c3e2bec938eacf9676302d05 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 3 Dec 2020 10:56:36 -0700
Subject: [PATCH 254/456] 2.00-alpha-6

---
 docs/Usage.html                         | 2 +-
 docs/design.html                        | 2 +-
 docs/index.html                         | 2 +-
 docs/libpython-clj.python.html          | 2 +-
 docs/libpython-clj.python.np-array.html | 2 +-
 docs/libpython-clj.require.html         | 2 +-
 docs/new-to-clojure.html                | 2 +-
 docs/scopes-and-gc.html                 | 2 +-
 docs/slicing.html                       | 2 +-
 project.clj                             | 4 ++--
 10 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index 9c3dfac..172e035 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index c6c3b46..d6dfacf 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index f2880f2..16c55ef 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-5</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-5"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-6</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-6"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
index 9b1bb43..2601321 100644
--- a/docs/libpython-clj.python.html
+++ b/docs/libpython-clj.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1119">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1119">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
 <p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L352">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L607">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L552">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L104">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1125">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L117">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L726">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
 <p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L365">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
diff --git a/docs/libpython-clj.python.np-array.html b/docs/libpython-clj.python.np-array.html
index 6aaafdb..e3650ec 100644
--- a/docs/libpython-clj.python.np-array.html
+++ b/docs/libpython-clj.python.np-array.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.require.html b/docs/libpython-clj.require.html
index 99563d4..7dc3cde 100644
--- a/docs/libpython-clj.require.html
+++ b/docs/libpython-clj.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 0a12f5c..1b4731c 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 26eaa29..a0841ab 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index a7f639d..e3c435f 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 39d505e..291a97b 100644
--- a/project.clj
+++ b/project.clj
@@ -1,11 +1,11 @@
-(defproject clj-python/libpython-clj "2.00-alpha-6-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-alpha-6"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2-alpha2"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.00-beta-1"]
+                 [cnuernber/dtype-next   "6.00-beta-9"]
                  [techascent/tech.jna    "4.04"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]]}

From 9e5526270271f84428cb68b430e5ac231dbe246a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 3 Dec 2020 10:56:42 -0700
Subject: [PATCH 255/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 291a97b..e3b113e 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-alpha-6"
+(defproject clj-python/libpython-clj "2.00-alpha-7-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 48286607b2cb7a270f02f1dfa1996d9deba260f6 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 12 Dec 2020 09:17:02 -0700
Subject: [PATCH 256/456] edit

---
 README.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f9a4fce..23851cc 100644
--- a/README.md
+++ b/README.md
@@ -142,10 +142,14 @@ the `libpython3.Xm.so` shared library so for example if we are loading python
 3.6 we look for `libpython3.6m.so` on Linux or `libpython3.6m.dylib` on the Mac.
 
 This pathway has allowed us support Conda albeit with some work.  For examples
-using Conda, check out the facial rec repository above or look into how we
+using Conda, check out the facial rec repository a)bove or look into how we
 [build](scripts/build-conda-docker)
 our test [docker containers](dockerfiles/CondaDockerfile).
 
+## Community
+
+We like to talk about libpython-clj on [Zulip](https://clojurians.zulipchat.com/#streams/215609/libpython-clj-dev) as the conversations are persistent and searchable.
+
 
 ## Further Information
 

From 226dc11ad5a55b366e9a76f60eac4d6624801fac Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 27 Dec 2020 15:29:33 -0700
Subject: [PATCH 257/456] 2.00-alpha-7

---
 docs/Usage.html                         | 2 +-
 docs/design.html                        | 2 +-
 docs/index.html                         | 2 +-
 docs/libpython-clj.python.html          | 2 +-
 docs/libpython-clj.python.np-array.html | 2 +-
 docs/libpython-clj.require.html         | 2 +-
 docs/new-to-clojure.html                | 2 +-
 docs/scopes-and-gc.html                 | 2 +-
 docs/slicing.html                       | 2 +-
 project.clj                             | 4 ++--
 10 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index 172e035..b205016 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index d6dfacf..085c058 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index 16c55ef..465e531 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-6</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-6"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-7</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-7"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.python.html b/docs/libpython-clj.python.html
index 2601321..23daa5d 100644
--- a/docs/libpython-clj.python.html
+++ b/docs/libpython-clj.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1119">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2 current"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.html#var-.24."><div class="inner"><span>$.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24.."><div class="inner"><span>$..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Enumpy"><div class="inner"><span>-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-float"><div class="inner"><span>-&gt;py-float</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-fn"><div class="inner"><span>-&gt;py-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-long"><div class="inner"><span>-&gt;py-long</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-string"><div class="inner"><span>-&gt;py-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var--.3Epython-incref"><div class="inner"><span>-&gt;python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-a.24"><div class="inner"><span>a$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-args-.3Epos-kw-args"><div class="inner"><span>args-&gt;pos-kw-args</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-numpy"><div class="inner"><span>as-numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-as-python-incref"><div class="inner"><span>as-python-incref</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-att-type-map"><div class="inner"><span>att-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-c.24"><div class="inner"><span>c$</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call"><div class="inner"><span>call</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-call-kw"><div class="inner"><span>call-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-bridge-from-att-map"><div class="inner"><span>create-bridge-from-att-map</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-equals.3F"><div class="inner"><span>equals?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-finalize.21"><div class="inner"><span>finalize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-gc.21"><div class="inner"><span>gc!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-hash-code"><div class="inner"><span>hash-code</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-libpython-clj-module-name"><div class="inner"><span>libpython-clj-module-name</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-fn"><div class="inner"><span>make-tuple-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-ptr-refcnt"><div class="inner"><span>ptr-refcnt</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler"><div class="inner"><span>python-pyerr-fetch-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-run-string"><div class="inner"><span>run-string</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-exit-error-handler"><div class="inner"><span>with-exit-error-handler</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python</h1><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="public anchor" id="var-.24."><h3>$.</h3><h4 class="type">macro</h4><div class="usage"><code>($. item attname)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L396">view source</a></div></div><div class="public anchor" id="var-.24.."><h3>$..</h3><h4 class="type">macro</h4><div class="usage"><code>($.. item attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Get the attribute of an object. If there are extra args, apply successive get-attribute calls to the arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L402">view source</a></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L378">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Copy an object into the jvm (if it wasn’t there already.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L91">view source</a></div></div><div class="public anchor" id="var--.3Enumpy"><h3>-&gt;numpy</h3><div class="usage"><code>(-&gt;numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Convert an object to numpy throwing an error if this isn’t possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1119">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict item)</code></div><div class="doc"><div class="markdown"><p>Create a python dictionary</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L135">view source</a></div></div><div class="public anchor" id="var--.3Epy-float"><h3>-&gt;py-float</h3><div class="usage"><code>(-&gt;py-float item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python float</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L283">view source</a></div></div><div class="public anchor" id="var--.3Epy-fn"><h3>-&gt;py-fn</h3><div class="usage"><code>(-&gt;py-fn item)</code></div><div class="doc"><div class="markdown"><p>Make a python function. If clojure function is passed in the arguments are marshalled from python to clojure, the function called, and the return value will be marshalled back.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L156">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list item)</code></div><div class="doc"><div class="markdown"><p>Create a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L142">view source</a></div></div><div class="public anchor" id="var--.3Epy-long"><h3>-&gt;py-long</h3><div class="usage"><code>(-&gt;py-long item)</code></div><div class="doc"><div class="markdown"><p>Convert an object into a python long</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-string"><h3>-&gt;py-string</h3><div class="usage"><code>(-&gt;py-string item)</code></div><div class="doc"><div class="markdown"><p>Copy an object into a python string</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L291">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple item)</code></div><div class="doc"><div class="markdown"><p>Create a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L149">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Completely convert a jvm object to a python copy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L213">view source</a></div></div><div class="public anchor" id="var--.3Epython-incref"><h3>-&gt;python-incref</h3><div class="usage"><code>(-&gt;python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. This is necessary for return values from functions as the -&gt;python pathway adds a reference but it also tracks it and releases it when it is not in use any more. Thus python ends up holding onto something with fewer refcounts than it should have. If you are just messing around in the repl you only need -&gt;python. There is an expectation that the return value of a function call is a new reference and not a borrowed reference hence this pathway.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/object.clj#L470">view source</a></div></div><div class="public anchor" id="var-a.24"><h3>a$</h3><h4 class="type">macro</h4><div class="usage"><code>(a$ item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Similar calling conventions to afn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p>
 <p>DEPRECATION POSSIBLE - use $a.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L352">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. Returns a bridge</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L607">view source</a></div></div><div class="public anchor" id="var-args-.3Epos-kw-args"><h3>args-&gt;pos-kw-args</h3><div class="usage"><code>(args-&gt;pos-kw-args arglist)</code></div><div class="doc"><div class="markdown"><p>Utility function that, given a list of arguments, separates them into positional and keyword arguments. Throws an exception if the keyword argument is not followed by any more arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L552">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L104">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list item)</code></div><div class="doc"><div class="markdown"><p>Return a List implementation using <strong>getitem</strong>, <strong>setitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map item)</code></div><div class="doc"><div class="markdown"><p>Return a Map implementation using <strong>getitem</strong>, <strong>setitem</strong>. Note that it may be incomplete especially if the object has no ‘keys’ attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-as-numpy"><h3>as-numpy</h3><div class="usage"><code>(as-numpy item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge an object into numpy sharing the backing store. If it is not possible to do this without copying data then return nil.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L1125">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python item &amp; [options])</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm object into python</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L117">view source</a></div></div><div class="public anchor" id="var-as-python-incref"><h3>as-python-incref</h3><div class="usage"><code>(as-python-incref item)</code></div><div class="doc"><div class="markdown"><p>Convert to python and add a reference. Necessary for return values from functions as python expects a new reference and the as-python pathway ensures the jvm garbage collector also sees the reference.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/bridge.clj#L726">view source</a></div></div><div class="public anchor" id="var-att-type-map"><h3>att-type-map</h3><div class="usage"><code>(att-type-map item)</code></div><div class="doc"><div class="markdown"><p>Get hashmap of att name to keyword datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-c.24"><h3>c$</h3><h4 class="type">macro</h4><div class="usage"><code>(c$ item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Similar calling conventions to cfn except: Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p>
 <p>DEPRECATION POSSIBLE - use $c.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L365">view source</a></div></div><div class="public anchor" id="var-call"><h3>call</h3><div class="usage"><code>(call callable &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with positional args. For keyword args, see call-kw.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L109">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr item att-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with positional arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L120">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw item att-name arglist kw-map)</code></div><div class="doc"><div class="markdown"><p>Call an object attribute with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L127">view source</a></div></div><div class="public anchor" id="var-call-kw"><h3>call-kw</h3><div class="usage"><code>(call-kw callable arglist kw-args)</code></div><div class="doc"><div class="markdown"><p>Call a python function with a vector of positional args and a map of keyword args.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/protocols.clj#L115">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? item)</code></div><div class="doc"><div class="markdown"><p>Return true if object is a python callable object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python.clj#L27">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
diff --git a/docs/libpython-clj.python.np-array.html b/docs/libpython-clj.python.np-array.html
index e3650ec..a1971cb 100644
--- a/docs/libpython-clj.python.np-array.html
+++ b/docs/libpython-clj.python.np-array.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.python.np-array.html#var-np-mod*"><div class="inner"><span>np-mod*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="public anchor" id="var-np-mod*"><h3>np-mod*</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Delay that dereferences to the python numpy module</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/python/np_array.clj#L77">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj.require.html b/docs/libpython-clj.require.html
index 7dc3cde..6226394 100644
--- a/docs/libpython-clj.require.html
+++ b/docs/libpython-clj.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj/require.clj#L291">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 1b4731c..25f8226 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index a0841ab..14b514e 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index e3c435f..8019215 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index e3b113e..b7a83fe 100644
--- a/project.clj
+++ b/project.clj
@@ -1,11 +1,11 @@
-(defproject clj-python/libpython-clj "2.00-alpha-7-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-alpha-7"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2-alpha2"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.00-beta-9"]
+                 [cnuernber/dtype-next   "6.00-beta-11"]
                  [techascent/tech.jna    "4.04"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]]}

From 9db1be612265efdfcc636707f54d120139a8f4cc Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 27 Dec 2020 15:29:42 -0700
Subject: [PATCH 258/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index b7a83fe..1372683 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-alpha-7"
+(defproject clj-python/libpython-clj "2.00-alpha-8-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From fd373ce5c5661e20dfa1324d0a1f63a4f535b6a9 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 29 Dec 2020 10:55:36 -0700
Subject: [PATCH 259/456] Edit

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 23851cc..be785e1 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# JNA libpython bindings to the tech ecosystem.
+# JNA libpython bindings to Clojure.
 
 ### Version Info
 

From f69073352e50dda0b1f4ba0671c6db245573de37 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 5 Feb 2021 15:20:40 -0700
Subject: [PATCH 260/456] Upgrade to 6.00 of dtype-next

---
 project.clj | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/project.clj b/project.clj
index 1372683..1beae34 100644
--- a/project.clj
+++ b/project.clj
@@ -3,9 +3,9 @@
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
-  :dependencies [[org.clojure/clojure    "1.10.2-alpha2"]
+  :dependencies [[org.clojure/clojure    "1.10.2" :scope "provided"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.00-beta-11"]
+                 [cnuernber/dtype-next   "6.00"]
                  [techascent/tech.jna    "4.04"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]]}

From aaf919c2f04d51b165ead9ff31da43ebb2fa2df7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 5 Feb 2021 16:15:31 -0700
Subject: [PATCH 261/456] Reducing interpreter scope

---
 src/libpython_clj/python/interpreter.clj | 26 +++++++++++++-----------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
index 210666f..3155d2f 100644
--- a/src/libpython_clj/python/interpreter.clj
+++ b/src/libpython_clj/python/interpreter.clj
@@ -366,18 +366,20 @@ print(json.dumps(
   [& body]
   `(do
      (let [interp# (ensure-interpreter)]
-       (locking interp#
-         (let [^AtomicLong bound-thread# libpy-base/gil-thread-id
-               previously-bound-thread-id# (.get bound-thread#)
-               thread-id# (libpy-base/current-thread-id)
-               gil-state# (when-not (== thread-id# previously-bound-thread-id#)
-                            (acquire-gil!))]
-           (try
-             ~@body
-             (finally
-               (when gil-state#
-                 (pygc/clear-reference-queue)
-                 (release-gil! gil-state# previously-bound-thread-id#)))))))))
+       (let [[previously-bound-thread-id# gil-state#]
+             (locking interp#
+               (let [^AtomicLong bound-thread# libpy-base/gil-thread-id
+                     previously-bound-thread-id# (.get bound-thread#)
+                     thread-id# (libpy-base/current-thread-id)
+                     gil-state# (when-not (== thread-id# previously-bound-thread-id#)
+                                  (acquire-gil!))]
+                 [previously-bound-thread-id# gil-state#]))]
+         (try
+           ~@body
+           (finally
+             (when gil-state#
+               (pygc/clear-reference-queue)
+               (release-gil! gil-state# previously-bound-thread-id#))))))))
 
 
 (defonce ^:dynamic *program-name* "")

From 0ff09a5e419f254e2500217f5c1c16bd10b23330 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 2 Mar 2021 08:36:25 -0700
Subject: [PATCH 262/456] V2 (#147)

* Carefully working through initialization.

* jdk-16 testing :-)

* Working through ABI issues.

* Adding 32bit analysis

* Starting down 32bit compat testing.

* Adding type kwd caching.

* Lots of work bringing the system up.

* Updating dtype-next and have 'dir' working

* Simple dict working.

* Unpacking dicts and lists,tuples is working.

* Error handling.

* Most of copying done and working on function bridging.

* defining python functions somewhat works.

* Started work on bridging.

* Lots of fixes and bridging *from* python works atm.

* Lots additions pulling the good parts of bridging over.

* Starting to carry tests across.

* Fixing initialization so loading local modules works.

* Unit tests passing again :-).

* Have just a couple more tests.

* All tests pass :-).

* v2 passes unit tests.

* Fix leaking tuple refcount && avoid looking up atts we don't use.

* Re-working how custom classes work.

* Major refactoring to greatly reduce GC interactions.

* Attempting to get more test feedback

* Turned on vastly more logging...

* Adding single test and working from there.

* test-golf

* Fixing unittest issues.

* Adding a few more tests back.

* The big daddy, require-python.  If this passes we are doing quite well.

* Final bit of tests.

* Disable debug tracing

* Carrying perf enhancements across from v1.

* Commenting namespaces
---
 .gitignore                                    |    4 +-
 .travis.yml                                   |    3 +
 docs/Usage.html                               |    2 +-
 docs/design.html                              |    2 +-
 docs/index.html                               |    2 +-
 docs/libpython-clj2.python.html               |   63 +
 docs/libpython-clj2.python.np-array.html      |    4 +
 docs/new-to-clojure.html                      |    2 +-
 docs/scopes-and-gc.html                       |    2 +-
 docs/slicing.html                             |    2 +-
 project.clj                                   |   16 +-
 questions/32bit.txt                           |   13 +
 questions/64bit.txt                           |   17 +
 questions/compile32.sh                        |    1 +
 questions/compile64.sh                        |    1 +
 questions/typeobject.cpp                      |   23 +
 src/libpython_clj/export_module_symbols.clj   |   29 -
 src/libpython_clj/jna.clj                     |  421 ------
 src/libpython_clj/jna/base.clj                |  115 --
 src/libpython_clj/jna/concrete/bytes.clj      |  109 --
 src/libpython_clj/jna/concrete/cfunction.clj  |   76 --
 src/libpython_clj/jna/concrete/code.clj       |   33 -
 src/libpython_clj/jna/concrete/dict.clj       |  235 ----
 src/libpython_clj/jna/concrete/err.clj        |  337 -----
 src/libpython_clj/jna/concrete/import.clj     |  130 --
 src/libpython_clj/jna/concrete/list.clj       |  128 --
 src/libpython_clj/jna/concrete/module.clj     |  124 --
 .../jna/concrete/numeric/boolean.clj          |   38 -
 .../jna/concrete/numeric/complex.clj          |   57 -
 .../jna/concrete/numeric/float.clj            |   65 -
 .../jna/concrete/numeric/integer.clj          |  100 --
 src/libpython_clj/jna/concrete/set.clj        |   92 --
 src/libpython_clj/jna/concrete/tuple.clj      |   59 -
 src/libpython_clj/jna/concrete/type.clj       |  137 --
 src/libpython_clj/jna/concrete/unicode.clj    |   87 --
 src/libpython_clj/jna/interpreter.clj         |  400 ------
 src/libpython_clj/jna/protocols/buffer.clj    |  108 --
 src/libpython_clj/jna/protocols/iterator.clj  |   31 -
 src/libpython_clj/jna/protocols/mapping.clj   |  118 --
 src/libpython_clj/jna/protocols/object.clj    |  409 ------
 src/libpython_clj/jna/protocols/sequence.clj  |  178 ---
 src/libpython_clj/py_modules/numpy.clj        |   15 -
 src/libpython_clj/python.clj                  |  539 --------
 src/libpython_clj/python/bridge.clj           | 1129 ----------------
 src/libpython_clj/python/gc.clj               |   67 -
 src/libpython_clj/python/interop.clj          |  444 -------
 src/libpython_clj/python/interpreter.clj      |  532 --------
 src/libpython_clj/python/logging.clj          |   35 -
 src/libpython_clj/python/np_array.clj         |  114 --
 src/libpython_clj/python/object.clj           | 1133 -----------------
 src/libpython_clj/python/protocols.clj        |  182 ---
 .../metadata.clj                              |   92 +-
 src/libpython_clj2/python.clj                 |  575 +++++++++
 src/libpython_clj2/python/base.clj            |  190 +++
 src/libpython_clj2/python/bridge_as_jvm.clj   |  435 +++++++
 .../python/bridge_as_python.clj               |  252 ++++
 src/libpython_clj2/python/class.clj           |  155 +++
 src/libpython_clj2/python/copy.clj            |  328 +++++
 src/libpython_clj2/python/dechunk_map.clj     |   11 +
 src/libpython_clj2/python/ffi.clj             |  883 +++++++++++++
 src/libpython_clj2/python/fn.clj              |  218 ++++
 src/libpython_clj2/python/gc.clj              |   85 ++
 src/libpython_clj2/python/info.clj            |  107 ++
 src/libpython_clj2/python/io_redirect.clj     |   55 +
 src/libpython_clj2/python/jvm_handle.clj      |   69 +
 src/libpython_clj2/python/np_array.clj        |  198 +++
 src/libpython_clj2/python/protocols.clj       |   91 ++
 .../python/windows.clj                        |   10 +-
 src/libpython_clj2/python/with.clj            |   63 +
 .../require.clj                               |   54 +-
 .../sugar.clj                                 |    6 +-
 test/libpython_clj/classes_test.clj           |   52 -
 test/libpython_clj2/classes_test.clj          |   42 +
 test/libpython_clj2/ffi_test.clj              |   36 +
 .../fncall_test.clj                           |   11 +-
 .../iter_gen_seq_test.clj                     |    6 +-
 .../python => libpython_clj2}/numpy_test.clj  |    7 +-
 .../python_test.clj                           |  116 +-
 .../require_python_test.clj                   |   14 +-
 .../stress_test.clj                           |   56 +-
 .../sugar_test.clj                            |    7 +-
 81 files changed, 4127 insertions(+), 8060 deletions(-)
 create mode 100644 docs/libpython-clj2.python.html
 create mode 100644 docs/libpython-clj2.python.np-array.html
 create mode 100644 questions/32bit.txt
 create mode 100644 questions/64bit.txt
 create mode 100755 questions/compile32.sh
 create mode 100755 questions/compile64.sh
 delete mode 100644 src/libpython_clj/export_module_symbols.clj
 delete mode 100644 src/libpython_clj/jna.clj
 delete mode 100644 src/libpython_clj/jna/base.clj
 delete mode 100644 src/libpython_clj/jna/concrete/bytes.clj
 delete mode 100644 src/libpython_clj/jna/concrete/cfunction.clj
 delete mode 100644 src/libpython_clj/jna/concrete/code.clj
 delete mode 100644 src/libpython_clj/jna/concrete/dict.clj
 delete mode 100644 src/libpython_clj/jna/concrete/err.clj
 delete mode 100644 src/libpython_clj/jna/concrete/import.clj
 delete mode 100644 src/libpython_clj/jna/concrete/list.clj
 delete mode 100644 src/libpython_clj/jna/concrete/module.clj
 delete mode 100644 src/libpython_clj/jna/concrete/numeric/boolean.clj
 delete mode 100644 src/libpython_clj/jna/concrete/numeric/complex.clj
 delete mode 100644 src/libpython_clj/jna/concrete/numeric/float.clj
 delete mode 100644 src/libpython_clj/jna/concrete/numeric/integer.clj
 delete mode 100644 src/libpython_clj/jna/concrete/set.clj
 delete mode 100644 src/libpython_clj/jna/concrete/tuple.clj
 delete mode 100644 src/libpython_clj/jna/concrete/type.clj
 delete mode 100644 src/libpython_clj/jna/concrete/unicode.clj
 delete mode 100644 src/libpython_clj/jna/interpreter.clj
 delete mode 100644 src/libpython_clj/jna/protocols/buffer.clj
 delete mode 100644 src/libpython_clj/jna/protocols/iterator.clj
 delete mode 100644 src/libpython_clj/jna/protocols/mapping.clj
 delete mode 100644 src/libpython_clj/jna/protocols/object.clj
 delete mode 100644 src/libpython_clj/jna/protocols/sequence.clj
 delete mode 100644 src/libpython_clj/py_modules/numpy.clj
 delete mode 100644 src/libpython_clj/python.clj
 delete mode 100644 src/libpython_clj/python/bridge.clj
 delete mode 100644 src/libpython_clj/python/gc.clj
 delete mode 100644 src/libpython_clj/python/interop.clj
 delete mode 100644 src/libpython_clj/python/interpreter.clj
 delete mode 100644 src/libpython_clj/python/logging.clj
 delete mode 100644 src/libpython_clj/python/np_array.clj
 delete mode 100644 src/libpython_clj/python/object.clj
 delete mode 100644 src/libpython_clj/python/protocols.clj
 rename src/{libpython_clj => libpython_clj2}/metadata.clj (84%)
 create mode 100644 src/libpython_clj2/python.clj
 create mode 100644 src/libpython_clj2/python/base.clj
 create mode 100644 src/libpython_clj2/python/bridge_as_jvm.clj
 create mode 100644 src/libpython_clj2/python/bridge_as_python.clj
 create mode 100644 src/libpython_clj2/python/class.clj
 create mode 100644 src/libpython_clj2/python/copy.clj
 create mode 100644 src/libpython_clj2/python/dechunk_map.clj
 create mode 100644 src/libpython_clj2/python/ffi.clj
 create mode 100644 src/libpython_clj2/python/fn.clj
 create mode 100644 src/libpython_clj2/python/gc.clj
 create mode 100644 src/libpython_clj2/python/info.clj
 create mode 100644 src/libpython_clj2/python/io_redirect.clj
 create mode 100644 src/libpython_clj2/python/jvm_handle.clj
 create mode 100644 src/libpython_clj2/python/np_array.clj
 create mode 100644 src/libpython_clj2/python/protocols.clj
 rename src/{libpython_clj => libpython_clj2}/python/windows.clj (83%)
 create mode 100644 src/libpython_clj2/python/with.clj
 rename src/{libpython_clj => libpython_clj2}/require.clj (92%)
 rename src/{libpython_clj => libpython_clj2}/sugar.clj (90%)
 delete mode 100644 test/libpython_clj/classes_test.clj
 create mode 100644 test/libpython_clj2/classes_test.clj
 create mode 100644 test/libpython_clj2/ffi_test.clj
 rename test/{libpython_clj => libpython_clj2}/fncall_test.clj (82%)
 rename test/{libpython_clj => libpython_clj2}/iter_gen_seq_test.clj (83%)
 rename test/{libpython_clj/python => libpython_clj2}/numpy_test.clj (79%)
 rename test/{libpython_clj => libpython_clj2}/python_test.clj (79%)
 rename test/{libpython_clj => libpython_clj2}/require_python_test.clj (93%)
 rename test/{libpython_clj => libpython_clj2}/stress_test.clj (74%)
 rename test/{libpython_clj => libpython_clj2}/sugar_test.clj (93%)

diff --git a/.gitignore b/.gitignore
index 217fc6e..8cf6946 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,4 +11,6 @@ pom.xml.asc
 .hgignore
 .hg/
 __pycache__
-.cpcache/
\ No newline at end of file
+.cpcache/
+cpython
+a.out
\ No newline at end of file
diff --git a/.travis.yml b/.travis.yml
index 3883953..bad2cf7 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -14,3 +14,6 @@ addons:
   apt:
     update: true
 install: clojure -Sdescribe
+cache:
+  directories:
+    - "$HOME/.m2"
diff --git a/docs/Usage.html b/docs/Usage.html
index b205016..63a8655 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 085c058..13bca35 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index 465e531..53464ed 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-7</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-7"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj.python.html">libpython-clj.python</a></h3><div class="doc"><div class="markdown"><p>Base low-level namespace for accessing Python via Clojure. Higher level interfaces are found in libpython-clj.require specifically require-python and import-python.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.html#var-.24.">$.</a> </li><li> <a href="libpython-clj.python.html#var-.24..">$..</a> </li><li> <a href="libpython-clj.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj.python.html#var--.3Enumpy">-&gt;numpy</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-float">-&gt;py-float</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-fn">-&gt;py-fn</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-long">-&gt;py-long</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-string">-&gt;py-string</a> </li><li> <a href="libpython-clj.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj.python.html#var--.3Epython-incref">-&gt;python-incref</a> </li><li> <a href="libpython-clj.python.html#var-a.24">a$</a> </li><li> <a href="libpython-clj.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj.python.html#var-args-.3Epos-kw-args">args-&gt;pos-kw-args</a> </li><li> <a href="libpython-clj.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj.python.html#var-as-numpy">as-numpy</a> </li><li> <a href="libpython-clj.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj.python.html#var-as-python-incref">as-python-incref</a> </li><li> <a href="libpython-clj.python.html#var-att-type-map">att-type-map</a> </li><li> <a href="libpython-clj.python.html#var-c.24">c$</a> </li><li> <a href="libpython-clj.python.html#var-call">call</a> </li><li> <a href="libpython-clj.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj.python.html#var-call-kw">call-kw</a> </li><li> <a href="libpython-clj.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj.python.html#var-create-bridge-from-att-map">create-bridge-from-att-map</a> </li><li> <a href="libpython-clj.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj.python.html#var-equals.3F">equals?</a> </li><li> <a href="libpython-clj.python.html#var-finalize.21">finalize!</a> </li><li> <a href="libpython-clj.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj.python.html#var-gc.21">gc!</a> </li><li> <a href="libpython-clj.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj.python.html#var-hash-code">hash-code</a> </li><li> <a href="libpython-clj.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj.python.html#var-len">len</a> </li><li> <a href="libpython-clj.python.html#var-libpython-clj-module-name">libpython-clj-module-name</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-fn">make-tuple-fn</a> </li><li> <a href="libpython-clj.python.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj.python.html#var-ptr-refcnt">ptr-refcnt</a> </li><li> <a href="libpython-clj.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj.python.html#var-python-pyerr-fetch-error-handler">python-pyerr-fetch-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj.python.html#var-run-string">run-string</a> </li><li> <a href="libpython-clj.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj.python.html#var-with">with</a> </li><li> <a href="libpython-clj.python.html#var-with-exit-error-handler">with-exit-error-handler</a> </li><li> <a href="libpython-clj.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.python.np-array.html">libpython-clj.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.python.np-array.html#var-np-mod*">np-mod*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj.require.html">libpython-clj.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-8-SNAPSHOT</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-8-SNAPSHOT"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
new file mode 100644
index 0000000..e5dfadf
--- /dev/null
+++ b/docs/libpython-clj2.python.html
@@ -0,0 +1,63 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L429">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L440">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L216">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L287">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L281">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L124">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L410">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L222">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L210">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L147">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L153">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L258">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L399">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+<p>Example:</p>
+<pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
+nil
+user&gt; (def cls-obj (py/create-class
+                    "myfancyclass"
+                    nil
+                    {"__init__" (py/make-instance-fn
+                                 (fn [this arg]
+                                   (py/set-attr! this "arg" arg)
+                                   ;;If you don't return nil from __init__ that is an
+                                   ;;error.
+                                   nil))
+                     "addarg" (py/make-instance-fn
+                               (fn [this otherarg]
+                                 (+ (py/get-attr this "arg")
+                                    otherarg)))}))
+#'user/cls-obj
+user&gt; cls-obj
+__no_module__.myfancyclass
+user&gt; (def inst (cls-obj 10))
+#'user/inst
+user&gt; (py/call-attr inst "addarg" 10)
+20
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L364">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L142">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L158">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L184">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L178">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L113">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; [{:keys [windows-anaconda-activate-bat library-path no-io-redirect?]} options])</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+<p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
+<p>Options:</p>
+<ul>
+  <li><code>:library-path</code> - Library path of the python library to use.</li>
+  <li><code>:program-name</code> - Optional – will show up in error messages from python.</li>
+  <li><code>:no-io-redirect?</code> - True if you don’t want python stdout and stderr redirection  to <em>out</em> and <em>err</em>.</li>
+  <li><code>:python-executable</code> - The python executable to use to find system information.</li>
+  <li><code>:python-home</code> - Python home directory. The system first uses this variable, then  the environment variable PYTHON_HOME, and finally information returned from  python system info.</li>
+  <li><code>:signals?</code> - defaults to false - true if you want python to initialized signals.  Be aware that the JVM itself uses quite a few signals - SIGSEGV, for instance -  during it’s normal course of operation. For more information see:
+    <ul>
+      <li><a href="https://docs.oracle.com/javase/10/troubleshoot/handle-signals-and-exceptions.htm#JSTGD356">used signals</a></li>
+      <li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
+    </ul>
+  </li>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L23">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L246">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L326">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L350">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L133">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+<p>Usage:</p>
+<p>(py* obj method args kwargs)</p>
+<p>Example:</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L464">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L486">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L457">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L450">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
+<p>is equivalent to Python’s</p>
+<p>import sys sys.path.append(‘/home/user/bin’)</p>
+<p>SPECIAL SYNTAX for programmatic *args and **kwargs</p>
+<p>Special syntax is provided to meet the needs required by Python’s *args and **kwargs syntax programmatically.</p>
+<p>(= (py.. obj (*method args))  (py* obj methods args))</p>
+<p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
+<p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
+<p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L521">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L240">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
+<p>Globals, locals may be provided but are not necessary.</p>
+<p>Implemented in cpython as:</p>
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L293">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L164">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L171">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L190">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L77">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L421">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L90">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L99">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
new file mode 100644
index 0000000..d1a5aef
--- /dev/null
+++ b/docs/libpython-clj2.python.np-array.html
@@ -0,0 +1,4 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p>
+<p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L36">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L54">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L40">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L24">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 25f8226..29f7a7d 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 14b514e..1495a8b 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 8019215..b3088e9 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj</span></div></div></li><li class="depth-2"><a href="libpython-clj.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 1beae34..a65f78c 100644
--- a/project.clj
+++ b/project.clj
@@ -5,10 +5,14 @@
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2" :scope "provided"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.00"]
-                 [techascent/tech.jna    "4.04"]
+                 [cnuernber/dtype-next   "6.05"]
+                 [net.java.dev.jna/jna "5.7.0"]
                  [org.clojure/data.json  "1.0.0"]]
-  :profiles {:dev {:dependencies [[criterium "0.4.5"]]}
+  :profiles {:dev {:dependencies [[criterium "0.4.5"]
+                                  [ch.qos.logback/logback-classic "1.1.3"]]}
+             :jdk-16 {:jvm-opts ["--add-modules" "jdk.incubator.foreign"
+                                 "-Dforeign.restricted=permit"
+                                 "-Djava.library.path=/usr/lib/x86_64-linux-gnu"]}
              :codox
              {:dependencies [[codox-theme-rdash "0.1.2"]]
               :plugins [[lein-codox "0.10.7"]]
@@ -19,9 +23,9 @@
                       :output-path "docs"
                       :doc-paths ["topics"]
                       :source-uri "https://github.com/clj-python/libpython-clj/blob/master/{filepath}#L{line}"
-                      :namespaces [libpython-clj.python
-                                   libpython-clj.require
-                                   libpython-clj.python.np-array]}}}
+                      :namespaces [libpython-clj2.python
+                                   libpython-clj2.require
+                                   libpython-clj2.python.np-array]}}}
   :java-source-paths ["java"]
   :aliases {"codox" ["with-profile" "codox,dev" "codox"]}
 
diff --git a/questions/32bit.txt b/questions/32bit.txt
new file mode 100644
index 0000000..ae5615d
--- /dev/null
+++ b/questions/32bit.txt
@@ -0,0 +1,13 @@
+PyObject size: 8
+PyTypeObject size: 204
+type.tp_basicsize: 16
+type.tp_as_number: 48
+type.tp_as_buffer: 80
+type.tp_finalize: 196
+py_hash_t: 4
+Py_TPFLAGS_DEFAULT: 262144
+PyObject details
+object size: 8
+ob_refcnt offset: 0
+ob_type   offset: 4
+gilstate size: 4
diff --git a/questions/64bit.txt b/questions/64bit.txt
new file mode 100644
index 0000000..de4ccfc
--- /dev/null
+++ b/questions/64bit.txt
@@ -0,0 +1,17 @@
+PyObject size: 16
+PyTypeObject size: 408
+type.tp_basicsize: 32
+type.tp_as_number: 96
+type.tp_as_buffer: 160
+type.tp_finalize: 392
+py_hash_t: 8
+Py_TPFLAGS_DEFAULT: 262144
+PyObject details
+object size: 16
+ob_refcnt offset: 0
+ob_type   offset: 8
+gilstate size: 4
+PyMethodDef details
+object size: 32
+ml_flags offset: 16
+ml_doc   offset: 24
diff --git a/questions/compile32.sh b/questions/compile32.sh
new file mode 100755
index 0000000..8b9e315
--- /dev/null
+++ b/questions/compile32.sh
@@ -0,0 +1 @@
+g++ typeobject.cpp -I../cpython/Include -I../cpython/32bit
diff --git a/questions/compile64.sh b/questions/compile64.sh
new file mode 100755
index 0000000..c989f98
--- /dev/null
+++ b/questions/compile64.sh
@@ -0,0 +1 @@
+g++ typeobject.cpp -I../cpython/Include -I../cpython/64bit
diff --git a/questions/typeobject.cpp b/questions/typeobject.cpp
index f5b5a2b..c837361 100644
--- a/questions/typeobject.cpp
+++ b/questions/typeobject.cpp
@@ -26,4 +26,27 @@ int main(int c, char** v)
    sizeof(Py_hash_t),
    Py_TPFLAGS_DEFAULT
     );
+
+
+  printf(
+    "PyObject details\n"
+    "object size: %ld\n"
+    "ob_refcnt offset: %ld\n"
+    "ob_type   offset: %ld\n"
+    "gilstate size: %ld\n",
+    sizeof(PyObject),
+    offsetof(PyObject, ob_refcnt),
+    offsetof(PyObject, ob_type),
+    sizeof(PyGILState_STATE));
+
+
+    printf(
+    "PyMethodDef details\n"
+    "object size: %ld\n"
+    "ml_flags offset: %ld\n"
+    "ml_doc   offset: %ld\n",
+    sizeof(PyMethodDef),
+    offsetof(PyMethodDef, ml_flags),
+    offsetof(PyMethodDef, ml_doc));
+
 }
diff --git a/src/libpython_clj/export_module_symbols.clj b/src/libpython_clj/export_module_symbols.clj
deleted file mode 100644
index b6e48c4..0000000
--- a/src/libpython_clj/export_module_symbols.clj
+++ /dev/null
@@ -1,29 +0,0 @@
-(ns libpython-clj.export-module-symbols
-  "A macro that will export all the symbols from a python module and make
-  them functions in the current clojure namespace.
-
-  DEPRECATED - please use 'libpython-clj.require/require-python"
-  (:require [libpython-clj.python :as py]))
-
-
-(def primitive-types #{:float :int :bool :string})
-
-
-(defmacro export-module-symbols
-  "DEPRECATED - please use 'libpython-clj.require/require-python"
-  [py-mod-name]
-  (py/initialize!)
-  (let [mod-data (py/import-module py-mod-name)]
-    `(do ~@(->> (py/att-type-map mod-data)
-                (map (fn [[att-name att-type]]
-                       (let [att-value (py/get-attr mod-data att-name)
-                             doc-str (if (contains? primitive-types att-type)
-                                       (str py-mod-name "." att-value)
-                                       (try
-                                         (py/get-attr att-value "__doc__")
-                                         (catch Throwable e "")))]
-                         `(def ~(with-meta (symbol att-name)
-                                  {:doc doc-str
-                                   :py-module py-mod-name})
-                            (-> (py/import-module ~py-mod-name)
-                                (py/get-attr ~att-name))))))))))
diff --git a/src/libpython_clj/jna.clj b/src/libpython_clj/jna.clj
deleted file mode 100644
index 241ce7b..0000000
--- a/src/libpython_clj/jna.clj
+++ /dev/null
@@ -1,421 +0,0 @@
-(ns libpython-clj.jna
-  (:require [tech.v3.datatype.export-symbols :refer [export-symbols]]
-            [libpython-clj.jna.base :as libpy-base]
-            [libpython-clj.jna.interpreter :as jnainterp]
-            [libpython-clj.jna.protocols.object]
-            [libpython-clj.jna.protocols.iterator]
-            [libpython-clj.jna.protocols.sequence]
-            [libpython-clj.jna.protocols.mapping]
-            [libpython-clj.jna.protocols.buffer]
-            [libpython-clj.jna.concrete.numeric.integer]
-            [libpython-clj.jna.concrete.numeric.float]
-            [libpython-clj.jna.concrete.numeric.boolean]
-            [libpython-clj.jna.concrete.numeric.complex]
-            [libpython-clj.jna.concrete.tuple]
-            [libpython-clj.jna.concrete.list]
-            [libpython-clj.jna.concrete.set]
-            [libpython-clj.jna.concrete.dict]
-            [libpython-clj.jna.concrete.unicode]
-            [libpython-clj.jna.concrete.cfunction]
-            [libpython-clj.jna.concrete.import]
-            [libpython-clj.jna.concrete.module]
-            [libpython-clj.jna.concrete.type]
-            [libpython-clj.jna.concrete.err])
-  (:import [com.sun.jna Pointer NativeLibrary]))
-
-
-(export-symbols libpython-clj.jna.base
-                find-pylib-symbol
-                as-pyobj
-                ensure-pyobj)
-
-
-(export-symbols libpython-clj.jna.interpreter
-                PySys_SetArgv
-                Py_SetProgramName
-                Py_SetPythonHome
-                Py_InitializeEx
-                Py_IsInitialized
-                Py_FinalizeEx
-                PyRun_SimpleString
-                get-type-name
-                lookup-type-symbols
-                Py_None
-                Py_NotImplemented
-                PyMem_Free
-                PyGILState_Ensure
-                PyGILState_Release
-                PyGILState_Check
-                PyEval_RestoreThread
-                PyEval_SaveThread
-                PyThreadState_Get
-                PyThreadState_Swap
-                PyRun_String
-                PyRun_StringFlags)
-
-
-(defmacro ^:private export-type-symbols
-  []
-  `(do
-     ~@(->> (vals jnainterp/type-symbol-table)
-            (map (fn [sym-name]
-                   `(defn ~(symbol sym-name)
-                      ~(format "%s type object" sym-name)
-                      []
-                      (libpy-base/find-pylib-symbol ~sym-name)))))))
-
-
-(export-type-symbols)
-
-
-(export-symbols libpython-clj.jna.protocols.object
-                Py_DecRef
-                Py_IncRef
-                PyObject_Type
-                PyObject_Repr
-                PyObject_Str
-                PyObject_HasAttr
-                PyObject_HasAttrString
-                PyObject_GetAttr
-                PyObject_GetAttrString
-                PyObject_GenericGetAttr
-                PyObject_SetAttr
-                PyObject_SetAttrString
-                PyObject_GenericSetAttr
-                PyObject_DelAttr
-                PyObject_DelAttrString
-                PyObject_GenericGetDict
-                PyObject_GenericSetDict
-                PyObject_RichCompare
-                PyObject_RichCompareBool
-                PyCallable_Check
-                PyObject_Call
-                PyObject_CallObject
-                PyObject_Hash
-                PyObject_IsInstance
-                PyObject_IsTrue
-                PyObject_Not
-                PyObject_Length
-                PyObject_GetItem
-                PyObject_SetItem
-                PyObject_DelItem
-                PyObject_Dir
-                PyObject_GetIter)
-
-
-(export-symbols libpython-clj.jna.protocols.iterator
-                PyIter_Check
-                PyIter_Next)
-
-
-(export-symbols libpython-clj.jna.protocols.sequence
-                PySequence_Check
-                PySequence_Concat
-                PySequence_Contains
-                PySequence_Count
-                PySequence_DelItem
-                PySequence_DelSlice
-                PySequence_GetItem
-                PySequence_GetSlice
-                PySequence_InPlaceConcat
-                PySequence_InPlaceRepeat
-                PySequence_Index
-                PySequence_Length
-                PySequence_List
-                PySequence_Repeat
-                PySequence_SetItem
-                PySequence_SetSlice
-                PySequence_Tuple)
-
-
-(export-symbols libpython-clj.jna.protocols.mapping
-                PyMapping_Check
-                PyMapping_DelItem
-                PyMapping_DelItemString
-                PyMapping_GetItemString
-                PyMapping_HasKey
-                PyMapping_HasKeyString
-                PyMapping_Items
-                PyMapping_Keys
-                PyMapping_Length
-                PyMapping_SetItemString
-                PyMapping_Values)
-
-
-(export-symbols libpython-clj.jna.protocols.buffer
-                PyBUF_ANY_CONTIGUOUS
-                PyBUF_CONTIG
-                PyBUF_CONTIG_RO
-                PyBUF_C_CONTIGUOUS
-                PyBUF_FORMAT
-                PyBUF_FULL
-                PyBUF_FULL_RO
-                PyBUF_F_CONTIGUOUS
-                PyBUF_INDIRECT
-                PyBUF_MAX_NDIM
-                PyBUF_ND
-                PyBUF_READ
-                PyBUF_RECORDS
-                PyBUF_RECORDS_RO
-                PyBUF_SIMPLE
-                PyBUF_STRIDED
-                PyBUF_STRIDED_RO
-                PyBUF_STRIDES
-                PyBUF_WRITABLE
-                PyBUF_WRITE
-                PyBUF_WRITEABLE
-                PyBuffer_IsContiguous
-                PyBuffer_Release
-                PyBuffer_ToContiguous
-                PyObject_CheckBuffer
-                PyObject_GetBuffer)
-
-
-(export-symbols libpython-clj.jna.concrete.numeric.integer
-                PyLong_Check
-                PyLong_CheckExact
-                PyLong_FromLong
-                PyLong_FromUnsignedLong
-                PyLong_FromSsize_t
-                PyLong_FromLongLong
-                PyLong_FromUnsignedLongLong
-                PyLong_FromDouble
-                PyLong_AsLong
-                PyLong_AsLongLong)
-
-
-(export-symbols libpython-clj.jna.concrete.numeric.float
-                PyFloat_AsDouble
-                PyFloat_Check
-                PyFloat_CheckExact
-                PyFloat_FromDouble
-                PyFloat_FromString
-                PyFloat_GetInfo
-                PyFloat_GetMax
-                PyFloat_GetMin)
-
-
-(export-symbols libpython-clj.jna.concrete.numeric.boolean
-                PyBool_Check
-                PyBool_FromLong
-                Py_False
-                Py_True)
-
-
-(export-symbols libpython-clj.jna.concrete.numeric.complex
-                PyComplex_AsCComplex
-                PyComplex_Check
-                PyComplex_FromCComplex
-                PyComplex_FromDoubles
-                PyComplex_ImagAsDouble
-                PyComplex_RealAsDouble)
-
-
-(export-symbols libpython-clj.jna.concrete.tuple
-                PyTuple_Check
-                PyTuple_GetItem
-                PyTuple_GetSlice
-                PyTuple_New
-                PyTuple_SetItem)
-
-
-(export-symbols libpython-clj.jna.concrete.list
-                PyList_Append
-                PyList_AsTuple
-                PyList_Check
-                PyList_GetItem
-                PyList_GetSlice
-                PyList_Insert
-                PyList_New
-                PyList_Reverse
-                PyList_SetItem
-                PyList_SetSlice
-                PyList_Size
-                PyList_Sort)
-
-
-(export-symbols libpython-clj.jna.concrete.set
-                PyFrozenSet_Check
-                PyFrozenSet_New
-                PySet_Add
-                PySet_Check
-                PySet_Clear
-                PySet_Contains
-                PySet_Discard
-                PySet_New
-                PySet_Pop)
-
-
-(export-symbols libpython-clj.jna.concrete.dict
-                PyDictProxy_New
-                PyDict_Check
-                PyDict_Clear
-                PyDict_Contains
-                PyDict_Copy
-                PyDict_DelItem
-                PyDict_DelItemString
-                PyDict_GetItem
-                PyDict_GetItemString
-                PyDict_GetItemWithError
-                PyDict_Items
-                PyDict_Keys
-                PyDict_Merge
-                PyDict_MergeFromSeq2
-                PyDict_New
-                PyDict_Next
-                PyDict_SetDefault
-                PyDict_SetItem
-                PyDict_SetItemString
-                PyDict_Size
-                PyDict_Update
-                PyDict_Values)
-
-
-(export-symbols libpython-clj.jna.concrete.unicode
-                PyUnicode_AsEncodedString
-                PyUnicode_AsUTF8AndSize
-                PyUnicode_AsUTF8
-                PyUnicode_Decode)
-
-
-(export-symbols libpython-clj.jna.concrete.cfunction
-                METH_CLASS
-                METH_COEXIST
-                METH_KEYWORDS
-                METH_NOARGS
-                METH_O
-                METH_STATIC
-                METH_VARARGS
-                PyCFunction_NewEx
-                PyInstanceMethod_New)
-
-
-(export-symbols libpython-clj.jna.concrete.import
-                PyImport_ImportModule
-                PyImport_Import
-                PyImport_AddModule
-                PyImport_ImportModuleLevel
-                PyImport_GetModuleDict)
-
-
-(export-symbols libpython-clj.jna.concrete.type
-                PyObject_Del
-                PyType_Check
-                PyType_GenericNew
-                PyType_Ready
-                Py_TPFLAGS_BASETYPE
-                Py_TPFLAGS_DEFAULT
-                Py_TPFLAGS_HAVE_GC
-                Py_TPFLAGS_HAVE_STACKLESS_EXTENSION
-                Py_TPFLAGS_HAVE_VERSION_TAG
-                Py_TPFLAGS_HEAPTYPE
-                Py_TPFLAGS_IS_ABSTRACT
-                Py_TPFLAGS_READY
-                Py_TPFLAGS_READYING
-                Py_TPFLAGS_VALID_VERSION_TAG
-                _PyObject_New)
-
-
-(export-symbols libpython-clj.jna.concrete.module
-                PyModule_AddFunctions
-                PyModule_AddIntConstant
-                PyModule_AddObject
-                PyModule_AddStringConstant
-                PyModule_Check
-                PyModule_GetDef
-                PyModule_GetDict
-                PyModule_GetNameObject
-                PyModule_GetState
-                PyModule_New
-                PyModule_SetDocString)
-
-
-(export-symbols libpython-clj.jna.concrete.err
-                PyErr_BadArgument
-                PyErr_BadInternalCall
-                PyErr_Clear
-                PyErr_Fetch
-                PyErr_NoMemory
-                PyErr_Print
-                PyErr_PrintEx
-                PyErr_Restore
-                PyErr_SetFromErrno
-                PyErr_SetNone
-                PyErr_SetObject
-                PyErr_SetString
-                PyErr_WarnEx
-                PyErr_WarnExplicit
-                PyErr_WriteUnraisable
-                PyErr_Occurred
-                ;; Exception classes
-                PyExc_ArithmeticError
-                PyExc_AssertionError
-                PyExc_AttributeError
-                PyExc_BaseException
-                PyExc_BlockingIOError
-                PyExc_BrokenPipeError
-                PyExc_BufferError
-                PyExc_BytesWarning
-                PyExc_ChildProcessError
-                PyExc_ConnectionAbortedError
-                PyExc_ConnectionError
-                PyExc_ConnectionRefusedError
-                PyExc_ConnectionResetError
-                PyExc_DeprecationWarning
-                PyExc_EOFError
-                PyExc_Exception
-                PyExc_FileExistsError
-                PyExc_FileNotFoundError
-                PyExc_FloatingPointError
-                PyExc_FutureWarning
-                PyExc_GeneratorExit
-                PyExc_ImportError
-                PyExc_ImportWarning
-                PyExc_IndentationError
-                PyExc_IndexError
-                PyExc_InterruptedError
-                PyExc_IsADirectoryError
-                PyExc_KeyError
-                PyExc_KeyboardInterrupt
-                PyExc_LookupError
-                PyExc_MemoryError
-                PyExc_ModuleNotFoundError
-                PyExc_NameError
-                PyExc_NotADirectoryError
-                PyExc_NotImplementedError
-                PyExc_OSError
-                PyExc_OverflowError
-                PyExc_PendingDeprecationWarning
-                PyExc_PermissionError
-                PyExc_ProcessLookupError
-                PyExc_RecursionError
-                PyExc_ReferenceError
-                PyExc_ResourceWarning
-                PyExc_RuntimeError
-                PyExc_RuntimeWarning
-                PyExc_StopAsyncIteration
-                PyExc_StopIteration
-                PyExc_SyntaxError
-                PyExc_SyntaxWarning
-                PyExc_SystemError
-                PyExc_SystemExit
-                PyExc_TabError
-                PyExc_TimeoutError
-                PyExc_TypeError
-                PyExc_UnboundLocalError
-                PyExc_UnicodeDecodeError
-                PyExc_UnicodeEncodeError
-                PyExc_UnicodeError
-                PyExc_UnicodeTranslateError
-                PyExc_UnicodeWarning
-                PyExc_UserWarning
-                PyExc_ValueError
-                PyExc_Warning
-                PyExc_ZeroDivisionError
-                ;;Exception data system
-                PyException_GetCause
-                PyException_GetContext
-                PyException_GetTraceback
-                PyException_SetCause
-                PyException_SetContext
-                PyException_SetTraceback)
diff --git a/src/libpython_clj/jna/base.clj b/src/libpython_clj/jna/base.clj
deleted file mode 100644
index 1011fa9..0000000
--- a/src/libpython_clj/jna/base.clj
+++ /dev/null
@@ -1,115 +0,0 @@
-(ns libpython-clj.jna.base
-  (:require [tech.v3.jna :as jna]
-            [tech.v3.jna.base :as jna-base])
-  (:import [com.sun.jna Pointer NativeLibrary]
-           [libpython_clj.jna PyObject]
-           [java.util.concurrent.atomic AtomicLong]))
-
-(set! *warn-on-reflection* true)
-
-(def ^:dynamic *python-library* "python3.6m")
-
-(def ^:dynamic *python-library-names* ["python3.7m" "python3.6m"])
-
-
-(defn library-names
-  []
-  *python-library-names*)
-
-
-(defprotocol PToPyObjectPtr
-  (convertible-to-pyobject-ptr? [item])
-  (->py-object-ptr [item]))
-
-
-(extend-type PyObject
-  PToPyObjectPtr
-  (convertible-to-pyobject-ptr? [item] true)
-  (->py-object-ptr [item] (.getPointer item)))
-
-
-(extend-type Pointer
-  PToPyObjectPtr
-  (convertible-to-pyobject-ptr? [item] true)
-  (->py-object-ptr [item] item))
-
-(extend-type Object
-  PToPyObjectPtr
-  (convertible-to-pyobject-ptr? [item] (jna/is-jna-ptr-convertible? item))
-  (->py-object-ptr [item] (jna/->ptr-backing-store item)))
-
-
-(defn as-pyobj
-  [item]
-  (when (and item (convertible-to-pyobject-ptr? item))
-    (->py-object-ptr item)))
-
-
-(defn ensure-pyobj
-  [item]
-  (if-let [retval (as-pyobj item)]
-    retval
-    (throw (ex-info "Failed to get a pyobject pointer from object." {}))))
-
-
-(defn ensure-pydict
-  "The return value of this has to be a python dictionary object."
-  [item]
-  (ensure-pyobj item))
-
-
-(defn ensure-pytuple
-  "The return value of this has to be a python tuple object."
-  [item]
-  (ensure-pyobj item))
-
-
-(definline current-thread-id
-  ^long []
-  (-> (Thread/currentThread)
-      (.getId)))
-
-(defonce gil-thread-id (AtomicLong. Long/MAX_VALUE))
-
-
-(defn set-gil-thread-id!
-  ^long [^long expected ^long new-value]
-  (when-not (.compareAndSet ^AtomicLong gil-thread-id expected new-value)
-    (throw (Exception. "Failed to set gil thread id")))
-  new-value)
-
-
-(defmacro def-no-gil-pylib-fn
-  "Define a pylib function where the gil doesn't need to be captured to call."
-  [fn-name docstring & args]
-  `(jna/def-jna-fn *python-library* ~fn-name ~docstring ~@args))
-
-
-(defmacro def-pylib-fn
-  [fn-name docstring rettype & argpairs]
-  `(defn ~fn-name
-     ~docstring
-     ~(mapv first argpairs)
-     (when-not (== (current-thread-id) (.get ^AtomicLong gil-thread-id))
-       (throw (Exception. "Failure to capture gil when calling into libpython")))
-     (let [~'tvm-fn (jna/find-function ~(str fn-name) *python-library*)
-           ~'fn-args (object-array
-                      ~(mapv (fn [[arg-symbol arg-coersion]]
-                               (when (= arg-symbol arg-coersion)
-                                 (throw (ex-info (format "Argument symbol (%s) cannot match coersion (%s)"
-                                                         arg-symbol arg-coersion)
-                                                 {})))
-                               `(~arg-coersion ~arg-symbol))
-                             argpairs))]
-       ~(if rettype
-          `(.invoke (jna-base/to-typed-fn ~'tvm-fn) ~rettype ~'fn-args)
-          `(.invoke (jna-base/to-typed-fn ~'tvm-fn) ~'fn-args)))))
-
-
-(defonce size-t-type (type (jna/size-t 0)))
-
-
-(defn find-pylib-symbol
-  ^Pointer [sym-name]
-  (.getGlobalVariableAddress ^NativeLibrary (jna-base/load-library *python-library*)
-                             sym-name))
diff --git a/src/libpython_clj/jna/concrete/bytes.clj b/src/libpython_clj/jna/concrete/bytes.clj
deleted file mode 100644
index d091821..0000000
--- a/src/libpython_clj/jna/concrete/bytes.clj
+++ /dev/null
@@ -1,109 +0,0 @@
-(ns libpython-clj.jna.concrete.bytes
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     as-pyobj
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.datatype.nio-buffer :as nio-buffer]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna Pointer]))
-
-
-
-(def-pylib-fn PyBytes_Check
-  "Return true if the object o is a bytes object or an instance of a subtype of the
-  bytes type."
-  Integer
-  [o ensure-pyobj])
-
-
-(def-pylib-fn PyBytes_CheckExact
-  "Return true if the object o is a bytes object, but not an instance of a subtype of
-  the bytes type."
-  Integer
-  [o ensure-pyobj])
-
-
-
-(def-pylib-fn PyBytes_FromString
-  "Return value: New reference.
-
-   Return a new bytes object with a copy of the string v as value on success, and NULL
-   on failure. The parameter v must not be NULL; it will not be checked."
-  Pointer
-  [v str])
-
-
-(def-pylib-fn PyBytes_FromStringAndSize
-  "Return value: New reference.
-
-   Return a new bytes object with a copy of the string v as value and length len on
-   success, and NULL on failure. If v is NULL, the contents of the bytes object are
-   uninitialized."
-  Pointer
-  [v nio-buffer/->nio-buffer]
-  [len jna/size-t])
-
-
-(def-pylib-fn PyBytes_AsString
-  "Return a pointer to the contents of o. The pointer refers to the internal buffer of
-  o, which consists of len(o) + 1 bytes. The last byte in the buffer is always null,
-  regardless of whether there are any other null bytes. The data must not be modified in
-  any way, unless the object was just created using PyBytes_FromStringAndSize(NULL,
-  size). It must not be deallocated. If o is not a bytes object at all,
-  PyBytes_AsString() returns NULL and raises TypeError."
-  String
-  [o ensure-pyobj])
-
-
-(def-pylib-fn PyBytes_AsStringAndSize
-  "Return the null-terminated contents of the object obj through the output variables
-  buffer and length.
-
-   If length is NULL, the bytes object may not contain embedded null bytes; if it does,
-   the function returns -1 and a ValueError is raised.
-
-   The buffer refers to an internal buffer of obj, which includes an additional null
-   byte at the end (not counted in length). The data must not be modified in any way,
-   unless the object was just created using PyBytes_FromStringAndSize(NULL, size). It
-   must not be deallocated. If obj is not a bytes object at all,
-   PyBytes_AsStringAndSize() returns -1 and raises TypeError.
-
-   Changed in version 3.5: Previously, TypeError was raised when embedded null bytes
-   were encountered in the bytes object.
-
-   Signature:
-   int (PyObject *obj, char **buffer, Py_ssize_t *length)"
-  Integer
-  [obj ensure-pyobj]
-  [ptr-to-buffer jna/ensure-ptr-ptr]
-  [length as-pyobj])
-
-
-
-(def-pylib-fn PyBytes_Concat
-  "Create a new bytes object in *bytes containing the contents of newpart appended to
-  bytes; the caller will own the new reference. The reference to the old value of bytes
-  will be stolen. If the new object cannot be created, the old reference to bytes will
-  still be discarded and the value of *bytes will be set to NULL; the appropriate
-  exception will be set.
-  Signature:
-  void (PyObject **bytes, PyObject *newpart)"
-  nil
-  [out-bytes jna/ensure-ptr-ptr]
-  [newpart ensure-pyobj])
-
-
-
-(def-pylib-fn PyBytes_ConcatAndDel
-  "Create a new bytes object in *bytes containing the contents of newpart appended to
-  bytes. This version decrements the reference count of newpart.
-  Signature:
-  void (PyObject **bytes, PyObject *newpart)"
-  nil
-  [out-bytes jna/ensure-ptr-ptr]
-  [newpart ensure-pyobj])
diff --git a/src/libpython_clj/jna/concrete/cfunction.clj b/src/libpython_clj/jna/concrete/cfunction.clj
deleted file mode 100644
index 70f9057..0000000
--- a/src/libpython_clj/jna/concrete/cfunction.clj
+++ /dev/null
@@ -1,76 +0,0 @@
-(ns libpython-clj.jna.concrete.cfunction
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     as-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna CallbackReference Pointer Callback]
-           [libpython_clj.jna
-            CFunction$KeyWordFunction
-            CFunction$TupleFunction
-            PyMethodDef
-            PyObject]))
-
-
-;; #define METH_OLDARGS  0x0000   -- unsupported now
-(def METH_VARARGS  0x0001)
-(def METH_KEYWORDS 0x0002)
-
-;; METH_NOARGS and METH_O must not be combined with the flags above.
-(def METH_NOARGS   0x0004)
-(def METH_O        0x0008)
-
-;; /* METH_CLASS and METH_STATIC are a little different; these control
-;;    the construction of methods for a class.  These cannot be used for
-;;    functions in modules. */
-(def METH_CLASS    0x0010)
-(def METH_STATIC   0x0020)
-
-;; /* METH_COEXIST allows a method to be entered even though a slot has
-;;    already filled the entry.  When defined, the flag allows a separate
-;;    method, "__contains__" for example, to coexist with a defined
-;;    slot like sq_contains. */
-
-(def METH_COEXIST   0x0040)
-
-;; We aren't going there for either of these...
-;; #ifndef Py_LIMITED_API
-;; #define METH_FASTCALL  0x0080
-;; #endif
-
-;; /* This bit is preserved for Stackless Python */
-;; #ifdef STACKLESS
-;; #define METH_STACKLESS 0x0100
-;; #else
-;; #define METH_STACKLESS 0x0000
-;; #endif
-
-
-(def-pylib-fn PyCFunction_NewEx
-  "Create a new callable from an item."
-  Pointer
-  [method-def (partial jna/ensure-type PyMethodDef)]
-  [self as-pyobj]
-  [module as-pyobj])
-
-
-(def-pylib-fn PyInstanceMethod_New
-  "Return value: New reference.
-
-  Return a new instance method object, with func being any callable object func is the
-  function that will be called when the instance method is called."
-  Pointer
-  [func ensure-pyobj])
-
-
-(def-pylib-fn PyInstanceMethod_Function
-  "Return value: Borrowed reference.
-
-  Return the function object associated with the instance method im."
-  Pointer
-  [im ensure-pyobj])
diff --git a/src/libpython_clj/jna/concrete/code.clj b/src/libpython_clj/jna/concrete/code.clj
deleted file mode 100644
index d90d5d9..0000000
--- a/src/libpython_clj/jna/concrete/code.clj
+++ /dev/null
@@ -1,33 +0,0 @@
-(ns libpython-clj.jna.concrete.code
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
-
-
-(def-pylib-fn PyCode_Check
-  "Return true if co is a code object."
-  Integer
-  [co ensure-pyobj])
-
-
-(def-pylib-fn PyCode_GetNumFree
-  "Return the number of free variables in co."
-  Integer
-  [co ensure-pyobj])
-
-
-
-(def-pylib-fn PyCode_NewEmpty
-  "Return a new empty code object with the specified filename, function name, and first
-  line number. It is illegal to exec or eval() the resulting code object."
-  Pointer
-  [filename str]
-  [funcname str]
-  [firstlineno int])
diff --git a/src/libpython_clj/jna/concrete/dict.clj b/src/libpython_clj/jna/concrete/dict.clj
deleted file mode 100644
index 50690d1..0000000
--- a/src/libpython_clj/jna/concrete/dict.clj
+++ /dev/null
@@ -1,235 +0,0 @@
-(ns libpython-clj.jna.concrete.dict
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject DirectMapped]))
-
-
-
-(def-pylib-fn PyDict_Check
-  "Return true if p is a dict object or an instance of a subtype of the dict type."
-  Integer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyDict_New
-  "Return value: New reference.
-
-   Return a new empty dictionary, or NULL on failure."
-  Pointer)
-
-
-(def-pylib-fn PyDictProxy_New
-  "Return value: New reference.
-
-   Return a types.MappingProxyType object for a mapping which enforces read-only
-   behavior. This is normally used to create a view to prevent modification of the
-   dictionary for non-dynamic class types."
-  Pointer
-  [mapping ensure-pyobj])
-
-
-(def-pylib-fn PyDict_Clear
-  "Empty an existing dictionary of all key-value pairs."
-  nil
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyDict_Contains
-  "Determine if dictionary p contains key. If an item in p is matches key, return 1,
-  otherwise return 0. On error, return -1. This is equivalent to the Python expression
-  key in p."
-  Integer
-  [p ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PyDict_Copy
-  "Return value: New reference.
-
-   Return a new dictionary that contains the same key-value pairs as p."
-  Pointer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyDict_SetItem
-  "Insert value into the dictionary p with a key of key. key must be hashable; if it
-  isn’t, TypeError will be raised. Return 0 on success or -1 on failure."
-  Integer
-  [p ensure-pyobj]
-  [key ensure-pyobj]
-  [val ensure-pyobj])
-
-
-(def-pylib-fn PyDict_SetItemString
-  "Insert value into the dictionary p using key as a key. key should be a const
-  char*. The key object is created using PyUnicode_FromString(key). Return 0 on success
-  or -1 on failure."
-  Integer
-  [p ensure-pyobj]
-  [key ensure-pyobj]
-  [val ensure-pyobj])
-
-
-(def-pylib-fn PyDict_DelItem
-  "Remove the entry in dictionary p with key key. key must be hashable; if it isn’t,
-  TypeError is raised. Return 0 on success or -1 on failure."
-  Integer
-  [p ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PyDict_DelItemString
-  "Remove the entry in dictionary p which has a key specified by the string key. Return
-  0 on success or -1 on failure."
-  Integer
-  [p ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PyDict_GetItem
-  "Return value: Borrowed reference.
-
-   Return the object from dictionary p which has a key key. Return NULL if the key key
-   is not present, but without setting an exception.
-
-   Note that exceptions which occur while calling __hash__() and __eq__() methods will
-   get suppressed. To get error reporting use PyDict_GetItemWithError() instead."
-  Pointer
-  [p ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PyDict_GetItemWithError
-  "Return value: Borrowed reference.
-
-   Variant of PyDict_GetItem() that does not suppress exceptions. Return NULL with an
-   exception set if an exception occurred. Return NULL without an exception set if the
-   key wasn’t present."
-  Pointer
-  [p ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PyDict_GetItemString
-  "Return value: Borrowed reference.
-
-   This is the same as PyDict_GetItem(), but key is specified as a const char*, rather
-   than a PyObject*.
-
-   Note that exceptions which occur while calling __hash__() and __eq__() methods and
-   creating a temporary string object will get suppressed. To get error reporting use
-   PyDict_GetItemWithError() instead."
-  Pointer
-  [p ensure-pyobj]
-  [key ensure-pyobj])
-
-
-
-
-(def-pylib-fn PyDict_SetDefault
-  "Return value: Borrowed reference.
-
-   This is the same as the Python-level dict.setdefault(). If present, it returns the
-   value corresponding to key from the dictionary p. If the key is not in the dict, it
-   is inserted with value defaultobj and defaultobj is returned. This function evaluates
-   the hash function of key only once, instead of evaluating it independently for the
-   lookup and the insertion.
-
-    New in version 3.4."
-  Pointer
-  [p ensure-pyobj]
-  [key ensure-pyobj]
-  [defaultobj ensure-pyobj])
-
-
-(def-pylib-fn PyDict_Items
-  "Return value: New reference.
-
-   Return a PyListObject containing all the items from the dictionary."
-  Pointer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyDict_Keys
-  "Return value: New reference.
-
-   Return a PyListObject containing all the keys from the dictionary."
-  Pointer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyDict_Values
-  "Return value: New reference.
-
-   Return a PyListObject containing all the values from the dictionary p."
-  Pointer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyDict_Size
-  "Return the number of items in the dictionary. This is equivalent to len(p) on a
-  dictionary."
-  size-t-type
-  [p ensure-pyobj])
-
-
-(defn PyDict_Next
-  "Iterate over all key-value pairs in the dictionary p. The Py_ssize_t referred to by
-  ppos must be initialized to 0 prior to the first call to this function to start the
-  iteration; the function returns true for each pair in the dictionary, and false once
-  all pairs have been reported. The parameters pkey and pvalue should either point to
-  PyObject* variables that will be filled in with each key and value, respectively, or
-  may be NULL. Any references returned through them are borrowed. ppos should not be
-  altered during iteration. Its value represents offsets within the internal dictionary
-  structure, and since the structure is sparse, the offsets are not consecutive."
-  ^long [p ppos pkey pvalue]
-  (long (DirectMapped/PyDict_Next (ensure-pyobj p)
-                                  (jna/ensure-type jna/size-t-ref-type ppos)
-                                  (jna/ensure-ptr-ptr pkey)
-                                  (jna/ensure-ptr-ptr pvalue))))
-
-
-(def-pylib-fn PyDict_Merge
-  "Iterate over mapping object b adding key-value pairs to dictionary a. b may be a
-  dictionary, or any object supporting PyMapping_Keys() and PyObject_GetItem(). If
-  override is true, existing pairs in a will be replaced if a matching key is found in
-  b, otherwise pairs will only be added if there is not a matching key in a. Return 0 on
-  success or -1 if an exception was raised."
-  Integer
-  [a ensure-pyobj]
-  [b ensure-pyobj]
-  [override int])
-
-
-(def-pylib-fn PyDict_Update
-  "This is the same as PyDict_Merge(a, b, 1) in C, and is similar to a.update(b) in
-  Python except that PyDict_Update() doesn’t fall back to the iterating over a sequence
-  of key value pairs if the second argument has no “keys” attribute. Return 0 on success
-  or -1 if an exception was raised."
-  Integer
-  [a ensure-pyobj]
-  [b ensure-pyobj])
-
-
-(def-pylib-fn PyDict_MergeFromSeq2
-  "Update or merge into dictionary a, from the key-value pairs in seq2. seq2 must be an
-  iterable object producing iterable objects of length 2, viewed as key-value pairs. In
-  case of duplicate keys, the last wins if override is true, else the first wins. Return
-  0 on success or -1 if an exception was raised. Equivalent Python (except for the
-  return value):
-def PyDict_MergeFromSeq2(a, seq2, override):
-    for key, value in seq2:
-        if override or key not in a:
-            a[key] = value"
-  Integer
-  [a ensure-pyobj]
-  [seq2 ensure-pyobj]
-  [override int])
diff --git a/src/libpython_clj/jna/concrete/err.clj b/src/libpython_clj/jna/concrete/err.clj
deleted file mode 100644
index 54b7c2b..0000000
--- a/src/libpython_clj/jna/concrete/err.clj
+++ /dev/null
@@ -1,337 +0,0 @@
-(ns libpython-clj.jna.concrete.err
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     find-pylib-symbol
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject PyTypeObject DirectMapped]))
-
-(set! *warn-on-reflection* true)
-
-
-(defn PyErr_Occurred
-  "Check if the error indicator is set.  If so, return the exception type."
-  ^Pointer []
-  (DirectMapped/PyErr_Occurred))
-
-
-(def-pylib-fn PyErr_Clear
-  "Clear the error indicator. If the error indicator is not set, there is no effect."
-  nil)
-
-
-(def-pylib-fn PyErr_PrintEx
-  "Print a standard traceback to sys.stderr and clear the error indicator. Unless the
-  error is a SystemExit. In that case the no traceback is printed and Python process
-  will exit with the error code specified by the SystemExit instance.
-
-   Call this function only when the error indicator is set. Otherwise it will cause a
-   fatal error!
-
-   If set_sys_last_vars is nonzero, the variables sys.last_type, sys.last_value and
-   sys.last_traceback will be set to the type, value and traceback of the printed
-   exception, respectively."
-  nil
-  [set-sys-last-vars int])
-
-
-(def-pylib-fn PyErr_Print
-  "Alias for PyErr_PrintEx(1)."
-  nil)
-
-
-(def-pylib-fn PyErr_WriteUnraisable
-  "This utility function prints a warning message to sys.stderr when an exception has
-   been set but it is impossible for the interpreter to actually raise the exception. It
-   is used, for example, when an exception occurs in an __del__() method.
-
-   The function is called with a single argument obj that identifies the context in
-   which the unraisable exception occurred. If possible, the repr of obj will be printed
-   in the warning message.
-
-   An exception must be set when calling this function."
-  nil
-  [obj ensure-pyobj])
-
-
-(def-pylib-fn PyErr_SetString
-  "This is the most common way to set the error indicator. The first argument specifies
-  the exception type; it is normally one of the standard exceptions,
-  e.g. PyExc_RuntimeError. You need not increment its reference count. The second
-  argument is an error message; it is decoded from 'utf-8’."
-  nil
-  [type ensure-pyobj]
-  [message str])
-
-
-(def-pylib-fn PyErr_SetObject
-  "This function is similar to PyErr_SetString() but lets you specify an arbitrary
-  Python object for the “value” of the exception."
-  nil
-  [type ensure-pyobj]
-  [value ensure-pyobj])
-
-
-(def-pylib-fn PyErr_SetNone
-  "This is a shorthand for PyErr_SetObject(type, Py_None)."
-  nil
-  [type ensure-pyobj])
-
-
-(def-pylib-fn PyErr_BadArgument
-  "This is a shorthand for PyErr_SetString(PyExc_TypeError, message), where message
-  indicates that a built-in operation was invoked with an illegal argument. It is mostly
-  for internal use."
-  Integer)
-
-
-
-(def-pylib-fn PyErr_NoMemory
-  "Return value: Always NULL.
-
-   This is a shorthand for PyErr_SetNone(PyExc_MemoryError); it returns NULL so an
-   object allocation function can write return PyErr_NoMemory(); when it runs out of
-   memory."
-  Pointer)
-
-
-(def-pylib-fn PyErr_SetFromErrno
-  "Return value: Always NULL.
-
-   This is a convenience function to raise an exception when a C library function has
-   returned an error and set the C variable errno. It constructs a tuple object whose
-   first item is the integer errno value and whose second item is the corresponding
-   error message (gotten from strerror()), and then calls PyErr_SetObject(type,
-   object). On Unix, when the errno value is EINTR, indicating an interrupted system
-   call, this calls PyErr_CheckSignals(), and if that set the error indicator, leaves it
-   set to that. The function always returns NULL, so a wrapper function around a system
-   call can write return PyErr_SetFromErrno(type); when the system call returns an
-   error."
-  Pointer
-  [type ensure-pyobj])
-
-
-(def-pylib-fn PyErr_BadInternalCall
-  "This is a shorthand for PyErr_SetString(PyExc_SystemError, message), where message
-  indicates that an internal operation (e.g. a Python/C API function) was invoked with
-  an illegal argument. It is mostly for internal use."
-  nil)
-
-
-(def-pylib-fn PyErr_WarnEx
-  "Issue a warning message. The category argument is a warning category (see below) or
-  NULL; the message argument is a UTF-8 encoded string. stack_level is a positive number
-  giving a number of stack frames; the warning will be issued from the currently
-  executing line of code in that stack frame. A stack_level of 1 is the function calling
-  PyErr_WarnEx(), 2 is the function above that, and so forth.
-
-   Warning categories must be subclasses of PyExc_Warning; PyExc_Warning is a subclass
-   of PyExc_Exception; the default warning category is PyExc_RuntimeWarning. The
-   standard Python warning categories are available as global variables whose names are
-   enumerated at Standard Warning Categories.
-
-   For information about warning control, see the documentation for the warnings module
-   and the -W option in the command line documentation. There is no C API for warning
-   control."
-  Integer
-  [category ensure-pyobj]
-  [message str]
-  [stack_level jna/size-t])
-
-
-(def-pylib-fn PyErr_WarnExplicit
-  "Similar to PyErr_WarnExplicitObject() except that message and module are UTF-8
-  encoded strings, and filename is decoded from the filesystem encoding (os.fsdecode())."
-  Integer
-  [category ensure-pyobj]
-  [message str]
-  [filename str]
-  [lineno int]
-  [module str]
-  [registry ensure-pyobj])
-
-
-(def-pylib-fn PyErr_Fetch
-  "Retrieve the error indicator into three variables whose addresses are passed. If the
-  error indicator is not set, set all three variables to NULL. If it is set, it will be
-  cleared and you own a reference to each object retrieved. The value and traceback
-  object may be NULL even when the type object is not.
-
-   Note
-
-   This function is normally only used by code that needs to catch exceptions or by code
-   that needs to save and restore the error indicator temporarily, e.g.:
-
-    {
-       PyObject *type, *value, *traceback;
-       PyErr_Fetch(&type, &value, &traceback);
-
-       /* ... code that might produce other errors ... */
-
-       PyErr_Restore(type, value, traceback);
-    }"
-  nil
-  [ptype jna/ensure-ptr-ptr]
-  [pvalue jna/ensure-ptr-ptr]
-  [ptraceback jna/ensure-ptr-ptr])
-
-
-
-(def-pylib-fn PyErr_Restore
-  "Set the error indicator from the three objects. If the error indicator is already
-   set, it is cleared first. If the objects are NULL, the error indicator is cleared. Do
-   not pass a NULL type and non-NULL value or traceback. The exception type should be a
-   class. Do not pass an invalid exception type or value. (Violating these rules will
-   cause subtle problems later.) This call takes away a reference to each object: you
-   must own a reference to each object before the call and after the call you no longer
-   own these references. (If you don’t understand this, don’t use this function. I warned
-   you.)
-
-   Note
-
-   This function is normally only used by code that needs to save and restore the error
-   indicator temporarily. Use PyErr_Fetch() to save the current error indicator."
-  nil
-  [type ensure-pyobj]
-  [value ensure-pyobj]
-  [traceback ensure-pyobj])
-
-
-(def-pylib-fn PyException_GetTraceback
-  "Return value: New reference.
-
-   Return the traceback associated with the exception as a new reference, as accessible
-   from Python through __traceback__. If there is no traceback associated, this returns
-   NULL."
-  Pointer
-  [ex ensure-pyobj])
-
-
-(def-pylib-fn PyException_SetTraceback
-  "Set the traceback associated with the exception to tb. Use Py_None to clear it."
-  Integer
-  [ex ensure-pyobj]
-  [tb ensure-pyobj])
-
-
-(def-pylib-fn PyException_GetContext
-  "Return value: New reference.
-
-   Return the context (another exception instance during whose handling ex was raised)
-   associated with the exception as a new reference, as accessible from Python through
-   __context__. If there is no context associated, this returns NULL."
-  Pointer
-  [ex ensure-pyobj])
-
-
-(def-pylib-fn PyException_SetContext
-  "Set the context associated with the exception to ctx. Use NULL to clear it. There is
-  no type check to make sure that ctx is an exception instance. This steals a reference
-  to ctx."
-  nil
-  [ex ensure-pyobj]
-  [ctx ensure-pyobj])
-
-
-(def-pylib-fn PyException_GetCause
-  "Return value: New reference.
-
-   Return the cause (either an exception instance, or None, set by raise ... from ...)
-   associated with the exception as a new reference, as accessible from Python through
-   __cause__."
-  Pointer
-  [ex ensure-pyobj])
-
-
-(def-pylib-fn PyException_SetCause
-  "Set the cause associated with the exception to cause. Use NULL to clear it. There is
-  no type check to make sure that cause is either an exception instance or None. This
-  steals a reference to cause.
-
-   __suppress_context__ is implicitly set to True by this function."
-  nil
-  [ex ensure-pyobj]
-  [cause ensure-pyobj])
-
-
-(defmacro def-err-symbol
-  [sym-name]
-  `(defn ~sym-name
-     []
-     (->
-      (find-pylib-symbol ~(name sym-name))
-      (.getPointer 0))))
-
-
-(def-err-symbol PyExc_BaseException)
-(def-err-symbol PyExc_Exception)
-(def-err-symbol PyExc_ArithmeticError)
-(def-err-symbol PyExc_AssertionError)
-(def-err-symbol PyExc_AttributeError)
-(def-err-symbol PyExc_BlockingIOError)
-(def-err-symbol PyExc_BrokenPipeError)
-(def-err-symbol PyExc_BufferError)
-(def-err-symbol PyExc_ChildProcessError)
-(def-err-symbol PyExc_ConnectionAbortedError)
-(def-err-symbol PyExc_ConnectionError)
-(def-err-symbol PyExc_ConnectionRefusedError)
-(def-err-symbol PyExc_ConnectionResetError)
-(def-err-symbol PyExc_EOFError)
-(def-err-symbol PyExc_FileExistsError)
-(def-err-symbol PyExc_FileNotFoundError)
-(def-err-symbol PyExc_FloatingPointError)
-(def-err-symbol PyExc_GeneratorExit)
-(def-err-symbol PyExc_ImportError)
-(def-err-symbol PyExc_IndentationError)
-(def-err-symbol PyExc_IndexError)
-(def-err-symbol PyExc_InterruptedError)
-(def-err-symbol PyExc_IsADirectoryError)
-(def-err-symbol PyExc_KeyError)
-(def-err-symbol PyExc_KeyboardInterrupt)
-(def-err-symbol PyExc_LookupError)
-(def-err-symbol PyExc_MemoryError)
-(def-err-symbol PyExc_ModuleNotFoundError)
-(def-err-symbol PyExc_NameError)
-(def-err-symbol PyExc_NotADirectoryError)
-(def-err-symbol PyExc_NotImplementedError)
-(def-err-symbol PyExc_OSError)
-(def-err-symbol PyExc_OverflowError)
-(def-err-symbol PyExc_PermissionError)
-(def-err-symbol PyExc_ProcessLookupError)
-(def-err-symbol PyExc_RecursionError)
-(def-err-symbol PyExc_ReferenceError)
-(def-err-symbol PyExc_RuntimeError)
-(def-err-symbol PyExc_StopAsyncIteration)
-(def-err-symbol PyExc_StopIteration)
-(def-err-symbol PyExc_SyntaxError)
-(def-err-symbol PyExc_SystemError)
-(def-err-symbol PyExc_SystemExit)
-(def-err-symbol PyExc_TabError)
-(def-err-symbol PyExc_TimeoutError)
-(def-err-symbol PyExc_TypeError)
-(def-err-symbol PyExc_UnboundLocalError)
-(def-err-symbol PyExc_UnicodeDecodeError)
-(def-err-symbol PyExc_UnicodeEncodeError)
-(def-err-symbol PyExc_UnicodeError)
-(def-err-symbol PyExc_UnicodeTranslateError)
-(def-err-symbol PyExc_ValueError)
-(def-err-symbol PyExc_ZeroDivisionError)
-
-
-(def-err-symbol PyExc_Warning)
-(def-err-symbol PyExc_BytesWarning)
-(def-err-symbol PyExc_DeprecationWarning)
-(def-err-symbol PyExc_FutureWarning)
-(def-err-symbol PyExc_ImportWarning)
-(def-err-symbol PyExc_PendingDeprecationWarning)
-(def-err-symbol PyExc_ResourceWarning)
-(def-err-symbol PyExc_RuntimeWarning)
-(def-err-symbol PyExc_SyntaxWarning)
-(def-err-symbol PyExc_UnicodeWarning)
-(def-err-symbol PyExc_UserWarning)
diff --git a/src/libpython_clj/jna/concrete/import.clj b/src/libpython_clj/jna/concrete/import.clj
deleted file mode 100644
index 34a16cf..0000000
--- a/src/libpython_clj/jna/concrete/import.clj
+++ /dev/null
@@ -1,130 +0,0 @@
-(ns libpython-clj.jna.concrete.import
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
-
-
-(def-pylib-fn PyImport_ImportModule
-  "Return value: New reference.
-
-   This is a simplified interface to PyImport_ImportModuleEx() below, leaving the
-   globals and locals arguments set to NULL and level set to 0. When the name argument
-   contains a dot (when it specifies a submodule of a package), the fromlist argument is
-   set to the list ['*'] so that the return value is the named module rather than the
-   top-level package containing it as would otherwise be the case. (Unfortunately, this
-   has an additional side effect when name in fact specifies a subpackage instead of a
-   submodule: the submodules specified in the package’s __all__ variable are loaded.)
-   Return a new reference to the imported module, or NULL with an exception set on
-   failure. A failing import of a module doesn’t leave the module in sys.modules.
-
-   This function always uses absolute imports."
-  Pointer
-  [name str])
-
-
-
-(def-pylib-fn PyImport_Import
-  "Return value: New reference.
-
-   This is a higher-level interface that calls the current “import hook function” (with
-   an explicit level of 0, meaning absolute import). It invokes the __import__()
-   function from the __builtins__ of the current globals. This means that the import is
-   done using whatever import hooks are installed in the current environment.
-
-   This function always uses absolute imports."
-  Pointer
-  [name ensure-pyobj])
-
-
-
-(def-pylib-fn PyImport_AddModule
-  "Return value: Borrowed reference.
-
-   Similar to PyImport_AddModuleObject(), but the name is a UTF-8 encoded string instead
-   of a Unicode object."
-  Pointer
-  [name str])
-
-
-(def-pylib-fn PyImport_ImportModuleLevel
-  "Return value: New reference.
-
-    Similar to PyImport_ImportModuleLevelObject(), but the name is a UTF-8 encoded
-    string instead of a Unicode object.
-
-     Changed in version 3.3: Negative values for level are no longer accepted.
-
-
-(documentation from python __import__ function
- __import__(name, globals=None, locals=None, fromlist=(), level=0)
-
-
-This function is invoked by the import statement. It can be replaced (by importing the
-builtins module and assigning to builtins.__import__) in order to change semantics of
-the import statement, but doing so is strongly discouraged as it is usually simpler to
-use import hooks (see PEP 302) to attain the same goals and does not cause issues with
-code which assumes the default import implementation is in use. Direct use of
-__import__() is also discouraged in favor of importlib.import_module().
-
-The function imports the module name, potentially using the given globals and locals to
-determine how to interpret the name in a package context. The fromlist gives the names
-of objects or submodules that should be imported from the module given by name. The
-standard implementation does not use its locals argument at all, and uses its globals
-only to determine the package context of the import statement.
-
-level specifies whether to use absolute or relative imports. 0 (the default) means only
-perform absolute imports. Positive values for level indicate the number of parent
-directories to search relative to the directory of the module calling __import__() (see
-PEP 328 for the details).
-
-When the name variable is of the form package.module, normally, the top-level package
-(the name up till the first dot) is returned, not the module named by name. However,
-when a non-empty fromlist argument is given, the module named by name is returned.
-
-For example, the statement import spam results in bytecode resembling the following
-code:
-
-spam = __import__('spam', globals(), locals(), [], 0)
-
-The statement import spam.ham results in this call:
-
-spam = __import__('spam.ham', globals(), locals(), [], 0)
-
-Note how __import__() returns the toplevel module here because this is the object that
-is bound to a name by the import statement.
-
-On the other hand, the statement from spam.ham import eggs, sausage as saus results in
-
-_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
-eggs = _temp.eggs
-saus = _temp.sausage
-
-Here, the spam.ham module is returned from __import__(). From this object, the names to
-import are retrieved and assigned to their respective names.
-
-If you simply want to import a module (potentially within a package) by name, use
-importlib.import_module().
-
-Changed in version 3.3: Negative values for level are no longer supported (which also
-changes the default value to 0)."
-  Pointer
-  [name str]
-  [globals ensure-pydict]
-  [locals ensure-pydict]
-  [fromlist ensure-pyobj]
-  [level int])
-
-
-(def-pylib-fn PyImport_GetModuleDict
-  "Return value: Borrowed reference.
-
-   Return the dictionary used for the module administration (a.k.a. sys.modules). Note
-   that this is a per-interpreter variable."
-  Pointer)
diff --git a/src/libpython_clj/jna/concrete/list.clj b/src/libpython_clj/jna/concrete/list.clj
deleted file mode 100644
index 7922b72..0000000
--- a/src/libpython_clj/jna/concrete/list.clj
+++ /dev/null
@@ -1,128 +0,0 @@
-(ns libpython-clj.jna.concrete.list
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
-
-(def-pylib-fn PyList_Check
-  "Return true if p is a list object or an instance of a subtype of the list type."
-  Integer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyList_New
-  "Return value: New reference.
-
-   Return a new list of length len on success, or NULL on failure.
-
-   Note
-
-   If len is greater than zero, the returned list object’s items are set to NULL. Thus
-   you cannot use abstract API functions such as PySequence_SetItem() or expose the
-   object to Python code before setting all items to a real object with
-   PyList_SetItem()."
-  Pointer
-  [len jna/size-t])
-
-
-(def-pylib-fn PyList_Size
-  "Return the length of the list object in list; this is equivalent to len(list) on a
-  list object."
-  size-t-type
-  [list ensure-pyobj])
-
-
-(def-pylib-fn PyList_GetItem
-  "Return value: Borrowed reference.
-
-   Return the object at position index in the list pointed to by list. The position must
-   be positive, indexing from the end of the list is not supported. If index is out of
-   bounds, return NULL and set an IndexError exception."
-  Pointer
-  [list ensure-pyobj]
-  [index jna/size-t])
-
-
-(def-pylib-fn PyList_SetItem
-  "Set the item at index index in list to item. Return 0 on success or -1 on failure.
-
-   Note
-
-   This function “steals” a reference to item and discards a reference to an item
-   already in the list at the affected position."
-  Integer
-  [list ensure-pyobj]
-  [index jna/size-t]
-  [item ensure-pyobj])
-
-
-(def-pylib-fn PyList_Insert
-  "Insert the item item into list list in front of index index. Return 0 if successful;
-  return -1 and set an exception if unsuccessful. Analogous to list.insert(index,
-  item)."
-  Integer
-  [list ensure-pyobj]
-  [index jna/size-t]
-  [item ensure-pyobj])
-
-
-(def-pylib-fn PyList_Append
-  "Append the object item at the end of list list. Return 0 if successful; return -1 and
-  set an exception if unsuccessful. Analogous to list.append(item)."
-  Integer
-  [list ensure-pyobj]
-  [item ensure-pyobj])
-
-
-(def-pylib-fn PyList_GetSlice
-  "Return value: New reference.
-
-   Return a list of the objects in list containing the objects between low and
-   high. Return NULL and set an exception if unsuccessful. Analogous to
-   list[low:high]. Negative indices, as when slicing from Python, are not supported."
-  Pointer
-  [list ensure-pyobj]
-  [low jna/size-t]
-  [high jna/size-t])
-
-
-(def-pylib-fn PyList_SetSlice
-  "Set the slice of list between low and high to the contents of itemlist. Analogous to
-  list[low:high] = itemlist. The itemlist may be NULL, indicating the assignment of an
-  empty list (slice deletion). Return 0 on success, -1 on failure. Negative indices, as
-  when slicing from Python, are not supported."
-  Integer
-  [list ensure-pyobj]
-  [low jna/size-t]
-  [high jna/size-t]
-  [itemlist ensure-pyobj])
-
-
-(def-pylib-fn PyList_Sort
-  "Sort the items of list in place. Return 0 on success, -1 on failure. This is
-  equivalent to list.sort()."
-  Integer
-  [list ensure-pyobj])
-
-
-(def-pylib-fn PyList_Reverse
-  "Reverse the items of list in place. Return 0 on success, -1 on failure. This is the
-  equivalent of list.reverse()."
-  Integer
-  [list ensure-pyobj])
-
-
-(def-pylib-fn PyList_AsTuple
-  "Return value: New reference.
-
-   Return a new tuple object containing the contents of list; equivalent to
-   tuple(list)."
-  Pointer
-  [list ensure-pyobj])
diff --git a/src/libpython_clj/jna/concrete/module.clj b/src/libpython_clj/jna/concrete/module.clj
deleted file mode 100644
index 10b2018..0000000
--- a/src/libpython_clj/jna/concrete/module.clj
+++ /dev/null
@@ -1,124 +0,0 @@
-(ns libpython-clj.jna.concrete.module
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyModuleDef PyMethodDef PyObject]))
-
-
-(def-pylib-fn PyModule_Check
-  "Return true if p is a module object, or a subtype of a module object."
-  Integer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyModule_New
-  "Return value: New reference.
-
-   Return a new module object with the __name__ attribute set to name. The module’s
-   __name__, __doc__, __package__, and __loader__ attributes are filled in (all but
-   __name__ are set to None); the caller is responsible for providing a __file__
-   attribute.
-
-   New in version 3.3.
-
-   Changed in version 3.4: __package__ and __loader__ are set to None."
-  Pointer
-  [name str])
-
-
-(def-pylib-fn PyModule_SetDocString
-  "Set the docstring for module to docstring. This function is called automatically when
-  creating a module from PyModuleDef, using either PyModule_Create or
-  PyModule_FromDefAndSpec.
-
-   New in version 3.5."
-  Integer
-  [module ensure-pyobj]
-  [docstring str])
-
-
-(def-pylib-fn PyModule_AddFunctions
-  "Add the functions from the NULL terminated functions array to module. Refer to the
-  PyMethodDef documentation for details on individual entries (due to the lack of a
-  shared module namespace, module level “functions” implemented in C typically receive
-  the module as their first parameter, making them similar to instance methods on Python
-  classes). This function is called automatically when creating a module from
-  PyModuleDef, using either PyModule_Create or PyModule_FromDefAndSpec."
-  Integer
-  [module ensure-pyobj]
-  [functions (partial jna/ensure-type PyMethodDef)])
-
-
-(def-pylib-fn PyModule_GetDict
-  "Return value: Borrowed reference.
-
-   Return the dictionary object that implements module’s namespace; this object is the
-   same as the __dict__ attribute of the module object. If module is not a module
-   object (or a subtype of a module object), SystemError is raised and NULL is
-   returned.
-
-   It is recommended extensions use other PyModule_*() and PyObject_*() functions
-   rather than directly manipulate a module’s __dict__."
-  Pointer
-  [module ensure-pyobj])
-
-
-(def-pylib-fn PyModule_GetNameObject
-  "Return value: New reference.
-
-   Return module’s __name__ value. If the module does not provide one, or if it is not a
-   string, SystemError is raised and NULL is returned.
-
-   New in version 3.3."
-  Pointer
-  [module ensure-pyobj])
-
-
-(def-pylib-fn PyModule_GetState
-  "Return the “state” of the module, that is, a pointer to the block of memory allocated
-  at module creation time, or NULL. See PyModuleDef.m_size."
-  Pointer
-  [module ensure-pyobj])
-
-
-(def-pylib-fn PyModule_GetDef
-  "Return a pointer to the PyModuleDef struct from which the module was created, or NULL
-  if the module wasn’t created from a definition."
-  PyModuleDef
-  [module ensure-pyobj])
-
-
-(def-pylib-fn PyModule_AddObject
-  "Add an object to module as name. This is a convenience function which can be used
-  from the module’s initialization function. This steals a reference to value. Return -1
-  on error, 0 on success."
-  Integer
-  [module ensure-pyobj]
-  [name str]
-  [value ensure-pyobj])
-
-
-(def-pylib-fn PyModule_AddIntConstant
-  "Add an integer constant to module as name. This convenience function can be used from
-  the module’s initialization function. Return -1 on error, 0 on success."
-  Integer
-  [module ensure-pyobj]
-  [name str]
-  [value int])
-
-
-(def-pylib-fn PyModule_AddStringConstant
-  "Add a string constant to module as name. This convenience function can be used from
-  the module’s initialization function. The string value must be NULL-terminated. Return
-  -1 on error, 0 on success."
-  Integer
-  [module ensure-pyobj]
-  [name str]
-  [value str])
diff --git a/src/libpython_clj/jna/concrete/numeric/boolean.clj b/src/libpython_clj/jna/concrete/numeric/boolean.clj
deleted file mode 100644
index 3350159..0000000
--- a/src/libpython_clj/jna/concrete/numeric/boolean.clj
+++ /dev/null
@@ -1,38 +0,0 @@
-(ns libpython-clj.jna.concrete.numeric.boolean
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     find-pylib-symbol]
-             :as libpy-base])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
-
-
-(def-pylib-fn PyBool_Check
-  "Return true if o is of type PyBool_Type."
-  Integer
-  [p ensure-pyobj])
-
-
-(defn Py_True
-  "The Python True object. This object has no methods. It needs to be treated just like
-  any other object with respect to reference counts."
-  ^Pointer []
-  (find-pylib-symbol "_Py_TrueStruct"))
-
-
-(defn Py_False
-  "The Python False object. This object has no methods. It needs to be treated just like
-  any other object with respect to reference counts."
-  ^Pointer []
-  (find-pylib-symbol "_Py_FalseStruct"))
-
-
-(def-pylib-fn PyBool_FromLong
-  "Return value: New reference.
-
-   Return a new reference to Py_True or Py_False depending on the truth value of v."
-  Pointer
-  [v int])
diff --git a/src/libpython_clj/jna/concrete/numeric/complex.clj b/src/libpython_clj/jna/concrete/numeric/complex.clj
deleted file mode 100644
index 215e97f..0000000
--- a/src/libpython_clj/jna/concrete/numeric/complex.clj
+++ /dev/null
@@ -1,57 +0,0 @@
-(ns libpython-clj.jna.concrete.numeric.complex
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     find-pylib-symbol]
-             :as libpy-base]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyComplex PyComplex$ByValue
-            PyObject]))
-
-
-(def-pylib-fn PyComplex_Check
-  "Return true if its argument is a PyComplexObject or a subtype of PyComplexObject."
-  Integer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyComplex_FromCComplex
-  "Return value: New reference.
-
-   Create a new Python complex number object from a C Py_complex value."
-  Pointer
-  [v (partial jna/ensure-type PyComplex$ByValue)])
-
-
-(def-pylib-fn PyComplex_FromDoubles
-  "Return value: New reference.
-
-   Return a new PyComplexObject object from real and imag."
-  Pointer
-  [real double]
-  [imag double])
-
-
-(def-pylib-fn PyComplex_RealAsDouble
-  "Return the real part of op as a C double."
-  Double
-  [op ensure-pyobj])
-
-
-(def-pylib-fn PyComplex_ImagAsDouble
-  "Return the imaginary part of op as a C double."
-  Double
-  [op ensure-pyobj])
-
-
-(def-pylib-fn PyComplex_AsCComplex
-  "Return the Py_complex value of the complex number op.
-
-   If op is not a Python complex number object but has a __complex__() method, this
-   method will first be called to convert op to a Python complex number object. Upon
-   failure, this method returns -1.0 as a real value."
-  PyComplex$ByValue
-  [op ensure-pyobj])
diff --git a/src/libpython_clj/jna/concrete/numeric/float.clj b/src/libpython_clj/jna/concrete/numeric/float.clj
deleted file mode 100644
index 14ed289..0000000
--- a/src/libpython_clj/jna/concrete/numeric/float.clj
+++ /dev/null
@@ -1,65 +0,0 @@
-(ns libpython-clj.jna.concrete.numeric.float
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     *python-library*]
-             :as libpy-base])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject DirectMapped]))
-
-
-(def-pylib-fn PyFloat_Check
-  "Return true if its argument is a PyFloatObject or a subtype of PyFloatObject."
-  Integer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyFloat_CheckExact
-  "Return true if its argument is a PyFloatObject, but not a subtype of PyFloatObject."
-  Integer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyFloat_FromString
-  "Return value: New reference.
-
-   Create a PyFloatObject object based on the string value in str, or NULL on failure."
-  Pointer
-  [str ensure-pyobj])
-
-
-(defn PyFloat_FromDouble
-  "Return value: New reference.
-
-   Create a PyFloatObject object from v, or NULL on failure."
-  ^Pointer [v]
-  (DirectMapped/PyFloat_FromDouble (double v)))
-
-
-(defn PyFloat_AsDouble
-  "Return a C double representation of the contents of pyfloat. If pyfloat is not a
-  Python floating point object but has a __float__() method, this method will first be
-  called to convert pyfloat into a float. This method returns -1.0 upon failure, so one
-  should call PyErr_Occurred() to check for errors."
-  ^double [v]
-  (DirectMapped/PyFloat_AsDouble (ensure-pyobj v)))
-
-
-(def-pylib-fn PyFloat_GetInfo
-  "Return value: New reference.
-
-   Return a structseq instance which contains information about the precision, minimum
-   and maximum values of a float. It’s a thin wrapper around the header file float.h."
-  Pointer)
-
-
-(def-pylib-fn PyFloat_GetMax
-  "Return the maximum representable finite float DBL_MAX as C double."
-  Double)
-
-
-(def-pylib-fn PyFloat_GetMin
-  "Return the minimum normalized positive float DBL_MIN as C double."
-  Double)
diff --git a/src/libpython_clj/jna/concrete/numeric/integer.clj b/src/libpython_clj/jna/concrete/numeric/integer.clj
deleted file mode 100644
index 2b80db4..0000000
--- a/src/libpython_clj/jna/concrete/numeric/integer.clj
+++ /dev/null
@@ -1,100 +0,0 @@
-(ns libpython-clj.jna.concrete.numeric.integer
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject DirectMapped]))
-
-
-(def-pylib-fn PyLong_Check
-  "Return true if its argument is a PyLongObject or a subtype of PyLongObject."
-  Integer
-  [p ensure-pyobj])
-
-
-
-(def-pylib-fn PyLong_CheckExact
-  "Return true if its argument is a PyLongObject, but not a subtype of PyLongObject."
-  Integer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyLong_FromLong
-  "Return value: New reference.
-
-   Return a new PyLongObject object from v, or NULL on failure.
-
-   The current implementation keeps an array of integer objects for all integers between
-   -5 and 256, when you create an int in that range you actually just get back a
-   reference to the existing object. So it should be possible to change the value of
-   1. I suspect the behaviour of Python in this case is undefined. :-)"
-  Pointer
-  [v int])
-
-
-(def-pylib-fn PyLong_FromUnsignedLong
-  "Return value: New reference.
-
-   Return a new PyLongObject object from a C unsigned long, or NULL on failure."
-  Pointer
-  [v unchecked-int])
-
-
-(def-pylib-fn PyLong_FromSsize_t
-  "Return value: New reference.
-
-   Return a new PyLongObject object from a C Py_ssize_t, or NULL on failure."
-  Pointer
-  [v jna/size-t])
-
-
-(defn PyLong_FromLongLong
-  "Return value: New reference.
-
-   Return a new PyLongObject object from a C long long, or NULL on failure."
-  ^Pointer [v]
-  (DirectMapped/PyLong_FromLongLong (long v)))
-
-
-(def-pylib-fn PyLong_FromUnsignedLongLong
-  "Return value: New reference.
-
-   Return a new PyLongObject object from a C unsigned long long, or NULL on failure."
-  Pointer
-  [v unchecked-long])
-
-
-(def-pylib-fn PyLong_FromDouble
-  "Return value: New reference.
-
-   Return a new PyLongObject object from the integer part of v, or NULL on failure."
-  Pointer
-  [v double])
-
-
-(def-pylib-fn PyLong_AsLong
-  "Return a C long representation of obj. If obj is not an instance of PyLongObject,
-  first call its __int__() method (if present) to convert it to a PyLongObject.
-
-   Raise OverflowError if the value of obj is out of range for a long.
-
-   Returns -1 on error. Use PyErr_Occurred() to disambiguate."
-  Integer
-  [obj ensure-pyobj])
-
-
-(defn PyLong_AsLongLong
-  "Return a C long long representation of obj. If obj is not an instance of
-  PyLongObject, first call its __int__() method (if present) to convert it to a
-  PyLongObject.
-
-   Raise OverflowError if the value of obj is out of range for a long.
-
-   Returns -1 on error. Use PyErr_Occurred() to disambiguate."
-  ^long [obj]
-  (DirectMapped/PyLong_AsLongLong (ensure-pyobj obj)))
diff --git a/src/libpython_clj/jna/concrete/set.clj b/src/libpython_clj/jna/concrete/set.clj
deleted file mode 100644
index 1370c9f..0000000
--- a/src/libpython_clj/jna/concrete/set.clj
+++ /dev/null
@@ -1,92 +0,0 @@
-(ns libpython-clj.jna.concrete.set
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
-
-
-(def-pylib-fn PySet_Check
-  "Return true if p is a set object or an instance of a subtype."
-  Integer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PyFrozenSet_Check
-  "Return true if p is a frozenset object or an instance of a subtype."
-  Integer
-  [p ensure-pyobj])
-
-
-(def-pylib-fn PySet_New
-  "Return value: New reference.
-
-   Return a new set containing objects returned by the iterable. The iterable may be
-   NULL to create a new empty set. Return the new set on success or NULL on
-   failure. Raise TypeError if iterable is not actually iterable. The constructor is
-   also useful for copying a set (c=set(s))."
-  Pointer
-  [iterable ensure-pyobj])
-
-
-(def-pylib-fn PyFrozenSet_New
-  "Return value: New reference.
-
-   Return a new frozenset containing objects returned by the iterable. The iterable may
-   be NULL to create a new empty frozenset. Return the new set on success or NULL on
-   failure. Raise TypeError if iterable is not actually iterable."
-  Pointer
-  [iterable ensure-pyobj])
-
-
-(def-pylib-fn PySet_Contains
-  "Return 1 if found, 0 if not found, and -1 if an error is encountered. Unlike the
-  Python __contains__() method, this function does not automatically convert unhashable
-  sets into temporary frozensets. Raise a TypeError if the key is unhashable. Raise
-  PyExc_SystemError if anyset is not a set, frozenset, or an instance of a subtype."
-  Integer
-  [anyset ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PySet_Add
-  "Add key to a set instance. Also works with frozenset instances (like
-  PyTuple_SetItem() it can be used to fill-in the values of brand new frozensets before
-  they are exposed to other code). Return 0 on success or -1 on failure. Raise a
-  TypeError if the key is unhashable. Raise a MemoryError if there is no room to
-  grow. Raise a SystemError if set is not an instance of set or its subtype."
-  Integer
-  [set ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PySet_Discard
-  "Return 1 if found and removed, 0 if not found (no action taken), and -1 if an error
-  is encountered. Does not raise KeyError for missing keys. Raise a TypeError if the key
-  is unhashable. Unlike the Python discard() method, this function does not
-  automatically convert unhashable sets into temporary frozensets. Raise
-  PyExc_SystemError if set is not an instance of set or its subtype."
-  Integer
-  [set ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PySet_Pop
-  "Return value: New reference.
-
-   Return a new reference to an arbitrary object in the set, and removes the object from
-   the set. Return NULL on failure. Raise KeyError if the set is empty. Raise a
-   SystemError if set is not an instance of set or its subtype."
-  Pointer
-  [set ensure-pyobj])
-
-
-(def-pylib-fn PySet_Clear
-  "Empty an existing set of all elements."
-  Integer
-  [set ensure-pyobj])
diff --git a/src/libpython_clj/jna/concrete/tuple.clj b/src/libpython_clj/jna/concrete/tuple.clj
deleted file mode 100644
index 5b44e04..0000000
--- a/src/libpython_clj/jna/concrete/tuple.clj
+++ /dev/null
@@ -1,59 +0,0 @@
-(ns libpython-clj.jna.concrete.tuple
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject DirectMapped]))
-
-
-(def-pylib-fn PyTuple_Check
-  "Return true if p is a tuple object or an instance of a subtype of the tuple type."
-  Integer
-  [p ensure-pyobj])
-
-
-(defn PyTuple_New
-  "Return value: New reference.
-
-   Return a new tuple object of size len, or NULL on failure."
-  ^Pointer [^long len]
-  (DirectMapped/PyTuple_New (long len)))
-
-
-(defn PyTuple_GetItem
-  "Return value: Borrowed reference.
-
-   Return the object at position pos in the tuple pointed to by p. If pos is out of
-   bounds, return NULL and sets an IndexError exception."
-  ^Pointer [p pos]
-  (DirectMapped/PyTuple_GetItem (ensure-pyobj p) (long pos)))
-
-
-(def-pylib-fn PyTuple_GetSlice
-  "Return value: New reference.
-
-   Take a slice of the tuple pointed to by p from low to high and return it as a new
-   tuple."
-  Pointer
-  [p ensure-pyobj]
-  [low jna/size-t]
-  [high jna/size-t])
-
-
-(defn PyTuple_SetItem
-  "Insert a reference to object o at position pos of the tuple pointed to by p. Return 0
-  on success.
-
-   Note
-
-   This function “steals” a reference to o"
-  ^long [p pos o]
-  (long (DirectMapped/PyTuple_SetItem (ensure-pyobj p)
-                                      (long pos)
-                                      (ensure-pyobj o))))
diff --git a/src/libpython_clj/jna/concrete/type.clj b/src/libpython_clj/jna/concrete/type.clj
deleted file mode 100644
index 52db927..0000000
--- a/src/libpython_clj/jna/concrete/type.clj
+++ /dev/null
@@ -1,137 +0,0 @@
-(ns libpython-clj.jna.concrete.type
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyMethodDef PyTypeObject PyObject]))
-
-
-(def Py_TPFLAGS_HEAPTYPE (bit-shift-left 1 9))
-
-;; /* Set if the type allows subclassing */
-(def Py_TPFLAGS_BASETYPE (bit-shift-left 1 10))
-
-;; /* Set if the type is 'ready' -- fully initialized */
-(def Py_TPFLAGS_READY (bit-shift-left 1 12))
-
-;; /* Set while the type is being 'readied', to prevent recursive ready calls */
-(def Py_TPFLAGS_READYING (bit-shift-left 1 13))
-
-;; /* Objects support garbage collection (see objimp.h) */
-(def Py_TPFLAGS_HAVE_GC (bit-shift-left 1 14))
-
-;; /* These two bits are preserved for Stackless Python, next after this is 17 */
-;;We aren't going there
-;; #ifdef STACKLESS
-;; #define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION (3UL << 15)
-;; #else
-(def Py_TPFLAGS_HAVE_STACKLESS_EXTENSION 0)
-;; #endif
-
-;; /* Objects support type attribute cache */
-(def Py_TPFLAGS_HAVE_VERSION_TAG (bit-shift-left 1 18))
-(def Py_TPFLAGS_VALID_VERSION_TAG (bit-shift-left 1 19))
-
-;; /* Type is abstract and cannot be instantiated */
-(def Py_TPFLAGS_IS_ABSTRACT (bit-shift-left 1 20))
-
-;; /* These flags are used to determine if a type is a subclass. */
-;; #define Py_TPFLAGS_LONG_SUBCLASS        (1UL << 24)
-;; #define Py_TPFLAGS_LIST_SUBCLASS        (1UL << 25)
-;; #define Py_TPFLAGS_TUPLE_SUBCLASS       (1UL << 26)
-;; #define Py_TPFLAGS_BYTES_SUBCLASS       (1UL << 27)
-;; #define Py_TPFLAGS_UNICODE_SUBCLASS     (1UL << 28)
-;; #define Py_TPFLAGS_DICT_SUBCLASS        (1UL << 29)
-;; #define Py_TPFLAGS_BASE_EXC_SUBCLASS    (1UL << 30)
-;; #define Py_TPFLAGS_TYPE_SUBCLASS        (1UL << 31)
-
-(def Py_TPFLAGS_DEFAULT  (bit-or Py_TPFLAGS_HAVE_STACKLESS_EXTENSION
-                                 Py_TPFLAGS_HAVE_VERSION_TAG))
-
-;;structmember
-
-;; #define T_SHORT     0
-;; #define T_INT       1
-;; #define T_LONG      2
-;; #define T_FLOAT     3
-;; #define T_DOUBLE    4
-;; #define T_STRING    5
-;; #define T_OBJECT    6
-;; /* XXX the ordering here is weird for binary compatibility */
-;; #define T_CHAR      7   /* 1-character string */
-;; #define T_BYTE      8   /* 8-bit signed int */
-;; /* unsigned variants: */
-;; #define T_UBYTE     9
-;; #define T_USHORT    10
-;; #define T_UINT      11
-;; #define T_ULONG     12
-
-;; /* Added by Jack: strings contained in the structure */
-;; #define T_STRING_INPLACE    13
-
-;; /* Added by Lillo: bools contained in the structure (assumed char) */
-;; #define T_BOOL      14
-
-;; #define T_OBJECT_EX 16  /* Like T_OBJECT, but raises AttributeError
-;;                            when the value is NULL, instead of
-;;                            converting to None. */
-;; #define T_LONGLONG      17
-;; #define T_ULONGLONG     18
-
-;; #define T_PYSSIZET      19      /* Py_ssize_t */
-;; #define T_NONE          20      /* Value is always None */
-
-
-;; /* Flags */
-;; #define READONLY            1
-;; #define READ_RESTRICTED     2
-;; #define PY_WRITE_RESTRICTED 4
-;; #define RESTRICTED          (READ_RESTRICTED | PY_WRITE_RESTRICTED)
-
-
-
-(def-pylib-fn PyType_Check
-  "Return true if the object o is a type object, including instances of types derived
-  from the standard type object. Return false in all other cases"
-  Integer
-  [o ensure-pyobj])
-
-
-(def-pylib-fn PyType_GenericNew
-  "Return value: New reference.
-
-   Generic handler for the tp_new slot of a type object. Create a new instance using the
-   type’s tp_alloc slot."
-  Pointer
-  [type (partial jna/ensure-type PyTypeObject)]
-  [args #(when % (ensure-pyobj %))]
-  [kwds #(when % (ensure-pyobj %))])
-
-
-(def-pylib-fn PyType_Ready
-  "Finalize a type object. This should be called on all type objects to finish their
-  initialization. This function is responsible for adding inherited slots from a type’s
-  base class. Return 0 on success, or return -1 and sets an exception on error."
-  Integer
-  [type (partial jna/ensure-type PyTypeObject)])
-
-
-(def-pylib-fn _PyObject_New
-  "Return value: New reference."
-  Pointer
-  [type (partial jna/ensure-type PyTypeObject)])
-
-
-(def-pylib-fn PyObject_Del
-  "Releases memory allocated to an object using PyObject_New() or
-  PyObject_NewVar(). This is normally called from the tp_dealloc handler specified in
-  the object’s type. The fields of the object should not be accessed after this call as
-  the memory is no longer a valid Python object."
-  Pointer
-  [op ensure-pyobj])
diff --git a/src/libpython_clj/jna/concrete/unicode.clj b/src/libpython_clj/jna/concrete/unicode.clj
deleted file mode 100644
index e44000c..0000000
--- a/src/libpython_clj/jna/concrete/unicode.clj
+++ /dev/null
@@ -1,87 +0,0 @@
-(ns libpython-clj.jna.concrete.unicode
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     find-pylib-symbol
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna]
-            [tech.v3.datatype :as dtype]
-            [tech.v3.datatype.nio-buffer :as nio-buffer])
-  (:import [com.sun.jna Pointer]
-           [com.sun.jna.ptr PointerByReference
-            LongByReference IntByReference]
-           [libpython_clj.jna PyObject DirectMapped]))
-
-
-
-(defn PyUnicode_Decode
-  "Return value: New reference.
-
-   Create a Unicode object by decoding size bytes of the encoded string s. encoding and
-   errors have the same meaning as the parameters of the same name in the str() built-in
-   function. The codec to be used is looked up using the Python codec registry. Return
-   NULL if an exception was raised by the codec.
-
-  Signature:
-  PyObject* (const char *s, Py_ssize_t size, const char *encoding, const char *errors)"
-  ^Pointer [s size encoding errors]
-  (DirectMapped/PyUnicode_Decode (nio-buffer/->nio-buffer s)
-                                 (jna/size-t size)
-                                 (str encoding)
-                                 (str errors)))
-
-
-(def-pylib-fn PyUnicode_AsEncodedString
-  "Return value: New reference.
-
-   Encode a Unicode object and return the result as Python bytes object. encoding and
-   errors have the same meaning as the parameters of the same name in the Unicode
-   encode() method. The codec to be used is looked up using the Python codec
-   registry. Return NULL if an exception was raised by the codec.
-   Signature:
-   PyObject* (PyObject *unicode, const char *encoding, const char *errors)"
-  Pointer
-  [s ensure-pyobj]
-  [encoding str]
-  [errors str])
-
-
-(defn size-t-by-reference-type
-  []
-  (if (instance? Long (jna/size-t 0))
-    LongByReference
-    IntByReference))
-
-
-(defn PyUnicode_AsUTF8AndSize
-  "Return a pointer to the UTF-8 encoding of the Unicode object, and store the size of
-   the encoded representation (in bytes) in size. The size argument can be NULL; in this
-   case no size will be stored. The returned buffer always has an extra null byte
-   appended (not included in size), regardless of whether there are any other null code
-   points.
-
-   In the case of an error, NULL is returned with an exception set and no size is stored.
-
-   This caches the UTF-8 representation of the string in the Unicode object, and
-   subsequent calls will return a pointer to the same buffer. The caller is not
-   responsible for deallocating the buffer.
-
-   New in version 3.3.
-
-   Changed in version 3.7: The return type is now const char * rather of char *."
-  ^Pointer [py-obj size-ptr]
-  (DirectMapped/PyUnicode_AsUTF8AndSize (ensure-pyobj py-obj)
-                                        ^LongByReference size-ptr))
-
-
-(def-pylib-fn PyUnicode_AsUTF8
-  "As PyUnicode_AsUTF8AndSize(), but does not store the size.
-
-   New in version 3.3.
-
-   Changed in version 3.7: The return type is now const char * rather of char *."
-  Pointer
-  [py-obj ensure-pyobj])
diff --git a/src/libpython_clj/jna/interpreter.clj b/src/libpython_clj/jna/interpreter.clj
deleted file mode 100644
index 7cdb26b..0000000
--- a/src/libpython_clj/jna/interpreter.clj
+++ /dev/null
@@ -1,400 +0,0 @@
-(ns libpython-clj.jna.interpreter
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     def-no-gil-pylib-fn
-                     as-pyobj
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     find-pylib-symbol
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna]
-            [libpython-clj.jna.protocols.object :as pyobj]
-            [libpython-clj.jna.concrete.unicode :as pyuni]
-            [camel-snake-kebab.core :refer [->kebab-case]]
-            [clojure.tools.logging :as log])
-  (:import [com.sun.jna Pointer Native NativeLibrary]
-           [com.sun.jna.ptr PointerByReference]
-           [libpython_clj.jna PyObject DirectMapped]))
-
-
-
-(def-no-gil-pylib-fn Py_SetProgramName
-  "This function should be called before Py_Initialize() is called for the first time,
-  if it is called at all. It tells the interpreter the value of the argv[0] argument to
-  the main() function of the program (converted to wide characters). This is used by
-  Py_GetPath() and some other functions below to find the Python run-time libraries
-  relative to the interpreter executable. The default value is 'python'. The argument
-  should point to a zero-terminated wide character string in static storage whose
-  contents will not change for the duration of the program’s execution. No code in the
-  Python interpreter will change the contents of this storage.
-
-  Use Py_DecodeLocale() to decode a bytes string to get a wchar_* string."
-  nil
-  [name jna/ensure-ptr])
-
-
-
-
-(def-no-gil-pylib-fn Py_SetPythonHome
-  "Set the default “home” directory, that is, the location of the standard Python
-  libraries. See PYTHONHOME for the meaning of the argument string.
-
-  The argument should point to a zero-terminated character string in static storage
-  whose contents will not change for the duration of the program’s execution. No code
-  in the Python interpreter will change the contents of this storage.
-
-  Use Py_DecodeLocale() to decode a bytes string to get a wchar_* string."
-  nil
-  [home jna/ensure-ptr])
-
-
-
-;; Bugs and caveats: The destruction of modules and objects in modules is done in random
-;; order; this may cause destructors (__del__() methods) to fail when they depend on
-;; other objects (even functions) or modules. Dynamically loaded extension modules
-;; loaded by Python are not unloaded. Small amounts of memory allocated by the Python
-;; interpreter may not be freed (if you find a leak, please report it). Memory tied up
-;; in circular references between objects is not freed. Some memory allocated by
-;; extension modules may not be freed. Some extensions may not work properly if their
-;; initialization routine is called more than once; this can happen if an application
-;; calls Py_Initialize() and Py_Finalize() more than once.
-
-
-(def-no-gil-pylib-fn Py_InitializeEx
-  "This function works like Py_Initialize() if initsigs is 1. If initsigs is 0, it skips
-  initialization registration of signal handlers, which might be useful when Python is
-  embedded."
-  nil
-  [initsigs int])
-
-
-
-(def-no-gil-pylib-fn Py_IsInitialized
-  "Return true (nonzero) when the Python interpreter has been initialized, false (zero)
-  if not. After Py_Finalize() is called, this returns false until Py_Initialize() is
-  called again."
-  Integer)
-
-
-(def-no-gil-pylib-fn Py_FinalizeEx
-  "Undo all initializations made by Py_Initialize() and subsequent use of Python/C API
-  functions, and destroy all sub-interpreters (see Py_NewInterpreter() below) that were
-  created and not yet destroyed since the last call to Py_Initialize(). Ideally, this
-  frees all memory allocated by the Python interpreter. This is a no-op when called for
-  a second time (without calling Py_Initialize() again first). There is no return value;
-  errors during finalization are ignored."
-  Integer)
-
-
-(def-pylib-fn PyRun_SimpleString
-  "This is a simplified interface to PyRun_SimpleStringFlags() below, leaving the
-  PyCompilerFlags* argument set to NULL."
-  Integer
-  [command str])
-
-;; System Functionality
-
-(def-no-gil-pylib-fn PySys_SetArgv
-  "This function works like PySys_SetArgvEx() with updatepath set to 1 unless the python
-  interpreter was started with the -I.
-
-    Use Py_DecodeLocale() to decode a bytes string to get a wchar_* string.
-
-    Changed in version 3.4: The updatepath value depends on -I."
-  nil
-  [argc int]
-  [argv ensure-pyobj])
-
-
-;; chrisn@chrisn-dt:~/dev/cnuernber/libpython-clj$ nm -D /usr/lib/x86_64-linux-gnu/libpython3.7m.so | grep -i _type
-;; Then a few more transformations.
-(def type-symbol-names
-  ["PyAsyncGen_Type"
-   "PyBaseObject_Type"
-   "PyBool_Type"
-   "PyBufferedIOBase_Type"
-   "PyBufferedRandom_Type"
-   "PyBufferedReader_Type"
-   "PyBufferedRWPair_Type"
-   "PyBufferedWriter_Type"
-   "PyByteArrayIter_Type"
-   "PyByteArray_Type"
-   "PyBytesIO_Type"
-   "PyBytesIter_Type"
-   "PyBytes_Type"
-   "PyCallIter_Type"
-   "PyCapsule_Type"
-   "PyCell_Type"
-   "PyCFunction_Type"
-   "PyClassMethodDescr_Type"
-   "PyClassMethod_Type"
-   "PyCode_Type"
-   "PyComplex_Type"
-   "PyContextTokenMissing_Type"
-   "PyContextToken_Type"
-   "PyContext_Type"
-   "PyContextVar_Type"
-   "PyCoro_Type"
-   "PyDictItems_Type"
-   "PyDictIterItem_Type"
-   "PyDictIterKey_Type"
-   "PyDictIterValue_Type"
-   "PyDictKeys_Type"
-   "PyDictProxy_Type"
-   "PyDict_Type"
-   "PyDictValues_Type"
-   "PyEllipsis_Type"
-   "PyEnum_Type"
-   "PyFileIO_Type"
-   "PyFilter_Type"
-   "PyFloat_Type"
-   "PyFrame_Type"
-   "PyFrozenSet_Type"
-   "PyFunction_Type"
-   "PyGen_Type"
-   "PyGetSetDescr_Type"
-   "PyIncrementalNewlineDecoder_Type"
-   "PyInstanceMethod_Type"
-   "PyIOBase_Type"
-   "PyListIter_Type"
-   "PyListRevIter_Type"
-   "PyList_Type"
-   "PyLongRangeIter_Type"
-   "PyLong_Type"
-   "PyMap_Type"
-   "PyMemberDescr_Type"
-   "PyMemoryView_Type"
-   "PyMethodDescr_Type"
-   "PyMethod_Type"
-   "PyModuleDef_Type"
-   "PyModule_Type"
-   "PyODictItems_Type"
-   "PyODictIter_Type"
-   "PyODictKeys_Type"
-   "PyODict_Type"
-   "PyODictValues_Type"
-   "PyProperty_Type"
-   "PyRangeIter_Type"
-   "PyRange_Type"
-   "PyRawIOBase_Type"
-   "PyReversed_Type"
-   "PySeqIter_Type"
-   "PySetIter_Type"
-   "PySet_Type"
-   "PySlice_Type"
-   "PyStaticMethod_Type"
-   "PyStdPrinter_Type"
-   "PySTEntry_Type"
-   "PyStringIO_Type"
-   "PySuper_Type"
-   "PyTextIOBase_Type"
-   "PyTextIOWrapper_Type"
-   "PyTraceBack_Type"
-   "PyTupleIter_Type"
-   "PyTuple_Type"
-   "PyType_Type"
-   "PyUnicodeIter_Type"
-   "PyUnicode_Type"
-   "PyWrapperDescr_Type"
-   "PyZip_Type"])
-
-
-(def type-symbol-table
-  (->> type-symbol-names
-       (map (juxt (comp keyword ->kebab-case) identity))
-       (into {})))
-
-
-;; (-> (pyobj/PyObject_GetAttrString symbol-addr "__name__")
-;;                                   (pyuni/PyUnicode_AsUTF8)
-;;                                   (jna/variable-byte-ptr->string)
-;;                                   keyword)
-
-
-(defn get-type-name
-  [type-pyobj]
-  (if-let [obj-name (pyobj/PyObject_GetAttrString type-pyobj "__name__")]
-    (-> (pyuni/PyUnicode_AsUTF8 obj-name)
-        (jna/variable-byte-ptr->string)
-        ->kebab-case
-        keyword)
-    (do
-      (log/warn "Failed to get typename for object")
-      :typename-lookup-failure)))
-
-
-(defn lookup-type-symbols
-  "Transform the static type-symbol-table map into a map of actual long pointer addresses to
-  {:typename :type-symbol-name}"
-  []
-  (->> type-symbol-table
-       (map (fn [[typename type-symbol-name]]
-              (try
-                (when-let [symbol-addr (find-pylib-symbol type-symbol-name)]
-                  [(Pointer/nativeValue symbol-addr)
-                   {:typename (get-type-name symbol-addr)
-                    :type-symbol-name type-symbol-name}])
-                (catch Throwable e nil))))
-       (remove nil?)
-       (into {})))
-
-
-(defn Py_None
-  []
-  (find-pylib-symbol "_Py_NoneStruct"))
-
-
-(defn Py_NotImplemented
-  []
-  (find-pylib-symbol "_Py_NotImplementedStruct"))
-
-;; Interpreter level protocols
-
-(def-pylib-fn PyMem_Free
-  "Frees the memory block pointed to by p, which must have been returned by a previous
-  call to PyMem_Malloc(), PyMem_Realloc() or PyMem_Calloc(). Otherwise, or if
-  PyMem_Free(p) has been called before, undefined behavior occurs.
-
-   If p is NULL, no operation is performed."
-  nil
-  [data-ptr jna/as-ptr])
-
-
-(defn PyGILState_Ensure
-  "Ensure that the current thread is ready to call the Python C API regardless of
-   the current state of Python, or of the global interpreter lock. This may be called
-   as many times as desired by a thread as long as each call is matched with a call
-   to PyGILState_Release(). In general, other thread-related APIs may be used between
-   PyGILState_Ensure() and PyGILState_Release() calls as long as the thread state is
-   restored to its previous state before the Release(). For example, normal usage of
-   the Py_BEGIN_ALLOW_THREADS and Py_END_ALLOW_THREADS macros is acceptable.
-
-   The return value is an opaque “handle” to the thread state when PyGILState_Ensure()
-   was called, and must be passed to PyGILState_Release() to ensure Python is left in
-   the same state. Even though recursive calls are allowed, these handles cannot be shared -
-   each unique call to PyGILState_Ensure() must save the handle for its call to PyGILState_Release().
-
-   When the function returns, the current thread will hold the GIL and be able to call
-   arbitrary Python code. Failure is a fatal error."
-  ^long []
-  (DirectMapped/PyGILState_Ensure))
-
-(defn PyGILState_Release
-  "Release any resources previously acquired. After this call, Python’s state will be
-   the same as it was prior to the corresponding PyGILState_Ensure() call (but generally
-   this state will be unknown to the caller, hence the use of the GILState API).
-
-   Every call to PyGILState_Ensure() must be matched by a call to PyGILState_Release()
-   on the same thread."
-  [^long s]
-  (DirectMapped/PyGILState_Release s))
-
-(defn PyGILState_Check
-  "Return 1 if the current thread is holding the GIL and 0 otherwise. This function
-  can be called from any thread at any time. Only if it has had its Python thread
-  state initialized and currently is holding the GIL will it return 1. This is
-  mainly a helper/diagnostic function. It can be useful for example in callback
-  contexts or memory allocation functions when knowing that the GIL is locked can
-  allow the caller to perform sensitive actions or otherwise behave differently."
-  ^long []
-  (DirectMapped/PyGILState_Check))
-
-
-;;Acquire the GIL of the given thread state
-(defn PyEval_RestoreThread
-  "Acquire the global interpreter lock (if it has been created and thread support is
-  enabled) and set the thread state to tstate, which must not be NULL. If the lock has
-  been created, the current thread must not have acquired it, otherwise deadlock ensues.
-
-  Note
-
-  Calling this function from a thread when the runtime is finalizing will terminate the
-  thread, even if the thread was not created by Python. You can use _Py_IsFinalizing()
-  or sys.is_finalizing() to check if the interpreter is in process of being finalized
-  before calling this function to avoid unwanted termination."
-  [tstate]
-  (DirectMapped/PyEval_RestoreThread (ensure-pyobj tstate)))
-
-
-;;Release the GIL, return thread state
-(defn PyEval_SaveThread
-  "Release the global interpreter lock (if it has been created and thread support is
-  enabled) and reset the thread state to NULL, returning the previous thread state
-  (which is not NULL). If the lock has been created, the current thread must have
-  acquired it."
-  ^Pointer []
-  (DirectMapped/PyEval_SaveThread))
-
-
-;;Get current thread state for interpreter
-(def-pylib-fn PyThreadState_Get
-  "Return the current thread state. The global interpreter lock must be held. When the
-  current thread state is NULL, this issues a fatal error (so that the caller needn’t
-  check for NULL)."
-  Pointer)
-
-
-;;Swap threadstate for new interpreter without releasing gil
-(def-pylib-fn PyThreadState_Swap
-  "Swap the current thread state with the thread state given by the argument tstate,
-  which may be NULL. The global interpreter lock must be held and is not released."
-  Pointer
-  [tstate ensure-pyobj])
-
-
-(def start-symbol-table
-  {:py-single-input 256
-   :py-file-input 257
-   :py-eval-input 258})
-
-
-(defn start-symbol
-  [item]
-  (let [value (cond
-               (number? item)
-               (long item)
-               (keyword? item)
-               (get start-symbol-table item 0))
-        valid-values (set (vals start-symbol-table))]
-    (when-not (contains? valid-values value)
-      (throw (ex-info (format "%s is not a start symbol" item) {})))
-    (int value)))
-
-
-(def-pylib-fn PyRun_String
-  "Return value: New reference.
-
-   Execute Python source code from str in the context specified by the objects globals
-   and locals with the compiler flags specified by flags. globals must be a dictionary;
-   locals can be any object that implements the mapping protocol. The parameter start
-   specifies the start token that should be used to parse the source code.
-
-   Returns the result of executing the code as a Python object, or NULL if an exception
-   was raised."
-  Pointer
-  [program str]
-  [start-sym start-symbol]
-  [globals ensure-pydict]
-  ;;Any object that implements the mapping protocol
-  [locals ensure-pydict])
-
-
-(def-pylib-fn PyRun_StringFlags
-  "Return value: New reference.
-
-   Execute Python source code from str in the context specified by the objects globals
-   and locals with the compiler flags specified by flags. globals must be a dictionary;
-   locals can be any object that implements the mapping protocol. The parameter start
-   specifies the start token that should be used to parse the source code.
-
-   Returns the result of executing the code as a Python object, or NULL if an exception
-   was raised."
-  Pointer
-  [program str]
-  [start-sym start-symbol]
-  [globals ensure-pydict]
-  ;;Any object that implements the mapping protocol
-  [locals ensure-pydict]
-  [compilerflags identity])
diff --git a/src/libpython_clj/jna/protocols/buffer.clj b/src/libpython_clj/jna/protocols/buffer.clj
deleted file mode 100644
index 66d94f3..0000000
--- a/src/libpython_clj/jna/protocols/buffer.clj
+++ /dev/null
@@ -1,108 +0,0 @@
-(ns libpython-clj.jna.protocols.buffer
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna]
-            [tech.v3.datatype.nio-buffer :as nio-buffer])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyBuffer]))
-
-
-(def-pylib-fn PyObject_CheckBuffer
-  "Return 1 if obj supports the buffer interface otherwise 0. When 1 is returned, it
-  doesn’t guarantee that PyObject_GetBuffer() will succeed. This function always
-  succeeds."
-  Integer
-  [obj ensure-pyobj])
-
-
-;; /* Maximum number of dimensions */
-(def PyBUF_MAX_NDIM 64)
-
-;; /* Flags for getting buffers */
-(def PyBUF_SIMPLE 0)
-(def PyBUF_WRITABLE 0x0001)
-;; /*  we used to include an E, backwards compatible alias  */
-(def PyBUF_WRITEABLE PyBUF_WRITABLE)
-(def PyBUF_FORMAT 0x0004)
-(def PyBUF_ND 0x0008)
-(def PyBUF_STRIDES (bit-or 0x0010 PyBUF_ND))
-(def PyBUF_C_CONTIGUOUS (bit-or 0x0020 PyBUF_STRIDES))
-(def PyBUF_F_CONTIGUOUS (bit-or 0x0040 PyBUF_STRIDES))
-(def PyBUF_ANY_CONTIGUOUS (bit-or 0x0080 PyBUF_STRIDES))
-(def PyBUF_INDIRECT (bit-or 0x0100 PyBUF_STRIDES))
-
-(def PyBUF_CONTIG (bit-or PyBUF_ND PyBUF_WRITABLE))
-(def PyBUF_CONTIG_RO PyBUF_ND)
-
-(def PyBUF_STRIDED (bit-or PyBUF_STRIDES PyBUF_WRITABLE))
-(def PyBUF_STRIDED_RO PyBUF_STRIDES)
-
-(def PyBUF_RECORDS (bit-or PyBUF_STRIDES PyBUF_WRITABLE PyBUF_FORMAT))
-(def PyBUF_RECORDS_RO (bit-or PyBUF_STRIDES PyBUF_FORMAT))
-
-(def PyBUF_FULL (bit-or PyBUF_INDIRECT PyBUF_WRITABLE PyBUF_FORMAT))
-(def PyBUF_FULL_RO (bit-or PyBUF_INDIRECT PyBUF_FORMAT))
-
-
-(def PyBUF_READ  0x100)
-(def PyBUF_WRITE 0x200)
-
-
-
-(def-pylib-fn PyObject_GetBuffer
-  "Send a request to exporter to fill in view as specified by flags. If the exporter
-  cannot provide a buffer of the exact type, it MUST raise PyExc_BufferError, set
-  view->obj to NULL and return -1.
-
-   On success, fill in view, set view->obj to a new reference to exporter and return
-   0. In the case of chained buffer providers that redirect requests to a single object,
-   view->obj MAY refer to this object instead of exporter (See Buffer Object
-   Structures).
-
-   Successful calls to PyObject_GetBuffer() must be paired with calls to
-   PyBuffer_Release(), similar to malloc() and free(). Thus, after the consumer is done
-   with the buffer, PyBuffer_Release() must be called exactly once."
-  Integer
-  [exporter ensure-pyobj]
-  [view (partial jna/ensure-type PyBuffer)]
-  [flags int])
-
-
-
-(def-pylib-fn PyBuffer_Release
-  "Release the buffer view and decrement the reference count for view->obj. This
-  function MUST be called when the buffer is no longer being used, otherwise reference
-  leaks may occur.
-
-   It is an error to call this function on a buffer that was not obtained via
-   PyObject_GetBuffer()."
-  nil
-  [view (partial jna/ensure-type PyBuffer)])
-
-
-(def-pylib-fn PyBuffer_IsContiguous
-  "Return 1 if the memory defined by the view is C-style (order is 'C') or Fortran-style
-  (order is 'F') contiguous or either one (order is 'A'). Return 0 otherwise. This
-  function always succeeds."
-  Integer
-  [view (partial jna/ensure-type PyBuffer)]
-  [order byte])
-
-
-
-(def-pylib-fn PyBuffer_ToContiguous
-  "Copy len bytes from src to its contiguous representation in buf. order can be 'C' or
-  'F' (for C-style or Fortran-style ordering). 0 is returned on success, -1 on error.
-
-   This function fails if len != src->len."
-  Integer
-  [buf nio-buffer/as-nio-buffer]
-  [src (partial jna/ensure-type PyBuffer)]
-  [len jna/size-t]
-  [order byte])
diff --git a/src/libpython_clj/jna/protocols/iterator.clj b/src/libpython_clj/jna/protocols/iterator.clj
deleted file mode 100644
index c28c8a7..0000000
--- a/src/libpython_clj/jna/protocols/iterator.clj
+++ /dev/null
@@ -1,31 +0,0 @@
-(ns libpython-clj.jna.protocols.iterator
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
-
-
-
-
-(def-pylib-fn PyIter_Check
-  "Return true if the object o supports the iterator protocol."
-  Integer
-  [o ensure-pyobj])
-
-
-
-(def-pylib-fn PyIter_Next
-  "Return value: New reference.
-
-   Return the next value from the iteration o. The object must be an iterator (it is up
-   to the caller to check this). If there are no remaining values, returns NULL with no
-   exception set. If an error occurs while retrieving the item, returns NULL and passes
-   along the exception."
-  Pointer
-  [o ensure-pyobj])
diff --git a/src/libpython_clj/jna/protocols/mapping.clj b/src/libpython_clj/jna/protocols/mapping.clj
deleted file mode 100644
index ff9ebcc..0000000
--- a/src/libpython_clj/jna/protocols/mapping.clj
+++ /dev/null
@@ -1,118 +0,0 @@
-(ns libpython-clj.jna.protocols.mapping
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject]))
-
-
-
-(def-pylib-fn PyMapping_Check
-  "Return 1 if the object provides mapping protocol or supports slicing, and 0
-  otherwise. Note that it returns 1 for Python classes with a __getitem__() method since
-  in general case it is impossible to determine what the type of keys it supports. This
-  function always succeeds."
-  Integer
-  [o ensure-pyobj])
-
-
-(def-pylib-fn PyMapping_Length
-  "Returns the number of keys in object o on success, and -1 on failure. This is
-  equivalent to the Python expression len(o)."
-  size-t-type
-  [o ensure-pyobj])
-
-
-(def-pylib-fn PyMapping_GetItemString
-  "Return value: New reference.
-
-   Return element of o corresponding to the string key or NULL on failure. This is the
-   equivalent of the Python expression o[key]. See also PyObject_GetItem()."
-  Pointer
-  [o ensure-pyobj]
-  [key str])
-
-
-(def-pylib-fn PyMapping_SetItemString
-  "Map the string key to the value v in object o. Returns -1 on failure. This is the
-  equivalent of the Python statement o[key] = v. See also PyObject_SetItem()."
-  Integer
-  [o ensure-pyobj]
-  [key str]
-  [v ensure-pyobj])
-
-
-(def-pylib-fn PyMapping_DelItem
-  "Remove the mapping for the object key from the object o. Return -1 on failure. This
-  is equivalent to the Python statement del o[key]. This is an alias of
-  PyObject_DelItem()."
-  Integer
-  [o ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PyMapping_DelItemString
-  "Remove the mapping for the string key from the object o. Return -1 on failure. This
-  is equivalent to the Python statement del o[key]."
-  Integer
-  [o ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PyMapping_HasKey
-  "Return 1 if the mapping object has the key key and 0 otherwise. This is equivalent to
-  the Python expression key in o. This function always succeeds.
-
-   Note that exceptions which occur while calling the __getitem__() method will get
-   suppressed. To get error reporting use PyObject_GetItem() instead."
-  Integer
-  [o ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PyMapping_HasKeyString
-  "Return 1 if the mapping object has the key key and 0 otherwise. This is equivalent to
-  the Python expression key in o. This function always succeeds.
-
-   Note that exceptions which occur while calling the __getitem__() method and creating
-   a temporary string object will get suppressed. To get error reporting use
-   PyMapping_GetItemString() instead."
-  Integer
-  [o ensure-pyobj]
-  [key str])
-
-
-(def-pylib-fn PyMapping_Keys
-  "Return value: New reference.
-
-   On success, return a list of the keys in object o. On failure, return NULL.
-
-   Changed in version 3.7: Previously, the function returned a list or a tuple."
-  Pointer
-  [o ensure-pyobj])
-
-
-(def-pylib-fn PyMapping_Values
-  "Return value: New reference.
-
-   On success, return a list of the values in object o. On failure, return NULL.
-
-   Changed in version 3.7: Previously, the function returned a list or a tuple."
-  Pointer
-  [o ensure-pyobj])
-
-
-(def-pylib-fn PyMapping_Items
-  "Return value: New reference.
-
-   On success, return a list of the items in object o, where each item is a tuple
-   containing a key-value pair. On failure, return NULL.
-
-   Changed in version 3.7: Previously, the function returned a list or a tuple."
-  Pointer
-  [o ensure-pyobj])
diff --git a/src/libpython_clj/jna/protocols/object.clj b/src/libpython_clj/jna/protocols/object.clj
deleted file mode 100644
index 3ad78aa..0000000
--- a/src/libpython_clj/jna/protocols/object.clj
+++ /dev/null
@@ -1,409 +0,0 @@
-(ns libpython-clj.jna.protocols.object
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     as-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base]
-            [camel-snake-kebab.core :refer [->kebab-case]])
-  (:import [com.sun.jna Pointer Native NativeLibrary]
-           [com.sun.jna.ptr PointerByReference]
-           [libpython_clj.jna PyObject DirectMapped]))
-
-
-;; Object Protocol
-
-(defn Py_DecRef
-  "Decrement the refference count on an object"
-  [py-obj]
-  (DirectMapped/Py_DecRef (ensure-pyobj py-obj)))
-
-
-(defn Py_IncRef
-  "Increment the reference count on an object"
-  [py-obj]
-  (DirectMapped/Py_IncRef (ensure-pyobj py-obj)))
-
-
-;; object.h:937
-(def bool-fn-table
-  (->> {"Py_LT" 0
-        "Py_LE" 1
-        "Py_EQ" 2
-        "Py_NE" 3
-        "Py_GT" 4
-        "Py_GE" 5}
-       (map (fn [[k v]]
-              [(-> (->kebab-case k)
-                   keyword)
-               v]))
-       (into {})))
-(def bool-fn-value-set (set (vals bool-fn-table)))
-
-
-(defn bool-fn-constant
-  [item]
-  (let [value (cond
-                (number? item)
-                (long item)
-                (keyword? item)
-                (get bool-fn-table item))
-        value-set bool-fn-value-set]
-    (when-not (contains? value-set value)
-      (throw (ex-info (format "Unrecognized bool fn %s" item) {})))
-    (int value)))
-
-
-;;There is a good reason to use this function; then you aren't dependent upon the
-;;compile time representation of the pyobject item itself which changes if, for instance,
-;;tracing is enabled.
-(def-pylib-fn PyObject_Type
-  "Return value: New reference.
-
-   When o is non-NULL, returns a type object corresponding to the object type of object
-   o. On failure, raises SystemError and returns NULL. This is equivalent to the Python
-   expression type(o). This function increments the reference count of the return
-   value. There’s really no reason to use this function instead of the common
-   expression o->ob_type, which returns a pointer of type PyTypeObject*, except when
-   the incremented reference count is needed."
-  Pointer
-  [py-obj ensure-pyobj])
-
-
-
-(def-pylib-fn PyObject_Repr
-  "Return value: New reference.
-
-   Compute a string representation of object o. Returns the string representation on
-   success, NULL on failure. This is the equivalent of the Python expression
-   repr(o). Called by the repr() built-in function.
-
-   Changed in version 3.4: This function now includes a debug assertion to help ensure
-   that it does not silently discard an active exception."
-  Pointer
-  [py_obj ensure-pyobj])
-
-
-(def-pylib-fn PyObject_Str
-  "Return value: New reference.
-
-   Compute a string representation of object o. Returns the string representation on
-   success, NULL on failure. This is the equivalent of the Python expression str(o). Called
-   by the str() built-in function and by the print statement."
-  Pointer
-  [py-obj ensure-pyobj])
-
-
-(def-pylib-fn PyObject_HasAttr
-  "Returns 1 if o has the attribute attr_name, and 0 otherwise. This is equivalent to
-  the Python expression hasattr(o, attr_name). This function always succeeds.
-
-   Note that exceptions which occur while calling __getattr__() and __getattribute__()
-   methods will get suppressed. To get error reporting use PyObject_GetAttr() instead."
-  Integer
-  [pyobj ensure-pyobj]
-  [attr-name ensure-pyobj])
-
-
-(defn PyObject_HasAttrString
-  "Returns 1 if o has the attribute attr_name, and 0 otherwise. This is equivalent to
-  the Python expression hasattr(o, attr_name). This function always succeeds.
-
-   Note that exceptions which occur while calling __getattr__() and __getattribute__()
-   methods and creating a temporary string object will get suppressed. To get error
-   reporting use Object_GetAttrString() instead."
-  ^long [pyobj attr-name]
-  (long
-   (DirectMapped/PyObject_HasAttrString (ensure-pyobj pyobj)
-                                        (str attr-name))))
-
-
-(def-pylib-fn PyObject_GetAttr
-  "Return value: New reference.
-
-   Retrieve an attribute named attr_name from object o. Returns the attribute value on
-   success, or NULL on failure. This is the equivalent of the Python expression
-   o.attr_name."
-  Pointer
-  [pyobj ensure-pyobj]
-  [attr-name ensure-pyobj])
-
-
-(defn PyObject_GetAttrString
-  "Return value: New reference.
-
-   Retrieve an attribute named attr_name from object o. Returns the attribute value on
-   success, or NULL on failure. This is the equivalent of the Python expression
-   o.attr_name."
-  ^Pointer [pyobj attr-name]
-  (DirectMapped/PyObject_GetAttrString (ensure-pyobj pyobj)
-                                       (str attr-name)))
-
-
-(def-pylib-fn PyObject_GenericGetAttr
-  "Return value: New reference.
-
-   Generic attribute getter function that is meant to be put into a type object’s
-   tp_getattro slot. It looks for a descriptor in the dictionary of classes in the
-   object’s MRO as well as an attribute in the object’s __dict__ (if present). As
-   outlined in Implementing Descriptors, data descriptors take preference over instance
-   attributes, while non-data descriptors don’t. Otherwise, an AttributeError is
-   raised."
-  Pointer
-  [pyobj ensure-pyobj]
-  [attr-name ensure-pyobj])
-
-
-(def-pylib-fn PyObject_SetAttr
-  "Set the value of the attribute named attr_name, for object o, to the value v. Raise
-   an exception and return -1 on failure; return 0 on success. This is the equivalent of
-   the Python statement o.attr_name = v.
-
-   If v is NULL, the attribute is deleted, however this feature is deprecated in favour
-   of using PyObject_DelAttr()."
-  Integer
-  [pyobj ensure-pyobj]
-  [attr-name ensure-pyobj]
-  [v ensure-pyobj])
-
-
-
-(def-pylib-fn PyObject_SetAttrString
-  "Set the value of the attribute named attr_name, for object o, to the value v. Raise
-   an exception and return -1 on failure; return 0 on success. This is the equivalent of
-   the Python statement o.attr_name = v.
-
-   If v is NULL, the attribute is deleted, however this feature is deprecated in favour
-   of using PyObject_DelAttrString()."
-  Integer
-  [pyobj ensure-pyobj]
-  [attr-name str]
-  [v ensure-pyobj])
-
-
-(def-pylib-fn PyObject_GenericSetAttr
-  "Generic attribute setter and deleter function that is meant to be put into a type
-  object’s tp_setattro slot. It looks for a data descriptor in the dictionary of classes
-  in the object’s MRO, and if found it takes preference over setting or deleting the
-  attribute in the instance dictionary. Otherwise, the attribute is set or deleted in
-  the object’s __dict__ (if present). On success, 0 is returned, otherwise an
-  AttributeError is raised and -1 is returned."
-  Integer
-  [pyobj ensure-pyobj]
-  [attr-name ensure-pyobj]
-  [v ensure-pyobj])
-
-
-(def-pylib-fn PyObject_DelAttr
-  "Delete attribute named attr_name, for object o. Returns -1 on failure. This is the
-  equivalent of the Python statement del o.attr_name."
-  Integer
-  [pyobj ensure-pyobj]
-  [attr-name ensure-pyobj])
-
-
-(def-pylib-fn PyObject_DelAttrString
-  "Delete attribute named attr_name, for object o. Returns -1 on failure. This is the
-  equivalent of the Python statement del o.attr_name."
-  Integer
-  [pyobj ensure-pyobj]
-  [attr-name str])
-
-
-(def-pylib-fn PyObject_GenericGetDict
-  "Return value: New reference.
-
-   A generic implementation for the getter of a __dict__ descriptor. It creates the
-   dictionary if necessary.
-
-   New in version 3.3."
-  Pointer
-  [pyobj ensure-pyobj]
-  [context ensure-pyobj])
-
-
-(def-pylib-fn PyObject_GenericSetDict
-  "A generic implementation for the setter of a __dict__ descriptor. This implementation
-   does not allow the dictionary to be deleted.
-
-   New in version 3.3."
-  Integer
-  [pyobj ensure-pyobj]
-  [context ensure-pyobj])
-
-
-(def-pylib-fn PyObject_RichCompare
-  "Return value: New reference.
-
-   Compare the values of o1 and o2 using the operation specified by opid, which must be
-   one of Py_LT, Py_LE, Py_EQ, Py_NE, Py_GT, or Py_GE, corresponding to <, <=, ==, !=,
-   >, or >= respectively. This is the equivalent of the Python expression o1 op o2,
-   where op is the operator corresponding to opid. Returns the value of the comparison
-   on success, or NULL on failure."
-  Pointer
-  [o1 ensure-pyobj]
-  [o2 ensure-pyobj]
-  [opid bool-fn-constant])
-
-
-(def-pylib-fn PyObject_RichCompareBool
-  "Compare the values of o1 and o2 using the operation specified by opid, which must be
-  one of Py_LT, Py_LE, Py_EQ, Py_NE, Py_GT, or Py_GE, corresponding to <, <=, ==, !=, >,
-  or >= respectively. Returns -1 on error, 0 if the result is false, 1 otherwise. This
-  is the equivalent of the Python expression o1 op o2, where op is the operator
-  corresponding to opid.
-
-   Note
-
-   If o1 and o2 are the same object, PyObject_RichCompareBool() will always return 1 for
-   Py_EQ and 0 for Py_NE."
-  Integer
-  [o1 ensure-pyobj]
-  [o2 ensure-pyobj]
-  [opid bool-fn-constant])
-
-
-(defn PyCallable_Check
-  "Determine if the object o is callable. Return 1 if the object is callable and 0
-  otherwise. This function always succeeds."
-  ^long [pyobj]
-  (long (DirectMapped/PyCallable_Check (ensure-pyobj pyobj))))
-
-
-(defn PyObject_Call
-  "Return value: New reference.
-
-   Call a callable Python object callable, with arguments given by the tuple args, and
-   named arguments given by the dictionary kwargs.
-
-   args must not be NULL, use an empty tuple if no arguments are needed. If no named
-   arguments are needed, kwargs can be NULL.
-
-   Returns the result of the call on success, or NULL on failure.
-
-   This is the equivalent of the Python expression: callable(*args, **kwargs)."
-  ^Pointer [callable args kwargs]
-  (DirectMapped/PyObject_Call (ensure-pyobj callable)
-                              (ensure-pytuple args)
-                              (as-pyobj kwargs)))
-
-(defn PyObject_CallObject
-  "Return value: New reference.
-
-   Call a callable Python object callable, with arguments given by the tuple args. If no
-   arguments are needed, then args can be NULL.
-
-   Returns the result of the call on success, or NULL on failure.
-
-   This is the equivalent of the Python expression: callable(*args)."
-  ^Pointer [callable args]
-  (DirectMapped/PyObject_CallObject (ensure-pyobj callable)
-                                    (as-pyobj args)))
-
-
-(def-pylib-fn PyObject_Hash
-  "Compute and return the hash value of an object o. On failure, return -1. This is the
-  equivalent of the Python expression hash(o).
-
-   Changed in version 3.2: The return type is now Py_hash_t. This is a signed integer
-   the same size as Py_ssize_t."
-  size-t-type
-  [o ensure-pyobj])
-
-
-(def-pylib-fn PyObject_IsInstance
-  "Return 1 if inst is an instance of the class cls or a subclass of cls, or 0 if
-   not. On error, returns -1 and sets an exception.
-
-   If cls is a tuple, the check will be done against every entry in cls. The result
-   will be 1 when at least one of the checks returns 1, otherwise it will be 0.
-
-   If cls has a __instancecheck__() method, it will be called to determine the
-   subclass status as described in PEP 3119. Otherwise, inst is an instance of cls
-   if its class is a subclass of cls.
-
-   An instance inst can override what is considered its class by having a __class__
-   attribute.
-
-   An object cls can override if it is considered a class, and what its base
-   classes are, by having a __bases__ attribute (which must be a tuple of base
-   classes)."
-  Integer
-  [inst ensure-pyobj]
-  [cls ensure-pyobj])
-
-
-
-(def-pylib-fn PyObject_IsTrue
-  "Returns 1 if the object o is considered to be true, and 0 otherwise. This is
-  equivalent to the Python expression not not o. On failure, return -1."
-  Integer
-  [py-obj ensure-pyobj])
-
-
-(def-pylib-fn PyObject_Not
-  "Returns 0 if the object o is considered to be true, and 1 otherwise. This is
-  equivalent to the Python expression not o. On failure, return -1."
-  Integer
-  [py-obj ensure-pyobj])
-
-
-(def-pylib-fn PyObject_Length
-  "Return the length of object o. If the object o provides either the sequence and
-  mapping protocols, the sequence length is returned. On error, -1 is returned. This is
-  the equivalent to the Python expression len(o)."
-  Integer
-  [py-obj ensure-pyobj])
-
-
-(def-pylib-fn PyObject_GetItem
-  "Return value: New reference.
-
-   Return element of o corresponding to the object key or NULL on failure. This is the
-   equivalent of the Python expression o[key]."
-  Pointer
-  [o ensure-pyobj]
-  [key ensure-pyobj])
-
-
-(def-pylib-fn PyObject_SetItem
-  "Map the object key to the value v. Raise an exception and return -1 on failure;
-   return 0 on success. This is the equivalent of the Python statement o[key] = v."
-  Integer
-  [o ensure-pyobj]
-  [key ensure-pyobj]
-  [v ensure-pyobj])
-
-
-(def-pylib-fn PyObject_DelItem
-  "Remove the mapping for the object key from the object o. Return -1 on failure. This
-  is equivalent to the Python statement del o[key]."
-  Integer
-  [o ensure-pyobj]
-  [key ensure-pyobj])
-
-
-
-(def-pylib-fn PyObject_Dir
-  "Return value: New reference.
-
-   This is equivalent to the Python expression dir(o), returning a (possibly empty)
-   list of strings appropriate for the object argument, or NULL if there was an
-   error. If the argument is NULL, this is like the Python dir(), returning the names
-   of the current locals; in this case, if no execution frame is active then NULL is
-   returned but PyErr_Occurred() will return false."
-  Pointer
-  [o ensure-pyobj])
-
-
-(def-pylib-fn PyObject_GetIter
-  "Return value: New reference.
-
-   This is equivalent to the Python expression iter(o). It returns a new iterator for
-   the object argument, or the object itself if the object is already an
-   iterator. Raises TypeError and returns NULL if the object cannot be iterated."
-  Pointer
-  [o ensure-pyobj])
diff --git a/src/libpython_clj/jna/protocols/sequence.clj b/src/libpython_clj/jna/protocols/sequence.clj
deleted file mode 100644
index 8a77b8f..0000000
--- a/src/libpython_clj/jna/protocols/sequence.clj
+++ /dev/null
@@ -1,178 +0,0 @@
-(ns libpython-clj.jna.protocols.sequence
-  (:require [libpython-clj.jna.base
-             :refer [def-pylib-fn
-                     ensure-pyobj
-                     ensure-pytuple
-                     ensure-pydict
-                     size-t-type
-                     *python-library*]
-             :as libpy-base]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna Pointer]
-           [libpython_clj.jna PyObject DirectMapped]))
-
-
-
-(defn PySequence_Check
-  "Return 1 if the object provides sequence protocol, and 0 otherwise. Note that it
-  returns 1 for Python classes with a __getitem__() method unless they are dict
-  subclasses since in general case it is impossible to determine what the type of keys
-  it supports. This function always succeeds."
-  ^long [o]
-  (long (DirectMapped/PySequence_Check (ensure-pyobj o))))
-
-
-(defn PySequence_Length
-  "Returns the number of objects in sequence o on success, and -1 on failure. This is
-  equivalent to the Python expression len(o)."
-  ^long [o]
-  (long (DirectMapped/PySequence_Length (ensure-pyobj o))))
-
-
-(def-pylib-fn PySequence_Concat
-  "Return value: New reference.
-
-   Return the concatenation of o1 and o2 on success, and NULL on failure. This is the
-   equivalent of the Python expression o1 + o2."
-  Pointer
-  [o1 ensure-pyobj]
-  [o2 ensure-pyobj])
-
-
-(def-pylib-fn PySequence_Repeat
-  "Return value: New reference.
-
-   Return the result of repeating sequence object o count times, or NULL on
-   failure. This is the equivalent of the Python expression o * count."
-  Pointer
-  [o ensure-pyobj]
-  [count jna/size-t])
-
-
-(def-pylib-fn PySequence_InPlaceConcat
-  "Return value: New reference.
-
-   Return the concatenation of o1 and o2 on success, and NULL on failure. The operation
-   is done in-place when o1 supports it. This is the equivalent of the Python expression
-   o1 += o2."
-  Pointer
-  [o1 ensure-pyobj]
-  [o2 ensure-pyobj])
-
-
-(def-pylib-fn PySequence_InPlaceRepeat
-  "Return value: New reference.
-
-   Return the result of repeating sequence object o count times, or NULL on failure. The
-   operation is done in-place when o supports it. This is the equivalent of the Python
-   expression o *= count."
-  Pointer
-  [o ensure-pyobj]
-  [count jna/size-t])
-
-
-(defn PySequence_GetItem
-  "Return value: New reference.
-
-   Return the ith element of o, or NULL on failure. This is the equivalent of the Python
-   expression o[i]."
-  ^Pointer [o i]
-  (DirectMapped/PySequence_GetItem (ensure-pyobj o) (jna/size-t i)))
-
-
-(def-pylib-fn PySequence_GetSlice
-  "Return value: New reference.
-
-   Return the slice of sequence object o between i1 and i2, or NULL on failure. This is
-   the equivalent of the Python expression o[i1:i2]."
-  Pointer
-  [o ensure-pyobj]
-  [i1 jna/size-t]
-  [i2 jna/size-t])
-
-
-(def-pylib-fn PySequence_SetItem
-  "Assign object v to the ith element of o. Raise an exception and return -1 on failure;
-   return 0 on success. This is the equivalent of the Python statement o[i] = v. This
-   function does not steal a reference to v.
-
-   If v is NULL, the element is deleted, however this feature is deprecated in favour
-   of using PySequence_DelItem()."
-  Integer
-  [o ensure-pyobj]
-  [i jna/size-t]
-  [v ensure-pyobj])
-
-
-(def-pylib-fn PySequence_DelItem
-  "Delete the ith element of object o. Returns -1 on failure. This is the equivalent of
-  the Python statement del o[i]."
-  Integer
-  [o ensure-pyobj]
-  [i jna/size-t])
-
-
-(def-pylib-fn PySequence_SetSlice
-  "Assign the sequence object v to the slice in sequence object o from i1 to i2. This is
-  the equivalent of the Python statement o[i1:i2] = v."
-  Integer
-  [o ensure-pyobj]
-  [i1 jna/size-t]
-  [i2 jna/size-t]
-  [v ensure-pyobj])
-
-
-(def-pylib-fn PySequence_DelSlice
-  "Delete the slice in sequence object o from i1 to i2. Returns -1 on failure. This is
-  the equivalent of the Python statement del o[i1:i2]."
-  Integer
-  [o ensure-pyobj]
-  [i1 jna/size-t]
-  [i2 jna/size-t])
-
-
-(def-pylib-fn PySequence_Count
-  "Return the number of occurrences of value in o, that is, return the number of keys
-  for which o[key] == value. On failure, return -1. This is equivalent to the Python
-  expression o.count(value)."
-  size-t-type
-  [o ensure-pyobj]
-  [value ensure-pyobj])
-
-
-(def-pylib-fn PySequence_Contains
-  "Determine if o contains value. If an item in o is equal to value, return 1, otherwise
-  return 0. On error, return -1. This is equivalent to the Python expression value in
-  o."
-  Integer
-  [o ensure-pyobj]
-  [value ensure-pyobj])
-
-
-(def-pylib-fn PySequence_Index
-  "Return the first index i for which o[i] == value. On error, return -1. This is
-  equivalent to the Python expression o.index(value)."
-  size-t-type
-  [o ensure-pyobj]
-  [value ensure-pyobj])
-
-
-(def-pylib-fn PySequence_List
-  "Return value: New reference.
-
-   Return a list object with the same contents as the sequence or iterable o, or NULL on
-   failure. The returned list is guaranteed to be new. This is equivalent to the Python
-   expression list(o)."
-  Pointer
-  [o ensure-pyobj])
-
-
-(def-pylib-fn PySequence_Tuple
-  "Return value: New reference.
-
-   Return a tuple object with the same contents as the sequence or iterable o, or NULL
-   on failure. If o is a tuple, a new reference will be returned, otherwise a tuple will
-   be constructed with the appropriate contents. This is equivalent to the Python
-   expression tuple(o)."
-  Pointer
-  [o ensure-pyobj])
diff --git a/src/libpython_clj/py_modules/numpy.clj b/src/libpython_clj/py_modules/numpy.clj
deleted file mode 100644
index 81bbf46..0000000
--- a/src/libpython_clj/py_modules/numpy.clj
+++ /dev/null
@@ -1,15 +0,0 @@
-(ns libpython-clj.py-modules.numpy
-  (:require [libpython-clj.python :as py]
-            [libpython-clj.require :refer [require-python]])
-  (:refer-clojure :exclude [test take str sort short require repeat partition
-                            mod min max long load int identity float empty double
-                            conj char cast byte]))
-
-
-(require-python '[numpy :refer :* :reload])
-
-
-(comment
-  (linspace 2 3)
-  (py/call-kw linspace [2 3] {:num 5})
-  )
diff --git a/src/libpython_clj/python.clj b/src/libpython_clj/python.clj
deleted file mode 100644
index c5b21f1..0000000
--- a/src/libpython_clj/python.clj
+++ /dev/null
@@ -1,539 +0,0 @@
-(ns libpython-clj.python
-  "Base low-level namespace for accessing Python via Clojure.  Higher level interfaces
-   are found in libpython-clj.require specifically require-python and import-python."
-  (:require [tech.v3.datatype.export-symbols :refer [export-symbols]]
-            [libpython-clj.python.interop :as pyinterop]
-            [libpython-clj.python.interpreter :as pyinterp]
-            [libpython-clj.python.object :as pyobj]
-            [libpython-clj.python.bridge :as pybridge]
-            [libpython-clj.python.windows :as win]
-            [libpython-clj.jna :as libpy]
-            ;;Protocol implementations purely for nd-ness
-            [libpython-clj.python.np-array]
-            [tech.v3.jna :as jna])
-  (:import [com.sun.jna Pointer]
-           [com.sun.jna.ptr PointerByReference]
-           [java.lang.reflect Field]
-           [java.io Writer]
-           [libpython_clj.jna PyObject DirectMapped
-            CFunction$KeyWordFunction
-            CFunction$TupleFunction
-            CFunction$NoArgFunction]))
-
-
-(set! *warn-on-reflection* true)
-
-
-(export-symbols libpython-clj.python.protocols
-                python-type
-                dir
-                att-type-map
-                get-attr
-                has-attr?
-                set-attr!
-                callable?
-                has-item?
-                get-item
-                set-item!
-                call
-                call-kw
-                call-attr
-                call-attr-kw
-                len
-                as-map
-                as-list)
-
-
-(export-symbols libpython-clj.python.object
-                ->py-float
-                ->py-long
-                ->py-string
-                ->python
-                ;;Used when you are returning a value from a function.
-                ->python-incref
-                ->jvm
-                make-tuple-fn
-                make-tuple-instance-fn
-                create-class
-                is-instance?
-                hash-code
-                equals?)
-
-
-(defmacro stack-resource-context
-  "Create a stack-based resource context.  All python objects allocated within this
-  context will be released at the termination of this context.
-  !!This means that no python objects can escape from this context!!
-  You must use copy semantics (->jvm) for anything escaping this context.
-  Furthermore, if you are returning generic python objects you may need
-  to call (into {}) or something like that just to ensure that absolutely
-  everything is copied into the jvm."
-  [& body]
-  `(pyobj/stack-resource-context
-    ~@body))
-
-
-(defmacro with-gil
-  "Capture the gil for an extended amount of time.  This can greatly speed up
-  operations as the mutex is captured and held once as opposed to find grained
-  grabbing/releasing of the mutex."
-  [& body]
-  `(pyinterp/with-gil
-     ~@body))
-
-
-(defmacro with-gil-stack-rc-context
-  "Capture the gil, open a resource context.  The resource context is released
-  before the gil is leading to much faster resource collection.  See documentation
-  on `stack-resource-context` for multiple warnings; the most important one being
-  that if a python object escapes this context your program will eventually, at
-  some undefined point in the future crash.  That being said, this is the recommended
-  pathway to use in production contexts where you want defined behavior and timings
-  related to use of python."
-  [& body]
-  `(with-gil
-     (stack-resource-context
-      ~@body)))
-
-
-(defn set-attrs!
-  "Set a sequence of [name value] attributes.
-  Returns item"
-  [item att-seq]
-  (with-gil
-    (doseq [[k v] att-seq]
-      (set-attr! item k v)))
-  item)
-
-
-(defn set-items!
-  "Set a sequence of [name value].
-  Returns item"
-  [item item-seq]
-  (with-gil
-    (doseq [[k v] item-seq]
-      (set-item! item k v)))
-  item)
-
-
-(export-symbols libpython-clj.python.interop
-                libpython-clj-module-name
-                create-bridge-from-att-map)
-
-
-(export-symbols libpython-clj.python.bridge
-                args->pos-kw-args
-                cfn
-                afn
-                as-jvm
-                as-python
-                as-python-incref ;; Used when returning a value from a function to python.
-                ->numpy
-                as-numpy)
-
-
-(defn ->py-dict
-  "Create a python dictionary"
-  [item]
-  (-> (pyobj/->py-dict item)
-      (as-jvm)))
-
-
-(defn ->py-list
-  "Create a python list"
-  [item]
-  (-> (pyobj/->py-list item)
-      (as-jvm)))
-
-
-(defn ->py-tuple
-  "Create a python tuple"
-  [item]
-  (-> (pyobj/->py-tuple item)
-      (as-jvm)))
-
-
-(defn ->py-fn
-  "Make a python function.  If clojure function is passed in the arguments are
-  marshalled from python to clojure, the function called, and the return value will be
-  marshalled back."
-  [item]
-  (-> (pyobj/->py-fn item)
-      (as-jvm)))
-
-
-(defn run-simple-string
-  "Run a string expression returning a map of
-  {:globals :locals}.
-  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;"
-  [program & {:keys [globals locals]}]
-  (->> (pyinterop/run-simple-string program :globals globals :locals locals)
-       (map (fn [[k v]]
-              [k (as-jvm v)]))
-       (into {})))
-
-
-(defn run-string
-  "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."
-  [program & {:keys [globals locals]}]
-  (->> (pyinterop/run-string program :globals globals :locals locals)
-       (map (fn [[k v]]
-              [k (as-jvm v)]))
-       (into {})))
-
-
-(defn import-module
-  "Import a python module.  Returns a bridge"
-  [modname]
-  (-> (pyinterop/import-module modname)
-      (as-jvm)))
-
-
-(defn add-module
-  "Add a python module.  Returns a bridge"
-  [modname]
-  (-> (pyinterop/add-module modname)
-      (as-jvm)))
-
-
-(defn module-dict
-  "Get the module dictionary.  Returns bridge."
-  [module]
-  (-> (pyinterop/module-dict module)
-      as-jvm))
-
-
-(defn initialize!
-  "Initialize the python library.  If library path is provided, then the python
-  :library-path Library path of the python library to use.
-  :program-name - optional but will show up in error messages from python.
-  :no-io-redirect - there if you don't want python stdout and stderr redirection
-     to *out* and *err*."
-  [& {:keys [program-name
-             library-path
-             python-home
-             no-io-redirect?
-             python-executable
-             windows-anaconda-activate-bat]}]
-  (when-not @pyinterp/main-interpreter*
-    (pyinterp/initialize! :program-name program-name
-                          :library-path library-path
-                          :python-home python-home
-                          :python-executable python-executable)
-    ;;setup bridge mechansim and io redirection
-    (pyinterop/register-bridge-type!)
-    (when-not no-io-redirect?
-      (pyinterop/setup-std-writer #'*err* "stderr")
-      (pyinterop/setup-std-writer #'*out* "stdout"))
-    (if-not (nil? windows-anaconda-activate-bat)
-      (win/setup-windows-conda! windows-anaconda-activate-bat)))
-  :ok)
-
-
-(defn ptr-refcnt
-  [item]
-  (-> (libpy/as-pyobj item)
-      (libpython_clj.jna.PyObject.)
-      (.ob_refcnt)))
-
-
-(defn finalize!
-  "Finalize the interpreter.  You probably shouldn't call this as it destroys the
-  global interpreter and reinitialization is unsupported cpython."
-  []
-  (pyinterp/finalize!))
-
-
-(defn python-pyerr-fetch-error-handler
-  "Utility code used in with macro"
-  []
-  (let [ptype# (PointerByReference.)
-        pvalue# (PointerByReference.)
-        ptraceback# (PointerByReference.)
-        _# (libpy/PyErr_Fetch ptype# pvalue# ptraceback#)
-        ptype# (-> (jna/->ptr-backing-store ptype#)
-                   (pyobj/wrap-pyobject true))
-        pvalue# (-> (jna/->ptr-backing-store pvalue#)
-                    (pyobj/wrap-pyobject true))
-        ptraceback# (-> (jna/->ptr-backing-store ptraceback#)
-                        (pyobj/wrap-pyobject true))]
-    ;;We own the references so they have to be released.
-    (throw (ex-info "python error in flight"
-                    {:ptype ptype#
-                     :pvalue pvalue#
-                     :ptraceback ptraceback#}))))
-
-
-(defn with-exit-error-handler
-  "Utility code used in with macro"
-  [with-var error]
-  (let [einfo (ex-data error)]
-    (if (every? #(contains? einfo %) [:ptype :pvalue :ptraceback])
-      (let [{ptype :ptype
-             pvalue :pvalue
-             ptraceback :ptraceback} einfo
-            suppress-error? (call-attr with-var "__exit__"
-                                       ptype
-                                       pvalue
-                                       ptraceback)]
-        (when (and ptype pvalue ptraceback
-                   (not suppress-error?))
-          (do
-            ;;Manual incref here because we cannot detach the object
-            ;;from our gc decref hook added during earlier pyerr-fetch handler.
-            (libpy/Py_IncRef ptype)
-            (libpy/Py_IncRef pvalue)
-            (libpy/Py_IncRef ptraceback)
-            (libpy/PyErr_Restore ptype pvalue ptraceback)
-            (pyinterp/check-error-throw))))
-      (do
-        (call-attr with-var "__exit__" nil nil nil)
-        (throw error)))))
-
-
-(defmacro with
-  "Support for the 'with' statement in python:
-  (py/with [item (py/call-attr testcode-module \"WithObjClass\" true fn-list)]
-                    (py/call-attr item \"doit_err\"))"
-  [bind-vec & body]
-  (when-not (= 2 (count bind-vec))
-    (throw (Exception. "Bind vector must have 2 items")))
-  (let [varname (first bind-vec)]
-    `(with-gil
-       (let [~@bind-vec]
-         (with-bindings
-           {#'libpython-clj.python.interpreter/*python-error-handler*
-            python-pyerr-fetch-error-handler}
-           (call-attr ~varname "__enter__")
-           (try
-             (let [retval#
-                   (do
-                     ~@body)]
-               (call-attr ~varname "__exit__" nil nil nil)
-               retval#)
-             (catch Throwable e#
-               (with-exit-error-handler ~varname e#))))))))
-
-
-(defn gc!
-  "Run the system garbage collection facility and then call the cooperative
-  'cleanup python objects' queue"
-  []
-  (System/gc)
-  (with-gil))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-
-(defmacro a$
-  "Call an attribute of an object.  Similar calling conventions to afn except:
-  Keywords must be compile time constants.  So this won't work with 'apply'.  On the
-  other hand, building the positional and kw argmaps happens at compile time as
-  opposed to at runtime.  The attr name can be a symbol.
-
-  DEPRECATION POSSIBLE - use $a."
-  [item attr & args]
-  (let [[pos-args kw-args] (args->pos-kw-args args)]
-    `(call-attr-kw ~item ~(pybridge/key-sym-str->str attr)
-                   ~pos-args ~kw-args)))
-
-
-(defmacro c$
-  "Call an object.  Similar calling conventions to cfn except:
-  Keywords must be compile time constants.  So this won't work with 'apply'.  On the
-  other hand, building the positional and kw argmaps happens at compile time as
-  opposed to at runtime.
-
-  DEPRECATION POSSIBLE - use $c."
-  [item & args]
-  (let [[pos-args kw-args] (args->pos-kw-args args)]
-    `(call-kw ~item ~pos-args ~kw-args)))
-
-
-
-(defmacro $a
-  "Call an attribute of an object.  Similar calling conventions to afn except:
-  Keywords must be compile time constants.  So this won't work with 'apply'.  On the
-  other hand, building the positional and kw argmaps happens at compile time as
-  opposed to at runtime.  The attr name can be a symbol."
-  [item attr & args]
-  `(a$ ~item ~attr ~@args))
-
-
-(defmacro $c
-  "Call an object.  Similar calling conventions to cfn except:
-  Keywords must be compile time constants.  So this won't work with 'apply'.  On the
-  other hand, building the positional and kw argmaps happens at compile time as
-  opposed to at runtime."
-  [item & args]
-  `(c$ ~item ~@args))
-
-
-(defmacro $.
-  "Get the attribute of an object."
-  [item attname]
-  `(get-attr ~item ~(pybridge/key-sym-str->str attname)))
-
-
-(defmacro $..
-  "Get the attribute of an object.  If there are extra args, apply successive
-  get-attribute calls to the arguments."
-  [item attname & args]
-  `(-> (get-attr ~item ~(pybridge/key-sym-str->str attname))
-       ~@(->> args
-              (map (fn [arg]
-                     `(get-attr ~(pybridge/key-sym-str->str arg)))))))
-
-
-(defmacro import-as
-  "Import a module and assign it to a var.  Documentation is included."
-  [module-path varname]
-  `(let [~'mod-data (import-module ~(name module-path))]
-     (def ~varname (import-module ~(name module-path)))
-     (alter-meta! #'~varname assoc :doc (get-attr ~'mod-data "__doc__"))
-     #'~varname))
-
-
-(defmacro from-import
-  "Support for the from a import b,c style of importing modules and symbols in python.
-  Documentation is included."
-  [module-path item & args]
-  `(do
-     (let [~'mod-data (import-module ~(name module-path))]
-       ~@(map (fn [varname]
-                `(let [~'var-data (get-attr ~'mod-data ~(name varname))]
-                   (def ~varname ~'var-data)
-                   (alter-meta! #'~varname assoc :doc (get-attr ~'var-data "__doc__"))
-                   #'~varname))
-              (concat [item] args)))))
-
-
-(defmacro py.-
-  "Class/object getter syntax.  (py.- obj attr) is equivalent to
-  Python's obj.attr syntax."
-  [x arg]
-  (list #'$. x arg))
-
-
-(defmacro py.
-  "Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
-  is equivalent to Python's obj.method(arg1, arg2, ..., argN) syntax."
-  [x & args]
-  (list* (into (vector #'$a x) args)))
-
-(defmacro py*
-  "Special syntax for passing along *args and **kwargs style arguments
-  to methods.
-
-  Usage:
-
-  (py* obj method args kwargs)
-
-  Example:
-
-  (def d (python/dict))
-  d ;;=> {}
-  (def iterable [[:a 1] [:b 2]])
-  (def kwargs {:cat \"dog\" :name \"taco\"})
-  (py* d  update [iterable] kwargs)
-  d ;;=> {\"a\": 1, \"b\": 2, \"cat\": \"dog\", \"name\": \"taco\"}"
-  ([x method args]
-   (list #'call-attr-kw x (str method) args nil))
-  ([x method args kwargs]
-   (list #'call-attr-kw x (str method) args kwargs)))
-
-(defmacro py**
-  "Like py*, but it is assumed that the LAST argument is kwargs."
-  ([x method kwargs]
-   (list #'call-attr-kw x (str method) nil kwargs))
-  ([x method arg & args]
-   (let [args   (into [arg] args)
-         kwargs (last args)
-         args   (vec (pop args))]
-     (list #'call-attr-kw x (str method) args kwargs))))
-
-
-(defn ^:private handle-pydotdot
-  ([x form]
-   (if (list? form)
-     (let [form-data (vec form)
-           [instance-member & args] form-data
-           symbol-str (str instance-member)]
-       (cond
-         (clojure.string/starts-with? symbol-str "-")
-         (list #'py.- x (symbol (subs symbol-str 1 (count symbol-str))))
-
-         (clojure.string/starts-with? symbol-str "**")
-         (list* #'py** x (symbol (subs symbol-str 2 (count symbol-str))) args)
-
-         (clojure.string/starts-with? symbol-str "*")
-         (list* #'py* x (symbol (subs symbol-str 1 (count symbol-str))) args)
-
-         :else ;; assumed to be method invocation
-
-         (list* (into (vector #'py. x instance-member) args))))
-     (handle-pydotdot x (list form))))
-  ([x form & more]
-   (apply handle-pydotdot (handle-pydotdot x form) more)))
-
-
-(defmacro py..
-  "Extended accessor notation, similar to the `..` macro in Clojure.
-
-  (require-python 'sys)
-  (py.. sys -path (append \"/home/user/bin\"))
-
-  is equivalent to Python's
-
-  import sys
-  sys.path.append('/home/user/bin')
-
-  SPECIAL SYNTAX for programmatic *args and **kwargs
-
-  Special syntax is provided to meet the needs required by
-  Python's *args and **kwargs syntax programmatically.
-
-
-  (= (py.. obj (*method args))
-     (py* obj methods args))
-
-  (= (py.. obj (*methods args kwargs))
-     (py* obj method args kwargs))
-
-  (= (py.. obj (**method kwargs))
-     (py** obj kwargs))
-
-  (= (py.. obj (**method arg1 arg2 arg3 ... argN kwargs))
-     (py** obj method arg1 arg2 arg3 ... argN kwargs)
-     (py*  obj method [arg1 arg2 arg3 ... argN] kwargs))
-
-
-  These forms exist for when you need to pass in a map of options
-  in the same way you would use the f(*args, **kwargs) forms in
-  Python."
-  [x & args]
-  (apply handle-pydotdot x args))
diff --git a/src/libpython_clj/python/bridge.clj b/src/libpython_clj/python/bridge.clj
deleted file mode 100644
index fecf9c1..0000000
--- a/src/libpython_clj/python/bridge.clj
+++ /dev/null
@@ -1,1129 +0,0 @@
-(ns libpython-clj.python.bridge
-  "Bridging classes to allow python and java to intermix."
-  (:require [libpython-clj.jna :as libpy]
-            [libpython-clj.jna.concrete.err :as err]
-            [libpython-clj.jna.base :as libpy-base]
-            [libpython-clj.python.protocols
-             :refer [python-type
-                     has-attr? get-attr call-attr
-                     dir att-type-map
-                     pyobject-as-jvm
-                     as-list]
-             :as py-proto]
-            [libpython-clj.python.interpreter
-             :refer
-             [with-gil
-              ensure-bound-interpreter
-              check-error-throw
-              initialize!]
-             :as pyinterp]
-            [libpython-clj.python.object
-             :refer
-             [->jvm
-              ->python
-              stringable?
-              stringable
-              incref
-              incref-wrap-pyobject
-              wrap-pyobject
-              python->jvm-iterable
-              python->jvm-iterator
-              py-none
-              ->py-list
-              ->py-tuple
-              ->py-dict
-              ->py-string
-              ->py-fn]
-             :as pyobj]
-            [libpython-clj.python.interop :as pyinterop
-             :refer
-             [expose-bridge-to-python!
-              pybridge->bridge
-              create-bridge-from-att-map]]
-            [libpython-clj.python.gc :as pygc]
-            [clojure.stacktrace :as st]
-            [tech.v3.jna :as jna]
-            [tech.v3.tensor :as dtt]
-            [tech.v3.datatype.protocols :as dtype-proto]
-            [tech.v3.datatype.casting :as casting]
-            [tech.v3.datatype.argops :as argops]
-            [tech.v3.datatype :as dtype]
-            [clojure.set :as c-set]
-            [clojure.tools.logging :as log])
-  (:import [java.util Map RandomAccess List Map$Entry Iterator UUID]
-           [java.util.concurrent ConcurrentHashMap ConcurrentLinkedQueue]
-           [clojure.lang IFn Symbol Keyword Seqable
-            Fn MapEntry Range LongRange]
-           [tech.v3.datatype NDBuffer ObjectBuffer]
-           [tech.v3.datatype.array_buffer ArrayBuffer]
-           [tech.v3.datatype.native_buffer NativeBuffer]
-           [com.sun.jna Pointer]
-           [tech.resource GCReference]
-           [java.io Writer]
-           [libpython_clj.jna JVMBridge
-            CFunction$KeyWordFunction
-            CFunction$TupleFunction
-            CFunction$NoArgFunction
-            PyFunction
-            PyObject]))
-
-
-(set! *warn-on-reflection* true)
-
-
-(def bridgeable-python-type-set
-  #{:list :dict :tuple :string :int :float})
-
-
-(defn bridgeable-python-type?
-  [pyobj]
-  (with-gil
-    (or (-> (python-type pyobj)
-            bridgeable-python-type-set
-            boolean)
-        (has-attr? pyobj "__iter__")
-        (has-attr? pyobj "__getitem__"))))
-
-
-(defn bridgeable-jvm-type?
-  [jvm-obj]
-  (or (number? jvm-obj)
-      (stringable? jvm-obj)
-      (instance? jvm-obj RandomAccess)
-      (instance? jvm-obj Map)
-      (instance? jvm-obj Iterable)
-      (fn? jvm-obj)))
-
-
-(defn check-py-method-return
-  [^long retval]
-  (when-not (= 0 retval)
-    (check-error-throw)))
-
-
-(defn as-jvm
-  "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."
-  [item & [options]]
-  (if (or (not item)
-          (= :none-type (python-type item)))
-    nil
-    (py-proto/as-jvm item options)))
-
-
-(defn as-python
-  "Bridge a jvm object into python"
-  [item & [options]]
-  (if (nil? item)
-    (py-none)
-    (py-proto/as-python item options)))
-
-
-(extend-protocol py-proto/PBridgeToJVM
-  Pointer
-  (as-jvm [item options]
-    (pyobject-as-jvm item))
-  PyObject
-  (as-jvm [item options]
-    (pyobject-as-jvm (.getPointer item))))
-
-
-;; These cannot be bridged.  Why would you, anyway?
-
-(defmethod pyobject-as-jvm :int
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :float
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :int-8
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :uint-8
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :int-16
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :uint-16
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :int-32
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :uint-32
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :int-64
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :uint-64
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :float-64
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :float-32
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :str
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :bool
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defmethod pyobject-as-jvm :range
-  [pyobj]
-  (->jvm pyobj))
-
-
-
-(defn mostly-copy-arg
-  "This is the dirty boundary between the languages.  Copying as often faster
-  for simple things but we have to be careful not to attempt a copy of things that
-  are only iterable (and not random access)."
-  [arg]
-  (cond
-    (libpy/as-pyobj arg)
-    (libpy/as-pyobj arg)
-    (dtype/reader? arg)
-    (->python arg)
-    (instance? Map arg)
-    (->python arg)
-    (instance? Iterable arg)
-    (as-python arg)
-    :else
-    (as-python arg)))
-
-
-(defmacro bridge-pyobject
-  [pyobj interpreter & body]
-  `(let [pyobj# ~pyobj
-         interpreter# ~interpreter]
-     (with-meta
-       (reify
-         libpy-base/PToPyObjectPtr
-         (convertible-to-pyobject-ptr? [item#] true)
-         (->py-object-ptr [item#] (libpy/as-pyobj pyobj#))
-         py-proto/PPythonType
-         (get-python-type [item]
-           (with-gil
-             (py-proto/get-python-type pyobj#)))
-         py-proto/PCopyToPython
-         (->python [item# options#] pyobj#)
-         py-proto/PBridgeToPython
-         (as-python [item# options#] pyobj#)
-         py-proto/PBridgeToJVM
-         (as-jvm [item# options#] item#)
-         py-proto/PCopyToJVM
-         (->jvm [item# options#]
-           (with-gil
-             (->jvm pyobj# options#)))
-         py-proto/PPyObject
-         (dir [item#]
-           (with-gil
-             (py-proto/dir pyobj#)))
-         (has-attr? [item# item-name#]
-           (with-gil
-             (py-proto/has-attr? pyobj# item-name#)))
-         (get-attr [item# item-name#]
-           (with-gil
-             (-> (py-proto/get-attr pyobj# item-name#)
-                 as-jvm)))
-         (set-attr! [item# item-name# item-value#]
-           (with-gil
-             (py-proto/set-attr! pyobj# item-name#
-                                 (as-python item-value#))))
-         (callable? [item#]
-           (with-gil
-             (py-proto/callable? pyobj#)))
-         (has-item? [item# item-name#]
-           (with-gil
-             (py-proto/has-item? pyobj# item-name#)))
-         (get-item [item# item-name#]
-           (with-gil
-             (-> (py-proto/get-item pyobj# item-name#)
-                 as-jvm)))
-         (set-item! [item# item-name# item-value#]
-           (with-gil
-             (py-proto/set-item! pyobj# item-name# (as-python item-value#))))
-         py-proto/PPyAttMap
-         (att-type-map [item#]
-           (with-gil
-             (py-proto/att-type-map pyobj#)))
-         py-proto/PyCall
-         (do-call-fn [callable# arglist# kw-arg-map#]
-           (with-gil
-             (let [arglist# (mapv mostly-copy-arg arglist#)
-                   kw-arg-map# (->> kw-arg-map#
-                                    (map (fn [[k# v#]]
-                                           [k# (mostly-copy-arg v#)]))
-                                    (into {}))]
-               (-> (py-proto/do-call-fn pyobj# arglist# kw-arg-map#)
-                   (as-jvm)))))
-         Object
-         (toString [this#]
-           (with-gil
-             (if (= 1 (libpy/PyObject_IsInstance pyobj# (libpy/PyType_Type)))
-               (format "%s.%s"
-                       (->jvm (py-proto/get-attr pyobj# "__module__"))
-                       (->jvm (py-proto/get-attr pyobj# "__name__")))
-               (->jvm (py-proto/call-attr pyobj# "__str__")))))
-         (equals [this# other#]
-           (pyobj/equals? this# other#))
-         (hashCode [this#]
-           (.hashCode ^Object (pyobj/hash-code this#)))
-         ~@body)
-       {:type :pyobject})))
-
-
-(defmethod print-method :pyobject
-  [pyobj w]
-  (.write ^Writer w ^String (.toString ^Object pyobj)))
-
-
-(defn as-tuple
-  "Create a python tuple from a sequence of things."
-  [item-seq]
-  (->> (map as-python item-seq)
-       (->py-tuple)))
-
-
-(defn as-dict
-  "Create a python dict from a sequence of things."
-  [map-data]
-  (->> map-data
-       (map (fn [[k v]]
-              [(as-python k) (as-python v)]))
-       (->py-dict)))
-
-
-
-(defn- py-impl-call-raw
-  [att-name att-map arglist]
-  (if-let [py-fn (get att-map att-name)]
-    (py-proto/do-call-fn py-fn (map as-python arglist) nil)
-    (throw (UnsupportedOperationException.
-            (format "Python object has no attribute: %s"
-                    att-name)))))
-
-
-(defn- py-impl-call-as
-  [att-name att-map arglist]
-  (-> (py-impl-call-raw att-name att-map arglist)
-      as-jvm))
-
-(defn- raw-python-iterator
-  [att-map]
-  (when-not (get att-map "__iter__")
-    (throw (ex-info "Object is not iterable!" {})))
-  (let [py-iter (python->jvm-iterator (get att-map "__iter__") identity)]
-    py-iter))
-
-(defn generic-python-as-map
-  [pyobj]
-  (with-gil
-    (let [interpreter (ensure-bound-interpreter)
-          dict-atts #{"__len__" "__getitem__" "__setitem__" "__iter__" "__contains__"
-                      "__eq__" "__hash__" "clear" "keys" "values"
-                      "__delitem__"}
-          dict-att-map (->> (py-proto/dir pyobj)
-                            (filter dict-atts)
-                            (map (juxt identity (partial py-proto/get-attr pyobj)))
-                            (into {}))
-          py-call (fn [fn-name & args]
-                    (with-gil
-                      (py-impl-call-as fn-name dict-att-map args)))]
-
-      (bridge-pyobject
-       pyobj
-       interpreter
-       Map
-       (clear [item] (py-call "clear"))
-       (containsKey [item k] (boolean (py-call "__contains__" k)))
-       (entrySet
-        [this]
-        (->> (.iterator this)
-             iterator-seq
-             set))
-       (get [this obj-key]
-            (py-call "__getitem__" obj-key))
-       (getOrDefault [item obj-key obj-default-value]
-                     (if (.containsKey item obj-key)
-                       (.get item obj-key)
-                       obj-default-value))
-       (isEmpty [this] (= 0 (.size this)))
-       (keySet [this] (->> (py-call "keys")
-                           set))
-       (put [this k v]
-            (py-call "__setitem__" k v))
-
-       (remove [this k]
-               (py-call "__delitem__" k))
-
-       (size [this]
-             (int (py-call "__len__")))
-
-
-       (values [this]
-               (py-call "values"))
-       Iterable
-       (iterator
-        [this]
-        (let [mapentry-seq
-              (->> (raw-python-iterator dict-att-map)
-                   iterator-seq
-                   (map (fn [pyobj-key]
-                          (with-gil
-                            (let [k (as-jvm pyobj-key)
-                                  v (.get this pyobj-key)
-                                  tuple [k v]]
-                              (MapEntry. k v))))))]
-          (.iterator ^Iterable mapentry-seq)))
-       IFn
-       (invoke [this arg] (.getOrDefault this arg nil))
-       (invoke [this k v] (.put this k v))
-       (applyTo [this arglist]
-                (let [arglist (vec arglist)]
-                  (case (count arglist)
-                    1 (.get this (first arglist))
-                    2 (.put this (first arglist) (second arglist)))))
-       py-proto/PPyObjectBridgeToMap
-       (as-map [item] item)))))
-
-
-(defn generic-python-as-list
-  [pyobj]
-  (with-gil
-    (let [interpreter (ensure-bound-interpreter)
-          dict-atts #{"__len__" "__getitem__" "__setitem__" "__iter__" "__contains__"
-                      "__eq__" "__hash__" "clear" "insert" "pop" "append"
-                      "__delitem__" "sort"}
-          dict-att-map (->> (py-proto/dir pyobj)
-                            (filter dict-atts)
-                            (map (juxt identity (partial py-proto/get-attr pyobj)))
-                            (into {}))
-          py-call (fn [fn-name & args]
-                    (with-gil
-                      (py-impl-call-as fn-name dict-att-map args)))]
-      (bridge-pyobject
-       pyobj
-       interpreter
-       ObjectBuffer
-       (lsize [reader]
-              (long (py-call "__len__")))
-       (readObject [reader idx]
-             (py-call "__getitem__" idx))
-       (sort [reader obj-com]
-             (when-not (= nil obj-com)
-               (throw (ex-info "Python lists do not support comparators" {})))
-             (py-call "sort"))
-       (writeObject [writer idx value]
-              (py-call "__setitem__" idx value))
-       (remove [writer ^int idx]
-               (py-call "__delitem__" idx))
-       (add [mutable idx value]
-            (py-call "insert" idx value))
-       (add [mutable value]
-            (.add mutable (.size mutable) value))))))
-
-
-
-(defmethod pyobject-as-jvm :list
-  [pyobj]
-  (generic-python-as-list pyobj))
-
-
-(defmethod pyobject-as-jvm :tuple
-  [pyobj]
-  (generic-python-as-list pyobj))
-
-
-(defn check-pybool-return
-  [^long retval]
-  (cond
-    (> retval 0) true
-    (= retval 0) false
-    :else
-    (check-error-throw)))
-
-
-(defmethod pyobject-as-jvm :dict
-  [pyobj]
-  (generic-python-as-map pyobj))
-
-
-(defn python-iterable-as-jvm
-  [pyobj]
-  (python->jvm-iterable pyobj ->jvm))
-
-
-(def py-dtype->dtype-map
-  (->> (concat (for [bit-width [8 16 32 64]
-                     unsigned? [true false]]
-                 (str (if unsigned?
-                        "uint"
-                        "int")
-                      bit-width))
-               ["float32" "float64"])
-       (map (juxt identity keyword))
-       (into {})))
-
-
-(def dtype->py-dtype-map
-  (c-set/map-invert py-dtype->dtype-map))
-
-
-(defn obj-dtype->dtype
-  [py-dtype]
-  (when-let [fields (get-attr py-dtype "fields")]
-    (throw (ex-info (format "Cannot convert numpy object with fields: %s"
-                            (call-attr fields "__str__"))
-                    {})))
-  (if-let [retval (->> (py-proto/get-attr py-dtype "name")
-                       (get py-dtype->dtype-map))]
-    retval
-    (throw (ex-info (format "Unable to find datatype: %s"
-                            (py-proto/get-attr py-dtype "name"))
-                    {}))))
-
-
-(defn numpy->desc
-  [np-obj]
-  (with-gil
-    (let [np (pyinterop/import-module "numpy")
-          ctypes (py-proto/as-jvm (get-attr np-obj "ctypes") {})
-          np-dtype (-> (py-proto/as-jvm (get-attr np-obj "dtype") {})
-                       (obj-dtype->dtype))
-          shape (-> (get-attr ctypes "shape")
-                    (as-list)
-                    vec)
-          strides (-> (get-attr ctypes "strides")
-                      (as-list)
-                      vec)
-          long-addr (get-attr ctypes "data")
-          hash-ary {:ctypes-map ctypes}
-          ptr-val long-addr]
-      (-> {:ptr ptr-val
-           :elemwise-datatype np-dtype
-           :shape shape
-           :strides strides}
-          (pygc/track #(get hash-ary :ctypes-map))))))
-
-
-(defmethod py-proto/python-obj-iterator :default
-  [pyobj interpreter]
-  (with-gil
-    (let [iter-fn (py-proto/get-attr pyobj "__iter__")]
-      (python->jvm-iterator iter-fn as-jvm))))
-
-
-(defn args->pos-kw-args
-  "Utility function that, given a list of arguments, separates them
-  into positional and keyword arguments.  Throws an exception if the
-  keyword argument is not followed by any more arguments."
-  [arglist]
-  (loop [args arglist
-         pos-args []
-         kw-args nil
-         found-kw? false]
-    (if-not (seq args)
-      [pos-args kw-args]
-      (let [arg (first args)
-            [pos-args kw-args args found-kw?]
-            (if (keyword? arg)
-              (if-not (seq (rest args))
-                (throw (Exception.
-                        (format "Keyword arguments must be followed by another arg: %s"
-                                (str arglist))))
-                [pos-args (assoc kw-args arg (first (rest args)))
-                 (drop 2 args) true])
-              (if found-kw?
-                (throw (Exception.
-                        (format "Positional arguments are not allowed after keyword arguments: %s"
-                                arglist)))
-                [(conj pos-args (first args))
-                 kw-args
-                 (rest args) found-kw?]))]
-        (recur args pos-args kw-args found-kw?)))))
-
-
-(defn cfn
-  "Call an object.
-  Arguments are passed in positionally.  Any keyword
-  arguments are paired with the next arg, gathered, and passed into the
-  system as *kwargs.
-
-  Not having an argument after a keyword argument is an error."
-  [item & args]
-  (let [[pos-args kw-args] (args->pos-kw-args args)]
-    (py-proto/call-kw item pos-args kw-args)))
-
-
-(defn key-sym-str->str
-  [attr-name]
-  (cond
-    (or (keyword? attr-name)
-        (symbol? attr-name))
-    (name attr-name)
-    (string? attr-name)
-    attr-name
-    :else
-    (throw (Exception.
-            "Only keywords, symbols, or strings can be used to access attributes."))))
-
-
-(defn afn
-  "Call an attribute of an object.
-  Arguments are passed in positionally.  Any keyword
-  arguments are paired with the next arg, gathered, and passed into the
-  system as *kwargs.
-
-  Not having an argument after a keyword argument is an error."
-  [item attr & args]
-  (let [[pos-args kw-args] (args->pos-kw-args args)]
-    (py-proto/call-attr-kw item (key-sym-str->str attr)
-                           pos-args kw-args)))
-
-;;utility fn to generate IFn arities
-(defn- emit-args
-  [bodyf varf]
-   (let [argify (fn [n argfn bodyf]
-                  (let [raw  `[~'this ~@(map #(symbol (str "arg" %))
-                                             (range n))]]
-                    `~(bodyf (argfn raw))))]
-     (concat (for [i (range 21)]
-               (argify i identity bodyf))
-             [(argify 21 (fn [xs]
-                          `[~@(butlast xs) ~'arg20-obj-array])
-                     varf)])))
-
-;;Python specific interop wrapper for IFn invocations.
-(defn- emit-py-args []
-  (emit-args    (fn [args] `(~'invoke [~@args]
-                             (~'with-gil
-                              (~'cfn ~@args))))
-                (fn [args]
-                  `(~'invoke [~@args]
-                    (~'with-gil
-                     (~'apply ~'cfn ~@(butlast args) ~(last args)))))))
-
-(defmacro bridge-callable-pyobject
-  "Like bridge-pyobject, except it populates the implementation of IFn
-   for us, where all arg permutations are supplied, as well as applyTo,
-   and the function invocation is of the form
-   (invoke [this arg] (with-gil (cfn this arg))).
-   If caller supplies an implementation for clojure.lang.IFn or aliased
-   Fn, the macro will use that instead (allowing more control but
-   requiring caller to specify implementations for all desired arities)."
-  [pyobj interpreter & body]
-  (let [fn-specs (when-not (some #{'IFn 'clojure.lang.IFn} body)
-                   `(~'IFn
-                     ~@(emit-py-args)
-                     (~'applyTo [~'this ~'arglist]
-                      (~'with-gil
-                       (~'apply ~'cfn ~'this ~'arglist)))))]
-    `(bridge-pyobject ~pyobj ~interpreter
-                      ~@fn-specs
-                      ~@body)))
-
-(defn generic-python-as-jvm
-  "Given a generic pyobject, wrap it in a read-only map interface
-  where the keys are the attributes."
-  [pyobj]
-  (with-gil
-    (if (= :none-type (python-type pyobj))
-      nil
-      (let [interpreter (ensure-bound-interpreter)]
-        (if (py-proto/callable? pyobj)
-          (bridge-callable-pyobject
-           pyobj
-           interpreter
-           Iterable
-           (iterator [this]
-                     (py-proto/python-obj-iterator pyobj interpreter))
-           py-proto/PPyObjectBridgeToMap
-           (as-map [item]
-                   (generic-python-as-map pyobj))
-           py-proto/PPyObjectBridgeToList
-           (as-list [item]
-                    (generic-python-as-list pyobj))
-           ;;IFn is now supplied for us by the macro.
-           ;;Mark this as executable
-           Fn
-           PyFunction
-           (invokeKeyWords [this tuple-args keyword-args]
-                           (-> (libpy/PyObject_Call pyobj
-                                                    (as-tuple tuple-args)
-                                                    (->py-dict keyword-args))
-                               wrap-pyobject
-                               as-jvm)))
-          (bridge-pyobject
-           pyobj
-           interpreter
-           Iterable
-           (iterator [this]
-                     (py-proto/python-obj-iterator pyobj interpreter))
-           py-proto/PPyObjectBridgeToMap
-           (as-map [item]
-                   (generic-python-as-map pyobj))
-           py-proto/PPyObjectBridgeToList
-           (as-list [item]
-                    (generic-python-as-list pyobj))
-           dtype-proto/PToTensor
-           (as-tensor [item]
-                      (-> (numpy->desc item)
-                          dtt/nd-buffer-descriptor->tensor))))))))
-
-
-(defmethod pyobject-as-jvm :default
-  [pyobj]
-  (generic-python-as-jvm pyobj))
-
-(defmacro wrap-jvm-context
-  [& body]
-  `(try
-     ~@body
-     (catch Throwable e#
-       (libpy/PyErr_SetString
-        libpy/PyExc_Exception
-        (format "%s:%s" (str e#)
-                (with-out-str
-                  (st/print-stack-trace e#)))))))
-
-
-(defn as-python-incref
-  "Convert to python and add a reference.  Necessary for return values from
-  functions as python expects a new reference and the as-python pathway
-  ensures the jvm garbage collector also sees the reference."
-  [item]
-  (-> (as-python item)
-      (pyobj/incref)))
-
-
-(defn- as-py-fn
-  ^Pointer [obj-fn]
-  (pyobj/make-tuple-fn obj-fn
-                       :arg-converter as-jvm
-                       :result-converter as-python-incref))
-
-
-(defonce ^:private jvm-handle-map (ConcurrentHashMap.))
-
-(defn- make-jvm-object-handle
-  ^long [item]
-  (let [^ConcurrentHashMap hash-map jvm-handle-map]
-    (loop [handle (pyinterp/get-object-handle item)]
-      (let [handle (long handle)]
-        (if (not (.containsKey hash-map handle))
-          (do
-            (.put hash-map handle item)
-            handle)
-          (recur (.hashCode (UUID/randomUUID))))))))
-
-(defn- get-jvm-object
-  [handle]
-  (.get ^ConcurrentHashMap jvm-handle-map (long handle)))
-
-(defn- remove-jvm-object
-  [handle]
-  (.remove ^ConcurrentHashMap jvm-handle-map (long handle))
-  nil)
-
-(defn- py-self->jvm-handle
-  [self]
-  (->jvm (py-proto/get-attr self "jvm_handle")))
-
-(defn- py-self->jvm-obj
-  ^Object [self]
-  (-> (py-self->jvm-handle self)
-      get-jvm-object))
-
-(defn- as-tuple-instance-fn
-  [fn-obj]
-  (pyobj/make-tuple-instance-fn fn-obj :result-converter as-python-incref))
-
-
-(defn- self->map
-  ^Map [self]
-  (py-self->jvm-obj self))
-
-
-(defmacro pydelay
-  "Create a delay object that uses only gc reference semantics.  If stack reference
-  semantics happen to be in effect when this delay executes the object may still be
-  reachable by your program when it's reference counts are released leading to
-  bad/crashy behavior.  This ensures that can't happen at the cost of possibly an object
-  sticking around."
-  [& body]
-  `(delay
-     (with-gil
-       (with-bindings {#'pygc/*stack-gc-context* nil}
-         ~@body))))
-
-
-(defonce mapping-type
-  (pydelay
-    (with-gil
-      (let [mod (pyinterop/import-module "collections.abc")
-            map-type (py-proto/get-attr mod "MutableMapping")]
-        ;;In order to make things work ingeneral
-        (pyobj/create-class
-         "jvm-map-as-python"
-         [map-type]
-         {"__init__" (as-tuple-instance-fn
-                      (fn [self jvm-handle]
-                        (py-proto/set-attr! self "jvm_handle" jvm-handle)
-                        nil))
-          "__del__" (as-tuple-instance-fn
-                     #(try
-                        (remove-jvm-object (py-self->jvm-handle %))
-                        (catch Throwable e
-                          (log/warnf e "Error removing object"))))
-          "__contains__" (as-tuple-instance-fn #(.containsKey (self->map %1) (as-jvm %2)))
-          "__eq__" (as-tuple-instance-fn #(.equals (self->map %1) (as-jvm %2)))
-          "__getitem__" (as-tuple-instance-fn
-                         #(do (println "getting" (as-jvm %2))
-                              (.get (self->map %1) (as-jvm %2))))
-          "__setitem__" (as-tuple-instance-fn #(.put (self->map %1) (as-jvm %2) %3))
-          "__delitem__" (as-tuple-instance-fn #(.remove (self->map %1) (as-jvm %2)))
-          "__hash__" (as-tuple-instance-fn #(.hashCode (self->map %1)))
-          "__iter__" (as-tuple-instance-fn #(.iterator ^Iterable (keys (self->map %1))))
-          "__len__" (as-tuple-instance-fn #(.size (self->map %1)))
-          "__str__" (as-tuple-instance-fn #(.toString (self->map %1)))
-          "clear" (as-tuple-instance-fn #(.clear (self->map %1)))
-          "keys" (as-tuple-instance-fn #(seq (.keySet (self->map %1))))
-          "values" (as-tuple-instance-fn #(seq (.values (self->map %1))))
-          "pop" (as-tuple-instance-fn #(.remove (self->map %1) (as-jvm %2)))})))))
-
-
-(defn jvm-map-as-python
-  [^Map jvm-data]
-  (with-gil
-    (py-proto/call (libpy/as-pyobj (deref mapping-type)) (make-jvm-object-handle jvm-data))))
-
-
-(defmethod py-proto/pyobject->jvm :jvm-map-as-python
-  [pyobj]
-  (py-self->jvm-obj pyobj))
-
-
-(defmethod pyobject-as-jvm :jvm-map-as-python
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defn- self->list
-  ^List [self]
-  (py-self->jvm-obj self))
-
-(defonce sequence-type
-  (pydelay
-    (let [mod (pyinterop/import-module "collections.abc")
-          seq-type (py-proto/get-attr mod "MutableSequence")]
-      (pyobj/create-class
-       "jvm-list-as-python"
-       [seq-type]
-       {"__init__" (as-tuple-instance-fn
-                      (fn [self jvm-handle]
-                        (py-proto/set-attr! self "jvm_handle" jvm-handle)
-                        nil))
-        "__del__" (as-tuple-instance-fn
-                   #(try
-                      (remove-jvm-object (py-self->jvm-handle %))
-                      (catch Throwable e
-                        (log/warnf e "Error removing object"))))
-        "__contains__" (as-tuple-instance-fn #(.contains (self->list %1) %2))
-        "__eq__" (as-tuple-instance-fn #(.equals (self->list %1) (->jvm %2)))
-        "__getitem__" (as-tuple-instance-fn #(.get (self->list %1) (int (->jvm %2))))
-        "__setitem__" (as-tuple-instance-fn #(.set (self->list %1)
-                                                   (int (->jvm %2))
-                                                   (as-jvm %3)))
-        "__delitem__" (as-tuple-instance-fn #(.remove (self->list %1)
-                                                      (int (->jvm %2))))
-        "__hash__" (as-tuple-instance-fn #(.hashCode (self->list %1)))
-        "__iter__" (as-tuple-instance-fn #(.iterator (self->list %1)))
-        "__len__" (as-tuple-instance-fn #(.size (self->list %1)))
-        "__str__" (as-tuple-instance-fn #(.toString (self->list %1)))
-        "clear" (as-tuple-instance-fn #(.clear (self->list %1)))
-        "sort" (as-tuple-instance-fn #(.sort (self->list %1) nil))
-        "append" (as-tuple-instance-fn #(.add (self->list %1) %2))
-        "insert" (as-tuple-instance-fn #(.add (self->list %1) (int (->jvm %2)) %3))
-        "pop" (as-tuple-instance-fn
-               (fn [self & args]
-                 (let [jvm-data (self->list self)
-                       args (map ->jvm args)
-                       index (int (if (first args)
-                                     (first args)
-                                     -1))
-                       index (if (< index 0)
-                               (- (.size jvm-data) index)
-                               index)]
-                   #(.remove jvm-data index))))}))))
-
-
-(defn jvm-list-as-python
-  [^List jvm-data]
-  (with-gil
-    (py-proto/call (libpy/as-pyobj (deref sequence-type)) (make-jvm-object-handle jvm-data))))
-
-
-(defmethod py-proto/pyobject->jvm :jvm-list-as-python
-  [pyobj]
-  (py-self->jvm-obj pyobj))
-
-
-(defmethod pyobject-as-jvm :jvm-list-as-python
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defonce iterable-type
-  (pydelay
-    (with-gil
-      (let [mod (pyinterop/import-module "collections.abc")
-            iter-base-cls (py-proto/get-attr mod "Iterable")]
-        (pyobj/create-class
-         "jvm-iterable-as-python"
-         [iter-base-cls]
-         {"__init__" (as-tuple-instance-fn
-                      (fn [self jvm-handle]
-                        (py-proto/set-attr! self "jvm_handle" jvm-handle)
-                        nil))
-          "__del__" (as-tuple-instance-fn
-                     #(try
-                        (remove-jvm-object (py-self->jvm-handle %))
-                        (catch Throwable e
-                          (log/warnf e "Error removing object"))))
-          "__iter__" (as-tuple-instance-fn
-                      #(.iterator ^Iterable (py-self->jvm-obj %)))
-          "__eq__" (as-tuple-instance-fn #(.equals (py-self->jvm-obj %1)
-                                                   (as-jvm %2)))
-          "__hash__" (as-tuple-instance-fn
-                      #(.hashCode (py-self->jvm-obj %)))
-          "__str__" (as-tuple-instance-fn
-                     #(.toString (py-self->jvm-obj %)))})))))
-
-
-(defn jvm-iterable-as-python
-  [^Iterable jvm-data]
-  (with-gil
-    (py-proto/call (libpy/as-pyobj (deref iterable-type)) (make-jvm-object-handle jvm-data))))
-
-
-(defmethod py-proto/pyobject->jvm :jvm-iterable-as-python
-  [pyobj]
-  (py-self->jvm-obj pyobj))
-
-
-(defmethod pyobject-as-jvm :jvm-iterable-as-python
-  [pyobj]
-  (->jvm pyobj))
-
-
-(defonce iterator-type
-  (pydelay
-    (with-gil
-      (let [mod (pyinterop/import-module "collections.abc")
-            iter-base-cls (py-proto/get-attr mod "Iterator")
-            next-fn (fn [self]
-                      (let [^Iterator item (py-self->jvm-obj self)]
-                        (if (.hasNext item)
-                          (-> (.next item)
-                              ;;As python tracks the object in a jvm context
-                              (as-python)
-                              (jna/->ptr-backing-store)
-                              ;;But we are handing the object back to python which is expecting
-                              ;;a new reference.
-                              (pyobj/incref))
-                          (do
-                            (libpy/PyErr_SetNone
-                             (err/PyExc_StopIteration))
-                            nil))))]
-        (pyobj/create-class
-         "jvm-iterator-as-python"
-         [iter-base-cls]
-         {"__init__" (as-tuple-instance-fn
-                      (fn [self jvm-handle]
-                        (py-proto/set-attr! self "jvm_handle" jvm-handle)
-                        nil))
-          "__del__" (as-tuple-instance-fn
-                     #(try
-                        (remove-jvm-object (py-self->jvm-handle %))
-                        (catch Throwable e
-                          (log/warnf e "Error removing object"))))
-          "__next__" (pyobj/make-tuple-instance-fn
-                      next-fn
-                      ;;In this case we are explicitly taking care of all conversions
-                      ;;to python and back so we do not ask for any converters.
-                      :arg-converter nil
-                      :result-converter nil)})))))
-
-
-(defn jvm-iterator-as-python
-  [^Iterator jvm-data]
-  (with-gil
-    (py-proto/call (libpy/as-pyobj (deref iterator-type)) (make-jvm-object-handle jvm-data))))
-
-
-(defmethod py-proto/pyobject->jvm :jvm-iterator-as-python
-  [pyobj]
-  (py-self->jvm-obj pyobj))
-
-
-(defmethod pyobject-as-jvm :jvm-iterator-as-python
-  [pyobj]
-  (->jvm pyobj))
-
-(extend-protocol py-proto/PBridgeToPython
-  Number
-  (as-python [item options] (->python item))
-  String
-  (as-python [item options] (->python item))
-  Character
-  (as-python [item options] (->python item))
-  Symbol
-  (as-python [item options] (->python item))
-  Keyword
-  (as-python [item options] (->python item))
-  Boolean
-  (as-python [item options] (->python item))
-  Range
-  (as-python [item options]
-    (if (casting/integer-type? (dtype/get-datatype item))
-      (->python item options)
-      (jvm-iterable-as-python item)))
-  LongRange
-  (as-python [item options]
-    (->python item options))
-  Iterable
-  (as-python [item options]
-    (cond
-      (instance? Map item)
-      (jvm-map-as-python item)
-      (instance? RandomAccess item)
-      (jvm-list-as-python item)
-      :else
-      (jvm-iterable-as-python item)))
-  NDBuffer
-  (as-python [item options] (py-proto/as-numpy item options))
-  ArrayBuffer
-  (as-python [item options] (py-proto/as-numpy item options))
-  NativeBuffer
-  (as-python [item options] (py-proto/as-numpy item options))
-  Iterator
-  (as-python [item options]
-    (jvm-iterator-as-python item))
-  Object
-  (as-python [item options]
-    (cond
-      (fn? item)
-      (as-py-fn item)
-      :else
-      (throw (Exception. (format "Unable to convert objects of type: %s"
-                                 (type item)))))))
-
-
-(defn datatype->ptr-type-name
-  [dtype]
-  (case dtype
-    :int8 "c_byte"
-    :uint8 "c_ubyte"
-    :int16 "c_short"
-    :uint16 "c_ushort"
-    :int32 "c_long"
-    :uint32 "c_ulong"
-    :int64 "c_longlong"
-    :uint64 "c_ulonglong"
-    :float32 "c_float"
-    :float64 "c_double"))
-
-
-(defn descriptor->numpy
-  [{:keys [ptr shape strides elemwise-datatype] :as buffer-desc}]
-  (with-gil
-    (let [stride-tricks (-> (pyinterop/import-module "numpy.lib.stride_tricks")
-                            as-jvm)
-          ctypes (-> (pyinterop/import-module "ctypes")
-                     as-jvm)
-          np-ctypes (-> (pyinterop/import-module "numpy.ctypeslib")
-                        as-jvm)
-          dtype-size (casting/numeric-byte-width elemwise-datatype)
-          max-stride-idx (argops/argmax strides)
-          buffer-len (* (long (dtype/get-value shape max-stride-idx))
-                        (long (dtype/get-value strides max-stride-idx)))
-          n-elems (quot buffer-len dtype-size)
-          lvalue (long ptr)
-          void-p (call-attr ctypes "c_void_p" lvalue)
-          actual-ptr (call-attr
-                      ctypes "cast" void-p
-                      (call-attr
-                       ctypes "POINTER"
-                       (py-proto/get-attr ctypes
-                                          (datatype->ptr-type-name elemwise-datatype))))
-
-          initial-buffer (call-attr
-                          np-ctypes "as_array"
-                          actual-ptr (->py-tuple [n-elems]))
-
-          retval (call-attr stride-tricks "as_strided"
-                            initial-buffer
-                            (->py-tuple shape)
-                            (->py-tuple strides))]
-      (pygc/track retval #(get buffer-desc :ptr)))))
-
-
-(extend-type Object
-  py-proto/PJvmToNumpy
-  (->numpy [item options]
-    (-> (dtt/ensure-nd-buffer-descriptor item)
-        descriptor->numpy))
-  py-proto/PJvmToNumpyBridge
-  (as-numpy [item options]
-    (when (dtype-proto/convertible-to-native-buffer? item)
-      (when-let [desc (dtt/ensure-nd-buffer-descriptor item)]
-        (descriptor->numpy desc)))))
-
-
-(defn ->numpy
-  "Convert an object to numpy throwing an error if this isn't possible."
-  [item & [options]]
-  (py-proto/->numpy item options))
-
-
-(defn as-numpy
-  "Bridge an object into numpy sharing the backing store.  If it is not possible to
-  do this without copying data then return nil."
-  [item & [options]]
-  (py-proto/as-numpy item options))
diff --git a/src/libpython_clj/python/gc.clj b/src/libpython_clj/python/gc.clj
deleted file mode 100644
index 23b47af..0000000
--- a/src/libpython_clj/python/gc.clj
+++ /dev/null
@@ -1,67 +0,0 @@
-(ns libpython-clj.python.gc
-  "Binding of various sort of gc semantics optimized specifically for
-  libpython-clj.  For general bindings, see tech.resource"
-  (:import [java.util.concurrent ConcurrentHashMap ConcurrentLinkedDeque]
-           [java.lang.ref ReferenceQueue]
-           [tech.resource GCReference]))
-
-
-(set! *warn-on-reflection* true)
-
-
-(defonce ^:dynamic *stack-gc-context* nil)
-(defn stack-context
-  ^ConcurrentLinkedDeque []
-  *stack-gc-context*)
-
-
-(defonce reference-queue-var (ReferenceQueue.))
-(defn reference-queue
-  ^ReferenceQueue []
-  reference-queue-var)
-
-
-(defonce ptr-set-var (ConcurrentHashMap/newKeySet))
-(defn ptr-set
-  ^java.util.Set []
-  ptr-set-var)
-
-
-(defn track
-  [item dispose-fn]
-  (let [ptr-val (GCReference. item (reference-queue) (fn [ptr-val]
-                                                       (.remove (ptr-set) ptr-val)
-                                                       (dispose-fn)))
-        ^ConcurrentLinkedDeque stack-context (stack-context)]
-    ;;We have to keep track of the pointer.  If we do not the pointer gets gc'd then
-    ;;it will not be put on the reference queue when the object itself is gc'd.
-    ;;Nice little gotcha there.
-    (if stack-context
-      (.add stack-context ptr-val)
-      ;;Ensure we don't lose track of the weak reference.  If it gets cleaned up
-      ;;the gc system will fail.
-      (.add (ptr-set) ptr-val))
-    item))
-
-
-(defn clear-reference-queue
-  []
-  (when-let [next-ref (.poll (reference-queue))]
-    (.run ^Runnable next-ref)
-    (recur)))
-
-
-(defn clear-stack-context
-  []
-  (when-let [next-ref (.pollLast (stack-context))]
-    (.run ^Runnable next-ref)
-    (recur)))
-
-
-(defmacro with-stack-context
-  [& body]
-  `(with-bindings {#'*stack-gc-context* (ConcurrentLinkedDeque.)}
-     (try
-       ~@body
-       (finally
-         (clear-stack-context)))))
diff --git a/src/libpython_clj/python/interop.clj b/src/libpython_clj/python/interop.clj
deleted file mode 100644
index 9e9990a..0000000
--- a/src/libpython_clj/python/interop.clj
+++ /dev/null
@@ -1,444 +0,0 @@
-(ns libpython-clj.python.interop
-  "The messy details of actual embedding python in the jvm, aside from interpreter
-  state, go here.  Don't expect a pleasant ride.  If you want to create a new python
-  type or function, something that requires knowledge of the C structures behind
-  everything that knowledge should be encoded in this file."
-  (:require [libpython-clj.jna :as libpy]
-            [libpython-clj.python.logging
-             :refer [log-error log-warn log-info]]
-            [libpython-clj.python.interpreter
-             :refer
-             [get-object-handle
-              with-gil
-              ensure-bound-interpreter
-              ensure-interpreter
-              find-jvm-bridge-entry
-              get-jvm-bridge
-              unregister-bridge!
-              register-bridge!
-              conj-forever!]
-             :as pyinterp]
-            [clojure.stacktrace :as st]
-            [tech.v3.jna :as jna]
-            ;;need memset
-            [tech.v3.datatype.native-buffer :as native-buffer]
-            [tech.v3.resource :as resource]
-            [libpython-clj.python.object
-             :refer [wrap-pyobject incref-wrap-pyobject
-                     incref
-                     ->jvm ->python
-                     ->py-dict
-                     get-attr
-                     py-none
-                     ->py-string
-                     ->py-list
-                     ->py-tuple
-                     ->py-fn
-                     apply-method-def-data!]
-             :as pyobject]
-            [libpython-clj.python.protocols
-             :refer [python-type]
-             :as py-proto])
-  (:import [java.lang.reflect Field Method]
-           [com.sun.jna Pointer Structure CallbackReference]
-           [libpython_clj.jna
-            CFunction$KeyWordFunction
-            CFunction$TupleFunction
-            CFunction$NoArgFunction
-            CFunction$tp_new
-            CFunction$tp_free
-            CFunction$tp_dealloc
-            CFunction$tp_att_getter
-            CFunction$tp_att_setter
-            CFunction$tp_getattr
-            CFunction$tp_getattro
-            CFunction$tp_setattr
-            CFunction$tp_setattro
-            CFunction$tp_hash
-            PyMethodDef PyObject
-            PyMethodDef$ByReference
-            PyTypeObject
-            JVMBridge
-            JVMBridgeType]
-           [java.io Writer]))
-
-
-(set! *warn-on-reflection* true)
-
-
-(def libpython-clj-module-name
-  "Module name of the libpython-clj python model.  Used to find binding-level objects
-  such as the type used for actual jvm bridging objects."
-  "libpython_clj")
-
-
-(defn import-module
-  [modname]
-  (with-gil
-    (-> (libpy/PyImport_ImportModule modname)
-        wrap-pyobject)))
-
-
-(defn add-module
-  [modname]
-  (with-gil
-    (-> (libpy/PyImport_AddModule modname)
-        (incref-wrap-pyobject))))
-
-
-(defn module-dict
-  [module]
-  (with-gil
-    (-> (libpy/PyModule_GetDict module)
-        incref-wrap-pyobject)))
-
-
-(defn run-simple-string
-  "Run a simple string returning boolean 1 or 0.  Note this will never
-  return the result of the expression:
-
-  https://mail.python.org/pipermail/python-list/1999-April/018011.html
-
-  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;"
-  [program & {:keys [globals locals]}]
-  (with-gil
-    (let [main-mod (libpy/PyImport_AddModule "__main__")
-          globals (or globals (incref-wrap-pyobject
-                               (libpy/PyModule_GetDict main-mod)))
-          locals (or locals globals)
-          retval (-> (libpy/PyRun_String (str program)
-                                         :py-file-input
-                                         globals locals)
-                     wrap-pyobject)]
-      {:globals globals
-       :locals locals})))
-
-
-(defn run-string
-  "If you don't know what you are doing, this will sink you.  See documentation for
-  run-simple-string."
-  [^String program & {:keys [globals locals]}]
-  (with-gil
-    (let [globals (or globals (->py-dict {}))
-          locals (or locals (->py-dict {}))]
-      {:result
-       (wrap-pyobject
-        (libpy/PyRun_String (str program) :py-file-input globals locals))
-       :globals globals
-       :locals locals})))
-
-
-(defn test-cpp-example
-  []
-  (with-gil
-    (let [python-script "result = multiplicand * multiplier\n"
-          local-dict (->py-dict {"multiplicand" 2
-                                 "multiplier" 5})]
-      (run-string python-script :locals local-dict))))
-
-
-(def fieldOffsetMethod
-  (memoize
-   (fn []
-     (doto (.getDeclaredMethod Structure "fieldOffset"
-                               (into-array Class [String]))
-       (.setAccessible true)))))
-
-
-(defn offsetof
-  [structure-instance fieldname]
-  (.invoke ^Method (fieldOffsetMethod)
-           structure-instance
-           (into-array Object [(str fieldname)])))
-
-
-(defn method-def-data-seq->method-def-ref
-  ^PyMethodDef$ByReference [method-def-data-seq]
-  (when (seq method-def-data-seq)
-    (let [n-elems (count method-def-data-seq)
-          method-def-ary (-> (PyMethodDef.)
-                             (.toArray (inc n-elems)))]
-      (->> method-def-data-seq
-           (map-indexed (fn [idx def-data]
-                          (apply-method-def-data!
-                           (aget method-def-ary idx)
-                           def-data)))
-           dorun)
-      (PyMethodDef$ByReference. (.getPointer ^PyMethodDef
-                                             (aget method-def-ary 0))))))
-
-
-(def type-obj-size (-> (PyTypeObject.)
-                       (.size)))
-
-
-(defn register-type!
-  "Register a new type.  Please refer to python documentation for meaning
-  of the variables."
-  [module {:keys [type-name
-                  docstring
-                  method-definitions
-                  tp_flags ;;may be nil
-                  tp_basicsize ;;size of binary type
-                  tp_init ;;init fn, may be nil
-                  tp_new ;;may be nil, will use generic
-                  tp_dealloc ;;may be nil, will use generic
-                  tp_getattr ;;may *not* be nil
-                  tp_setattr ;;may *not* be nil
-                  tp_iter ;;may be nil
-                  tp_iternext ;;may be nil
-                  ]
-           :as type-definition}]
-  (resource/stack-resource-context
-   (when (or (not type-name)
-             (= 0 (count type-name)))
-     (throw (ex-info "Cannot create unnamed type." {})))
-   (let [tp_new (or tp_new
-                    (reify CFunction$tp_new
-                      (pyinvoke [this self varargs kw_args]
-                        (let [retval (libpy/PyType_GenericNew self varargs kw_args)]
-                          retval)
-                        )))
-         module-name (get-attr module "__name__")
-         ;;These get leaked.  Really, types are global objects that cannot be released.
-         ;;Until we can destroy interpreters, it isn't worth the effort to track the
-         ;;type and memory related to the type.
-         docstring-ptr (when docstring (jna/string->ptr-untracked docstring))
-         type-name-ptr (jna/string->ptr-untracked (str module-name "." type-name))
-         tp_flags (long (or tp_flags
-                            (bit-or libpy/Py_TPFLAGS_DEFAULT
-                                    libpy/Py_TPFLAGS_BASETYPE)))
-         ;;We allocate our memory manually here else the system will gc the
-         ;;type object memory when the type goes out of scope.
-         new-mem (jna/malloc-untracked type-obj-size)
-         _ (.setMemory (native-buffer/unsafe) (Pointer/nativeValue new-mem) type-obj-size (unchecked-byte 0))
-         new-type (PyTypeObject. new-mem)]
-     (set! (.tp_name new-type) type-name-ptr)
-     (set! (.tp_init new-type) tp_init)
-     (set! (.tp_doc new-type) docstring-ptr)
-     (set! (.tp_basicsize new-type) tp_basicsize)
-     (set! (.tp_flags new-type) tp_flags)
-     (set! (.tp_new new-type) tp_new)
-     (set! (.tp_dealloc new-type) tp_dealloc)
-     (set! (.tp_getattr new-type) tp_getattr)
-     (set! (.tp_setattr new-type) tp_setattr)
-     (set! (.tp_methods new-type) (method-def-data-seq->method-def-ref
-                                   method-definitions))
-     (when tp_iter
-       (set! (.tp_iter new-type) tp_iter))
-     (when tp_iternext
-       (set! (.tp_iternext new-type) tp_iternext))
-     (let [type-ready (libpy/PyType_Ready new-type)]
-       (if (>= 0 type-ready)
-         (do
-           (libpy/Py_IncRef new-type)
-           (.read new-type)
-           (libpy/PyModule_AddObject module (str type-name "_type") new-type)
-           ;;We are careful to keep track of the static data we give to python.
-           ;;the GC cannot now remove any of this stuff pretty much
-           ;;forever now.
-           (conj-forever! (assoc type-definition
-                                 :tp_name type-name-ptr
-                                 :tp_doc docstring-ptr
-                                 :tp_new tp_new
-                                 :tp_init tp_init
-                                 :tp_dealloc tp_dealloc
-                                 :tp_getattr tp_getattr
-                                 :tp_setattr tp_setattr
-                                 :tp_iter tp_iter
-                                 :tp_iternext tp_iternext))
-           (libpy/Py_IncRef new-type)
-           new-type)
-         (throw (ex-info (format "Type failed to register: %d" type-ready)
-                         {})))))))
-
-(defn pybridge->bridge
-  ^JVMBridge [^Pointer pybridge]
-  (let [bridge-type (JVMBridgeType. pybridge)]
-    (get-jvm-bridge (Pointer/nativeValue pybridge)
-                    (.jvm_interpreter_handle bridge-type))))
-
-
-(defn register-bridge-type!
-  "Register the bridge type and return newly created type."
-  [& {:keys [type-name module]
-      :or {type-name "jvm_bridge"}}]
-  (with-gil
-    (let [module (or module (add-module
-                             libpython-clj-module-name))]
-      (register-type!
-       module
-       {:type-name type-name
-        :docstring "Type used to create the jvmbridge python objects"
-        :method-definitions [{:name "__dir__"
-                              :doc "Custom jvm bridge  __dir__ method"
-                              :function (reify CFunction$NoArgFunction
-                                          (pyinvoke [this self]
-                                            (try
-                                              (-> (pybridge->bridge self)
-                                                  (.dir)
-                                                  (->py-list))
-                                              (catch Throwable e
-                                                (log-error "error calling __dir__:" e )
-                                                (->py-list [])))))}]
-        :tp_basicsize (.size (JVMBridgeType.))
-        :tp_dealloc (reify CFunction$tp_dealloc
-                      (pyinvoke [this self]
-                        (try
-                          (let [bridge (pybridge->bridge self)]
-                            (try (.close bridge)
-                                 (catch Throwable e
-                                   (log-error (format "%s:%s"
-                                               e
-                                               (with-out-str
-                                                 (st/print-stack-trace e))))))
-                            (unregister-bridge! bridge self))
-                          (catch Throwable e
-                            (log-error e)))
-                        (try
-                          (let [^CFunction$tp_free free-func
-                                (.tp_free (PyTypeObject.
-                                           (libpy/PyObject_Type self)))]
-                            (when free-func
-                              (.pyinvoke free-func self)))
-                          (catch Throwable e
-                            (log-error (format "%s:%s"
-                                               e
-                                               (with-out-str
-                                                 (st/print-stack-trace e))))))))
-        :tp_getattr (reify CFunction$tp_getattr
-                      (pyinvoke [this self att-name]
-                        (try
-                          (-> (pybridge->bridge self)
-                              (.getAttr att-name))
-                          (catch Throwable e
-                            (log-error (format "getattr: %s: %s" att-name e))
-                            nil))))
-        :tp_setattr (reify CFunction$tp_setattr
-                      (pyinvoke [this self att-name att-value]
-                        (try
-                          (-> (pybridge->bridge self)
-                              (.setAttr att-name att-value))
-                          (catch Throwable e
-                            (log-error (format "setattr: %s: %s" att-name e))
-                            0))))
-        :tp_iter (reify CFunction$NoArgFunction
-                   (pyinvoke [this self]
-                     (if-let [attr (-> (pybridge->bridge self)
-                                         (.getAttr "__iter__"))]
-                       (libpy/PyObject_CallObject (libpy/as-pyobj attr) nil)
-                       (do
-                         (libpy/PyErr_SetNone (libpy/PyExc_Exception))
-                         nil))))
-        :tp_iternext (reify CFunction$NoArgFunction
-                       (pyinvoke [this self]
-                         (if-let [next (-> (pybridge->bridge self)
-                                           (.getAttr "__next__"))]
-                           (libpy/PyObject_CallObject (libpy/as-pyobj next) nil)
-                           (do
-                             (libpy/PyErr_SetNone (libpy/PyExc_Exception))
-                             nil))))}))))
-
-
-(defn expose-bridge-to-python!
-  "Create a python object for this bridge."
-  [^JVMBridge bridge & [libpython-module]]
-  (with-gil
-    (let [libpython-module (or libpython-module
-                               (add-module libpython-clj-module-name))
-          ^Pointer bridge-type-ptr (get-attr libpython-module
-                                             "jvm_bridge_type")
-          _ (when-not bridge-type-ptr
-              (throw (ex-info "Failed to find bridge type" {})))
-          bridge-type (PyTypeObject. bridge-type-ptr)
-          ^Pointer new-py-obj (libpy/_PyObject_New bridge-type)
-          pybridge (JVMBridgeType. new-py-obj)]
-      (set! (.jvm_interpreter_handle pybridge) (get-object-handle
-                                                (.interpreter bridge)))
-      (set! (.jvm_handle pybridge) (get-object-handle (.wrappedObject bridge)))
-      (.write pybridge)
-      (register-bridge! bridge new-py-obj)
-      (wrap-pyobject new-py-obj))))
-
-
-(defn create-bridge-from-att-map
-  [src-item att-map]
-  (with-gil
-    (let [interpreter (ensure-bound-interpreter)
-          dir-data (->> (keys att-map)
-                        sort
-                        (into-array String))
-          bridge
-          (reify
-            JVMBridge
-            (getAttr [bridge att-name]
-              (if-let [retval (get att-map att-name)]
-                (incref retval)
-                (incref (libpy/Py_None))))
-            (setAttr [bridge att-name att-value]
-              (throw (ex-info "Cannot set attributes" {})))
-            (dir [bridge] dir-data)
-            (interpreter [bridge] interpreter)
-            (wrappedObject [bridge] src-item)
-            py-proto/PCopyToJVM
-            (->jvm [item options] src-item)
-            py-proto/PBridgeToJVM
-            (as-jvm [item options] src-item))]
-      (expose-bridge-to-python! bridge))))
-
-
-(defmethod py-proto/pyobject->jvm :jvm-bridge
-  [pyobj]
-  (-> (pybridge->bridge pyobj)
-      (.wrappedObject)))
-
-
-(defmethod py-proto/pyobject-as-jvm :jvm-bridge
-  [pyobj]
-  (-> (pybridge->bridge pyobj)
-      (.wrappedObject)))
-
-
-(defn create-var-writer
-  "Returns an unregistered bridge"
-  ^Pointer [writer-var varname]
-  (with-gil
-    (create-bridge-from-att-map
-     writer-var
-     {"write" (->python (fn [& args]
-                          (.write ^Writer @writer-var (str (first args)))
-                          ))
-      "flush" (->python (fn [& args]))
-      "isatty" (->python (fn [& args]
-                           (libpy/Py_False)))
-      })))
-
-
-(defn get-or-create-var-writer
-  [writer-var varname]
-  (if-let [existing-writer (find-jvm-bridge-entry (get-object-handle writer-var)
-                                                  (ensure-interpreter))]
-    (:pyobject existing-writer)
-    (create-var-writer writer-var varname)))
-
-
-(defn setup-std-writer
-  [writer-var sys-mod-attname]
-  (with-gil
-    (let [sys-module (import-module "sys")
-          std-out-writer (get-or-create-var-writer writer-var sys-mod-attname)]
-      (py-proto/set-attr! sys-module sys-mod-attname std-out-writer)
-      :ok)))
diff --git a/src/libpython_clj/python/interpreter.clj b/src/libpython_clj/python/interpreter.clj
deleted file mode 100644
index 3155d2f..0000000
--- a/src/libpython_clj/python/interpreter.clj
+++ /dev/null
@@ -1,532 +0,0 @@
-(ns libpython-clj.python.interpreter
-  (:require [libpython-clj.jna :as libpy]
-            [libpython-clj.jna.base :as libpy-base]
-            [libpython-clj.python.gc :as pygc]
-            [libpython-clj.python.logging
-             :refer [log-error log-warn log-info]]
-            [tech.v3.jna :as jna]
-            [clojure.java.shell :refer [sh]]
-            [clojure.java.io :as io]
-            [clojure.string :as s]
-            [clojure.tools.logging :as log]
-            [clojure.data.json :as json]
-            [clojure.pprint :as pp])
-  (:import [libpython_clj.jna JVMBridge PyObject DirectMapped]
-           [java.util.concurrent.atomic AtomicLong]
-           [com.sun.jna Pointer]
-           [com.sun.jna.ptr PointerByReference]
-           [java.io StringWriter]
-           [java.nio.file Paths Path]))
-
-
-(set! *warn-on-reflection* true)
-
-
-(defn get-object-handle
-  [obj]
-  (System/identityHashCode obj))
-
-
-(defn python-system-data [executable]
-  (let [{:keys [out err exit]}
-        (sh executable "-c" "import sys, json;
-print(json.dumps(
-{'platform':          sys.platform,
-  'prefix':           sys.prefix,
-  'base_prefix':      sys.base_prefix,
-  'executable':       sys.executable,
-  'base_exec_prefix': sys.base_exec_prefix,
-  'exec_prefix':      sys.exec_prefix,
-  'version':          list(sys.version_info)[:3]}))")]
-    (when (= 0 exit)
-      (json/read-str out :key-fn keyword))))
-
-(defn python-system-info
-  "An information map about the Python system information provided
-  by a Python executable (string).
-
-  :platform (operating system information)
-  :prefix
-  A string giving the site-specific directory prefix where the platform independent Python files are installed; by default, this is the string '/usr/local'. This can be set at build time with the --prefix argument to the configure script. The main collection of Python library modules is installed in the directory prefix/lib/pythonX.Y while the platform independent header files (all except pyconfig.h) are stored in prefix/include/pythonX.Y, where X.Y is the version number of Python, for example 3.2.
-  Note If a virtual environment is in effect, this value will be changed in site.py to point to the virtual environment. The value for the Python installation will still be available, via base_prefix.
-
-  :base-prefix
-  Set during Python startup, before site.py is run, to the same value as prefix. If not running in a virtual environment, the values will stay the same; if site.py finds that a virtual environment is in use, the values of prefix and exec_prefix will be changed to point to the virtual environment, whereas base_prefix and base_exec_prefix will remain pointing to the base Python installation (the one which the virtual environment was created from).
-
-  :executable
-  A string giving the absolute path of the executable binary for the Python interpreter, on systems where this makes sense. If Python is unable to retrieve the real path to its executable, sys.executable will be an empty string or None.
-
-  :exec-prefix
-  A string giving the site-specific directory prefix where the platform-dependent Python files are installed; by default, this is also '/usr/local'. This can be set at build time with the --exec-prefix argument to the configure script. Specifically, all configuration files (e.g. the pyconfig.h header file) are installed in the directory exec_prefix/lib/pythonX.Y/config, and shared library modules are installed in exec_prefix/lib/pythonX.Y/lib-dynload, where X.Y is the version number of Python, for example 3.2.
-  Note If a virtual environment is in effect, this value will be changed in site.py to point to the virtual environment. The value for the Python installation will still be available, via base_exec_prefix.
-
-  :base-exec-prefix
-  Set during Python startup, before site.py is run, to the same value as exec_prefix. If not running in a virtual environment, the values will stay the same; if site.py finds that a virtual environment is in use, the values of prefix and exec_prefix will be changed to point to the virtual environment, whereas base_prefix and base_exec_prefix will remain pointing to the base Python installation (the one which the virtual environment was created from).
-
-  :version
-  (list python-major python-minor python-micro)"
-  [executable]
-  (let [{platform         :platform
-         prefix           :prefix
-         base-prefix      :base_prefix
-         executable       :executable
-         exec-prefix      :exec_prefix
-         base-exec-prefix :base_exec_prefix
-         version          :version}
-        (python-system-data executable)]
-    {:platform         platform
-     :prefix           prefix
-     :base-prefix      base-prefix
-     :executable       executable
-     :exec-prefix      exec-prefix
-     :base-exec-prefix base-exec-prefix
-     :version          version}))
-
-
-(defn python-library-regex [system-info]
-  (let [{version  :version
-         platform :platform} system-info
-        [major minor micro]  (vec version)]
-    (re-pattern
-     (format
-      (condp (partial =) (keyword platform)
-        ;; TODO: not sure what the strings returned by
-        ;;   ..: mac and windows are for sys.platform
-        :linux   "libpython%s.%sm?.so$"
-        :mac     "libpython%s.%sm?.dylib$"
-        :darwin  "libpython%s.%sm?.dylib$"
-        :win32   "python%s%s.dll$")
-      major minor))))
-
-
-(defn python-library-paths
-  "Returns vector of matching python libraries in order of:
-  - virtual-env (library)
-  - installation prefix (library)
-  - default installation location
-  - virtual-env (executable)
-  - installation prefix (executable)
-  - default executable location"
-  [system-info python-regex]
-  (println system-info)
-  (transduce
-   (comp
-    (map io/file)
-    (map file-seq)
-    cat
-    (map str)
-    (filter #(re-find python-regex %)))
-   (fn
-     ([[seen results]] results)
-     ([[seen? results] input]
-      (if (not (seen? input))
-        [(conj seen? input) (conj results input)]
-        [seen? results])))
-   ;; [seen? results]
-   [#{} []]
-   ((comp
-     vec
-     (juxt :base-prefix :prefix :base-exec-prefix :exec-prefix))
-    system-info)))
-
-(comment
-  ;; library paths workflow
-
-  (let [executable "python3.6"
-        system-info (python-system-info executable)
-        pyregex (python-library-regex system-info)]
-    (python-library-paths system-info pyregex)))
-  ;;=> ["/usr/lib/x86_64-linux-gnu/libpython3.7m.so" "/usr/lib/python3.7/config-3.7m-x86_64-linux-gnu/libpython3.7m.so"]
-
-
-(defn- ignore-shell-errors
-  [& args]
-  (try
-    (apply sh args)
-    (catch Throwable e nil)))
-
-
-(def default-python-executables
-  ["python3" "python3.6" "python3.7" "python3.8" "python3.9" "python"])
-
-
-(defn detect-startup-info
-  [{:keys [library-path python-home python-executable]}]
-  (log-info
-   (str "Detecting startup-info for Python executable: "
-        python-executable))
-  (let [executable-seq                (concat
-                                       (when python-executable
-                                         [python-executable])
-                                       default-python-executables)
-        system-info                (->> executable-seq
-                                        (map #(try (python-system-info %)
-                                                   (catch Throwable e
-                                                     nil)))
-                                        (remove nil?)
-                                        (first))
-        _ (when-not system-info
-            (throw (Exception. (format "Python executable was not found.  Tried: %s"
-                                       (vec executable-seq)))))
-        python-home                (cond
-                                     python-home
-                                     python-home
-                                     (seq (System/getenv "PYTHONHOME"))
-                                     (System/getenv "PYTHONHOME")
-                                     :else
-                                     (:prefix system-info))
-        java-library-path-addendum (when python-home
-                                     (-> (Paths/get python-home
-                                                    (into-array String ["lib"]))
-                                         (.toString)))
-        [ver-maj ver-med _ver-min] (:version system-info)
-        lib-version                (format "%s.%s" ver-maj ver-med)
-        libname                    (or library-path
-                                       (when (seq lib-version)
-                                         (str "python" lib-version "m")))
-        libnames                   (concat [libname]
-                                           ;;Make sure we try without the 'm' suffix
-                                           (when lib-version
-                                             [(str "python" lib-version)]))
-        retval
-        (merge
-         system-info
-         {:python-home                python-home
-          :lib-version                lib-version
-          :libname                    libname
-          :libnames                   libnames
-          :java-library-path-addendum java-library-path-addendum})]
-    (log/infof "Startup info detected:\n%s"
-               (with-out-str
-                 (pp/pprint (dissoc retval :libname))))
-    retval))
-
-
-;;All interpreters share the same type symbol table as types are uniform
-;;across initializations.  So given an unknown item, we can in constant time
-;;get the type of that item if we have seen it before.
-(defrecord Interpreter [
-                        interpreter-state* ;;Thread state, per interpreter
-                        shared-state*]) ;;state shared among all interpreters
-
-
-
-;; Main interpreter booted up during initialize!
-;; * in the right to indicate atom
-(defonce main-interpreter* (atom nil))
-
-(defn main-interpreter
-  ^Interpreter []
-  @main-interpreter*)
-
-
-
-(defn handle-or-interpreter->interpreter
-  [hdl-or-interp]
-  (if (number? hdl-or-interp)
-    (throw (Exception. "Interpreters are no long handles"))
-    hdl-or-interp))
-
-
-;;Bridge objects are generically created objects that can bridge between
-;;python and java.  At the very least, they implement JVMBridge
-(defn find-jvm-bridge-entry
-  ^JVMBridge [handle interpreter]
-  (when-let [interpreter (handle-or-interpreter->interpreter interpreter)]
-    (when-let [^JVMBridge bridge-object (get-in @(:interpreter-state* interpreter)
-                                                [:bridge-objects handle])]
-      bridge-object)))
-
-
-(defn get-jvm-bridge
-  ^JVMBridge [handle interpreter]
-  (if-let [bridge-obj (find-jvm-bridge-entry handle (main-interpreter))]
-    (:jvm-bridge bridge-obj)
-    (throw (Exception.
-            (format "Unable to find bridge for interpreter %s and handle %s"
-                    interpreter handle)))))
-
-
-(defn register-bridge!
-  [^JVMBridge bridge ^Pointer bridge-pyobject]
-  (let [interpreter (.interpreter bridge)
-        bridge-handle (Pointer/nativeValue bridge-pyobject)]
-    (when (contains? (get-in @(:interpreter-state* interpreter)
-                           [:bridge-objects])
-                     bridge-handle)
-      (throw (Exception. (format "Bridge already exists!! - 0x%x" bridge-handle))))
-    (swap! (:interpreter-state* interpreter) assoc-in
-           [:bridge-objects bridge-handle]
-           {:jvm-bridge bridge
-            :pyobject bridge-handle})
-    :ok))
-
-
-(defn unregister-bridge!
-  [^JVMBridge bridge ^Pointer bridge-pyobject]
-  (let [interpreter (.interpreter bridge)
-        bridge-handle (Pointer/nativeValue bridge-pyobject)]
-    (swap! (:interpreter-state* interpreter)
-           update :bridge-objects dissoc bridge-handle)
-    :ok))
-
-
-(defn- construct-main-interpreter!
-  [thread-state type-symbol-table]
-  (swap!
-   main-interpreter*
-   (fn [existing-interpreter]
-     (when existing-interpreter
-       (throw (Exception. "Main interpreter is already constructed")))
-
-     (let [retval (->Interpreter
-                                 (atom {:thread-state thread-state
-                                        :bridge-objects {}
-                                        :sub-interpreters []})
-                                 ;;This that have to live as long as the main
-                                 ;;interpreter does
-                                 (atom {:type-symbol-table type-symbol-table
-                                        :forever []}))]
-       retval)))
-  :ok)
-
-
-(defn- python-thread-state
-  [interpreter]
-  (get @(:interpreter-state* interpreter) :thread-state))
-
-
-(defn release-gil!
-  "Reentrant pathway to release the gil."
-  [gil-state ^long original-thread-id]
-  (.set ^AtomicLong libpy-base/gil-thread-id original-thread-id)
-  (libpy/PyGILState_Release gil-state))
-
-
-(defn acquire-gil!
-  "Reentrant pathway to acquire gil."
-  []
-  (let [retval (libpy/PyGILState_Ensure)]
-    (.set ^AtomicLong libpy-base/gil-thread-id (libpy-base/current-thread-id))
-    retval))
-
-
-(defn swap-interpreters!
-  "The gil must be held by this thread.  This swaps out the current interpreter
-  to make a new one current."
-  [old-interp new-interp]
-  (libpy/PyThreadState_Swap (python-thread-state old-interp)
-                            (python-thread-state new-interp)))
-
-
-(defn main-interpreter-thread-id
-  ^long []
-  (.get ^AtomicLong libpy-base/gil-thread-id))
-
-
-(defn ensure-interpreter
-  ^Interpreter []
-  (let [retval (main-interpreter)]
-    (when-not retval
-      (throw (Exception. "No interpreters found, perhaps an initialize! call is missing?")))
-    retval))
-
-
-(defn ensure-bound-interpreter
-  []
-  (let [interp (main-interpreter)]
-    (if (and interp
-             (= (libpy-base/current-thread-id) (main-interpreter-thread-id)))
-      interp
-      (throw (Exception. "No interpreters found, perhaps an initialize! call is missing?")))))
-
-
-(defn py-type-keyword
-  "Get a keyword that corresponds to the current type.  Uses global type symbol
-  table. Add the type to the symbol table if it does not exist already."
-  [typeobj]
-  (let [type-addr (Pointer/nativeValue (libpy/as-pyobj typeobj))
-        interpreter (ensure-bound-interpreter)
-        symbol-table (-> (swap! (:shared-state* interpreter)
-                                (fn [{:keys [type-symbol-table] :as shared-state}]
-                                  (if-let [found-item (get type-symbol-table
-                                                           type-addr)]
-                                    shared-state
-                                    (assoc-in shared-state [:type-symbol-table
-                                                            type-addr]
-                                              {:typename (libpy/get-type-name
-                                                          typeobj)}))))
-                         :type-symbol-table)]
-    (get-in symbol-table [type-addr :typename])))
-
-
-
-(defmacro with-gil
-  "Grab the gil and use the main interpreter using reentrant acquire-gil pathway."
-  [& body]
-  `(do
-     (let [interp# (ensure-interpreter)]
-       (let [[previously-bound-thread-id# gil-state#]
-             (locking interp#
-               (let [^AtomicLong bound-thread# libpy-base/gil-thread-id
-                     previously-bound-thread-id# (.get bound-thread#)
-                     thread-id# (libpy-base/current-thread-id)
-                     gil-state# (when-not (== thread-id# previously-bound-thread-id#)
-                                  (acquire-gil!))]
-                 [previously-bound-thread-id# gil-state#]))]
-         (try
-           ~@body
-           (finally
-             (when gil-state#
-               (pygc/clear-reference-queue)
-               (release-gil! gil-state# previously-bound-thread-id#))))))))
-
-
-(defonce ^:dynamic *program-name* "")
-
-
-(defn- find-python-lib-version
-  []
-  (let [{:keys [out err exit]} (ignore-shell-errors "python3" "--version")]
-    (when (= 0 exit)
-      ;;Anaconda prints version info only to the error stream.
-      (when-let [version-info (first (filter seq [out err]))]
-        (log/infof "Python detected: %s" version-info)
-        (let [version-data (re-find #"\d+\.\d+\.\d+" version-info)
-              parts (->> (s/split version-data #"\.")
-                         (take 2)
-                         seq)]
-          (s/join "." parts))))))
-
-
-(defn append-java-library-path!
-  [new-search-path]
-  (let [existing-paths (-> (System/getProperty "java.library.path")
-                           (s/split #":"))]
-    (when-not (contains? (set existing-paths) new-search-path)
-      (let [new-path-str (s/join ":" (concat [new-search-path]
-                                             existing-paths))]
-        (log/infof "Setting java library path: %s" new-path-str)
-        (System/setProperty "java.library.path" new-path-str)))))
-
-
-(defonce ^:private python-home-wide-ptr* (atom nil))
-(defonce ^:private python-path-wide-ptr* (atom nil))
-
-
-(defn- try-load-python-library!
-  [libname python-home-wide-ptr python-path-wide-ptr]
-  (try
-    (jna/load-library libname)
-    (alter-var-root #'libpy-base/*python-library* (constantly libname))
-    (when python-home-wide-ptr
-      (libpy/Py_SetPythonHome python-home-wide-ptr))
-    (when python-path-wide-ptr
-      (libpy/Py_SetProgramName python-path-wide-ptr))
-    (libpy/Py_InitializeEx 0)
-    libname
-    (catch Exception e)))
-
-
-(defn- setup-direct-mapping!
-  []
-  (let [library (jna/load-library libpy-base/*python-library*)]
-    (com.sun.jna.Native/register DirectMapped library)))
-
-
-(defn initialize!
-  [& {:keys [program-name
-             library-path]
-      :as options}]
-  (when-not (main-interpreter)
-    (log-info (str "Executing python initialize with options:" options))
-    (let [{:keys [python-home libnames java-library-path-addendum
-                  executable] :as startup-info}
-          (detect-startup-info options)
-          library-names (concat
-                         (when library-path
-                           [library-path])
-                         libnames
-                         (libpy-base/library-names))]
-      (reset! python-home-wide-ptr* nil)
-      (reset! python-path-wide-ptr* nil)
-      (log/infof "Trying python library names %s" (vec library-names))
-      (when python-home
-        (append-java-library-path! java-library-path-addendum)
-        ;;This can never be released if load-library succeeeds
-        (reset! python-home-wide-ptr* (jna/string->wide-ptr python-home))
-        (reset! python-path-wide-ptr* (jna/string->wide-ptr
-                                       (format "%s/bin/python3"
-                                               python-home))))
-      (loop [[library-name & library-names] library-names]
-        (if (and library-name
-                 (not (try-load-python-library! library-name
-                                                @python-home-wide-ptr*
-                                                @python-path-wide-ptr*)))
-          (recur library-names)))
-      (setup-direct-mapping!)
-      ;;Set program name
-      (when-let [program-name (or program-name executable "")]
-        (libpy/PySys_SetArgv 0 (-> program-name
-                                   (jna/string->wide-ptr)))))
-    (let [type-symbols (libpy/lookup-type-symbols)
-          context (do
-                    (libpy-base/set-gil-thread-id!
-                     Long/MAX_VALUE (libpy-base/current-thread-id))
-                    (let [retval (libpy/PyEval_SaveThread)]
-                      (libpy-base/set-gil-thread-id!
-                       (libpy-base/current-thread-id) Long/MAX_VALUE)
-                      retval))]
-      (construct-main-interpreter! context type-symbols))))
-
-
-(def ^:dynamic *python-error-handler* nil)
-
-
-(defn check-error-str
-  "Function assumes python stdout and stderr have been redirected"
-  []
-  (with-gil
-    (when-not (= nil (libpy/PyErr_Occurred))
-      (if-not *python-error-handler*
-        (let [custom-writer (StringWriter.)]
-          (with-bindings {#'*err* custom-writer}
-            (libpy/PyErr_Print))
-          (.toString custom-writer))
-        (*python-error-handler*)))))
-
-
-(defn check-error-throw
-  []
-  (when-let [error-str (check-error-str)]
-    (throw (Exception. ^String error-str))))
-
-
-(defn check-error-log
-  []
-  (when-let [error-str (check-error-str)]
-    (log-error error-str)))
-
-
-(defn finalize!
-  []
-  (when-not (== Long/MAX_VALUE (.get ^AtomicLong libpy-base/gil-thread-id))
-    (throw (Exception. (format "A thread still owns the interpreter: "
-                               (.get ^AtomicLong libpy-base/gil-thread-id)))))
-  (let [interp (ensure-interpreter)]
-    (locking interp
-      (check-error-throw)
-      (log-info "executing python finalize!")
-      (let [finalize-value (libpy/Py_FinalizeEx)]
-        (when-not (= 0 finalize-value)
-          (log-error (format "PyFinalize returned nonzero value: %s" finalize-value)))))))
-
-
-(defn conj-forever!
-  [items]
-  (let [interpreter (ensure-bound-interpreter)]
-    (swap! (:shared-state* interpreter) update :forever conj items)
-    :ok))
-
-
-;;Sub interpreter work goes here
diff --git a/src/libpython_clj/python/logging.clj b/src/libpython_clj/python/logging.clj
deleted file mode 100644
index 4098c8d..0000000
--- a/src/libpython_clj/python/logging.clj
+++ /dev/null
@@ -1,35 +0,0 @@
-(ns libpython-clj.python.logging
-  "Wrapper for simple logging.  Use tools.logging ns directly for more
-  advanced usages."
-  (:require [clojure.tools.logging :as log]))
-
-
-(set! *warn-on-reflection* true)
-
-
-(defn log-level
-  [level msg]
-  (case level
-    :info (log/info msg)
-    :warn (log/warn msg)
-    :error (log/error msg)))
-
-
-(defn log-error
-  [log-str]
-  (log-level :error log-str))
-
-
-(defn log-warn
-  [log-str]
-  (log-level :warn log-str))
-
-
-(defn log-info
-  [log-str]
-  (log-level :info log-str))
-
-
-(defn logthrow-error
-  [log-str & [data]]
-  (throw (ex-info log-str data)))
diff --git a/src/libpython_clj/python/np_array.clj b/src/libpython_clj/python/np_array.clj
deleted file mode 100644
index 38998e0..0000000
--- a/src/libpython_clj/python/np_array.clj
+++ /dev/null
@@ -1,114 +0,0 @@
-(ns libpython-clj.python.np-array
-  "Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This allows somewhat more
-  seamless usage of numpy arrays in datatype and tensor functionality such as enabling
-  the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible)."
-  (:require [tech.v3.datatype.protocols :as dtype-proto]
-            [tech.v3.tensor :as dtt]
-            [libpython-clj.python.interpreter :as py-interp]
-            [libpython-clj.python.protocols :as py-proto]
-            [libpython-clj.python.bridge :as py-bridge]
-            [libpython-clj.python.interop :as py-interop]))
-
-
-(defmethod py-proto/pyobject->jvm :ndarray
-  [pyobj]
-  (-> (py-bridge/numpy->desc pyobj)
-      (dtt/nd-buffer-descriptor->tensor)
-      (dtt/clone)))
-
-
-(defmethod py-proto/pyobject-as-jvm :ndarray
-  [pyobj]
-  (py-interp/with-gil
-    (let [interpreter (py-interp/ensure-bound-interpreter)]
-      (py-bridge/bridge-pyobject
-       pyobj
-       interpreter
-       Iterable
-       (iterator [this]
-                 (py-proto/python-obj-iterator pyobj interpreter))
-       py-proto/PPyObjectBridgeToMap
-       (as-map [item]
-               (py-bridge/generic-python-as-map pyobj))
-       py-proto/PPyObjectBridgeToList
-       (as-list [item]
-                (py-bridge/generic-python-as-list pyobj))
-       dtype-proto/PToTensor
-       (as-tensor [item]
-                  (-> (py-bridge/numpy->desc item)
-                      dtt/nd-buffer-descriptor->tensor))
-       dtype-proto/PElemwiseDatatype
-       (elemwise-datatype
-        [this]
-        (-> (py-proto/get-attr pyobj "dtype")
-            (py-proto/as-jvm {})
-            (py-bridge/obj-dtype->dtype)))
-
-
-       dtype-proto/PECount
-       (ecount [this] (apply * (dtype-proto/shape this)))
-
-       dtype-proto/PShape
-       (shape
-        [this]
-        (-> (py-proto/get-attr pyobj "shape")
-            (py-proto/->jvm {})))
-
-       dtype-proto/PToNativeBuffer
-       (convertible-to-native-buffer? [item] true)
-       (->native-buffer
-        [item]
-        (dtype-proto/->native-buffer
-         (dtype-proto/as-tensor item)))
-
-       dtype-proto/PSubBuffer
-       (sub-buffer
-        [buffer offset length]
-        (-> (dtype-proto/as-tensor buffer)
-            (dtype-proto/sub-buffer offset length)))
-
-       dtype-proto/PToNDBufferDesc
-       (convertible-to-nd-buffer-desc? [item] true)
-       (->nd-buffer-descriptor
-        [item]
-        (py-bridge/numpy->desc item))))))
-
-
-(def np-mod*
-  "Delay that dereferences to the python numpy module"
-  (py-bridge/pydelay
-   (-> (py-interop/import-module "numpy")
-       (py-proto/as-jvm {}))))
-
-
-(comment
-
-  ;;Dispatch table for what tech.v3.datatype.functional methods are found in the numpy module.
-
-  (defn- dispatch-binary-op
-    [op lhs rhs options]
-    (case op
-      :max (py-proto/call-attr @np-mod "max" lhs rhs)
-      :min (py-proto/call-attr @np-mod "min" lhs rhs)
-      :+ (py-proto/call-attr @np-mod "add" lhs rhs)
-      :- (py-proto/call-attr @np-mod "subtract" lhs rhs)
-      :div (py-proto/call-attr @np-mod "divide" lhs rhs)
-      :* (py-proto/call-attr @np-mod "multiply" lhs rhs)
-      :pow (py-proto/call-attr @np-mod "power" lhs rhs)
-      :quot (py-proto/call-attr @np-mod "floor_divide" lhs rhs)
-      :rem (py-proto/call-attr @np-mod "mod" lhs rhs)
-      :bit-and (py-proto/call-attr @np-mod "bitwise_and" lhs rhs)
-      :bit-flip (py-proto/call-attr @np-mod "bitwise_not" lhs rhs)
-      :bit-or (py-proto/call-attr @np-mod "bitwise_or" lhs rhs)
-      :bit-xor (py-proto/call-attr @np-mod "bitwise_xor" lhs rhs)
-      :bit-shift-left (py-proto/call-attr @np-mod "left_shift" lhs rhs)
-      :bit-shift-right (py-proto/call-attr @np-mod "right_shift" lhs rhs)
-      :and (py-proto/call-attr @np-mod "logical_and" lhs rhs)
-      :or (py-proto/call-attr @np-mod "logical_or" lhs rhs)
-      :not (py-proto/call-attr @np-mod "logical_not" lhs rhs)
-      :xor (py-proto/call-attr @np-mod "logical_xor" lhs rhs)
-      :< (py-proto/call-attr @np-mod "less" lhs rhs)
-      :<= (py-proto/call-attr @np-mod "less_equal" lhs rhs)
-      :eq (py-proto/call-attr @np-mod "equal" lhs rhs)
-      :> (py-proto/call-attr @np-mod "greater" lhs rhs)
-      :>= (py-proto/call-attr @np-mod "greater_equal" lhs rhs))))
diff --git a/src/libpython_clj/python/object.clj b/src/libpython_clj/python/object.clj
deleted file mode 100644
index 352ec97..0000000
--- a/src/libpython_clj/python/object.clj
+++ /dev/null
@@ -1,1133 +0,0 @@
-(ns libpython-clj.python.object
-  "Base support for python objects and python->jvm interop.  At this level (without
-  interop), we can only support the copying protocols; we can't do bridging.  Still,
-  copying gets you quite far and you can, for instance, call python functions and get
-  the attribute map from a python object.
-
-  Protocol functions implemented:
-  python-type
-  ->python
-  ->jvm
-  dir
-  has-attr?
-  attr
-  callable?
-  has-item?
-  item
-  set-item!
-  do-call-fn
-  len
-
-  Results of these, when they return python pointers, return the raw,unwrapped pointers.
-  Callers at this level are sitting just close enough to the actual libpy calls to still
-  get pointers back *but* they don't have to manage the gil."
-  (:require [libpython-clj.python.interpreter
-             :refer [with-gil
-                     ensure-interpreter
-                     ensure-bound-interpreter
-                     check-error-throw]
-             :as pyinterp]
-            [libpython-clj.python.protocols
-             :refer [pyobject->jvm
-                     python-type]
-             :as py-proto]
-            [libpython-clj.jna.base :as libpy-base]
-            [libpython-clj.jna :as libpy]
-            [libpython-clj.python.gc :as pygc]
-            [clojure.stacktrace :as st]
-            [tech.v3.jna :as jna]
-            [tech.v3.datatype :as dtype]
-            [tech.v3.datatype.protocols :as dtype-proto]
-            [tech.v3.datatype.casting :as casting]
-            [clojure.tools.logging :as log])
-  (:import [com.sun.jna Pointer CallbackReference]
-           [com.sun.jna.ptr PointerByReference]
-           [java.lang.reflect Field]
-           [libpython_clj.jna
-            PyObject
-            CFunction$KeyWordFunction
-            CFunction$TupleFunction
-            CFunction$NoArgFunction
-            PyMethodDef]
-           [java.nio.charset StandardCharsets]
-           [java.util RandomAccess Map Set Map$Entry]
-           [tech.v3.datatype ObjectReader NDBuffer Buffer]
-           [tech.v3.datatype.array_buffer ArrayBuffer]
-           [tech.v3.datatype.native_buffer NativeBuffer]
-           [clojure.lang Symbol Keyword
-            IPersistentMap
-            IPersistentVector
-            IPersistentSet
-            Range LongRange]))
-
-
-(set! *warn-on-reflection* true)
-
-
-
-(extend-protocol py-proto/PCopyToJVM
-  Pointer
-  (->jvm [item options]
-    (pyobject->jvm item))
-  PyObject
-  (->jvm [item options]
-    (pyobject->jvm (.getPointer item))))
-
-
-(extend-protocol py-proto/PBridgeToPython
-  Pointer
-  (as-python [item options] item)
-  PyObject
-  (as-python [item options] (.getPointer item)))
-
-
-(extend-protocol py-proto/PCopyToPython
-  Pointer
-  (->python [item options] item)
-  PyObject
-  (->python [item options] (.getPointer item)))
-
-
-(defn ->jvm
-  "Copy an object into the jvm (if it wasn't there already.)"
-  [item & [options]]
-  (when-not (nil? item)
-    (py-proto/->jvm item options)))
-
-
-(def object-reference-logging (atom false))
-
-
-(defn incref
-  "Incref and return object"
-  [pyobj]
-  (let [pyobj (libpy/as-pyobj pyobj)]
-    (libpy/Py_IncRef pyobj)
-    pyobj))
-
-
-(defn refcount
-  ^long [pyobj]
-  (long (.ob_refcnt (PyObject. (libpy/as-pyobj pyobj)))))
-
-
-(def ^:private non-native-val
-  (delay (Pointer/nativeValue (libpy/as-pyobj (libpy/Py_None)))))
-
-
-(defn wrap-pyobject
-  "Wrap object such that when it is no longer accessible via the program decref is
-  called. Used for new references.  This is some of the meat of the issue, however,
-  in that getting the two system's garbage collectors to play nice is kind
-  of tough.
-  This is a hot path; it is called quite a lot from a lot of places."
-  ([pyobj skip-check-error?]
-   ;;We don't wrap pynone
-   (if pyobj
-     (let [pyobj-value (Pointer/nativeValue (libpy/as-pyobj pyobj))
-           ^PyObject obj-data (when @object-reference-logging
-                                (PyObject. (Pointer. pyobj-value)))]
-       (if (not= pyobj-value
-                 (long @non-native-val))
-         (do
-           (ensure-bound-interpreter)
-           (when @object-reference-logging
-             (println (format "tracking object  - 0x%x:%4d:%s"
-                              pyobj-value
-                              (.ob_refcnt obj-data)
-                              (name (python-type pyobj)))))
-           ;;We ask the garbage collector to track the python object and notify
-           ;;us when it is released.  We then decref on that event.
-           (pygc/track
-            pyobj
-            ;;No longer with-gil.  Because cleanup is cooperative, the gil is
-            ;;guaranteed to be captured here already.
-            #(try
-               ;;Intentionally overshadow pyobj.  We cannot access it here.
-               (let [pyobj (Pointer. pyobj-value)]
-                 (when @object-reference-logging
-                   (let [_ (.read obj-data)
-                         refcount (.ob_refcnt obj-data)]
-                     (if (< refcount 1)
-                       (log/errorf "Fatal error -- releasing object - 0x%x:%4d:%s
-Object's refcount is bad.  Crash is imminent"
-                                   pyobj-value
-                                   refcount
-                                   (name (python-type pyobj)))
-                       (println (format "releasing object - 0x%x:%4d:%s"
-                                        pyobj-value
-                                        refcount
-                                        (name (python-type pyobj)))))))
-                 (libpy/Py_DecRef pyobj))
-               (catch Throwable e
-                 (log/error e "Exception while releasing object"))))
-           (when-not skip-check-error? (check-error-throw))
-           pyobj)
-         (do
-           ;;Special handling for PyNone types
-           (libpy/Py_DecRef pyobj)
-           (when-not skip-check-error? (check-error-throw))
-           nil)))
-     (when-not skip-check-error? (check-error-throw))))
-  ([pyobj]
-   (wrap-pyobject pyobj false)))
-
-
-(defmacro stack-resource-context
-  [& body]
-  `(pygc/with-stack-context
-     ~@body))
-
-
-(defn incref-wrap-pyobject
-  "Increment the object's refcount and then call wrap-pyobject.  Used for borrowed
-  references that need to escape the current scope."
-  [pyobj]
-  (with-gil
-    (let [pyobj (libpy/as-pyobj pyobj)]
-      (libpy/Py_IncRef pyobj)
-      (wrap-pyobject pyobj))))
-
-
-(defn py-true
-  []
-  (libpy/Py_True))
-
-
-(defn py-false
-  []
-  (libpy/Py_False))
-
-
-(defn py-none
-  []
-  (libpy/Py_None))
-
-
-(defn py-not-implemented
-  []
-  (libpy/Py_NotImplemented))
-
-
-;; Now we can completely implement ->python
-(defn ->python
-  "Completely convert a jvm object to a python copy."
-  [item & [options]]
-  (if (nil? item)
-    (py-none)
-    (py-proto/->python item options)))
-
-
-(defn py-raw-type
-  ^Pointer [pyobj]
-  (let [^Pointer pyobj (libpy/as-pyobj pyobj)]
-    (jna/size-t-compile-time-switch
-     (.getPointer pyobj 4) (.getPointer pyobj 8))))
-
-
-(extend-protocol py-proto/PPythonType
-  Pointer
-  (get-python-type [pyobj]
-    (with-gil
-    (-> pyobj
-        py-raw-type
-        pyinterp/py-type-keyword)))
-  PyObject
-  (get-python-type [item]
-    (py-proto/get-python-type (.getPointer item))))
-
-
-(defn py-string->string
-  "Given a python string return a string"
-  ^String [pyobj]
-  (with-gil
-    (when-not (= :str (python-type pyobj))
-      (throw (ex-info (format "Object passed in is not a string: %s"
-                              (python-type pyobj))
-                      {})))
-    (let [size-obj (jna/size-t-ref)
-          ^Pointer str-ptr (libpy/PyUnicode_AsUTF8AndSize pyobj size-obj)
-          n-elems (jna/size-t-ref-value size-obj)]
-      (-> (.decode StandardCharsets/UTF_8 (.getByteBuffer str-ptr 0 n-elems))
-          (.toString)))))
-
-
-(defn py-str
-  "Call the __str__ attribute on an object return a new string pyobject"
-  ^String [pyobj]
-  (with-gil
-    (let [py-str (if (= :str (python-type pyobj))
-                   pyobj
-                   (-> (libpy/PyObject_Str pyobj)
-                       wrap-pyobject))]
-      (py-string->string py-str))))
-
-
-(defn py-dir
-  "List the attribute names of an object"
-  [pyobj]
-  (with-gil
-    (-> (libpy/PyObject_Dir pyobj)
-        wrap-pyobject
-        (py-proto/->jvm {}))))
-
-
-(defn ->py-long
-  "Convert an object into a python long"
-  [item]
-  (with-gil
-    (wrap-pyobject
-     (libpy/PyLong_FromLongLong (long item)))))
-
-
-(defn ->py-float
-  "Convert an object into a python float"
-  [item]
-  (with-gil
-    (wrap-pyobject
-     (libpy/PyFloat_FromDouble (double item)))))
-
-
-(defn ->py-string
-  "Copy an object into a python string"
-  [item]
-  (with-gil
-    (let [byte-data (.getBytes ^String item StandardCharsets/UTF_16)]
-      (wrap-pyobject
-       (libpy/PyUnicode_Decode byte-data (dtype/ecount byte-data)
-                               "UTF-16" "strict")))))
-
-
-(defn ->py-dict
-  "Copy an object into a new python dictionary."
-  [item]
-  (with-gil
-    (let [dict (libpy/PyDict_New)]
-      (doseq [[k v] item]
-        (libpy/PyDict_SetItem dict (->python k)
-                              (->python v)))
-      (wrap-pyobject
-       dict))))
-
-
-(defn ->py-list
-  "Copy an object into a new python list."
-  [item-seq]
-  (with-gil
-    (let [retval (libpy/PyList_New (count item-seq))]
-      (->> item-seq
-           (map-indexed (fn [idx item]
-                          (libpy/PyList_SetItem
-                           retval
-                           idx
-                           (let [new-val (->python item)]
-                             (libpy/Py_IncRef new-val)
-                             new-val))))
-           dorun)
-      (wrap-pyobject retval))))
-
-
-(defn ->py-tuple
-  "Copy an object into a new python tuple"
-  [item-seq]
-  (with-gil
-    (let [n-items (count item-seq)
-          new-tuple (libpy/PyTuple_New n-items)]
-      (->> item-seq
-           (map-indexed (fn [idx item]
-                          (libpy/PyTuple_SetItem
-                           new-tuple
-                           idx
-                           (let [new-val (->python item)]
-                             (libpy/Py_IncRef new-val)
-                             new-val))))
-           dorun)
-      (wrap-pyobject new-tuple))))
-
-
-(defn ->py-set
-  [item]
-  (with-gil
-    (-> (libpy/PySet_New (->py-list item))
-        wrap-pyobject)))
-
-
-
-(extend-protocol libpy-base/PToPyObjectPtr
-  Number
-  (convertible-to-pyobject-ptr? [item] true)
-  (->py-object-ptr [item]
-    (with-gil
-      (->python item)))
-  Character
-  (convertible-to-pyobject-ptr? [item] true)
-  (->py-object-ptr [item]
-    (with-gil
-      (->python (str item))))
-  String
-  (convertible-to-pyobject-ptr? [item] true)
-  (->py-object-ptr [item]
-    (with-gil
-      (->python item)))
-  ;;The container classes are mirrored into python, not copied.
-  ;;so no entries here for map, list, etc.
-  )
-
-
-;; Chosen by fair dice roll, the item cutoff decides how many items
-;; a persistent vector should have in it before it is considered a list
-;; instead of a tuple.  If you know something should always be a tuple, then
-;; call ->py-tuple explicitly.
-(def ^:dynamic *item-tuple-cutoff* 8)
-
-
-(defn- cfunc-instance?
-  [function]
-  (or (instance? CFunction$KeyWordFunction function)
-      (instance? CFunction$TupleFunction function)
-      (instance? CFunction$NoArgFunction function)))
-
-
-(defn apply-method-def-data!
-  [^PyMethodDef method-def {:keys [name
-                                   doc
-                                   function]
-                            :as method-data}]
-  ;;Here we really do need a resource stack context
-  (when-not (cfunc-instance? function)
-    (throw (Exception.
-            (format "Callbacks must implement one of the CFunction interfaces:
-%s" (type function)))))
-  (let [meth-flags (long (cond
-                           (instance? CFunction$NoArgFunction function)
-                           libpy/METH_NOARGS
-
-                           (instance? CFunction$TupleFunction function)
-                           libpy/METH_VARARGS
-
-                           (instance? CFunction$KeyWordFunction function)
-                           (bit-or libpy/METH_KEYWORDS libpy/METH_VARARGS)
-                           :else
-                           (throw (ex-info (format "Failed due to type: %s"
-                                                   (type function))
-                                           {}))))
-        name-ptr (jna/string->ptr-untracked name)
-        doc-ptr (jna/string->ptr-untracked doc)]
-    (set! (.ml_name method-def) name-ptr)
-    (set! (.ml_meth method-def) (CallbackReference/getFunctionPointer function))
-    (set! (.ml_flags method-def) (int meth-flags))
-    (set! (.ml_doc method-def) doc-ptr)
-    (.write method-def)
-    (pyinterp/conj-forever! (assoc method-data
-                                   :name-ptr name-ptr
-                                   :doc-ptr doc-ptr
-                                   :callback-object function
-                                   :method-definition method-def))
-    method-def))
-
-
-(defn method-def-data->method-def
-  [method-data]
-  (apply-method-def-data! (PyMethodDef.) method-data))
-
-
-
-(defn- cfunc-impl->pyobject
-  [cfunc {:keys [method-name
-                 documentation
-                 py-self]
-          :or {method-name "unnamed_function"
-               documentation "not documented"}}]
-  (with-gil
-    ;;This is a nice little tidbit, cfunction_new
-    ;;steals the reference.
-    (let [py-self (when py-self (incref (->python py-self)))]
-      (-> (libpy/PyCFunction_NewEx (method-def-data->method-def
-                                    {:name method-name
-                                     :doc documentation
-                                     :function cfunc})
-                                   py-self
-                                   nil)
-          (wrap-pyobject)))))
-
-
-(defn py-tuple->borrowed-reference-reader
-  "Given a python tuple, return an object reader that iterates
-  through the items.  If you hold onto one of these items you need
-  to add to it's reference count.  If unsure of what you are doing
-  don't use this method, use ->jvm."
-  [tuple]
-  (with-gil
-    (let [interpreter (ensure-bound-interpreter)
-          n-items (long (libpy/PyObject_Length tuple))]
-      (reify ObjectReader
-        (lsize [_] n-items)
-        (readObject [_ idx]
-          (with-gil
-            (libpy/PyTuple_GetItem tuple idx)))))))
-
-
-(defn ->python-incref
-  "Convert to python and add a reference.  This is necessary for return values from
-  functions as the ->python pathway adds a reference but it also tracks it and
-  releases it when it is not in use any more.  Thus python ends up holding onto
-  something with fewer refcounts than it should have.  If you are just messing
-  around in the repl you only need ->python.  There is an expectation that the
-  return value of a function call is a new reference and not a borrowed reference
-  hence this pathway."
-  [item]
-  (-> (->python item)
-      (incref)))
-
-
-
-(defn make-tuple-fn
-  "Given a clojure function, create a python tuple function.
-  arg-convert is applied to arguments before the clojure function
-  gets them and result-converter is applied to the outbound result.
-  Exceptions are caught, logged, and propagated to python.
-
-  arg-converter: A function to be called on arguments before they get to
-    clojure.  Defaults to ->jvm.
-  result-converter: A function to be called on the return value before it
-    makes it back to python.  Defaults to ->python-incref.
-  method-name: Name of function exposed to python.
-  documentation: Documentation of function exposed to python."
-  [fn-obj & {:keys [arg-converter
-                    result-converter]
-             :or {arg-converter ->jvm
-                  result-converter ->python-incref}
-             :as options}]
-  (with-gil
-    (-> (reify CFunction$TupleFunction
-          (pyinvoke [this self args]
-            (try
-              (let [argseq (cond->> (py-tuple->borrowed-reference-reader args)
-                             arg-converter
-                             (map arg-converter))]
-                (cond-> (apply fn-obj argseq)
-                  result-converter
-                  (result-converter)))
-              (catch Throwable e
-                (log/error e "Error executing clojure function.")
-                (libpy/PyErr_SetString (libpy/PyExc_Exception)
-                                       (format "%s:%s" e (with-out-str
-                                                           (st/print-stack-trace e))))
-                nil))))
-        (cfunc-impl->pyobject options))))
-
-
-(defn ->py-fn
-  "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.
-  Options are
-  method-name: Name of function exposed to python.
-  documentation: Documentation of function exposed to python.
-  py-self: The 'self' object to be used for the function."
-  ([fn-obj {:keys []
-            :as options}]
-   (cond
-     (instance? clojure.lang.IFn fn-obj)
-     (apply make-tuple-fn fn-obj (apply concat options))
-     (cfunc-instance? fn-obj)
-     (cfunc-impl->pyobject fn-obj options)
-     :else
-     (throw (Exception. "fn-obj is neither a CFunction nor clojure callable."))))
-  ([fn-obj]
-   (->py-fn fn-obj {})))
-
-
-(defn py-fn->instance-fn
-  "Given a python callable, return an instance function meant to be used
-  in class definitions."
-  [py-fn]
-  (with-gil
-    (-> (libpy/PyInstanceMethod_New py-fn)
-        (wrap-pyobject))))
-
-
-(defn make-tuple-instance-fn
-  "Make an instance function.  In this case the default behavior is to
-  pass raw python object ptr args  to the clojure function without marshalling
-  as that can add confusion and unnecessary overhead.  Self will be the first argument.
-  Callers can change this behavior by setting the 'arg-converter' option as in
-  'make-tuple-fn'.
-  Options are the same as make-tuple-fn."
-  [clj-fn & {:keys [arg-converter]
-             :as options}]
-  (with-gil
-    (-> (apply make-tuple-fn
-               clj-fn
-               ;;Explicity set arg-convert to override make-tuple-fn's default
-               ;;->jvm arg-converter.
-               (->> (assoc options :arg-converter arg-converter)
-                    (apply concat)))
-        ;;Mark this as an instance function.
-        (py-fn->instance-fn))))
-
-
-(defn create-class
-  "Create a new class object.  Any callable values in the cls-hashmap
-  will be presented as instance methods.
-  Things in the cls hashmap had better be either atoms or already converted
-  python objects.  You may get surprised otherwise; you have been warned.
-  See the classes-test file in test/libpython-clj"
-  [name bases cls-hashmap]
-  (with-gil
-    (let [cls-dict (reduce (fn [cls-dict [k v]]
-                             (py-proto/set-item! cls-dict k (->python v))
-                             cls-dict)
-                           (->py-dict {})
-                           cls-hashmap)
-          bases (->py-tuple bases)
-          new-cls (py-proto/call (libpy/PyType_Type) name bases cls-dict)]
-      (py-proto/as-jvm new-cls nil))))
-
-(def ^:private lr-step-field (doto (.getDeclaredField ^Class LongRange "step")
-                               (.setAccessible true)))
-
-
-(def ^:private r-step-field (doto (.getDeclaredField ^Class Range "step")
-                              (.setAccessible true)))
-
-
-(extend-protocol py-proto/PCopyToPython
-  Number
-  (->python [item options]
-    (if (integer? item)
-      (->py-long item)
-      (->py-float item)))
-  String
-  (->python [item options]
-    (->py-string item))
-  Character
-  (->python [item options]
-    (->py-string (str item)))
-  Symbol
-  (->python [item options]
-    (->py-string (name item)))
-  Keyword
-  (->python [item optins]
-    (->py-string (name item)))
-  Boolean
-  (->python [item options]
-    (if item
-      (py-true)
-      (py-false)))
-  Range
-  (->python [item options]
-    (if (casting/integer-type? (dtype/get-datatype item))
-      (let [start (first item)
-            step (.get ^Field r-step-field item)
-            stop (+ start (* step (count item)))]
-        (py-proto/call (libpy/PyRange_Type) start stop step))
-      (->py-list item)))
-  LongRange
-  (->python [item options]
-    (let [start (first item)
-          step (.get ^Field lr-step-field item)
-          stop (+ start (* step (count item)))]
-      (py-proto/call (libpy/PyRange_Type) start stop step)))
-  Iterable
-  (->python [item options]
-    (cond
-      (instance? RandomAccess item)
-      (if (and (instance? IPersistentVector item)
-               (< (count item) (long *item-tuple-cutoff*)))
-        (->py-tuple item)
-        (->py-list item))
-      (instance? Map$Entry item)
-      (->py-tuple [(.getKey ^Map$Entry item)
-                   (.getValue ^Map$Entry item)])
-      (or (set? item)
-          (instance? Set item))
-      (->py-set item)
-      ;;Careful here!
-      (fn? item)
-      (->py-fn item)
-      (or (map? item)
-          (instance? Map item))
-      (->py-dict item)
-      :else
-      (->py-list item)))
-  Pointer
-  (->python [item options] item)
-  PyObject
-  (->python [item options] (.getPointer item))
-  NDBuffer
-  (->python [item options] (py-proto/as-numpy item options))
-  ArrayBuffer
-  (->python [item options] (py-proto/as-numpy item options))
-  NativeBuffer
-  (->python [item options] (py-proto/as-numpy item options))
-  Object
-  (->python [item options]
-    (cond
-      (fn? item)
-      (->py-fn item {})
-      (casting/numeric-type? (dtype/get-datatype item))
-      (py-proto/as-numpy item options)
-      :else
-      (if-let [item-reader (dtype/->reader item)]
-        (->py-list item-reader)
-        ;;Out of sane options at the moment.
-        (throw (Exception. (format "Unable to convert java object to python: %s"
-                                   (type item))))))))
-
-
-(extend-protocol py-proto/PPythonType
-  Number
-  (get-python-type [item]
-    (if (integer? item)
-      :int
-      :float))
-  Boolean
-  (get-python-type [item] :bool)
-  String
-  (get-python-type [item] :str)
-  Symbol
-  (get-python-type [item] :str)
-  Keyword
-  (get-python-type [item] :str)
-  Map$Entry
-  (get-python-type [item] :tuple)
-  Iterable
-  (get-python-type [item]
-    (cond
-      (instance? RandomAccess item)
-      (if (and (instance? IPersistentVector item)
-               (< (count item) (long *item-tuple-cutoff*)))
-        :tuple
-        :list)
-      (or (instance? Set item)
-          (instance? IPersistentSet item))
-      :set
-      (or (instance? Map item)
-          (instance? IPersistentMap item))
-      :dict
-      :else
-      :list))
-  Object
-  (get-python-type [item]
-    (if (casting/numeric-type? (dtype/get-datatype item))
-      :nd-array
-      (if (dtype-proto/convertible-to-reader? item)
-        :list
-        :unknown-type))))
-
-
-(defn stringable?
-  [item]
-  (or (keyword? item)
-      (string? item)
-      (symbol? item)))
-
-
-(defn stringable
-  ^String [item]
-  (when (stringable? item)
-    (if (string? item)
-      item
-      (name item))))
-
-
-(defn has-attr?
-  [pyobj attr-name]
-  (with-gil
-    (= 1
-       (if (stringable? attr-name)
-         (libpy/PyObject_HasAttrString pyobj (stringable attr-name))
-         (libpy/PyObject_HasAttr pyobj (->python attr-name))))))
-
-
-(defn get-attr
-  [pyobj attr-name]
-  (with-gil
-    (-> (if (stringable? attr-name)
-          (libpy/PyObject_GetAttrString pyobj (stringable attr-name))
-          (libpy/PyObject_GetAttr pyobj (->python attr-name)))
-        wrap-pyobject)))
-
-
-(defn set-attr!
-  [pyobj attr-name attr-value]
-  (with-gil
-    (let [py-value (->python attr-value)]
-      (if (stringable? attr-name)
-        (libpy/PyObject_SetAttrString pyobj
-                                      (stringable attr-name)
-                                      py-value)
-        (libpy/PyObject_SetAttr pyobj
-                                (->python attr-name)
-                                py-value)))
-    pyobj))
-
-
-(defn obj-has-item?
-  [elem elem-name]
-  (with-gil
-    (= 1
-       (if (stringable? elem-name)
-         (libpy/PyMapping_HasKeyString elem (stringable elem-name))
-         (libpy/PyMapping_HasKey elem (->python elem-name))))))
-
-
-(defn obj-get-item
-  [elem elem-name]
-  (with-gil
-    (-> (libpy/PyObject_GetItem elem (->python elem-name))
-        wrap-pyobject)))
-
-
-(defn obj-set-item!
-  [elem elem-name elem-value]
-  (with-gil
-    (let [py-value (->python elem-value)]
-      (libpy/PyObject_SetItem elem
-                              (->python elem-name)
-                              (->python elem-value)))
-    elem))
-
-
-(extend-protocol py-proto/PPyObject
-  Pointer
-  (dir [item]
-    (py-dir item))
-  (has-attr? [item name] (has-attr? item name))
-  (get-attr [item name] (get-attr item name))
-  (set-attr! [item item-name item-value] (set-attr! item item-name item-value))
-  (callable? [item] (= 1 (libpy/PyCallable_Check item)))
-  (has-item? [item item-name] (obj-has-item? item item-name))
-  (get-item [item item-name] (obj-get-item item item-name))
-  (set-item! [item item-name item-value] (obj-set-item! item item-name item-value))
-  PyObject
-  (dir [item] (py-proto/dir (.getPointer item)))
-  (has-attr? [item item-name] (py-proto/has-attr? (.getPointer item) item-name))
-  (get-attr [item item-name] (py-proto/get-attr (.getPointer item) item-name))
-  (set-attr! [item item-name item-value]
-    (py-proto/set-attr! (.getPointer item) item-name item-value))
-  (callable? [item] (py-proto/callable? (.getPointer item)))
-  (has-item? [item item-name] (py-proto/has-item? (.getPointer item) item-name))
-  (item [item item-name] (py-proto/get-item (.getPointer item) item-name))
-  (set-item! [item item-name item-value]
-    (py-proto/set-item! (.getPointer item) item-name item-value)))
-
-
-;;This one is dangerous.  But there are times (like in the actual type object)
-;;that we don't want to be wrapping the results in any way; they are getting passed
-;;directly to python and not to java.
-(def ^:dynamic *passthrough-exceptions* false)
-
-
-(extend-protocol py-proto/PyCall
-  Pointer
-  (do-call-fn [callable arglist kw-arg-map]
-    (with-gil
-      (-> (cond
-            (seq kw-arg-map)
-            (libpy/PyObject_Call callable
-                                 (->py-tuple arglist)
-                                 (->py-dict kw-arg-map))
-            (seq arglist)
-            (libpy/PyObject_CallObject callable (->py-tuple arglist))
-            :else
-            (libpy/PyObject_CallObject callable nil))
-          (wrap-pyobject *passthrough-exceptions*))))
-  PyObject
-  (do-call-fn [callable arglist kw-arg-map]
-    (py-proto/do-call-fn (.getPointer callable) arglist kw-arg-map)))
-
-
-(extend-protocol py-proto/PPyObjLength
-  Pointer
-  (len [item]
-    (libpy/PyObject_Length item))
-  PyObject
-  (len [item]
-    (py-proto/len (.getPointer item))))
-
-
-(defn python->jvm-copy-hashmap
-  [pyobj & [map-items]]
-  (with-gil
-    (when-not (= 1 (libpy/PyMapping_Check pyobj))
-      (throw (ex-info (format "Object does not implement the mapping protocol: %s"
-                              (python-type pyobj)))))
-    (->> (or map-items
-             (libpy/PyMapping_Items pyobj)
-             wrap-pyobject)
-         ->jvm
-         (into {}))))
-
-
-(defn python->jvm-copy-persistent-vector
-  [pyobj]
-  (with-gil
-    (when-not (= 1 (libpy/PySequence_Check pyobj))
-      (throw (ex-info (format "Object does not implement sequence protocol: %s"
-                              (python-type pyobj)))))
-
-    (->> (range (libpy/PySequence_Length pyobj))
-         (mapv (fn [idx]
-                 (-> (libpy/PySequence_GetItem pyobj idx)
-                     wrap-pyobject
-                     ->jvm))))))
-
-
-(defn python->jvm-iterator
-  "This is a tough function to get right.  The iterator could return nil as in
-  you could have a list of python none types or something so you have to iterate
-  till you get a StopIteration error."
-  [iter-fn & [item-conversion-fn]]
-  (with-gil
-    (let [interpreter (ensure-bound-interpreter)]
-      (let [py-iter (py-proto/call iter-fn)
-            py-next-fn (when py-iter (py-proto/get-attr py-iter "__next__"))
-            next-fn (fn [last-item]
-                      (with-gil
-                        (let [retval (libpy/PyObject_CallObject py-next-fn nil)]
-                          (if (libpy/PyErr_Occurred)
-                            (let [ptype (PointerByReference.)
-                                  pvalue (PointerByReference.)
-                                  ptraceback (PointerByReference.)
-                                  _ (libpy/PyErr_Fetch ptype pvalue ptraceback)
-                                  ptype (jna/->ptr-backing-store ptype)
-                                  pvalue (jna/->ptr-backing-store pvalue)
-                                  ptraceback (jna/->ptr-backing-store ptraceback)]
-                              (if (= ptype
-                                     (libpy/PyExc_StopIteration))
-                                (do
-                                  (libpy/Py_DecRef ptype)
-                                  (when pvalue (libpy/Py_DecRef pvalue))
-                                  (when ptraceback (libpy/Py_DecRef ptraceback))
-                                  nil)
-                                (do (libpy/PyErr_Restore ptype pvalue ptraceback)
-                                    (check-error-throw))))
-                            [(cond-> (wrap-pyobject retval)
-                               item-conversion-fn
-                               item-conversion-fn)]))))
-            cur-item-store (atom (next-fn nil))]
-        (reify
-          jna/PToPtr
-          (is-jna-ptr-convertible? [item] true)
-          (->ptr-backing-store [item] py-iter)
-
-          java.util.Iterator
-          (hasNext [obj-iter]
-            (not (nil? @cur-item-store)))
-          (next [obj-iter]
-            (-> (swap-vals! cur-item-store next-fn)
-                ffirst)))))))
-
-
-(defn python->jvm-iterable
-  "Create an iterable that auto-copies what it iterates completely into the jvm.  It
-  maintains a reference to the python object, however, so this method isn't necessarily
-  safe."
-  [pyobj & [item-conversion-fn]]
-  (with-gil
-    (when-not (has-attr? pyobj "__iter__")
-      (throw (ex-info (format "object is not iterable: %s"
-                              (python-type pyobj))
-                      {})))
-    (let [item-conversion-fn (or item-conversion-fn ->jvm)
-          iter-callable (get-attr pyobj "__iter__")
-          interpreter (ensure-bound-interpreter)]
-      (reify
-        jna/PToPtr
-        (is-jna-ptr-convertible? [item] true)
-        (->ptr-backing-store [item] pyobj)
-        Iterable
-        (iterator [item]
-          (python->jvm-iterator iter-callable item-conversion-fn))))))
-
-
-(defmethod pyobject->jvm :int
-  [pyobj]
-  (with-gil
-    (libpy/PyLong_AsLongLong pyobj)))
-
-
-(defmethod pyobject->jvm :float
-  [pyobj]
-  (with-gil
-    (libpy/PyFloat_AsDouble pyobj)))
-
-
-(defmethod pyobject->jvm :none-type
-  [pyobj]
-  nil)
-
-
-(defmethod pyobject->jvm :str
-  [pyobj]
-  (with-gil
-    (py-string->string pyobj)))
-
-
-(defn pyobj-true?
-  [pyobj]
-  (with-gil
-    (= 1 (libpy/PyObject_IsTrue pyobj))))
-
-
-(defmethod pyobject->jvm :bool
-  [pyobj]
-  (pyobj-true? pyobj))
-
-
-(defmethod pyobject->jvm :tuple
-  [pyobj]
-  (python->jvm-copy-persistent-vector pyobj))
-
-
-(defmethod pyobject->jvm :list
-  [pyobj]
-  (python->jvm-copy-persistent-vector pyobj))
-
-
-(defmethod pyobject->jvm :dict
-  [pyobj]
-  (with-gil
-    (let [ppos (jna/size-t-ref 0)
-          pkey (PointerByReference.)
-          pvalue (PointerByReference.)
-          retval (java.util.ArrayList.)]
-      ;;Dictionary iteration doesn't appear to be reentrant so we have
-      ;;to do 2 passes.
-      (loop [next-retval (libpy/PyDict_Next pyobj ppos pkey pvalue)]
-        (if (not= 0 next-retval)
-          (do
-            (.add retval [(libpy/as-pyobj pkey)
-                          (libpy/as-pyobj pvalue)])
-            (recur (libpy/PyDict_Next pyobj ppos pkey pvalue)))
-          (->> retval
-               (map (fn [[k v]]
-                      [(->jvm k) (->jvm v)]))
-               (into {})))))))
-
-
-(defmethod pyobject->jvm :set
-  [pyobj]
-  (with-gil
-    (->> (python->jvm-iterable pyobj)
-         set)))
-
-
-;;numpy types
-(defn numpy-scalar->jvm
-  [pyobj]
-  (with-gil
-    (-> (py-proto/get-attr pyobj "data")
-        (py-proto/get-item (->py-tuple []))
-        ->jvm)))
-
-(defmethod pyobject->jvm :uint-8
-  [pyobj]
-  (numpy-scalar->jvm pyobj))
-
-
-(defmethod pyobject->jvm :int-8
-  [pyobj]
-  (numpy-scalar->jvm pyobj))
-
-
-(defmethod pyobject->jvm :uint-16
-  [pyobj]
-  (numpy-scalar->jvm pyobj))
-
-
-(defmethod pyobject->jvm :int-16
-  [pyobj]
-  (numpy-scalar->jvm pyobj))
-
-
-(defmethod pyobject->jvm :uint-32
-  [pyobj]
-  (numpy-scalar->jvm pyobj))
-
-
-(defmethod pyobject->jvm :int-32
-  [pyobj]
-  (numpy-scalar->jvm pyobj))
-
-
-(defmethod pyobject->jvm :uint-64
-  [pyobj]
-  (numpy-scalar->jvm pyobj))
-
-
-(defmethod pyobject->jvm :int-64
-  [pyobj]
-  (numpy-scalar->jvm pyobj))
-
-
-(defmethod pyobject->jvm :float-64
-  [pyobj]
-  (numpy-scalar->jvm pyobj))
-
-
-(defmethod pyobject->jvm :float-32
-  [pyobj]
-  (numpy-scalar->jvm pyobj))
-
-
-(defmethod pyobject->jvm :range
-  [pyobj]
-  (with-gil
-    (let [start (->jvm (py-proto/get-attr pyobj "start"))
-          step (->jvm (py-proto/get-attr pyobj "step"))
-          stop (->jvm (py-proto/get-attr pyobj "stop"))]
-      (range start stop step))))
-
-
-(defmethod pyobject->jvm :default
-  [pyobj]
-  (with-gil
-    (cond
-      ;;Things could implement mapping and sequence logically so mapping
-      ;;takes precedence
-      (= 1 (libpy/PyMapping_Check pyobj))
-      (if-let [map-items (try (-> (libpy/PyMapping_Items pyobj)
-                                  wrap-pyobject)
-                              (catch Throwable e nil))]
-        (python->jvm-copy-hashmap pyobj map-items)
-        (do
-          ;;Ignore error.  The mapping check isn't thorough enough to work.
-          (libpy/PyErr_Clear)
-          (python->jvm-copy-persistent-vector pyobj)))
-      ;;Sequences become persistent vectors
-      (= 1 (libpy/PySequence_Check pyobj))
-      (python->jvm-copy-persistent-vector pyobj)
-      :else
-      {:type (python-type pyobj)
-       :value (Pointer/nativeValue (libpy/as-pyobj pyobj))})))
-
-
-(defn is-instance?
-  "Returns true if inst is an instance of type.
-  False otherwise."
-  [py-inst py-type]
-  (with-gil
-    (= 1 (libpy/PyObject_IsInstance (->python py-inst)
-                                    ;;The type has to be a python type already.
-                                    py-type))))
-
-
-(defn hash-code
-  ^long [py-inst]
-  (with-gil
-    (long (libpy/PyObject_Hash (->python py-inst)))))
-
-
-(defn equals?
-  "Returns true of the python equals operator returns 1."
-  [lhs rhs]
-  (with-gil
-    (= 1 (libpy/PyObject_RichCompareBool (->python lhs)
-                                         (->python rhs)
-                                         :py-eq))))
diff --git a/src/libpython_clj/python/protocols.clj b/src/libpython_clj/python/protocols.clj
deleted file mode 100644
index 2f36bf1..0000000
--- a/src/libpython_clj/python/protocols.clj
+++ /dev/null
@@ -1,182 +0,0 @@
-(ns libpython-clj.python.protocols
-  "Protocols to help generalize the python bindings.  There is a clear distinction
-  made between building a bridging type and thus allowing communication between the
-  two systems and building a complete copy of the datastructure of one system in
-  another.  Generic objects must only bridge but if we know more about the object
-  (like it implements java.util.Map) then we can implement either a bridge or a
-  copy.
-
-  Atomic objects:
-  * numbers
-  * booleans
-  * strings-convertible things like strings, keywords, symbols
-
-  Standard containers:
-  * list
-  * map
-  * set
-  * tuple (persistent vector of length less than 8)")
-
-
-(defprotocol PPythonType
-  (get-python-type [item]
-    "Return a keyword that describes the python datatype of this object."))
-
-
-(defn python-type
-  "Return a keyword that describes the python datatype of this object."
-  [item]
-  (if item
-    (get-python-type item)
-    :none-type))
-
-
-(defprotocol PCopyToPython
-  (->python [item options]
-    "Copy this item into a python representation.  Must never return nil.
-Items may fallback to as-python if copying is untenable."))
-
-
-(defprotocol PBridgeToPython
-  (as-python [item options]
-    "Aside from atom types, this means the object represented by a zero copy python
-    mirror.  May return nil.  This convertible to pointers get converted
-    to numpy implementations that share the backing store."))
-
-
-
-(defprotocol PCopyToJVM
-  (->jvm [item options]
-    "Copy the python object into the jvm leaving no references.  This not copying
-are converted into a {:type :pyobject-address} pairs."))
-
-
-(defprotocol PBridgeToJVM
-  (as-jvm [item options]
-    "Return a pyobject implementation that wraps the python object."))
-
-
-(extend-type Object
-  PBridgeToPython
-  (as-python [item options] nil)
-  PCopyToJVM
-  (->jvm [item options] item)
-  PBridgeToJVM
-  (as-jvm [item options] item))
-
-
-(extend-type Object
-  PBridgeToJVM
-  (as-jvm [item options] item))
-
-
-(defprotocol PPyObject
-  (dir [item]
-    "Get sorted list of all attribute names.")
-  (has-attr? [item item-name] "Return true of object has attribute")
-  (get-attr [item item-name] "Get attribute from object")
-  (set-attr! [item item-name item-value] "Set attribute on object")
-  (callable? [item] "Return true if object is a python callable object.")
-  (has-item? [item item-name] "Return true of object has item")
-  (get-item [item item-name] "Get an item of a given name from an object")
-  (set-item! [item item-name item-value] "Set an item of to a value"))
-
-
-(defprotocol PPyAttMap
-  (att-type-map [item]
-    "Get hashmap of att name to keyword datatype."))
-
-
-(extend-type Object
-  PPyObject
-  (callable? [_] false)
-  (has-attr? [_ _] false)
-  PPyAttMap
-  (att-type-map [item]
-    (->> (dir item)
-         (map (juxt identity #(try
-                                (-> (get-attr item %)
-                                    python-type)
-                                (catch Throwable e
-                                  :get-attr-exception!!))))
-         (into (sorted-map)))))
-
-
-(defprotocol PyCall
-  (do-call-fn [callable arglist kw-arg-map]))
-
-
-(defn call
-  "Call a python function with positional args.  For keyword args, see call-kw."
-  [callable & args]
-  (do-call-fn callable args nil))
-
-
-(defn call-kw
-  "Call a python function with a vector of positional args and a map of keyword args."
-  [callable arglist kw-args]
-  (do-call-fn callable arglist kw-args))
-
-(defn call-attr
-  "Call an object attribute with positional arguments."
-  [item att-name & args]
-  (-> (get-attr item att-name)
-      (do-call-fn args nil)))
-
-
-(defn call-attr-kw
-  "Call an object attribute with a vector of positional args and a
-  map of keyword args."
-  [item att-name arglist kw-map]
-  (-> (get-attr item att-name)
-      (do-call-fn arglist kw-map)))
-
-
-(defprotocol PPyObjLength
-  "Call the __len__ attribute."
-  (len [item] "Call the __len__ attribute."))
-
-
-(extend-type Object
-  PPyObjLength
-  (len [item]
-    (-> (call-attr item "__len__")
-        (->jvm {}))))
-
-
-(defprotocol PPyObjectBridgeToMap
-  (as-map [item]
-    "Return a Map implementation using __getitem__, __setitem__.  Note that it may be
-incomplete especially if the object has no 'keys' attribute."))
-
-
-(defprotocol PPyObjectBridgeToList
-  (as-list [item]
-    "Return a List implementation using __getitem__, __setitem__."))
-
-
-(defprotocol PJvmToNumpyBridge
-  (as-numpy [item options]
-    "Never copy data, operation returns nil of would require copy."))
-
-
-(defprotocol PJvmToNumpy
-  (->numpy [item options]
-    "Never return nil.  Copy or otherwise, numpy or bust."))
-
-
-(defmulti pyobject->jvm
-  (fn [pyobj]
-    (python-type pyobj)))
-
-
-(defmulti pyobject-as-jvm
-  (fn [pyobj]
-    (python-type pyobj)))
-
-(defmulti python-obj-iterator
-  "Given a python object, produce an iterator.  Python is fairly confused about
-  what an iterator is or does, so some things require iteritems and some things
-  require calling __iter__."
-  (fn [pyobj interpreter]
-    (python-type pyobj)))
diff --git a/src/libpython_clj/metadata.clj b/src/libpython_clj2/metadata.clj
similarity index 84%
rename from src/libpython_clj/metadata.clj
rename to src/libpython_clj2/metadata.clj
index 4f5f7c7..a4fdc3f 100644
--- a/src/libpython_clj/metadata.clj
+++ b/src/libpython_clj2/metadata.clj
@@ -1,20 +1,24 @@
-(ns libpython-clj.metadata
+(ns libpython-clj2.metadata
+  "Namespace to create metadata from python objects.   This namespace requires
+  python helper fns to work correctly and thus cannot be used until after python
+  has been initialized."
   (:refer-clojure :exclude [fn? doc])
-  (:require [libpython-clj.python
+  (:require [libpython-clj2.python
              :refer [import-module as-jvm get-attr call-attr callable? has-attr?
                      ->jvm with-gil]
              :as py]
-            [libpython-clj.python.protocols :as py-proto]
+            [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python.protocols :as py-proto]
+            [tech.v3.datatype.ffi :as dt-ffi]
             [clojure.core.protocols :as clj-proto]
-            [clojure.tools.logging :as log])
-  (:import [libpython_clj.python.protocols PPyObject]))
+            [clojure.tools.logging :as log]))
 
 
 (py/initialize!)
 
 
-(def builtins (as-jvm (import-module "builtins") {}))
-(def inspect (as-jvm (import-module "inspect") {}))
+(def builtins (import-module "builtins"))
+(def inspect (import-module "inspect"))
 (def argspec (get-attr inspect "getfullargspec"))
 (def py-source (get-attr inspect "getsource"))
 (def py-sourcelines (get-attr inspect "getsourcelines"))
@@ -52,7 +56,7 @@
 
 
 (defn find-lineno [x]
-  (try 
+  (try
     (-> x py-sourcelines last)
     (catch Exception _
       nil)))
@@ -67,13 +71,13 @@
   (if-let [spec (try (when-not (pyclass? f)
                        (argspec f))
                      (catch Throwable e nil))]
-    {:args           (->jvm (get-attr spec "args") {})
-     :varargs        (->jvm (get-attr spec "varargs") {})
-     :varkw          (->jvm (get-attr spec "varkw") {})
-     :defaults       (->jvm (get-attr spec "defaults") {})
-     :kwonlyargs     (->jvm (get-attr spec "kwonlyargs") {})
-     :kwonlydefaults (->jvm (get-attr spec "kwonlydefaults") {})
-     :annotations    (->jvm (get-attr spec "annotations") {})}
+    {:args           (->jvm (get-attr spec "args"))
+     :varargs        (->jvm (get-attr spec "varargs"))
+     :varkw          (->jvm (get-attr spec "varkw"))
+     :defaults       (->jvm (get-attr spec "defaults"))
+     :kwonlyargs     (->jvm (get-attr spec "kwonlyargs"))
+     :kwonlydefaults (->jvm (get-attr spec "kwonlydefaults"))
+     :annotations    (->jvm (get-attr spec "annotations"))}
     (py-fn-argspec (get-attr f "__init__"))))
 
 (defn py-class-argspec [class]
@@ -202,7 +206,9 @@
 
 (defn base-pyobj-map
   [item]
-  (cond-> {:type  (py/python-type item)
+  (cond-> {:type  (cond (pyclass? item) :type
+                        (pymodule? item) :module
+                        :else (py/python-type item))
            :doc   (doc item)
            :str   (.toString item)
            :flags (pyobj-flags item)
@@ -221,12 +227,12 @@
   (or (string? att-val)
       (number? att-val)))
 
-(defn datafy-module [item]
+(defn datafy-module-or-class [item]
   (with-gil
     (->> (if (or (pyclass? item)
                  (pymodule? item))
            (->> (vars item)
-                (py-proto/as-map)
+                (py/as-map)
                 (into {}))
            (->> (py/dir item)
                 (map (juxt identity #(get-attr item %)))))
@@ -247,14 +253,57 @@
          (remove nil?)
          (into (base-pyobj-map item)))))
 
+
+(defmethod py-proto/pydatafy :default
+  [pyobj]
+  (if (or (pyclass? pyobj)
+          (pymodule? pyobj))
+    (datafy-module-or-class pyobj)
+    (base-pyobj-map pyobj)))
+
+
+(defmethod py-proto/pydatafy :dict
+  [pyobj]
+  (->> (py/as-jvm pyobj)
+       (map (fn [[k v]]
+              [k (clj-proto/datafy v)]))
+       (into {})))
+
+
+(defmethod py-proto/pydatafy :list
+  [pyobj]
+  (->> (py/as-jvm pyobj)
+       (mapv clj-proto/datafy)))
+
+
+(defmethod py-proto/pydatafy :tuple
+  [pyobj]
+  (->> (py/as-jvm pyobj)
+       (mapv clj-proto/datafy)))
+
+
+(defmethod py-proto/pydatafy :set
+  [pyobj]
+  (->> (py/as-jvm pyobj)
+       (map clj-proto/datafy)
+       (set)))
+
+
+(defmethod py-proto/pydatafy :frozenset
+  [pyobj]
+  (->> (py/as-jvm pyobj)
+       (map clj-proto/datafy)
+       (set)))
+
+
 (defn nav-module [coll f val]
   (with-gil
     (if (map? val)
       (cond
         (= :module (:type val))
-        (as-jvm (import-module (:name val)) {})
+        (import-module (:name val))
         (= :type (:type val))
-        (let [mod (as-jvm (import-module (:module val)) {})
+        (let [mod (import-module (:module val))
               cls-obj (get-attr mod (:name val))]
           cls-obj)
         :else
@@ -301,7 +350,8 @@
       :module (import-module (:name metadata-map))
       :type   (-> (import-module (:module metadata-map))
                   (get-attr (:name metadata-map))))
-    (catch Exception _
+    (catch Exception e
+      (log/warnf e "metadata-map: %s" metadata-map)
       ;; metatypes -- e.g. socket.SocketIO
       (-> (import-module (:module metadata-map))
           (get-attr (:name metadata-map))))))
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
new file mode 100644
index 0000000..99587dd
--- /dev/null
+++ b/src/libpython_clj2/python.clj
@@ -0,0 +1,575 @@
+(ns libpython-clj2.python
+  "Python bindings for Clojure.  This library dynamically finds the installed
+  python, loads the shared library and allows Clojure users to use Python modules
+  as if they were Clojure namespaces.
+
+
+Example:
+
+  ```clojure
+user> (require '[libpython-clj2.python :as py])
+nil
+user> (py/initialize!)
+;;  ... (logging)
+:ok
+user> (def np (py/import-module \"numpy\"))
+#'user/np
+user> (py/py. np linspace 2 3 :num 10)
+[2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
+ 2.66666667 2.77777778 2.88888889 3.        ]
+```"
+  (:require [libpython-clj2.python.info :as py-info]
+            [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python.base :as py-base]
+            [libpython-clj2.python.fn :as py-fn]
+            [libpython-clj2.python.protocols :as py-proto]
+            [libpython-clj2.python.class :as py-class]
+            [libpython-clj2.python.with :as py-with]
+            [libpython-clj2.python.dechunk-map :refer [dechunk-map]]
+            [libpython-clj2.python.copy :as py-copy]
+            [libpython-clj2.python.bridge-as-jvm :as py-bridge-jvm]
+            [libpython-clj2.python.bridge-as-python]
+            [libpython-clj2.python.io-redirect :as io-redirect]
+            [libpython-clj2.python.gc :as pygc]
+            [libpython-clj2.python.windows :as win]
+            [tech.v3.datatype.ffi :as dtype-ffi]
+            [clojure.tools.logging :as log])
+  (:import [java.util Map List]
+           [clojure.lang IFn]))
+
+
+
+(defn initialize!
+    "Initialize the python library.  If library path is not provided, then the system
+  attempts to execute a simple python program and have python return system info.
+
+
+  Returns either `:ok` in which case the initialization completed successfully or
+  `:already-initialized` in which case we detected that python has already been
+  initialized via `Py_IsInitialized` and we do nothing more.
+
+  Options:
+
+  * `:library-path` - Library path of the python library to use.
+  * `:program-name` - Optional -- will show up in error messages from python.
+  * `:no-io-redirect?` - True if you don't want python stdout and stderr redirection
+     to *out* and *err*.
+  * `:python-executable` - The python executable to use to find system information.
+  * `:python-home` - Python home directory.  The system first uses this variable, then
+     the environment variable PYTHON_HOME, and finally information returned from
+     python system info.
+  * `:signals?` - defaults to false - true if you want python to initialized signals.
+     Be aware that the JVM itself uses quite a few signals - SIGSEGV, for instance -
+     during it's normal course of operation.  For more information see:
+       * [used signals](https://docs.oracle.com/javase/10/troubleshoot/handle-signals-and-exceptions.htm#JSTGD356)
+       * [signal-chaining](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html)"
+  [& [{:keys [windows-anaconda-activate-bat
+              library-path
+              no-io-redirect?]} options]]
+  (if-not (and (py-ffi/library-loaded?)
+                 (= 1 (py-ffi/Py_IsInitialized)))
+    (let [info (py-info/detect-startup-info options)
+          _ (log/infof "Startup info %s" info)
+          libname (->> (concat (when library-path [library-path]) (:libnames info))
+                       (dechunk-map identity)
+                       (filter #(try
+                                  (boolean (dtype-ffi/library-loadable? %))
+                                  (catch Throwable e false)))
+                       (first))]
+      (log/infof "Loading python library: %s" libname)
+      (py-ffi/initialize! libname (:python-home info)
+                          (assoc options :program-name
+                                 (or (:program-name options)
+                                     (:executable info)
+                                     "")))
+
+      (when-not (nil? windows-anaconda-activate-bat)
+        (win/setup-windows-conda! windows-anaconda-activate-bat
+                                  py-ffi/run-simple-string))
+
+      (when-not no-io-redirect?
+        (io-redirect/redirect-io!))
+      :ok)
+    :already-initialized))
+
+
+(defmacro stack-resource-context
+  "Create a stack-based resource context.  All python objects allocated within this
+  context will be released at the termination of this context.
+  !!This means that no python objects can escape from this context!!
+  You must use copy semantics (->jvm) for anything escaping this context.
+  Furthermore, if you are returning generic python objects you may need
+  to call (into {}) or something like that just to ensure that absolutely
+  everything is copied into the jvm."
+  [& body]
+  `(pygc/with-stack-context
+     ~@body))
+
+
+(defmacro with-gil
+  "Capture the gil for an extended amount of time.  This can greatly speed up
+  operations as the mutex is captured and held once as opposed to find grained
+  grabbing/releasing of the mutex."
+  [& body]
+  `(py-ffi/with-gil
+     ~@body))
+
+
+(defmacro with-gil-stack-rc-context
+  "Capture the gil, open a resource context.  The resource context is released
+  before the gil is leading to much faster resource collection.  See documentation
+  on `stack-resource-context` for multiple warnings; the most important one being
+  that if a python object escapes this context your program will eventually, at
+  some undefined point in the future crash.  That being said, this is the recommended
+  pathway to use in production contexts where you want defined behavior and timings
+  related to use of python."
+  [& body]
+  `(py-ffi/with-gil
+     (pygc/with-stack-context
+      ~@body)))
+
+
+(defn import-module
+  "Import a python module returning an implementation of java.util.Map wrapping
+  the module object and consisting of module attributes."
+  [modname]
+  (with-gil
+    (if-let [mod (py-ffi/PyImport_ImportModule modname)]
+      (-> (py-ffi/track-pyobject mod)
+          (py-base/as-jvm))
+      (py-ffi/check-error-throw))))
+
+
+(defn add-module
+  "Add a python module.  This can create a module if it doesn't exist."
+  [modname]
+  (with-gil
+    (-> (py-ffi/PyImport_AddModule modname)
+        (py-ffi/incref-track-pyobject)
+        (py-base/as-jvm))))
+
+
+(defn module-dict
+  "Get the module dictionary."
+  [mod]
+  (with-gil
+    (-> (py-ffi/PyModule_GetDict mod)
+        (py-ffi/incref-track-pyobject)
+        (py-base/as-jvm))))
+
+
+(defn dir
+  [pyobj]
+  (with-gil (py-proto/dir pyobj)))
+
+
+(defn call-attr
+  "Call an attribute on a python object using only positional arguments"
+  [pyobj attname & args]
+  (with-gil (py-fn/call-attr pyobj attname args)))
+
+
+(defn call-attr-kw
+  "Call an attribute passing in both positional and keyword arguments."
+  [pyobj attname args kw-list]
+  (with-gil (py-fn/call-attr-kw pyobj attname args kw-list py-base/as-python)))
+
+(defn get-attr
+  "Get an attribute from a python object"
+  [pyobj attname]
+  (with-gil (py-proto/get-attr pyobj attname)))
+
+
+(defn set-attr!
+  "Set an attribute on a python object.  Returns pyobj."
+  [pyobj attname attval]
+  (with-gil (py-proto/set-attr! pyobj attname attval))
+  pyobj)
+
+
+(defn set-attrs!
+  "Set a sequence of [name value] attributes.  Returns pyobj."
+  [pyobj att-seq]
+  (with-gil (doseq [[k v] att-seq] (set-attr! pyobj k v)))
+  pyobj)
+
+
+(defn has-attr?
+  "Return true if this python object has this attribute."
+  [pyobj att-name]
+  (py-proto/has-attr? pyobj att-name))
+
+
+(defn get-item
+  "Get an item from a python object using  __getitem__"
+  [pyobj item-name]
+  (with-gil (py-proto/get-item pyobj item-name)))
+
+
+(defn set-item!
+  "Get an item from a python object using  __setitem__"
+  [pyobj item-name item-val]
+  (with-gil (py-proto/set-item! pyobj item-name item-val))
+  pyobj)
+
+
+(defn set-items!
+  "Set a sequence of [name value]. Returns pyobj"
+  [pyobj item-seq]
+  (with-gil (doseq [[k v] item-seq] (set-item! pyobj k v)))
+  pyobj)
+
+
+(defn ->python
+  "Copy a jvm value into a python object"
+  [v]
+  (py-ffi/with-gil (py-base/->python v)))
+
+
+(defn as-python
+  "Bridge a jvm value into a python object"
+  [v]
+  (py-ffi/with-gil (py-base/as-python v)))
+
+
+(defn ->jvm
+  "Copy a python value into java datastructures"
+  [v & [opts]]
+  (py-ffi/with-gil (py-base/->jvm v opts)))
+
+
+(defn as-jvm
+  "Copy a python value into java datastructures"
+  [v & [opts]]
+  (py-ffi/with-gil (py-base/as-jvm v opts)))
+
+
+(defn as-map
+  "Make a python object appear as a map of it's items"
+  ^Map [pobj]
+  (py-bridge-jvm/generic-python-as-map pobj))
+
+
+(defn as-list
+  "Make a python object appear as a list"
+  ^List [pobj]
+  (py-bridge-jvm/generic-python-as-list pobj))
+
+
+(defn python-type
+  "Get the type (as a keyword) of a python object"
+  [v]
+  (py-ffi/with-gil (py-proto/python-type v)))
+
+
+(defn is-instance?
+  "Return true if inst is an instance of cls.  Note that arguments
+  are reversed as compared to `instance?`"
+  [py-inst py-cls]
+  (py-ffi/with-gil
+    (let [retval (long (py-ffi/PyObject_IsInstance py-inst py-cls))]
+      (case retval
+        0 false
+        1 true
+        (py-ffi/check-error-throw)))))
+
+
+(defn callable?
+  "Return true if python object is callable."
+  [pyobj]
+  (cond
+    (instance? IFn pyobj)
+    true
+    (dtype-ffi/convertible-to-pointer? pyobj)
+    (py-ffi/with-gil
+      (let [retval (long (py-ffi/PyCallable_Check pyobj))]
+        (case retval
+          0 false
+          1 true
+          (py-ffi/check-error-throw))))
+    :else
+    false))
+
+
+(defn ->py-list
+  "Copy the data into a python list"
+  [v]
+  (py-ffi/with-gil (-> (py-copy/->py-list v) (as-jvm))))
+
+
+(defn ->py-tuple
+  "Copy v into a python tuple"
+  [v]
+  (py-ffi/with-gil (-> (py-copy/->py-tuple v) (as-jvm))))
+
+
+(defn ->py-dict
+  "Copy v into a python dict"
+  [v]
+  (py-ffi/with-gil (-> (py-copy/->py-dict v) (as-jvm))))
+
+
+(defn run-simple-string
+  "Run a string expression returning a map of
+  {:globals :locals}.
+  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;"
+  [program & {:keys [globals locals]}]
+  (->> (py-ffi/run-simple-string program :globals globals :locals locals)
+       (map (fn [[k v]]
+              [k (py-base/as-jvm v)]))
+       (into {})))
+
+
+(defn make-callable
+  "Make a python callable object from a clojure function.  This is called for you
+  if you use `as-python` on an implementation of IFn.
+
+Options:
+  * `:arg-converter` - Function called for each function argument before your ifn
+     gets access to it.  Defaults to `->jvm`.
+  * `:result-converter` - Function called on return value before it gets returned to
+     python.  Must return a python object.  Defaults to `->python`; the result will
+     get an extra incref before being returned to Python to account for the implied
+     tracking of `as-python` or `->python`.
+  * `:name` - Name of the python method.  This will appear in stack traces.
+  * `:doc` - documentation for method."
+  ([ifn options]
+   (py-fn/make-tuple-fn ifn options))
+  ([ifn] (make-callable ifn nil)))
+
+
+(defn ^:no-doc make-tuple-fn
+  "Deprecated - use make-callable"
+  [ifn & {:as options}]
+  (make-callable ifn options))
+
+
+(defn make-instance-fn
+  "Make an callable instance function - a function which will be passed the 'this'
+  object as it's first argument.  In addition, this function calls `make-callable`
+  with a `arg-converter` defaulted to `as-jvm`.  See documentation for
+  make-callable."
+  ([ifn options] (py-class/make-tuple-instance-fn ifn options))
+  ([ifn] (make-instance-fn ifn nil)))
+
+
+(defn ^:no-doc make-tuple-instance-fn
+  [ifn & {:as options}]
+  (make-instance-fn ifn options))
+
+
+(defn create-class
+  "Create a new class object.  Any callable values in the cls-hashmap
+  will be presented as instance methods.  If you want access to the
+  'this' object then you must use `make-instance-fn`.
+
+  Example:
+
+```clojure
+user> (require '[libpython-clj2.python :as py])
+nil
+user> (def cls-obj (py/create-class
+                    \"myfancyclass\"
+                    nil
+                    {\"__init__\" (py/make-instance-fn
+                                 (fn [this arg]
+                                   (py/set-attr! this \"arg\" arg)
+                                   ;;If you don't return nil from __init__ that is an
+                                   ;;error.
+                                   nil))
+                     \"addarg\" (py/make-instance-fn
+                               (fn [this otherarg]
+                                 (+ (py/get-attr this \"arg\")
+                                    otherarg)))}))
+#'user/cls-obj
+user> cls-obj
+__no_module__.myfancyclass
+user> (def inst (cls-obj 10))
+#'user/inst
+user> (py/call-attr inst \"addarg\" 10)
+20
+```"
+  [name bases cls-hashmap]
+  (py-class/create-class name bases cls-hashmap))
+
+
+(defn cfn
+  "Call an object.
+  Arguments are passed in positionally.  Any keyword
+  arguments are paired with the next arg, gathered, and passed into the
+  system as *kwargs.
+
+  Not having an argument after a keyword argument is an error."
+  [item & args]
+  (apply py-fn/cfn item args))
+
+
+(defn afn
+  "Call an attribute of an object.
+  Arguments are passed in positionally.  Any keyword
+  arguments are paired with the next arg, gathered, and passed into the
+  system as *kwargs.
+
+  Not having an argument after a keyword is an error."
+  [item attr & args]
+  (apply py-fn/afn item attr args))
+
+
+(defmacro with
+  "Support for the 'with' statement in python:
+  (py/with [item (py/call-attr testcode-module \"WithObjClass\" true fn-list)]
+      (py/call-attr item \"doit_err\"))"
+  [bind-vec & body]
+  `(py-with/with ~bind-vec ~@body))
+
+
+(defmacro $a
+  "Call an attribute of an object using automatic detection of the python kwargs.
+  Keywords must be compile time constants.  So this won't work with 'apply'.  On the
+  other hand, building the positional and kw argmaps happens at compile time as
+  opposed to at runtime.  The attr name can be a symbol."
+  [item attr & args]
+  (let [[pos-args kw-args] (py-fn/args->pos-kw-args args)]
+    `(call-attr-kw ~item ~(py-fn/key-sym-str->str attr)
+                   ~pos-args ~kw-args)))
+
+
+(defmacro $c
+  "Call an object using automatic detection of the python kwargs.
+  Keywords must be compile time constants.  So this won't work with 'apply'.  On the
+  other hand, building the positional and kw argmaps happens at compile time as
+  opposed to at runtime."
+  [item & args]
+  (let [[pos-args kw-args] (py-fn/args->pos-kw-args args)]
+    `(py-fn/call-kw ~item ~pos-args ~kw-args)))
+
+
+(defmacro py.-
+  "Class/object getter syntax.  (py.- obj attr) is equivalent to
+  Python's obj.attr syntax."
+  [x arg]
+  `(get-attr ~x ~(py-fn/key-sym-str->str arg)))
+
+
+(defmacro py.
+  "Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
+  is equivalent to Python's obj.method(arg1, arg2, ..., argN) syntax."
+  [x & args]
+  (list* (into (vector #'$a x) args)))
+
+
+(defmacro py*
+  "Special syntax for passing along *args and **kwargs style arguments
+  to methods.
+
+  Usage:
+
+  (py* obj method args kwargs)
+
+  Example:
+
+  (def d (python/dict))
+  d ;;=> {}
+  (def iterable [[:a 1] [:b 2]])
+  (def kwargs {:cat \"dog\" :name \"taco\"})
+  (py* d  update [iterable] kwargs)
+  d ;;=> {\"a\": 1, \"b\": 2, \"cat\": \"dog\", \"name\": \"taco\"}"
+  ([x method args]
+   (list #'call-attr-kw x (py-fn/key-sym-str->str method) args nil))
+  ([x method args kwargs]
+   (list #'call-attr-kw x (py-fn/key-sym-str->str method) args kwargs)))
+
+
+(defmacro py**
+  "Like py*, but it is assumed that the LAST argument is kwargs."
+  ([x method kwargs]
+   (list #'call-attr-kw x (str method) nil kwargs))
+  ([x method arg & args]
+   (let [args   (into [arg] args)
+         kwargs (last args)
+         args   (vec (pop args))]
+     (list #'call-attr-kw x (py-fn/key-sym-str->str method) args kwargs))))
+
+
+(defn ^:private handle-pydotdot
+  ([x form]
+   (if (list? form)
+     (let [form-data (vec form)
+           [instance-member & args] form-data
+           symbol-str (str instance-member)]
+       (cond
+         (clojure.string/starts-with? symbol-str "-")
+         (list #'py.- x (symbol (subs symbol-str 1 (count symbol-str))))
+
+         (clojure.string/starts-with? symbol-str "**")
+         (list* #'py** x (symbol (subs symbol-str 2 (count symbol-str))) args)
+
+         (clojure.string/starts-with? symbol-str "*")
+         (list* #'py* x (symbol (subs symbol-str 1 (count symbol-str))) args)
+
+         :else ;; assumed to be method invocation
+
+         (list* (into (vector #'py. x instance-member) args))))
+     (handle-pydotdot x (list form))))
+  ([x form & more]
+   (apply handle-pydotdot (handle-pydotdot x form) more)))
+
+
+(defmacro py..
+  "Extended accessor notation, similar to the `..` macro in Clojure.
+
+  (require-python 'sys)
+  (py.. sys -path (append \"/home/user/bin\"))
+
+  is equivalent to Python's
+
+  import sys
+  sys.path.append('/home/user/bin')
+
+  SPECIAL SYNTAX for programmatic *args and **kwargs
+
+  Special syntax is provided to meet the needs required by
+  Python's *args and **kwargs syntax programmatically.
+
+
+  (= (py.. obj (*method args))
+     (py* obj methods args))
+
+  (= (py.. obj (*method args kwargs))
+     (py* obj method args kwargs))
+
+  (= (py.. obj (**method kwargs))
+     (py** obj method kwargs))
+
+  (= (py.. obj (**method arg1 arg2 arg3 ... argN kwargs))
+     (py** obj method arg1 arg2 arg3 ... argN kwargs)
+     (py*  obj method [arg1 arg2 arg3 ... argN] kwargs))
+
+
+  These forms exist for when you need to pass in a map of options
+  in the same way you would use the f(*args, **kwargs) forms in
+  Python."
+  [x & args]
+  (apply handle-pydotdot x args))
diff --git a/src/libpython_clj2/python/base.clj b/src/libpython_clj2/python/base.clj
new file mode 100644
index 0000000..0eec110
--- /dev/null
+++ b/src/libpython_clj2/python/base.clj
@@ -0,0 +1,190 @@
+(ns libpython-clj2.python.base
+  "Shared basic functionality and wrapper functions"
+  (:require [libpython-clj2.python.protocols :as py-proto]
+            [libpython-clj2.python.ffi :as py-ffi]
+            [tech.v3.datatype.ffi :as dt-ffi]
+            [camel-snake-kebab.core :as csk])
+  (:import [tech.v3.datatype.ffi Pointer]))
+
+
+(defn ->jvm
+  "Copying conversion to the jvm."
+  ([obj]
+   (when obj
+     (py-proto/->jvm obj nil)))
+  ([obj opts]
+   (when obj
+     (py-proto/->jvm obj opts))))
+
+
+(defn as-jvm
+  "Bridge/proxy conversion to the jvm"
+  ([obj]
+   (as-jvm obj nil))
+  ([obj opts]
+   (when obj
+     (py-proto/as-jvm obj opts))))
+
+
+(defn ->python
+  "Copying conversion to python"
+  ([obj]
+   (->python obj nil))
+  ([obj opts]
+   (cond
+     (nil? obj)
+     (py-ffi/py-none)
+     (boolean? obj)
+     (if obj (py-ffi/py-true) (py-ffi/py-false))
+     :else
+     (py-proto/->python obj nil))))
+
+
+(defn ->python-incref
+  [pyobj]
+  (let [pyobj (->python pyobj)]
+    (py-ffi/Py_IncRef pyobj)
+    pyobj))
+
+
+(defn as-python
+  "Bridge/proxy conversion to python"
+  ([obj]
+   (as-python obj nil))
+  ([obj opts]
+   (cond
+     (nil? obj)
+     (py-ffi/py-none)
+     (boolean? obj)
+     (if obj (py-ffi/py-true) (py-ffi/py-false))
+     :else
+     (py-proto/as-python obj nil))))
+
+
+(defn stringable?
+  [item]
+  (or (keyword? item)
+      (string? item)
+      (symbol? item)))
+
+
+(defn stringable
+  ^String [item]
+  (when (stringable? item)
+    (if (string? item)
+      item
+      (name item))))
+
+
+;;base defaults for forwarding calls
+(extend-type Object
+  py-proto/PCopyToJVM
+  (->jvm [item options]
+    (if (dt-ffi/convertible-to-pointer? item)
+      (py-proto/pyobject->jvm item options)
+      ;;item is already a jvm object
+      item))
+  py-proto/PBridgeToJVM
+  (as-jvm [item options]
+    (if (dt-ffi/convertible-to-pointer? item)
+      (py-proto/pyobject-as-jvm item options)
+      item))
+  py-proto/PPyCallable
+  (callable? [this] false)
+  py-proto/PPyAttr
+  (has-attr? [this attr-name] false)
+  py-proto/PPyItem
+  (has-item? [this item-name] false)
+  py-proto/PPyDir
+  (dir [this] []))
+
+
+(extend-protocol py-proto/PPythonType
+  Boolean
+  (get-python-type [item] :bool)
+  Number
+  (get-python-type [item]
+    (if (integer? item) :int :float))
+  String
+  (get-python-type [item] :str)
+  Object
+  (get-python-type [item] (py-ffi/pyobject-type-kwd item)))
+
+
+(extend-type Pointer
+  py-proto/PCopyToJVM
+  (->jvm [item options]
+    (py-proto/pyobject->jvm item options))
+  py-proto/PBridgeToJVM
+  (as-jvm [item options]
+    (py-proto/pyobject-as-jvm item options))
+  py-proto/PPyDir
+  (dir [item]
+    (py-ffi/with-decref [dirlist (py-ffi/PyObject_Dir item)]
+      (if dirlist
+        (->jvm dirlist)
+        (py-ffi/check-error-throw))))
+  py-proto/PPyAttr
+  (has-attr? [item item-name]
+    (if (stringable? item-name)
+      (= 1 (py-ffi/PyObject_HasAttrString item (stringable item-name)))
+      (= 1 (py-ffi/PyObject_HasAttr item (->python item-name nil)))))
+  (get-attr [item item-name]
+    (->
+     (if (stringable? item-name)
+       (py-ffi/PyObject_GetAttrString item (stringable item-name))
+       (py-ffi/with-decref [item-name (py-ffi/untracked->python item-name ->python)]
+         (py-ffi/PyObject_GetAttr item item-name)))
+        (py-ffi/simplify-or-track)))
+  (set-attr! [item item-name item-value]
+    (let [item-val (->python item-value)]
+      (if (stringable? item-name)
+        (py-ffi/PyObject_SetAttrString item (stringable item-name) item-val)
+        (py-ffi/PyObject_SetAttr item (->python item-name) item-val)))
+    (py-ffi/check-error-throw)
+    nil)
+  py-proto/PPyCallable
+  (callable? [item]
+    (== 1 (long (py-ffi/PyCallable_Check item))))
+  py-proto/PPyItem
+  (has-item? [item item-name]
+    (if (stringable? item-name)
+      (= 1 (py-ffi/PyObject_HasAttrString item (stringable item-name)))
+      (= 1 (py-ffi/PyObject_HasAttr item (->python item-name)))))
+  (get-item [item item-name]
+    (py-ffi/with-decref [item-name (py-ffi/untracked->python item-name ->python)]
+      (-> (py-ffi/PyObject_GetItem item item-name)
+          (py-ffi/simplify-or-track))))
+  (set-item! [item item-name item-value]
+    (py-ffi/with-decref [item-name (py-ffi/untracked->python item-name ->python)
+                         item-val (py-ffi/untracked->python item-value ->python)]
+      (py-ffi/PyObject_SetItem item item-name item-val)
+      (py-ffi/check-error-throw))
+    nil))
+
+
+(def bool-fn-table
+  (->> {"Py_LT" 0
+        "Py_LE" 1
+        "Py_EQ" 2
+        "Py_NE" 3
+        "Py_GT" 4
+        "Py_GE" 5}
+       (map (fn [[k v]]
+              [(csk/->kebab-case-keyword k) v]))
+       (into {})))
+
+
+(defn hash-code
+  ^long [py-inst]
+  (py-ffi/with-gil
+    (long (py-ffi/PyObject_Hash py-inst))))
+
+
+(defn equals?
+  "Returns true of the python equals operator returns 1."
+  [lhs rhs]
+  (py-ffi/with-gil
+    (= 1 (py-ffi/PyObject_RichCompareBool (->python lhs)
+                                          (->python rhs)
+                                          (bool-fn-table :py-eq)))))
diff --git a/src/libpython_clj2/python/bridge_as_jvm.clj b/src/libpython_clj2/python/bridge_as_jvm.clj
new file mode 100644
index 0000000..0cb2a84
--- /dev/null
+++ b/src/libpython_clj2/python/bridge_as_jvm.clj
@@ -0,0 +1,435 @@
+(ns libpython-clj2.python.bridge-as-jvm
+  "Functionality related to proxying python objects such that they interact natively
+  with the JVM --  Python dicts become java.util.Maps, for instance."
+  (:require [libpython-clj2.python.protocols :as py-proto]
+            [libpython-clj2.python.base :as py-base]
+            [libpython-clj2.python.fn :as py-fn]
+            [libpython-clj2.python.ffi :refer [with-gil] :as py-ffi]
+            [libpython-clj2.python.gc :as pygc]
+            [tech.v3.datatype.errors :as errors]
+            [tech.v3.datatype.ffi :as dt-ffi]
+            [clojure.core.protocols :as clj-proto])
+  (:import [java.util Map]
+           [clojure.lang IFn MapEntry Fn]
+           [tech.v3.datatype.ffi Pointer]
+           [tech.v3.datatype ObjectBuffer]))
+
+
+(extend-protocol py-proto/PBridgeToJVM
+  Pointer
+  (as-jvm [ptr opts]
+    (py-proto/pyobject-as-jvm ptr opts)))
+
+
+(defmethod py-proto/pyobject-as-jvm :int
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :float
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :int-8
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :uint-8
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :int-16
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :uint-16
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :int-32
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :uint-32
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :int-64
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :uint-64
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :float-64
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :float-32
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :str
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :bool
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defmethod py-proto/pyobject-as-jvm :range
+  [pyobj & [opts]]
+  (py-base/->jvm pyobj opts))
+
+
+(defn python->jvm-iterator
+  "This is a tough function to get right.  The iterator could return nil as in
+  you could have a list of python none types or something so you have to iterate
+  till you get a StopIteration error.
+
+  If item-conversion-fn is nil, returns the raw fn output.
+  Else calls item-conversion-fn."
+  [pyobj item-conversion-fn]
+  (with-gil
+    (let [py-iter (py-fn/call-attr pyobj "__iter__" nil)
+          py-next-fn (when py-iter (py-proto/get-attr py-iter "__next__"))
+          next-fn (fn [last-item]
+                    (when (= last-item ::iteration-finished)
+                      (errors/throw-iterator-past-end))
+                    (with-gil
+                      (let [retval (py-ffi/PyObject_CallObject py-next-fn nil)]
+                        (if (and (nil? retval) (py-ffi/PyErr_Occurred))
+                          (pygc/with-stack-context
+                            (let [type (dt-ffi/make-ptr :pointer 0)
+                                  value (dt-ffi/make-ptr :pointer 0)
+                                  tb (dt-ffi/make-ptr :pointer 0)
+                                  _ (py-ffi/PyErr_Fetch type value tb)]
+                              (if (= (Pointer. (type 0)) (py-ffi/py-exc-stopiter-type))
+                                (do
+                                  (py-ffi/Py_DecRef (Pointer. (type 0)))
+                                  (when-not (== 0 (long (value 0)))
+                                    (py-ffi/Py_DecRef (Pointer. (value 0))))
+                                  (when-not (== 0 (long (tb 0)))
+                                    (py-ffi/Py_DecRef (Pointer. (tb 0))))
+                                  ::iteration-finished)
+                                (do
+                                  (py-ffi/PyErr_Restore (Pointer. (type 0))
+                                                        (Pointer. (value 0))
+                                                        (Pointer. (tb 0)))
+                                  (py-ffi/check-error-throw)))))
+                          (if item-conversion-fn
+                            (item-conversion-fn (py-ffi/track-pyobject retval))
+                            retval)))))
+          cur-item-store (atom (next-fn nil))]
+      (reify
+        java.util.Iterator
+        (hasNext [obj-iter]
+          (boolean (not= ::iteration-finished @cur-item-store)))
+        (next [obj-iter]
+          (-> (swap-vals! cur-item-store next-fn)
+              first))))))
+
+
+(defmacro bridge-pyobject
+  [pyobj & body]
+  `(let [pyobj# ~pyobj]
+     (with-meta
+       (reify
+         dt-ffi/PToPointer
+         (convertible-to-pointer? [item#] true)
+         (->pointer [item#] (dt-ffi/->pointer pyobj#))
+         py-proto/PPythonType
+         (get-python-type [item]
+           (with-gil (py-proto/get-python-type pyobj#)))
+         py-proto/PCopyToPython
+         (py-base/->python [item# options#] pyobj#)
+         py-proto/PBridgeToPython
+         (py-base/as-python [item# options#] pyobj#)
+         py-proto/PBridgeToJVM
+         (py-base/as-jvm [item# options#] item#)
+         py-proto/PCopyToJVM
+         (->jvm [item# options#]
+           (with-gil
+             (py-base/->jvm pyobj# options#)))
+         py-proto/PPyDir
+         (dir [item#]
+           (with-gil (py-proto/dir pyobj#)))
+         py-proto/PPyAttr
+         (has-attr? [item# item-name#]
+           (with-gil
+             (py-proto/has-attr? pyobj# item-name#)))
+         (get-attr [item# item-name#]
+           (with-gil
+             (-> (py-proto/get-attr pyobj# item-name#)
+                 py-base/as-jvm)))
+         (set-attr! [item# item-name# item-value#]
+           (with-gil
+             (py-ffi/with-decref [item-value# (py-ffi/untracked->python
+                                               item-value# py-base/as-python)]
+               (py-proto/set-attr! pyobj# item-name# item-value#))))
+         py-proto/PPyItem
+         (has-item? [item# item-name#]
+           (with-gil
+             (py-proto/has-item? pyobj# item-name#)))
+         (get-item [item# item-name#]
+           (with-gil
+             (-> (py-proto/get-item pyobj# item-name#)
+                 py-base/as-jvm)))
+         (set-item! [item# item-name# item-value#]
+           (with-gil
+             (py-ffi/with-decref [item-value# (py-ffi/untracked->python
+                                               item-value# py-base/as-python)]
+               (py-proto/set-item! pyobj# item-name# item-value#))))
+         py-proto/PyCall
+         (call [callable# arglist# kw-arg-map#]
+           (-> (py-fn/call-py-fn pyobj# arglist# kw-arg-map# py-base/as-python)
+               (py-base/as-jvm)))
+         (marshal-return [callable# retval#]
+           (py-base/as-jvm retval#))
+         clj-proto/Datafiable
+         (datafy [callable#] (py-proto/pydatafy callable#))
+         Object
+         (toString [this#]
+           (with-gil
+             (pygc/with-stack-context
+               (if (= 1 (py-ffi/PyObject_IsInstance pyobj# (py-ffi/py-type-type)))
+                 (format "%s.%s"
+                         (if (py-proto/has-attr? pyobj# "__module__")
+                           (py-base/->jvm (py-proto/get-attr pyobj# "__module__"))
+                           "__no_module__")
+                         (if (py-proto/has-attr? pyobj# "__name__")
+                           (py-base/->jvm (py-proto/get-attr pyobj# "__name__"))
+                           "__unnamed__"))
+                 (py-base/->jvm (py-fn/call-attr pyobj# "__str__" nil))))))
+         (equals [this# other#]
+           (boolean
+            (when (dt-ffi/convertible-to-pointer? other#)
+              (py-base/equals? pyobj# other#))))
+         (hashCode [this#]
+           (.hashCode ^Object (py-base/hash-code this#)))
+         ~@body)
+       {:type :pyobject})))
+
+
+(defmethod print-method :pyobject
+  [pyobj w]
+  (.write ^java.io.Writer w ^String (.toString ^Object pyobj)))
+
+
+(defn call-impl-fn
+  [fn-name att-map args]
+  (if-let [py-fn* (get att-map fn-name)]
+    ;;laziness is carefully constructed here in order to allow the arguments to
+    ;;be released within the context of the function call during fn.clj call-py-fn.
+    (-> (py-fn/call-py-fn @py-fn* args nil py-base/as-python)
+        (py-base/as-jvm))
+    (throw (UnsupportedOperationException.
+            (format "Python object has no attribute: %s"
+                    fn-name)))))
+
+
+(defn make-dict-att-map
+  [pyobj attnames]
+  (let [dict-atts (set attnames)
+        gc-ctx (pygc/gc-context)]
+    (->> (py-proto/dir pyobj)
+         (filter dict-atts)
+         (map (juxt identity #(delay
+                                (pygc/with-gc-context gc-ctx
+                                  (py-proto/get-attr pyobj %)))))
+         (into {}))))
+
+
+(defn make-instance-pycall
+  [pyobj attnames]
+  (let [dict-att-map (make-dict-att-map pyobj attnames)]
+    (fn [fn-name & args]
+      (py-ffi/with-gil (call-impl-fn fn-name dict-att-map args)))))
+
+
+
+(defn generic-python-as-map
+  [pyobj]
+  (with-gil
+    (let [py-call
+          (make-instance-pycall
+           pyobj
+           #{"__len__" "__getitem__" "__setitem__" "__iter__" "__contains__"
+             "__eq__" "__hash__" "clear" "keys" "values" "__delitem__"})]
+      (bridge-pyobject
+       pyobj
+       Map
+       (clear [item] (py-call "clear"))
+       (containsKey [item k] (boolean (py-call "__contains__" k)))
+       (entrySet
+        [this]
+        (py-ffi/with-gil
+          (->> (.iterator this)
+               iterator-seq
+               set)))
+       (get [this obj-key]
+            (py-call "__getitem__" obj-key))
+       (getOrDefault [item obj-key obj-default-value]
+                     (if (.containsKey item obj-key)
+                       (.get item obj-key)
+                       obj-default-value))
+       (isEmpty [this] (= 0 (.size this)))
+       (keySet [this] (->> (py-call "keys")
+                           set))
+       (put [this k v]
+            (py-call "__setitem__" k v))
+
+       (remove [this k]
+               (py-call "__delitem__" k))
+
+       (size [this]
+             (int (py-call "__len__")))
+       (values [this]
+               (py-ffi/with-gil
+                 (-> (py-call "values")
+                     (vec))))
+       Iterable
+       (iterator
+        [this]
+        (let [mapentry-seq
+              (->> (python->jvm-iterator pyobj nil)
+                   iterator-seq
+                   (map (fn [pyobj-key]
+                          (with-gil
+                            (let [k (py-base/as-jvm pyobj-key)
+                                  v (.get this pyobj-key)
+                                  retval
+                                  (MapEntry. k v)]
+                              retval)))))]
+
+          (.iterator ^Iterable mapentry-seq)))
+       IFn
+       (invoke [this arg] (.getOrDefault this arg nil))
+       (applyTo [this arglist]
+                (let [arglist (vec arglist)]
+                  (case (count arglist)
+                    1 (.get this (first arglist)))))))))
+
+
+(defmethod py-proto/pyobject-as-jvm :dict
+  [pyobj & [opts]]
+  (generic-python-as-map pyobj))
+
+
+(defn generic-python-as-list
+  [pyobj]
+  (with-gil
+    (let [py-call (make-instance-pycall
+                  pyobj
+                  #{"__len__" "__getitem__" "__setitem__" "__iter__" "__contains__"
+                    "__eq__" "__hash__" "clear" "insert" "pop" "append"
+                    "__delitem__" "sort"})]
+      (bridge-pyobject
+       pyobj
+       ObjectBuffer
+       (lsize [reader]
+              (long (py-call "__len__")))
+       (readObject [reader idx]
+             (py-call "__getitem__" idx))
+       (sort [reader obj-com]
+             (when-not (= nil obj-com)
+               (throw (ex-info "Python lists do not support comparators" {})))
+             (py-call "sort"))
+       (writeObject [writer idx value]
+              (py-call "__setitem__" idx value))
+       (remove [writer ^int idx]
+               (py-call "__delitem__" idx))
+       (add [mutable idx value]
+            (py-call "insert" idx value))
+       (add [mutable value]
+            (.add mutable (.size mutable) value))))))
+
+
+(defmethod py-proto/pyobject-as-jvm :list
+  [pyobj & [opts]]
+  (generic-python-as-list pyobj))
+
+
+(defmethod py-proto/pyobject-as-jvm :tuple
+  [pyobj & [opts]]
+  (generic-python-as-list pyobj))
+
+
+;;utility fn to generate IFn arities
+(defn- emit-args
+  [bodyf varf]
+   (let [argify (fn [n argfn bodyf]
+                  (let [raw  `[~'this ~@(map #(symbol (str "arg" %))
+                                             (range n))]]
+                    `~(bodyf (argfn raw))))]
+     (concat (for [i (range 21)]
+               (argify i identity bodyf))
+             [(argify 21 (fn [xs]
+                          `[~@(butlast xs) ~'arg20-obj-array])
+                     varf)])))
+
+;;Python specific interop wrapper for IFn invocations.
+(defn- emit-py-args []
+  (emit-args (fn [args] `(~'invoke [~@args]
+                          (py-fn/cfn ~@args)))
+             (fn [args]
+               `(~'invoke [~@args]
+                 (apply py-fn/cfn ~@(butlast args) ~(last args))))))
+
+
+(defmacro bridge-callable-pyobject
+  "Like bridge-pyobject, except it populates the implementation of IFn
+   for us, where all arg permutations are supplied, as well as applyTo,
+   and the function invocation is of the form
+   (invoke [this arg] (with-gil (cfn this arg))).
+   If caller supplies an implementation for clojure.lang.IFn or aliased
+   Fn, the macro will use that instead (allowing more control but
+   requiring caller to specify implementations for all desired arities)."
+  [pyobj interpreter & body]
+  (let [fn-specs (when-not (some #{'IFn 'clojure.lang.IFn} body)
+                   `(~'IFn
+                     ~@(emit-py-args)
+                     (~'applyTo [~'this ~'arglist]
+                      (~'apply py-fn/cfn ~'this ~'arglist))))]
+    `(bridge-pyobject ~pyobj ~interpreter
+                      ~@fn-specs
+                      ~@body)))
+
+
+(defn generic-python-as-jvm
+  "Given a generic pyobject, wrap it in a read-only map interface
+  where the keys are the attributes."
+  [pyobj]
+  (with-gil
+    (if (= :none-type (py-ffi/pyobject-type-kwd pyobj))
+      nil
+      (if (py-proto/callable? pyobj)
+        (bridge-callable-pyobject
+         pyobj
+         Iterable
+         (iterator [this] (python->jvm-iterator pyobj py-base/as-jvm))
+         Fn)
+        (bridge-pyobject
+         pyobj
+         Iterable
+         (iterator [this] (python->jvm-iterator pyobj  py-base/as-jvm)))))))
+
+
+
+(defmethod py-proto/pyobject-as-jvm :default
+  [pyobj & [opts]]
+  (generic-python-as-jvm pyobj))
diff --git a/src/libpython_clj2/python/bridge_as_python.clj b/src/libpython_clj2/python/bridge_as_python.clj
new file mode 100644
index 0000000..676e792
--- /dev/null
+++ b/src/libpython_clj2/python/bridge_as_python.clj
@@ -0,0 +1,252 @@
+(ns libpython-clj2.python.bridge-as-python
+  "Functionality related to proxying JVM objects into Python so for instance a
+  java.util.Map implementation will appear to python as being dict-like."
+  (:require [libpython-clj2.python.ffi :refer [with-gil] :as py-ffi]
+            [libpython-clj2.python.base :as py-base]
+            [libpython-clj2.python.class :as py-class]
+            [libpython-clj2.python.protocols :as py-proto]
+            [libpython-clj2.python.gc :as pygc]
+            [libpython-clj2.python.jvm-handle :as jvm-handle]
+            [tech.v3.datatype.errors :as errors]
+            [tech.v3.datatype :as dtype])
+  (:import [java.util Map RandomAccess UUID List Iterator]
+           [java.util.concurrent ConcurrentHashMap]
+           [tech.v3.datatype.ffi Pointer]
+           [tech.v3.datatype ObjectBuffer]
+           [clojure.lang Keyword Symbol IFn]))
+
+
+(defn as-python-incref
+  "Convert to python and add a reference.  Necessary for return values from
+  functions as python expects a new reference and the as-python pathway
+  ensures the jvm garbage collector also sees the reference."
+  [item]
+  (when-let [retval (py-base/as-python item)]
+    (do
+      (py-ffi/Py_IncRef retval)
+      retval)))
+
+
+(defn- as-tuple-instance-fn
+  [fn-obj & [options]]
+  (py-class/make-tuple-instance-fn fn-obj
+                                   (merge {:result-converter py-base/as-python
+                                           :arg-converter identity}
+                                          options)))
+
+(defn self->list
+  ^List [self]
+  (jvm-handle/py-self->jvm-obj self))
+
+
+(defonce sequence-type*
+  (jvm-handle/py-global-delay
+   (py-ffi/with-gil
+     (py-ffi/with-decref
+       [mod (py-ffi/PyImport_ImportModule "collections.abc")
+        seq-type (py-ffi/PyObject_GetAttrString mod "MutableSequence")]
+       (py-class/create-class
+        "jvm-list-as-python"
+        [seq-type]
+        {"__init__" (py-class/wrapped-jvm-constructor)
+         "__del__" (py-class/wrapped-jvm-destructor)
+         "__contains__" (as-tuple-instance-fn #(.contains (self->list %1) %2))
+         "__eq__" (as-tuple-instance-fn #(.equals (self->list %1)
+                                                  (py-base/->jvm %2)))
+         "__getitem__" (as-tuple-instance-fn #(.get (self->list %1)
+                                                    (int (py-base/->jvm %2))))
+         "__setitem__" (as-tuple-instance-fn #(.set (self->list %1)
+                                                    (int (py-base/->jvm %2))
+                                                    (py-base/as-jvm %3)))
+         "__delitem__" (as-tuple-instance-fn #(.remove (self->list %1)
+                                                       (int (py-base/->jvm %2))))
+         "__hash__" (as-tuple-instance-fn #(.hashCode (self->list %1)))
+         "__iter__" (as-tuple-instance-fn #(.iterator (self->list %1)))
+         "__len__" (as-tuple-instance-fn #(.size (self->list %1)))
+         "__str__" (as-tuple-instance-fn #(.toString (self->list %1)))
+         "clear" (as-tuple-instance-fn #(.clear (self->list %1)))
+         "sort" (as-tuple-instance-fn #(.sort (self->list %1) nil))
+         "append" (as-tuple-instance-fn #(.add (self->list %1) %2))
+         "insert" (as-tuple-instance-fn #(.add (self->list %1)
+                                               (int (py-base/->jvm %2)) %3))
+         "pop" (as-tuple-instance-fn
+                (fn [self & args]
+                  (let [jvm-data (self->list self)
+                        args (map py-base/->jvm args)
+                        index (int (if (first args)
+                                     (first args)
+                                     -1))
+                        index (if (< index 0)
+                                (- (.size jvm-data) index)
+                                index)]
+                    #(.remove jvm-data index))))})))))
+
+
+(defn list-as-python
+  [item]
+  (let [list-data (if (instance? List item)
+                    item
+                    (dtype/->buffer item))
+        hdl (jvm-handle/make-jvm-object-handle list-data)]
+    (@sequence-type* hdl)))
+
+
+(defmethod py-proto/pyobject->jvm :jvm-list-as-python
+  [pyobj opt]
+  (jvm-handle/py-self->jvm-obj pyobj))
+
+
+
+(defn self->map
+  ^Map [self]
+  (jvm-handle/py-self->jvm-obj self))
+
+
+(defonce mapping-type*
+  (jvm-handle/py-global-delay
+    (with-gil
+      (py-ffi/with-decref
+        [mod (py-ffi/PyImport_ImportModule "collections.abc")
+         map-type (py-ffi/PyObject_GetAttrString mod "MutableMapping")]
+        ;;In order to make things work ingeneral
+        (py-class/create-class
+         "jvm-map-as-python"
+         [map-type]
+         {"__init__" (py-class/wrapped-jvm-constructor)
+          "__del__" (py-class/wrapped-jvm-destructor)
+          "__contains__" (as-tuple-instance-fn #(.containsKey (self->map %1)
+                                                              (py-base/as-jvm %2)))
+          "__eq__" (as-tuple-instance-fn #(.equals (self->map %1) (py-base/as-jvm %2)))
+          "__getitem__" (as-tuple-instance-fn
+                         #(.get (self->map %1) (py-base/as-jvm %2)))
+          "__setitem__" (as-tuple-instance-fn #(.put (self->map %1) (py-base/as-jvm %2) %3))
+          "__delitem__" (as-tuple-instance-fn #(.remove (self->map %1) (py-base/as-jvm %2)))
+          "__hash__" (as-tuple-instance-fn #(.hashCode (self->map %1)))
+          "__iter__" (as-tuple-instance-fn #(.iterator ^Iterable (keys (self->map %1))))
+          "__len__" (as-tuple-instance-fn #(.size (self->map %1)))
+          "__str__" (as-tuple-instance-fn #(.toString (self->map %1)))
+          "clear" (as-tuple-instance-fn #(.clear (self->map %1)))
+          "keys" (as-tuple-instance-fn #(seq (.keySet (self->map %1))))
+          "values" (as-tuple-instance-fn #(seq (.values (self->map %1))))
+          "pop" (as-tuple-instance-fn #(.remove (self->map %1) (py-base/as-jvm %2)))})))))
+
+
+(defn map-as-python
+  [^Map jvm-data]
+  (errors/when-not-errorf
+   (instance? Map jvm-data)
+   "arg (%s) is not an instance of Map" (type jvm-data))
+  (@mapping-type* (jvm-handle/make-jvm-object-handle jvm-data)))
+
+
+(defmethod py-proto/pyobject->jvm :jvm-map-as-python
+  [pyobj opt]
+  (jvm-handle/py-self->jvm-obj pyobj))
+
+
+(def iterable-type*
+  (jvm-handle/py-global-delay
+    (py-ffi/with-gil
+      (py-ffi/with-decref
+        [mod (py-ffi/PyImport_ImportModule "collections.abc")
+         iter-base-cls (py-ffi/PyObject_GetAttrString mod  "Iterable")]
+        (py-class/create-class
+         "jvm-iterable-as-python"
+         [iter-base-cls]
+         {"__init__" (py-class/wrapped-jvm-constructor)
+          "__del__" (py-class/wrapped-jvm-destructor)
+          "__iter__" (as-tuple-instance-fn
+                      #(.iterator ^Iterable (jvm-handle/py-self->jvm-obj %))
+                      {:name "__iter__"})
+          "__eq__" (as-tuple-instance-fn #(.equals (jvm-handle/py-self->jvm-obj %1)
+                                                   (py-base/as-jvm %2))
+                                         {:name "__eq__"})
+          "__hash__" (as-tuple-instance-fn
+                      #(.hashCode (jvm-handle/py-self->jvm-obj %))
+                      {:name "__hash__"})
+          "__str__" (as-tuple-instance-fn
+                     #(.toString (jvm-handle/py-self->jvm-obj %))
+                     {:name "__str__"})})))))
+
+
+(defn iterable-as-python
+  [^Iterable jvm-data]
+  (errors/when-not-errorf
+   (instance? Iterable jvm-data)
+   "Argument (%s) is not an instance of Iterable" (type jvm-data))
+  (@iterable-type* (jvm-handle/make-jvm-object-handle jvm-data)))
+
+
+(defmethod py-proto/pyobject->jvm :jvm-iterable-as-python
+  [pyobj opt]
+  (jvm-handle/py-self->jvm-obj pyobj))
+
+
+(def iterator-type*
+  (jvm-handle/py-global-delay
+    (py-ffi/with-gil
+      (let [mod (py-ffi/PyImport_ImportModule "collections.abc")
+            iter-base-cls (py-ffi/PyObject_GetAttrString mod  "Iterator")
+            next-fn (fn [self]
+                      (let [^Iterator item (jvm-handle/py-self->jvm-obj self)]
+                        (if (.hasNext item)
+                          (pygc/with-stack-context
+                            (py-ffi/untracked->python (.next item) py-base/as-python))
+                          (do
+                            (py-ffi/PyErr_SetNone (py-ffi/py-exc-stopiter-type))
+                            nil))))]
+        (py-class/create-class
+         "jvm-iterator-as-python"
+         [iter-base-cls]
+         {"__init__" (py-class/wrapped-jvm-constructor)
+          "__del__" (py-class/wrapped-jvm-destructor)
+          "__next__" (py-class/make-tuple-instance-fn
+                      next-fn
+                      ;;In this case we are explicitly taking care of all conversions
+                      ;;to python and back so we do not ask for any converters.
+                      {:arg-converter nil
+                       :result-converter nil})})))))
+
+
+(defn iterator-as-python
+  [^Iterator jvm-data]
+  (errors/when-not-errorf
+   (instance? Iterator jvm-data)
+   "Argument (%s) is not a java Iterator" (type jvm-data))
+  (@iterator-type* (jvm-handle/make-jvm-object-handle jvm-data)))
+
+
+(defmethod py-proto/pyobject->jvm :jvm-iterator-as-python
+  [pyobj opt]
+  (jvm-handle/py-self->jvm-obj pyobj))
+
+
+(extend-protocol py-proto/PBridgeToPython
+  ;;already bridged!
+  Pointer
+  (as-python [item opts] item)
+  Boolean
+  (as-python [item opts] (py-proto/->python item opts))
+  Number
+  (as-python [item opts] (py-proto/->python item opts))
+  String
+  (as-python [item opts] (py-proto/->python item opts))
+  Keyword
+  (as-python [item opts] (py-proto/->python item opts))
+  Symbol
+  (as-python [item opts] (py-proto/->python item opts))
+  Object
+  (as-python [item opts]
+    (cond
+      (instance? Map item)
+      (map-as-python item)
+      (dtype/reader? item)
+      (list-as-python item)
+      (instance? IFn item)
+      (py-class/wrap-ifn item)
+      (instance? Iterable item)
+      (iterable-as-python item)
+      (instance? Iterator item)
+      (iterator-as-python item)
+      :else
+      (errors/throwf "Enable to bridge type %s" (type item)))))
diff --git a/src/libpython_clj2/python/class.clj b/src/libpython_clj2/python/class.clj
new file mode 100644
index 0000000..4e53310
--- /dev/null
+++ b/src/libpython_clj2/python/class.clj
@@ -0,0 +1,155 @@
+(ns libpython-clj2.python.class
+  "Namespace to help create a new python class from Clojure.  Used as a core
+  implementation technique for bridging JVM objects into python."
+  (:require [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python.base :as py-base]
+            [libpython-clj2.python.jvm-handle :as jvm-handle]
+            [libpython-clj2.python.fn :as py-fn]
+            [libpython-clj2.python.protocols :as py-proto]
+            [tech.v3.datatype.errors :as errors])
+  (:import [clojure.lang IFn]))
+
+
+(defn- py-fn->instance-fn
+  "Given a python callable, return an instance function meant to be used
+  in class definitions."
+  [py-fn]
+  (py-ffi/check-gil)
+  (let [retval (-> (py-ffi/PyInstanceMethod_New py-fn)
+                   (py-ffi/track-pyobject))]
+    retval))
+
+
+(defn make-tuple-instance-fn
+  "Make an instance function - a function which will be passed the 'this' object as
+  it's first argument.  In this case the default behavior is to
+  pass raw python object ptr args to the clojure function without marshalling
+  as that can add confusion and unnecessary overhead.  Self will be the first argument.
+  Callers can change this behavior by setting the 'arg-converter' option as in
+  'make-tuple-fn'.
+  Options are the same as make-tuple-fn."
+  ([clj-fn & [{:keys [arg-converter]
+               :or {arg-converter py-base/as-jvm}
+               :as options}]]
+   (py-ffi/with-gil
+     ;;Explicity set arg-converter to override make-tuple-fn's default
+     ;;->jvm arg-converter.
+     (-> (py-fn/make-tuple-fn clj-fn (assoc options :arg-converter arg-converter))
+         ;;Mark this as an instance function.
+         (py-fn->instance-fn)))))
+
+
+(defn create-class
+  "Create a new class object.  Any callable values in the cls-hashmap
+  will be presented as instance methods.
+  Things in the cls hashmap had better be either atoms or already converted
+  python objects.  You may get surprised otherwise; you have been warned.
+  See the classes-test file in test/libpython-clj"
+  [name bases cls-hashmap]
+  (py-ffi/with-gil
+    (py-ffi/with-decref
+      [cls-dict (py-ffi/untracked-dict cls-hashmap py-base/->python)
+       bases (py-ffi/untracked-tuple bases py-base/->python)]
+      (-> (py-fn/call (py-ffi/py-type-type) name bases cls-dict)
+          (py-base/as-jvm)))))
+
+
+(def wrapped-jvm-destructor*
+  (jvm-handle/py-global-delay
+   (make-tuple-instance-fn
+    (fn [self]
+      (let [jvm-hdl (jvm-handle/py-self->jvm-handle self)]
+        #_(log/debugf "Deleting bridged handle %d" jvm-hdl)
+        (jvm-handle/remove-jvm-object jvm-hdl)
+        nil)))))
+
+
+(defn wrapped-jvm-destructor
+  []
+  @wrapped-jvm-destructor*)
+
+
+(def wrapped-jvm-constructor*
+  (jvm-handle/py-global-delay
+   (make-tuple-instance-fn jvm-handle/py-self-set-jvm-handle!)))
+
+
+(defn wrapped-jvm-constructor
+  []
+  @wrapped-jvm-constructor*)
+
+
+(def abc-callable-type*
+  (jvm-handle/py-global-delay
+   (py-ffi/with-decref [mod (py-ffi/PyImport_ImportModule "collections.abc")]
+     (py-proto/get-attr mod "Callable"))))
+
+
+(def wrapped-fn-class*
+  (jvm-handle/py-global-delay
+     (create-class
+      "LibPythonCLJWrappedFn" [@abc-callable-type*]
+      {"__init__" (wrapped-jvm-constructor)
+       "__del__" (wrapped-jvm-destructor)
+       "__call__" (make-tuple-instance-fn
+                   (fn [self & args]
+                     (let [jvm-obj (jvm-handle/py-self->jvm-obj self)]
+                       (-> (apply jvm-obj (map py-base/as-jvm args))
+                           (py-ffi/untracked->python py-base/as-python)))))
+       "__str__" (make-tuple-instance-fn
+                  (fn [self]
+                    (format
+                     "libpython-clj-wrapper[%s]"
+                     (.toString (jvm-handle/py-self->jvm-obj self)))))})))
+
+
+(defn wrap-ifn
+  [ifn]
+  (errors/when-not-errorf
+   (instance? IFn ifn)
+   "Object %s is not an instance of clojure.lang.IFn" ifn)
+  (@wrapped-fn-class* (jvm-handle/make-jvm-object-handle ifn)))
+
+
+
+(comment
+  (def cls-obj*
+)
+  (@cls-obj* (jvm-handle/make-jvm-object-handle
+              #(println "in python:" %)))
+
+
+  (def cls-obj (create-class
+                "Stock" nil
+                {"__init__" (make-tuple-instance-fn
+                             (fn init [self name shares price]
+                               ;;Because we did not use an arg-converter, all the
+                               ;;arguments above are raw jna Pointers - borrowed
+                               ;;references.
+                               (py-proto/set-attr! self "name" name)
+                               (py-proto/set-attr! self "shares" shares)
+                               (py-proto/set-attr! self "price" price)
+                                ;;If you don't return nil from __init__ that is an
+                                ;;error.
+                               nil))
+                 "__del__" (wrapped-jvm-destructor)
+                 "cost" (make-tuple-instance-fn
+                         (fn cost [self]
+                           (* (py-proto/get-attr self "shares")
+                              (py-proto/get-attr self "price")))
+                          ;;Convert self to something that auto-marshals things.
+                          ;;This pathway will autoconvert all arguments to the function.
+                         {:arg-converter py-base/as-jvm})
+                  "__str__" (make-tuple-instance-fn
+                             (fn str [self]
+                               ;;Alternative to using arg-converter.  This way you can
+                               ;;explicitly control which arguments are converted.
+                               (let [self (py-base/as-jvm self)]
+                                 (pr-str {"name" (py-proto/get-attr self "name")
+                                          "shares" (py-proto/get-attr self "shares")
+                                          "price" (py-proto/get-attr self "price")}))))
+                 "clsattr" 55}))
+
+  (def inst (cls-obj "ACME" 50 90))
+  (py-fn/call-attr inst "cost")
+  )
diff --git a/src/libpython_clj2/python/copy.clj b/src/libpython_clj2/python/copy.clj
new file mode 100644
index 0000000..9b1af56
--- /dev/null
+++ b/src/libpython_clj2/python/copy.clj
@@ -0,0 +1,328 @@
+(ns libpython-clj2.python.copy
+  "Bindings to copy jvm <-> python.  Most functions in this namespace expect the
+  GIL to be captured."
+  (:require [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python.protocols :as py-proto]
+            [libpython-clj2.python.base :as py-base]
+            [libpython-clj2.python.gc :as pygc]
+            [tech.v3.datatype :as dtype]
+            [tech.v3.datatype.protocols :as dt-proto]
+            [tech.v3.datatype.ffi :as dt-ffi]
+            [tech.v3.datatype.errors :as errors])
+  (:import [tech.v3.datatype.ffi Pointer]
+           [java.util Map RandomAccess Set]
+           [clojure.lang Keyword Symbol IFn]))
+
+(declare ->py-tuple)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; python -> jvm
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;;protocol defaults and wrapper functions
+(defn python->jvm-copy-hashmap
+  [pyobj & [map-items]]
+  (when-not (= 1 (py-ffi/PyMapping_Check pyobj))
+    (errors/throwf "Object does not implement the mapping protocol: %s"
+                   (py-proto/python-type pyobj)))
+  (when-let [map-items (or map-items (py-ffi/PyMapping_Items pyobj))]
+    (try
+      (->> (py-base/->jvm map-items)
+           (into {}))
+      (finally
+        (py-ffi/Py_DecRef map-items)))))
+
+
+(defn python->jvm-copy-persistent-vector
+  [pyobj]
+  (when-not (= 1 (py-ffi/PySequence_Check pyobj))
+    (errors/throwf "Object does not implement sequence protocol: %s"
+                   (py-proto/python-type pyobj)))
+  (->> (range (py-ffi/PySequence_Length pyobj))
+       (mapv (fn [idx]
+               (let [pyitem (py-ffi/PySequence_GetItem pyobj idx)]
+                 (try
+                   (py-base/->jvm pyitem)
+                   (finally
+                     (py-ffi/Py_DecRef pyitem))))))))
+
+
+(defmethod py-proto/pyobject->jvm :str
+  [pyobj & args]
+  (py-ffi/pystr->str pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :int
+  [pyobj & args]
+  (py-ffi/PyLong_AsLongLong pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :float
+  [pyobj & args]
+  (py-ffi/PyFloat_AsDouble pyobj))
+
+
+(defn pyobj-true?
+  [pyobj]
+  (= 1 (py-ffi/PyObject_IsTrue pyobj)))
+
+
+(defmethod py-proto/pyobject->jvm :bool
+  [pyobj & [options]]
+  (pyobj-true? pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :tuple
+  [pyobj & [options]]
+  (let [n-elems (py-ffi/PyTuple_Size pyobj)]
+    (mapv (fn [^long idx]
+            (py-base/->jvm (py-ffi/PyTuple_GetItem pyobj idx)))
+          (range n-elems))))
+
+
+(defmethod py-proto/pyobject->jvm :dict
+  [pyobj & [options]]
+  (let [ppos (dt-ffi/make-ptr :size-t 0)
+        pkey (dt-ffi/make-ptr :pointer 0)
+        pvalue (dt-ffi/make-ptr :pointer 0)
+        retval (java.util.ArrayList.)]
+    ;;Dictionary iteration doesn't appear to be reentrant so we have
+    ;;to do 2 passes.
+    (loop [next-retval (py-ffi/PyDict_Next pyobj ppos pkey pvalue)]
+      (if (not= 0 next-retval)
+        (do
+          (.add retval [(Pointer. (long (pkey 0)))
+                        (Pointer. (long (pvalue 0)))])
+          (recur (py-ffi/PyDict_Next pyobj ppos pkey pvalue)))
+        (->> retval
+             (map (fn [[k v]]
+                    [(py-base/->jvm k) (py-base/->jvm v)]))
+             (into {}))))))
+
+
+(defn numpy-scalar->jvm
+  [pyobj]
+  (pygc/with-stack-context
+    (-> (py-proto/get-attr pyobj "data")
+        (py-proto/get-item (->py-tuple []))
+        py-base/->jvm)))
+
+
+(defmethod py-proto/pyobject->jvm :uint-8
+  [pyobj & [opts]]
+  (numpy-scalar->jvm pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :int-8
+  [pyobj & [opts]]
+  (numpy-scalar->jvm pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :uint-16
+  [pyobj & [opts]]
+  (numpy-scalar->jvm pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :int-16
+  [pyobj & [opts]]
+  (numpy-scalar->jvm pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :uint-32
+  [pyobj & [opts]]
+  (numpy-scalar->jvm pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :int-32
+  [pyobj & [opts]]
+  (numpy-scalar->jvm pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :uint-64
+  [pyobj & [opts]]
+  (numpy-scalar->jvm pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :int-64
+  [pyobj & [opts]]
+  (numpy-scalar->jvm pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :float-64
+  [pyobj & [opts]]
+  (numpy-scalar->jvm pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :float-32
+  [pyobj & [opts]]
+  (numpy-scalar->jvm pyobj))
+
+
+(defmethod py-proto/pyobject->jvm :range
+  [pyobj & [opts]]
+  (pygc/with-stack-context
+    (let [start (py-base/->jvm (py-proto/get-attr pyobj "start"))
+          step (py-base/->jvm (py-proto/get-attr pyobj "step"))
+          stop (py-base/->jvm (py-proto/get-attr pyobj "stop"))]
+      (range start stop step))))
+
+
+(defmethod py-proto/pyobject->jvm :default
+  [pyobj & [options]]
+  (cond
+    (= :none-type (py-ffi/pyobject-type-kwd pyobj))
+    nil
+    ;;Things could implement mapping and sequence logically so mapping
+    ;;takes precedence
+    (= 1 (py-ffi/PyMapping_Check pyobj))
+    (if-let [map-items (py-ffi/PyMapping_Items pyobj)]
+      (try
+        (python->jvm-copy-hashmap pyobj map-items)
+        (finally
+          (py-ffi/Py_DecRef map-items)))
+      (do
+        ;;Ignore error.  The mapping check isn't thorough enough to work for all
+        ;;python objects.
+        (py-ffi/PyErr_Clear)
+        (python->jvm-copy-persistent-vector pyobj)))
+    ;;Sequences become persistent vectors
+    (= 1 (py-ffi/PySequence_Check pyobj))
+    (python->jvm-copy-persistent-vector pyobj)
+    :else
+    {:type (py-ffi/pyobject-type-kwd pyobj)
+     ;;Create a new GC root as the old reference is released.
+     :value (let [new-obj (py-ffi/track-pyobject
+                           (Pointer. (.address (dt-ffi/->pointer pyobj))))]
+              (py-ffi/Py_IncRef new-obj)
+              new-obj)}))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; jvm -> python
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(def ^:dynamic *item-tuple-cutoff* 8)
+
+
+(defn ->py-tuple
+  [args]
+  (-> (py-ffi/untracked-tuple args py-base/->python)
+      (py-ffi/track-pyobject)))
+
+
+(defn ->py-dict
+  "Copy an object into a new python dictionary."
+  [item]
+  (py-ffi/check-gil)
+  (-> (py-ffi/untracked-dict item py-base/->python)
+      (py-ffi/track-pyobject)))
+
+
+(defn ->py-string
+  "Copy an object into a python string"
+  [item]
+  (-> (py-ffi/PyUnicode_FromString (str item))
+      (py-ffi/track-pyobject)))
+
+
+(defn ->py-list
+  "Copy an object into a new python list."
+  [item-seq]
+  (py-ffi/check-gil)
+  (let [item-seq (vec item-seq)
+        retval (py-ffi/PyList_New (count item-seq))]
+    (pygc/with-stack-context
+      (dotimes [idx (count item-seq)]
+        (let [si-retval
+              ;;setitem does steal the reference
+              (py-ffi/PyList_SetItem
+               retval
+               idx
+               (py-ffi/untracked->python (item-seq idx) py-base/->python))]
+          (when-not (== 0 (long si-retval))
+            (py-ffi/check-error-throw)))))
+    (py-ffi/track-pyobject retval)))
+
+
+(defn ->py-set
+  [item]
+  (py-ffi/check-gil)
+  (-> (py-ffi/PySet_New (->py-list item))
+      (py-ffi/track-pyobject)))
+
+
+(defn ->py-long
+  [item]
+  (py-ffi/track-pyobject (py-ffi/PyLong_FromLongLong (long item))))
+
+
+(defn ->py-double
+  [item]
+  (py-ffi/track-pyobject (py-ffi/PyFloat_FromDouble (double item))))
+
+
+(defn ->py-range
+  [item]
+  (let [dt-range (dt-proto/->range item {})
+        start (long (dt-proto/range-start dt-range))
+        inc (long (dt-proto/range-increment dt-range))
+        n-elems (long (dtype/ecount dt-range))
+        stop (+ start (* inc n-elems))
+        ;;the tuple steals the references
+        argtuple (py-ffi/untracked-tuple [start stop inc])
+        retval (py-ffi/PyObject_CallObject (py-ffi/py-range-type) argtuple)]
+    ;;we drop the tuple
+    (py-ffi/Py_DecRef argtuple)
+    ;;and wrap the retval
+    (py-ffi/track-pyobject retval)))
+
+
+(extend-protocol py-proto/PCopyToPython
+  Boolean
+  (->python [item opts]
+    (if item (py-ffi/py-true) (py-ffi/py-false)))
+  Long
+  (->python [item opts] (->py-long item))
+  Double
+  (->python [item opts] (->py-double item))
+  Number
+  (->python [item opts]
+    (if (integer? item)
+      (->py-long item)
+      (->py-double item)))
+  String
+  (->python [item ops] (->py-string item))
+  Keyword
+  (->python [item ops] (->py-string (name item)))
+  Symbol
+  (->python [item ops] (->py-string (name item)))
+  Character
+  (->python [item ops] (->py-string (str item)))
+  Map
+  (->python [item opts] (->py-dict item))
+  RandomAccess
+  (->python [item opts]
+    (if (< (count item) (long *item-tuple-cutoff*))
+      (->py-tuple item)
+      (->py-list item)))
+  Set
+  (->python [item opts] (->py-set item))
+  Pointer
+  (->python [item opts] item)
+  Object
+  (->python [item opts]
+    (cond
+      (dt-proto/convertible-to-range? item)
+      (->py-range item)
+      (dtype/reader? item)
+      (py-proto/->python (dtype/->reader item) opts)
+      ;;There is one more case here for iterables (sequences)
+      (instance? Iterable item)
+      ;;Iterables we *have* to convert lazily; we cannot copy them.
+      (py-proto/as-python item opts)
+      (instance? IFn item)
+      (py-proto/as-python item opts)
+      :else
+      (errors/throwf "Unable to convert object: %s" item))))
diff --git a/src/libpython_clj2/python/dechunk_map.clj b/src/libpython_clj2/python/dechunk_map.clj
new file mode 100644
index 0000000..7146d72
--- /dev/null
+++ b/src/libpython_clj2/python/dechunk_map.clj
@@ -0,0 +1,11 @@
+(ns libpython-clj2.python.dechunk-map
+  "Utility namespace with a function that works like a single-sequence map but
+  stops chunking.")
+
+
+(defn dechunk-map
+  "Map a function across a sequence without chunking."
+  [f s]
+  (lazy-seq
+   (when-let [[x] (seq s)]
+     (cons (f x) (dechunk-map f (rest s))))))
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
new file mode 100644
index 0000000..80ab939
--- /dev/null
+++ b/src/libpython_clj2/python/ffi.clj
@@ -0,0 +1,883 @@
+(ns libpython-clj2.python.ffi
+  "Low level bindings to the python shared library system.  Several key pieces of
+  functionality are implemented:
+
+  * Declare/implement actual C binding layer
+  * Low level library initialization
+  * GIL management
+  * Error checking
+  * High perf tuple, dict creation
+  * Addref/decref reference management including tracking objects - binding them
+    to the JVM GC
+  * python type->clojure keyword table"
+  (:require [tech.v3.datatype :as dtype]
+            [tech.v3.datatype.ffi :as dt-ffi]
+            [tech.v3.datatype.ffi.size-t :as ffi-size-t]
+            [tech.v3.datatype.struct :as dt-struct]
+            [tech.v3.datatype.errors :as errors]
+            [tech.v3.datatype.native-buffer :as native-buffer]
+            [tech.v3.datatype.nio-buffer :as nio-buffer]
+            [tech.v3.datatype.protocols :as dt-proto]
+            [tech.v3.resource :as resource]
+            [libpython-clj2.python.gc :as pygc]
+            [camel-snake-kebab.core :as csk]
+            [clojure.tools.logging :as log]
+            [clojure.string :as s])
+  (:import [java.util.concurrent ConcurrentHashMap]
+           [java.util.function Function]
+           [tech.v3.datatype.ffi Pointer Library]
+           [clojure.lang Keyword Symbol]
+           [java.nio.charset StandardCharsets]))
+
+
+(set! *warn-on-reflection* true)
+
+
+(declare track-pyobject py-none pystr->str check-error-throw pyobject-type-kwd
+         PyGILState_Check)
+
+
+(def python-library-fns
+  {:Py_InitializeEx {:rettype :void
+                     :argtypes [['signals :int32]]
+                     :requires-gil? false
+                     :doc "Initialize the python shared library"}
+   :Py_IsInitialized {:rettype :int32
+                      :requires-gil? false
+                      :doc "Return 1 if library is initalized, 0 otherwise"}
+
+   :PyRun_SimpleString {:rettype :int32
+                        :argtypes [['argstr :string]]
+                        :doc "Low-level run a simple python string."}
+   :PyRun_String {:rettype :pointer
+                  :argtypes [['program :string]
+                             ['start-sym :int32]
+                             ['globals :pointer]
+                             ['locals :pointer]]
+                  :doc "Run a string setting the start type, globals and locals"}
+   :PySys_SetArgvEx {:rettype :void
+                     :argtypes [['argc :int32]
+                                ['argv-wide-ptr-ptr :pointer]
+                                ['update :int32]]
+                   :doc "Set the argv/argc for the interpreter.
+Required for some python modules"}
+   :Py_SetProgramName {:rettype :void
+                       :requires-gil? false
+                       :argtypes [['program-name-wideptr :pointer]]
+                       :doc "Set the program name"}
+   :PyEval_SaveThread {:rettype :pointer
+                       :requires-gil? false
+                       :doc "Release the GIL on the current thread"}
+   :PyGILState_Ensure {:rettype :int32
+                       :requires-gil? false
+                       :doc "Ensure this thread owns the python GIL.
+Each call must be matched with PyGILState_Release"}
+   :PyGILState_Check {:rettype :int32
+                      :requires-gil? false
+                      :doc "Return 1 if gil is held, 0 otherwise"}
+   :PyGILState_Release {:rettype :void
+                        :argtypes [['modhdl :int32]]
+                        :doc "Release the GIL state."}
+   :Py_IncRef {:rettype :void
+               :argtypes [['pyobj :pointer]]
+               :doc "Increment the reference count on a pyobj"}
+   :Py_DecRef {:rettype :void
+               :argtypes [['pyobj :pointer]]
+               :doc "Decrement the reference count on a pyobj"}
+   :PyErr_Occurred {:rettype :pointer
+                    :doc "Return the current in-flight exception without clearing it."}
+   :PyErr_Fetch {:rettype :void
+                 :argtypes [['type :pointer]
+                            ['value :pointer]
+                            ['tb :pointer]]
+                 :doc "Fetch and clear the current exception information"}
+   :PyErr_Restore {:rettype :void
+                   :argtypes [['type :pointer]
+                              ['value :pointer?]
+                              ['tb :pointer?]]
+                   :doc "Restore the current error state"}
+   :PyErr_NormalizeException {:rettype :void
+                              :argtypes [['type :pointer]
+                                         ['value :pointer]
+                                         ['tb :pointer]]
+                              :doc "Normalize a python exception."}
+   :PyErr_Clear {:rettype :void
+                 :doc "Clear the current python error"}
+   :PyErr_SetString {:rettype :void
+                     :argtypes [['ex-type :pointer]
+                                ['data :string]]
+                     :doc "Raise an exception with a message"}
+   :PyErr_SetNone {:rettype :void
+                   :argtypes [['ex-type :pointer]]
+                   :doc "Raise an exception with no message"}
+   :PyException_SetTraceback {:rettype :int32
+                              :argtypes [['val :pointer]
+                                         ['tb :pointer]]
+                              :doc "Set the traceback on the exception object"}
+   :PyUnicode_AsUTF8 {:rettype :pointer
+                      :argtypes [['obj :pointer]]
+                      :doc "convert a python unicode object to a utf8 encoded string"}
+   :PyUnicode_AsUTF8AndSize {:rettype :pointer
+                             :argtypes [['obj :pointer]
+                                        ['size :pointer]]
+                             :doc "Return both the data and the size of the data"}
+   :PyImport_ImportModule {:rettype :pointer
+                           :argtypes [['modname :string]]
+                           :doc "Import a python module"}
+   :PyImport_AddModule {:rettype :pointer
+                        :argtypes [['modname :string]]
+                        :doc "Add a python module"}
+   :PyModule_GetDict {:rettype :pointer
+                      :argtypes [['module :pointer]]
+                      :doc "Get the module dictionary"}
+   :PyObject_Dir {:rettype :pointer
+                  :argtypes [['pyobj :pointer]]
+                  :doc "Get a python sequence of string attribute names"}
+   :PyObject_HasAttr {:rettype :int32
+                      :argtypes [['o :pointer]
+                                 ['attr_name :pointer]]
+                      :doc "Return 1 if object has an attribute"}
+   :PyObject_HasAttrString {:rettype :int32
+                            :argtypes [['o :pointer]
+                                       ['attr_name :string]]
+                            :doc "Return 1 if object has an attribute"}
+   :PyObject_GetAttr {:rettype :pointer
+                      :argtypes [['o :pointer]
+                                 ['attr_name :pointer]]
+                      :doc "get an attribute from an object"}
+   :PyObject_GetAttrString {:rettype :pointer
+                            :argtypes [['o :pointer]
+                                       ['attr_name :string]]
+                            :doc "get an attribute from an object"}
+   :PyObject_SetAttrString {:rettype :int32
+                            :argtypes [['o :pointer]
+                                       ['attr_name :string]
+                                       ['v :pointer]]}
+   :PyObject_SetAttr {:rettype :int32
+                      :argtypes [['o :pointer]
+                                 ['attr_name :pointer]
+                                 ['v :pointer]]
+                      :doc "Set an attribute on a python object"}
+   :PyObject_GetItem {:rettype :pointer
+                      :argtypes [['o :pointer]
+                                 ['args :pointer]]
+                      :doc "Get an item from a python object"}
+   :PyObject_SetItem {:rettype :int32
+                      :argtypes [['o :pointer]
+                                 ['args :pointer]
+                                 ['val :pointer]]
+                      :doc "Set an item on a python object"}
+   :PyObject_IsTrue {:rettype :int32
+                     :argtypes [['o :pointer]]
+                     :doc "Check if a python object is true"}
+   :PyObject_IsInstance {:rettype :int32
+                         :argtypes [['inst :pointer]
+                                    ['cls :pointer]]
+                         :doc "Check if this object is an instance of this class"}
+   :PyObject_Hash {:rettype :size-t
+                   :argtypes [['o :pointer]]
+                   :doc "Get the hash value of a python object"}
+   :PyObject_RichCompareBool {:rettype :int32
+                              :argtypes [['lhs :pointer]
+                                         ['rhs :pointer]
+                                         ['opid :int32]]
+                              :doc "Compare two python objects"}
+   :PyCallable_Check {:rettype :int32
+                      :argtypes [['o :pointer]]
+                      :doc "Return 1 if this is a callable object"}
+   :PyObject_Call {:rettype :pointer
+                   :argtypes [['callable :pointer]
+                              ['args :pointer]
+                              ['kwargs :pointer?]]
+                   :doc "Call a callable object"}
+   :PyObject_CallObject {:rettype :pointer
+                   :argtypes [['callable :pointer]
+                              ['args :pointer?]]
+                   :doc "Call a callable object with no kwargs.  args may be nil"}
+   :PyMapping_Check {:rettype :int32
+                     :argtypes [['pyobj :pointer]]
+                     :doc "Check if this object implements the mapping protocol"}
+   :PyMapping_Items {:rettype :pointer
+                     :argtypes [['pyobj :pointer]]
+                     :doc "Get an iterable of tuples of this map."}
+   :PySequence_Check {:rettype :int32
+                      :argtypes [['pyobj :pointer]]
+                      :doc "Check if this object implements the sequence protocol"}
+   :PySequence_Length {:rettype :size-t
+                       :argtypes [['pyobj :pointer]]
+                       :doc "Get the length of a sequence"}
+   :PySequence_GetItem {:rettype :pointer
+                        :argtypes [['pyobj :pointer]
+                                   ['idx :size-t]]
+                        :doc "Get a specific item from a sequence"}
+   :PyFloat_AsDouble {:rettype :float64
+                     :argtypes [['pyobj :pointer]]
+                       :doc "Get a double value from a python float"}
+   :PyFloat_FromDouble {:rettype :pointer
+                       :argtypes [['data :float64]]
+                       :doc "Get a pyobject form a long."}
+
+   :PyLong_AsLongLong {:rettype :int64
+                       :argtypes [['pyobj :pointer]]
+                       :doc "Get the long value from a python integer"}
+   :PyLong_FromLongLong {:rettype :pointer
+                         :argtypes [['data :int64]]
+                         :doc "Get a pyobject form a long."}
+   :PyDict_New {:rettype :pointer
+                :doc "Create a new dictionary"}
+   :PyDict_SetItem {:rettype :int32
+                    :argtypes [['dict :pointer]
+                               ['k :pointer]
+                               ['v :pointer]]
+                    :doc "Insert val into the dictionary p with a key of key. key must be hashable; if it isn’t, TypeError will be raised. Return 0 on success or -1 on failure. This function does not steal a reference to val."}
+   :PyDict_Next {:rettype :int32
+                 :argtypes [['pyobj :pointer]
+                            ['ppos :pointer]
+                            ['pkey :pointer]
+                            ['pvalue :pointer]]
+                 :doc "Get the next value from a dictionary"}
+   :PyTuple_New {:rettype :pointer
+                 :argtypes [['len :size-t]]
+                 :doc "Create a new uninitialized tuple"}
+   :PyTuple_SetItem {:rettype :int32
+                     :argtypes [['tuple :pointer]
+                                ['idx :size-t]
+                                ['pvalue :pointer]]
+                     :doc "Insert a reference to object o at position pos of the tuple pointed to by p. Return 0 on success. If pos is out of bounds, return -1 and set an IndexError exception."}
+   :PyTuple_Size {:rettype :size-t
+                  :argtypes [['o :pointer]]
+                  :doc "return the length of a tuple"}
+   :PyTuple_GetItem {:rettype :pointer
+                     :argtypes [['o :pointer]
+                                ['idx :size-t]]
+                     :doc "return a borrowed reference to item at idx"}
+   :PyList_New {:rettype :pointer
+                :argtypes [['len :size-t]]
+                :doc "create a new list"}
+   :PyList_SetItem {:rettype :int32
+                    :argtypes [['l :pointer]
+                               ['idx :size-t]
+                               ['v :pointer]]
+                    :doc "Set the item at index index in list to item. Return 0 on success. If index is out of bounds, return -1 and set an IndexError exception.  This function steals the reference to v"}
+   :PyList_Size {:rettype :size-t
+                  :argtypes [['o :pointer]]
+                  :doc "return the length of a list"}
+   :PyList_GetItem {:rettype :pointer
+                     :argtypes [['o :pointer]
+                                ['idx :size-t]]
+                     :doc "return a borrowed reference to item at idx"}
+   :PySet_New {:rettype :pointer
+               :argtypes [['items :pointer]]
+               :doc "Create a new set"}
+   :PyUnicode_FromString {:rettype :pointer
+                          :argtypes [['data :string]]
+                          :doc "Create a python unicode object from a string"}
+   :PyCFunction_NewEx {:rettype :pointer
+                       :argtypes [['method-def :pointer]
+                                  ['self :pointer?]
+                                  ['module :pointer?]]}
+   :PyInstanceMethod_New {:rettype :pointer
+                          :argtypes [['pyfn :pointer]]
+                          :doc "Mark a python function as being an instance method."}
+   })
+
+
+(def python-lib-def* (delay (dt-ffi/define-library python-library-fns)))
+(defonce pyobject-struct-type*
+  (delay (dt-struct/define-datatype!
+           :pyobject [{:name :ob_refcnt :datatype (ffi-size-t/size-t-type)}
+                      {:name :ob_type :datatype (ffi-size-t/size-t-type)}])))
+
+(defn pytype-offset
+  ^long []
+  (first (dt-struct/offset-of @pyobject-struct-type* :ob_type)))
+
+
+(defn pyrefcnt-offset
+  ^long []
+  (first (dt-struct/offset-of @pyobject-struct-type* :ob_refcnt)))
+
+
+(defn ptr->struct
+  [struct-type ptr-type]
+  (let [n-bytes (:datatype-size (dt-struct/get-struct-def struct-type))
+        src-ptr (dt-ffi/->pointer ptr-type)
+        nbuf (native-buffer/wrap-address (.address src-ptr)
+                                         n-bytes
+                                         src-ptr)]
+    (dt-struct/inplace-new-struct struct-type nbuf)))
+
+
+(defonce ^:private library* (atom nil))
+(defonce ^:private library-path* (atom nil))
+
+
+(defn reset-library!
+  []
+  (when @library-path*
+    (reset! library* (dt-ffi/instantiate-library @python-lib-def* @library-path*))))
+
+
+(defn set-library!
+  [libpath]
+  (when @library*
+    (log/warnf "Python library is being reinitialized to (%s).  Is this what you want?"
+               libpath))
+  (reset! library-path* libpath)
+  (reset-library!))
+
+
+
+
+;;Useful for repling around - this regenerates the library function bindings
+(reset-library!)
+
+
+(defn library-loaded? [] (not (nil? @library*)))
+
+
+(defn current-library
+  ^Library []
+  @library*)
+
+
+(defmacro check-gil
+  "Maybe the most important insurance policy"
+  []
+  `(errors/when-not-error
+    (= 1 (PyGILState_Check))
+    "GIL is not captured"))
+
+
+;;When this is true, generated functions will throw an exception if called when the
+;;GIL is not captured.  It makes sense to periodically enable this flag in order
+;;to ensure we aren't getting away with sneaky non-GIL access to Python.
+(def enable-api-gilcheck false)
+
+
+(defn- find-pylib-fn
+  [fn-kwd]
+  (let [pylib @library*]
+    (errors/when-not-error
+     pylib
+     "Library not found.  Has set-library! been called?")
+    (if-let [retval (fn-kwd @pylib)]
+      retval
+      (errors/throwf "Python function %s not found" (symbol (name fn-kwd))))))
+
+
+(defmacro def-py-fn
+  [fn-name docs & args]
+  (let [fn-kwd (keyword (name fn-name))]
+    (errors/when-not-errorf
+     (contains? python-library-fns fn-kwd)
+     "Python function %s is not defined" fn-name)
+    `(defn ~fn-name ~docs
+       ~(vec (map first args))
+       (let [retval#
+             (resource/stack-resource-context
+              ((find-pylib-fn ~fn-kwd) ~@(map (fn [[argname marshal-fn]]
+                                                `(~marshal-fn ~argname))
+                                              args)))]))))
+
+
+(defmacro define-pylib-functions
+  []
+  `(do
+     ~@(->>
+        python-library-fns
+        (map
+         (fn [[fn-name {:keys [rettype argtypes] :as fn-data}]]
+           (let [fn-symbol (symbol (name fn-name))
+                 requires-resctx? (first (filter #(= :string %)
+                                                 (map second argtypes)))
+                 gilcheck? (when enable-api-gilcheck
+                             (if (contains? fn-data :requires-gil?)
+                               (fn-data :requires-gil?)
+                               true))]
+             `(defn ~fn-symbol
+                ~(:doc fn-data "No documentation!")
+                ~(mapv first argtypes)
+                (let [~'ifn (find-pylib-fn ~fn-name)]
+                  (do
+                    ~(when gilcheck? `(check-gil))
+                    ~(if requires-resctx?
+                       `(resource/stack-resource-context
+                         (~'ifn ~@(map (fn [[argname argtype]]
+                                         (cond
+                                           (#{:int8 :int16 :int32 :int64} argtype)
+                                           `(long ~argname)
+                                           (#{:float32 :float64} argtype)
+                                           `(double ~argname)
+                                           (= :string argtype)
+                                           `(dt-ffi/string->c ~argname)
+                                           :else
+                                           argname))
+                                       argtypes)))
+                       `(~'ifn ~@(map (fn [[argname argtype]]
+                                        (cond
+                                          (#{:int8 :int16 :int32 :int64} argtype)
+                                          `(long ~argname)
+                                          (#{:float32 :float64} argtype)
+                                          `(double ~argname)
+                                          (= :string argtype)
+                                          `(dt-ffi/string->c ~argname)
+                                          :else
+                                          argname))
+                                      argtypes))))))))))))
+
+
+(define-pylib-functions)
+
+
+(defn- deref-ptr-ptr
+  ^Pointer [^Pointer val]
+  (Pointer. (case (ffi-size-t/size-t-type)
+              :int32 (.getInt (native-buffer/unsafe) (.address val))
+              :int64 (.getLong (native-buffer/unsafe) (.address val)))))
+
+
+(defmacro define-static-symbol
+  [symbol-fn symbol-name deref-ptr?]
+  (let [sym-delay-name (with-meta (symbol (str symbol-fn "*"))
+                         {:doc (format "Dereferences to the value of %s" symbol-name)
+                          :private true})]
+    `(do
+       (def ~sym-delay-name (delay (.findSymbol (current-library) ~symbol-name)))
+       ~(if deref-ptr?
+          `(defn ~symbol-fn [] (deref-ptr-ptr (deref ~sym-delay-name)))
+          `(defn ~symbol-fn [] (deref ~sym-delay-name))))))
+
+
+(define-static-symbol py-none "_Py_NoneStruct" false)
+(define-static-symbol py-true "_Py_TrueStruct" false)
+(define-static-symbol py-false "_Py_FalseStruct" false)
+(define-static-symbol py-range-type "PyRange_Type" false)
+(define-static-symbol py-exc-type "PyExc_Exception" true)
+(define-static-symbol py-exc-stopiter-type "PyExc_StopIteration" true)
+(define-static-symbol py-type-type "PyType_Type" false)
+
+
+(defmacro with-decref
+  [vardefs & body]
+  (let [n-vars (count vardefs)]
+    (if (= 2 n-vars)
+      `(let ~vardefs
+         (try
+           ~@body
+           (finally
+             (when ~(first vardefs)
+               (Py_DecRef ~(first vardefs))))))
+      `(let [~'obj-data (object-array ~n-vars)]
+         (try
+           (let [~@(mapcat (fn [[idx [varsym varform]]]
+                             [varsym `(let [vardata# ~varform]
+                                        (aset ~'obj-data ~idx vardata#)
+                                        vardata#)])
+                           (map-indexed vector (partition 2 vardefs)))]
+             ~@body)
+           (finally
+             (check-gil)
+             (dotimes [idx# ~n-vars]
+               (when-let [pyobj#  (aget ~'obj-data idx#)]
+                 (Py_DecRef pyobj#)))))))))
+
+
+(defn incref
+  "Increment the refcount returning object.  Legal to call
+  on nil, will not incref item and return nil."
+  [pyobj]
+  (when pyobj (Py_IncRef pyobj))
+  pyobj)
+
+
+(defonce ^{:tag ConcurrentHashMap
+           :private true}
+  forever-map (ConcurrentHashMap.))
+
+
+(defn retain-forever
+  [item-key item-val]
+  (.put forever-map item-key item-val)
+  item-val)
+
+
+(defonce format-exc-pyfn* (atom nil))
+
+
+(defn- init-exc-formatter
+  []
+  (check-gil)
+  (let [tback-mod (PyImport_ImportModule "traceback")
+        format-fn (PyObject_GetAttrString tback-mod "format_exception")]
+    ;;the tback module cannot be removed from memory and it always has a reference
+    ;;to format-fn so we drop our reference.
+    (Py_DecRef tback-mod)
+    (Py_DecRef format-fn)
+    (reset! format-exc-pyfn* format-fn)))
+
+
+(defn- exc-formatter
+  []
+  (when-not @format-exc-pyfn*
+    (init-exc-formatter))
+  @format-exc-pyfn*)
+
+
+(defn initialize!
+  [libpath python-home & [{:keys [signals? program-name]
+                           :or {signals? true
+                                program-name ""}}]]
+  (set-library! libpath)
+  (when-not (= 1 (Py_IsInitialized))
+    (log/debug "Initializing Python C Layer")
+    (let [program-name (retain-forever :program-name
+                                       (-> (or program-name "")
+                                           (dt-ffi/string->c {:encoding :utf-16})))]
+      (Py_SetProgramName program-name)
+      (Py_InitializeEx (if signals? 1 0))
+      (PySys_SetArgvEx 0 program-name 1)
+      ;;return value ignored :-)
+      ;;This releases the GIL until further processing and allows with-gil to work
+      ;;correctly.
+      (PyEval_SaveThread)))
+  :ok)
+
+
+(defn untracked->python
+  ^Pointer [item & [conversion-fallback]]
+  (cond
+    (instance? Pointer item)
+    (-> (if (.isNil ^Pointer item)
+          (py-none)
+          item)
+        (incref))
+    (instance? Number item) (if (integer? item)
+                              (PyLong_FromLongLong (long item))
+                              (PyFloat_FromDouble (double item)))
+    (instance? Boolean item) (-> (if item (py-true) (py-false))
+                                 (incref))
+    (instance? String item) (PyUnicode_FromString item)
+    (instance? Keyword item) (PyUnicode_FromString (name item))
+    (instance? Symbol item) (PyUnicode_FromString (name item))
+    (nil? item) (incref (py-none))
+    :else
+    (if conversion-fallback
+      (incref (conversion-fallback item))
+      (throw (Exception. "Unable to convert value %s" item)))))
+
+
+(defn untracked-tuple
+  "Low-level make tuple fn.  conv-fallback is used when an argument isn't an
+  atomically convertible python type.  Returns an untracked python tuple."
+  [args & [conv-fallback]]
+  (check-gil)
+  (let [args (vec args)
+        argcount (count args)
+        tuple (PyTuple_New argcount)]
+    (dotimes [idx argcount]
+      (PyTuple_SetItem tuple idx (untracked->python (args idx)
+                                                    conv-fallback)))
+    tuple))
+
+
+(defn untracked-dict
+  "Low-level make dict fn.  conv-fallback is used when a key or value isn't an
+  atomically convertible python type. Returns an untracked dict."
+  [item-seq & [conv-fallback]]
+  (check-gil)
+  (let [dict (PyDict_New)]
+    (pygc/with-stack-context
+      (doseq [[k v] item-seq]
+        ;;setitem does not steal the reference
+        (let [k (untracked->python k conv-fallback)
+              v (untracked->python v conv-fallback)
+              si-retval (PyDict_SetItem dict k v)]
+          (Py_DecRef k)
+          (Py_DecRef v)
+          (when-not (== (long si-retval) 0)
+            (check-error-throw)))))
+    dict))
+
+(def ^:dynamic *python-error-handler* nil)
+
+
+(defn fetch-normalize-exception
+  []
+  (check-gil)
+  (resource/stack-resource-context
+   (let [type (dt-ffi/make-ptr :pointer 0)
+         value (dt-ffi/make-ptr :pointer 0)
+         tb (dt-ffi/make-ptr :pointer 0)]
+     (PyErr_Fetch type value tb)
+     (PyErr_NormalizeException type value tb)
+     {:type (Pointer/constructNonZero (type 0))
+      :value (Pointer/constructNonZero (value 0))
+      :traceback (Pointer/constructNonZero (tb 0))})))
+
+
+(defn check-error-str
+  "Function assumes python stdout and stderr have been redirected"
+  []
+  (check-gil)
+  (when-not (= nil (PyErr_Occurred))
+    (if *python-error-handler*
+      (*python-error-handler*)
+      (let [{:keys [type value traceback]}
+            (fetch-normalize-exception)]
+        (with-decref [argtuple (untracked-tuple [type value traceback])
+                      exc-str-tuple (PyObject_CallObject (exc-formatter) argtuple)]
+          (case (pyobject-type-kwd exc-str-tuple)
+            :list (->> (range (PyList_Size exc-str-tuple))
+                       (map (fn [idx]
+                              (let [strdata (PyList_GetItem exc-str-tuple idx)]
+                                (pystr->str strdata))))
+                       (s/join))
+            :tuple (->> (range (PyTuple_Size exc-str-tuple))
+                        (map (fn [idx]
+                               (let [strdata (PyTuple_GetItem exc-str-tuple idx)]
+                                 (pystr->str strdata))))
+                       (s/join))))))))
+
+(defn check-error-throw
+  []
+  (when-let [error-str (check-error-str)]
+    (throw (Exception. ^String error-str))))
+
+
+(defmacro with-error-check
+  [& body]
+  `(let [retval# (do ~@body)]
+     (check-error-throw)
+     retval#))
+
+
+(defn check-py-method-return
+  [^long retval]
+  (when-not (= 0 retval)
+    (check-error-throw)))
+
+
+(defmacro with-gil
+  "Grab the gil and use the main interpreter using reentrant acquire-gil pathway."
+  [& body]
+  `(let [gil-state# (when-not (== 1 (long (PyGILState_Check)))
+                      (PyGILState_Ensure))]
+     (try
+       (let [retval# (do ~@body)]
+         (check-error-throw)
+         retval#)
+       (finally
+         (when gil-state#
+           #_(System/gc)
+           (pygc/clear-reference-queue)
+           (PyGILState_Release gil-state#))))))
+
+
+(defn pyobject-type
+  ^Pointer [pobj]
+  (if (= :int32 (ffi-size-t/size-t-type))
+    (Pointer. (.getInt (native-buffer/unsafe)
+                       (+ (.address (dt-ffi/->pointer pobj)) (pytype-offset))))
+    (Pointer. (.getLong (native-buffer/unsafe)
+                        (+ (.address (dt-ffi/->pointer pobj)) (pytype-offset))))))
+
+
+(defn pyobject-refcount
+  ^long [pobj]
+  (if (= :int32 (ffi-size-t/size-t-type))
+    (.getInt (native-buffer/unsafe)
+             (+ (.address (dt-ffi/->pointer pobj)) (pyrefcnt-offset)))
+    (.getLong (native-buffer/unsafe)
+              (+ (.address (dt-ffi/->pointer pobj)) (pyrefcnt-offset)))))
+
+
+(defn pystr->str
+  ^String [pyobj]
+  ;;manually allocate/deallocate for speed; this gets called a lot
+  (let [size-obj (dt-ffi/make-ptr (ffi-size-t/size-t-type) 0 {:resource-type nil
+                                                              :uninitialized? true})
+        ^Pointer str-ptr (PyUnicode_AsUTF8AndSize pyobj size-obj)
+        nbuf (native-buffer/wrap-address (.address str-ptr)
+                                         (size-obj 0)
+                                         nil)]
+    (native-buffer/free size-obj)
+    (-> (.decode StandardCharsets/UTF_8
+                 ;;avoid resource chaining for performance
+                 ^java.nio.ByteBuffer (nio-buffer/native-buf->nio-buf
+                                       nbuf {:resource-type nil}))
+        (.toString))))
+
+(defn pytype-name
+  ^String [type-pyobj]
+  (with-gil
+    (if-let [obj-name (PyObject_GetAttrString type-pyobj "__name__")]
+      (pystr->str obj-name)
+      (do
+        (log/warn "Failed to get typename for object")
+        "failed-typename-lookup"))))
+
+
+(defonce ^{:tag ConcurrentHashMap} type-addr->typename-kwd (ConcurrentHashMap.))
+
+
+(defn pyobject-type-kwd
+  [pyobject]
+  (let [pytype (pyobject-type pyobject)]
+    (.computeIfAbsent type-addr->typename-kwd
+                      (.address pytype)
+                      (reify Function
+                        (apply [this type-addr]
+                          (-> (pytype-name pytype)
+                              (csk/->kebab-case-keyword)))))))
+
+
+
+(def object-reference-logging (atom nil))
+
+
+(defn- wrap-obj-ptr
+  "This must be called with the GIL captured"
+  [pyobj ^Pointer pyobjptr gc-data]
+  (let [addr (.address pyobjptr)]
+    (when @object-reference-logging
+      (log/infof "tracking object  - 0x%x:%4d:%s"
+                 addr
+                 (pyobject-refcount pyobj)
+                 (name (pyobject-type-kwd pyobjptr))
+                 #_(with-out-str
+                     (try
+                       (throw (Exception. "test"))
+                       ""
+                       (catch Exception e
+                         (clojure.stacktrace/print-stack-trace e))))))
+    (pygc/track pyobj
+                ;;we know the GIL is captured in this method
+                #(try
+                   ;;Intentionally overshadow pyobj.  We cannot access it here.
+                   (let [pyobjptr (Pointer. addr)
+                         ;;reference gc data
+                         gc-data (identity gc-data)]
+                     (let [refcount (pyobject-refcount pyobjptr)
+                           typename (pyobject-type-kwd pyobjptr)]
+                       (if (< refcount 1)
+                         (log/errorf "Fatal error -- releasing object - 0x%x:%4d:%s
+Object's refcount is bad.  Crash is imminent"
+                                     addr
+                                     refcount
+                                     typename)
+                         (when @object-reference-logging
+                           (log/infof (format "releasing object - 0x%x:%4d:%s"
+                                              addr
+                                              refcount
+                                              typename)))))
+                     (Py_DecRef pyobjptr))
+                   (catch Throwable e
+                     (log/error e "Exception while releasing object"))))))
+
+
+(defn track-pyobject
+  ^Pointer [pyobj & [{:keys [skip-error-check?
+                             gc-data]}]]
+  (check-gil)
+  (when-let [^Pointer pyobjptr (when pyobj (dt-ffi/->pointer pyobj))]
+    (if-not (= (py-none) pyobjptr)
+      (wrap-obj-ptr pyobj pyobjptr gc-data)
+      ;;Py_None is handled separately
+      (do
+        (Py_DecRef pyobjptr)
+        (when-not skip-error-check? (check-error-throw))
+        nil))))
+
+
+(defn incref-track-pyobject
+  ^Pointer [pyobj]
+  (when pyobj
+    (Py_IncRef pyobj)
+    (track-pyobject pyobj)))
+
+
+
+(def start-symbol-table
+  {:py-single-input 256
+   :py-file-input 257
+   :py-eval-input 258})
+
+
+(defn start-symbol
+  [item]
+  (let [value (cond
+               (number? item)
+               (long item)
+               (keyword? item)
+               (get start-symbol-table item 0))
+        valid-values (set (vals start-symbol-table))]
+    (when-not (contains? valid-values value)
+      (throw (ex-info (format "%s is not a start symbol" item) {})))
+    (int value)))
+
+
+(defn import-module
+  [modname]
+  (if-let [mod (PyImport_ImportModule modname)]
+    (track-pyobject mod)
+    (check-error-throw)))
+
+
+(defn run-simple-string
+  "Run a simple string.  Results are only visible if they are saved in the
+  global or local context.
+
+  https://mail.python.org/pipermail/python-list/1999-April/018011.html
+
+  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;"
+  [program & {:keys [globals locals]}]
+  (with-gil
+    ;;borrowed reference
+    (let [main-mod (PyImport_AddModule "__main__")
+          ;;another borrowed reference that we will expose to the user
+          globals (or globals (incref-track-pyobject (PyModule_GetDict main-mod)))
+          locals (or locals globals)
+          retval (track-pyobject
+                  (PyRun_String (str program)
+                                (start-symbol :py-file-input)
+                                globals locals))]
+      {:globals globals
+       :locals locals
+       :retval retval})))
+
+
+(defn simplify-or-track
+  "If input is an atomic python object (long, float, string, bool), return
+  the JVM equivalent and release the reference to pyobj.  Else track the object."
+  [^Pointer pyobj]
+  (if-not (or (nil? pyobj) (.isNil pyobj))
+    (if (= pyobj (py-none))
+      (do (Py_DecRef pyobj)
+          nil)
+      (case (pyobject-type-kwd pyobj)
+        :int (with-decref [pyobj pyobj]
+               (PyLong_AsLongLong pyobj))
+        :float (with-decref [pyobj pyobj]
+                 (PyFloat_AsDouble pyobj))
+        :str (with-decref [pyobj pyobj]
+               (pystr->str pyobj))
+        :bool (with-decref [pyobj pyobj]
+                (= (dt-ffi/->pointer pyobj)
+                   (py-true)))
+        ;;maybe copy, maybe bridge - in any case we have to decref the item
+        (track-pyobject pyobj)))
+    (check-error-throw)))
diff --git a/src/libpython_clj2/python/fn.clj b/src/libpython_clj2/python/fn.clj
new file mode 100644
index 0000000..5d7dc98
--- /dev/null
+++ b/src/libpython_clj2/python/fn.clj
@@ -0,0 +1,218 @@
+(ns libpython-clj2.python.fn
+  "Pathways for creating clojure functions from python callable objects and
+  vice versa.  This namespace expects the GIL is captured.
+  Functions bridging this way is relatively expensive but it is the foundation
+  that the more advanced bridging in class.clj is built upon.
+
+  Also contains mechanisms for calling python functions and attributes."
+  (:require [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python.base :as py-base]
+            [libpython-clj2.python.protocols :as py-proto]
+            [libpython-clj2.python.gc :as pygc]
+            [tech.v3.datatype.ffi :as dt-ffi]
+            [tech.v3.datatype.ffi.size-t :as ffi-size-t]
+            [tech.v3.datatype.struct :as dt-struct]
+            [clojure.tools.logging :as log]
+            [clojure.stacktrace :as st])
+  (:import [tech.v3.datatype.ffi Pointer]))
+
+(set! *warn-on-reflection* true)
+
+
+(def methoddef-type (dt-struct/define-datatype! :pymethoddef
+                      [{:name :ml_name :datatype (ffi-size-t/ptr-t-type)}
+                       {:name :ml_meth :datatype (ffi-size-t/ptr-t-type)}
+                       {:name :ml_flags :datatype :int32}
+                       {:name :ml_doc :datatype (ffi-size-t/ptr-t-type)}]))
+
+
+(def tuple-fn-iface* (delay  (dt-ffi/define-foreign-interface :pointer? [:pointer :pointer])))
+
+
+(def ^{:tag 'long} METH_VARARGS  0x0001)
+(def ^{:tag 'long} METH_KEYWORDS 0x0002)
+;; METH_NOARGS and METH_O must not be combined with the flags above.
+(def ^{:tag 'long} METH_NOARGS   0x0004)
+
+
+(defn make-tuple-fn
+  ([ifn {:keys [arg-converter
+                result-converter
+                name doc]
+         :or {arg-converter py-base/->jvm
+              result-converter py-base/->python
+              name "_unamed"
+              doc "no documentation provided"}}]
+   (py-ffi/with-gil
+     (let [arg-converter (or arg-converter identity)
+           fn-inst
+           (dt-ffi/instantiate-foreign-interface
+            @tuple-fn-iface*
+            (fn [self tuple-args]
+              (try
+                (let [retval
+                      (apply ifn
+                             (->> (range (py-ffi/PyTuple_Size tuple-args))
+                                  (map (fn [idx]
+                                         (-> (py-ffi/PyTuple_GetItem tuple-args idx)
+                                             (arg-converter))))))]
+                  (if result-converter
+                    (py-ffi/untracked->python retval result-converter)
+                    retval))
+                (catch Throwable e
+                  (log/error e "Error executing clojure function.")
+                  (py-ffi/PyErr_SetString
+                   (py-ffi/py-exc-type)
+                   (format "%s:%s" e (with-out-str
+                                       (st/print-stack-trace e))))))))
+           fn-ptr (dt-ffi/foreign-interface-instance->c @tuple-fn-iface* fn-inst)
+           ;;no resource tracking - we leak the struct
+           method-def (dt-struct/new-struct :pymethoddef {:resource-type nil
+                                                          :container-type :native-heap})
+           name (dt-ffi/string->c name {:resource-type nil})
+           doc (dt-ffi/string->c doc {:resource-type nil})]
+       (.put method-def :ml_name (.address (dt-ffi/->pointer name)))
+       (.put method-def :ml_meth (.address (dt-ffi/->pointer fn-ptr)))
+       (.put method-def :ml_flags METH_VARARGS)
+       (.put method-def :ml_doc (.address (dt-ffi/->pointer doc)))
+       ;;the method def cannot ever go out of scope
+       (py-ffi/retain-forever (gensym) {:md method-def
+                                        :name name
+                                        :doc doc
+                                        :fn-ptr fn-ptr
+                                        :fn-inst fn-inst})
+       ;;no self, no module reference
+       (-> (py-ffi/PyCFunction_NewEx method-def nil nil)
+           (py-ffi/track-pyobject)))))
+  ([ifn]
+   (make-tuple-fn ifn nil)))
+
+
+(defn call-py-fn
+  [callable arglist kw-arg-map arg-converter]
+  (py-ffi/with-gil
+    ;;Release objects marshalled just for this call immediately
+    (let [retval
+          (pygc/with-stack-context
+            (py-ffi/with-decref
+              ;;We go out of our way to avoid tracking the arglist because it is
+              ;;allocated/deallocated so often
+              [arglist (when (or (seq kw-arg-map) (seq arglist))
+                         (py-ffi/untracked-tuple arglist arg-converter))
+               kw-arg-map (when (seq kw-arg-map)
+                            (py-ffi/untracked-dict kw-arg-map arg-converter))]
+              (cond
+                kw-arg-map
+                (py-ffi/PyObject_Call callable arglist kw-arg-map)
+                arglist
+                (py-ffi/PyObject_CallObject callable arglist)
+                :else
+                (py-ffi/PyObject_CallObject callable nil))))]
+      (py-ffi/simplify-or-track retval))))
+
+
+(extend-type Pointer
+  py-proto/PyCall
+  (call [callable arglist kw-arg-map]
+    (call-py-fn callable arglist kw-arg-map py-base/->python))
+  (marshal-return [callable retval] retval))
+
+
+(defn call
+  "Call a python function with positional args.  For keyword args, see call-kw."
+  [callable & args]
+  (py-proto/call callable args nil))
+
+
+(defn call-kw
+  "Call a python function with a vector of positional args and a map of keyword args."
+  [callable arglist kw-args]
+  (py-proto/call callable arglist kw-args))
+
+
+(defn call-attr-kw
+  "Call an object attribute with a vector of positional args and a
+  map of keyword args."
+  [item att-name arglist kw-map arg-converter]
+  (py-ffi/with-gil
+    (if (string? att-name)
+      (py-ffi/with-decref [attval (py-ffi/PyObject_GetAttrString item att-name)]
+        (->> (call-py-fn attval arglist kw-map arg-converter)
+             (py-proto/marshal-return item)))
+      (py-ffi/with-decref
+        [att-name (py-ffi/untracked->python att-name py-base/->python)
+         att-val (py-ffi/untracked->python att-name py-base/->python)]
+        (->> (call-py-fn att-val arglist kw-map arg-converter)
+             (py-proto/marshal-return item))))))
+
+(defn call-attr
+  "Call an object attribute with only positional arguments."
+  [item att-name arglist]
+  (call-attr-kw item att-name arglist nil py-base/->python))
+
+(defn args->pos-kw-args
+  "Utility function that, given a list of arguments, separates them
+  into positional and keyword arguments.  Throws an exception if the
+  keyword argument is not followed by any more arguments."
+  [arglist]
+  (loop [args arglist
+         pos-args []
+         kw-args nil
+         found-kw? false]
+    (if-not (seq args)
+      [pos-args kw-args]
+      (let [arg (first args)
+            [pos-args kw-args args found-kw?]
+            (if (keyword? arg)
+              (if-not (seq (rest args))
+                (throw (Exception.
+                        (format "Keyword arguments must be followed by another arg: %s"
+                                (str arglist))))
+                [pos-args (assoc kw-args arg (first (rest args)))
+                 (drop 2 args) true])
+              (if found-kw?
+                (throw (Exception.
+                        (format "Positional arguments are not allowed after keyword arguments: %s"
+                                arglist)))
+                [(conj pos-args (first args))
+                 kw-args
+                 (rest args) found-kw?]))]
+        (recur args pos-args kw-args found-kw?)))))
+
+
+(defn cfn
+  "Call an object.
+  Arguments are passed in positionally.  Any keyword
+  arguments are paired with the next arg, gathered, and passed into the
+  system as *kwargs.
+
+  Not having an argument after a keyword argument is an error."
+  [item & args]
+  (let [[pos-args kw-args] (args->pos-kw-args args)]
+    (call-kw item pos-args kw-args)))
+
+
+(defn key-sym-str->str
+  [attr-name]
+  (cond
+    (or (keyword? attr-name)
+        (symbol? attr-name))
+    (name attr-name)
+    (string? attr-name)
+    attr-name
+    :else
+    (throw (Exception.
+            "Only keywords, symbols, or strings can be used to access attributes."))))
+
+
+(defn afn
+  "Call an attribute of an object.
+  Arguments are passed in positionally.  Any keyword
+  arguments are paired with the next arg, gathered, and passed into the
+  system as *kwargs.
+
+  Not having an argument after a keyword argument is an error."
+  [item attr & args]
+  (let [[pos-args kw-args] (args->pos-kw-args args)]
+    (call-attr-kw item (key-sym-str->str attr)
+                  pos-args kw-args py-base/->python)))
diff --git a/src/libpython_clj2/python/gc.clj b/src/libpython_clj2/python/gc.clj
new file mode 100644
index 0000000..c68e0e8
--- /dev/null
+++ b/src/libpython_clj2/python/gc.clj
@@ -0,0 +1,85 @@
+(ns libpython-clj2.python.gc
+  "Binding of various sort of gc semantics optimized specifically for
+  libpython-clj."
+  (:import [java.util.concurrent ConcurrentHashMap ConcurrentLinkedDeque]
+           [java.lang.ref ReferenceQueue]
+           [tech.resource GCReference]))
+
+
+(set! *warn-on-reflection* true)
+
+
+(defonce ^:dynamic *stack-gc-context* nil)
+(defn stack-context
+  ^ConcurrentLinkedDeque []
+  *stack-gc-context*)
+
+
+(defonce reference-queue-var (ReferenceQueue.))
+(defn reference-queue
+  ^ReferenceQueue []
+  reference-queue-var)
+
+
+(defonce ptr-set-var (ConcurrentHashMap/newKeySet))
+(defn ptr-set
+  ^java.util.Set []
+  ptr-set-var)
+
+
+(defn track
+  [item dispose-fn]
+  (let [stack-context (stack-context)]
+    (if (= stack-context :disabled)
+      item
+      (let [ptr-val (GCReference. item (reference-queue) (fn [ptr-val]
+                                                           (.remove (ptr-set) ptr-val)
+                                                           (dispose-fn)))]
+        ;;We have to keep track of the pointer.  If we do not the pointer gets gc'd then
+        ;;it will not be put on the reference queue when the object itself is gc'd.
+        ;;Nice little gotcha there.
+        (if stack-context
+          (.add ^ConcurrentLinkedDeque stack-context ptr-val)
+          ;;Ensure we don't lose track of the weak reference.  If it gets cleaned up
+          ;;the gc system will fail.
+          (.add (ptr-set) ptr-val))
+        item))))
+
+
+(defn clear-reference-queue
+  []
+  (when-let [next-ref (.poll (reference-queue))]
+    (.run ^Runnable next-ref)
+    (recur)))
+
+
+(defn clear-stack-context
+  []
+  (when-let [next-ref (.pollLast (stack-context))]
+    (.run ^Runnable next-ref)
+    (recur)))
+
+
+(defmacro with-stack-context
+  [& body]
+  `(with-bindings {#'*stack-gc-context* (ConcurrentLinkedDeque.)}
+     (try
+       ~@body
+       (finally
+         (clear-stack-context)))))
+
+
+(defmacro with-disabled-gc
+  [& body]
+  `(with-bindings {#'*stack-gc-context* :disabled}
+     ~@body))
+
+(defn gc-context
+  []
+  *stack-gc-context*)
+
+
+(defmacro with-gc-context
+  [gc-ctx & body]
+  `(with-bindings {#'*stack-gc-context* ~gc-ctx}
+     ~@body))
diff --git a/src/libpython_clj2/python/info.clj b/src/libpython_clj2/python/info.clj
new file mode 100644
index 0000000..fca3a7d
--- /dev/null
+++ b/src/libpython_clj2/python/info.clj
@@ -0,0 +1,107 @@
+(ns libpython-clj2.python.info
+  "Python system information.  Uses the installed python executable to find out
+  various details about how python is expecting to run."
+  (:require [clojure.java.shell :as sh]
+            [clojure.data.json :as json]
+            [clojure.tools.logging :as log])
+  (:import [java.nio.file Paths]))
+
+
+(def ^:private default-python-executables
+  ["python3" "python3.6" "python3.7" "python3.8" "python3.9" "python"])
+
+
+(defn python-system-info
+  "An information map about the Python system information provided
+  by a Python executable (string).
+
+  :platform (operating system information)
+  :prefix
+  A string giving the site-specific directory prefix where the platform independent Python files are installed; by default, this is the string '/usr/local'. This can be set at build time with the --prefix argument to the configure script. The main collection of Python library modules is installed in the directory prefix/lib/pythonX.Y while the platform independent header files (all except pyconfig.h) are stored in prefix/include/pythonX.Y, where X.Y is the version number of Python, for example 3.2.
+  Note If a virtual environment is in effect, this value will be changed in site.py to point to the virtual environment. The value for the Python installation will still be available, via base_prefix.
+
+  :base-prefix
+  Set during Python startup, before site.py is run, to the same value as prefix. If not running in a virtual environment, the values will stay the same; if site.py finds that a virtual environment is in use, the values of prefix and exec_prefix will be changed to point to the virtual environment, whereas base_prefix and base_exec_prefix will remain pointing to the base Python installation (the one which the virtual environment was created from).
+
+  :executable
+  A string giving the absolute path of the executable binary for the Python interpreter, on systems where this makes sense. If Python is unable to retrieve the real path to its executable, sys.executable will be an empty string or None.
+
+  :exec-prefix
+  A string giving the site-specific directory prefix where the platform-dependent Python files are installed; by default, this is also '/usr/local'. This can be set at build time with the --exec-prefix argument to the configure script. Specifically, all configuration files (e.g. the pyconfig.h header file) are installed in the directory exec_prefix/lib/pythonX.Y/config, and shared library modules are installed in exec_prefix/lib/pythonX.Y/lib-dynload, where X.Y is the version number of Python, for example 3.2.
+  Note If a virtual environment is in effect, this value will be changed in site.py to point to the virtual environment. The value for the Python installation will still be available, via base_exec_prefix.
+
+  :base-exec-prefix
+  Set during Python startup, before site.py is run, to the same value as exec_prefix. If not running in a virtual environment, the values will stay the same; if site.py finds that a virtual environment is in use, the values of prefix and exec_prefix will be changed to point to the virtual environment, whereas base_prefix and base_exec_prefix will remain pointing to the base Python installation (the one which the virtual environment was created from).
+
+  :version
+  (list python-major python-minor python-micro)"
+  [executable]
+  (let [{:keys [out err exit]}
+        (sh/sh executable "-c" "import sys, json;
+print(json.dumps(
+{'platform':          sys.platform,
+  'prefix':           sys.prefix,
+  'base-prefix':      sys.base_prefix,
+  'executable':       sys.executable,
+  'base-exec-prefix': sys.base_exec_prefix,
+  'exec-prefix':      sys.exec_prefix,
+  'version':          list(sys.version_info)[:3]}))")]
+    (when (= 0 exit)
+      (json/read-str out :key-fn keyword))))
+
+
+(defn find-python-info
+  [& [{:keys [python-executable]}]]
+  (->> (concat (when python-executable [python-executable])
+               default-python-executables)
+       (map #(try
+               (python-system-info %)
+               (catch Throwable e nil)))
+       (remove nil?)
+       (first)))
+
+
+(defn find-python-home
+  [system-info & [{:keys [python-home]}]]
+  (cond
+    python-home
+    python-home
+    (seq (System/getenv "PYTHONHOME"))
+    (System/getenv "PYTHONHOME")
+    :else
+    (:prefix system-info)))
+
+
+(defn java-library-path-addendum
+  [system-info & [{:keys [python-home]}]]
+  (when python-home
+    (-> (Paths/get python-home
+                   (into-array String ["lib"]))
+        (.toString))))
+
+
+(defn detect-startup-info
+  [& [{:keys [python-executable library-path] :as options}]]
+  (if python-executable
+    (log/infof "Detecting startup info for Python executable %s" python-executable)
+    (log/info "Detecting startup info"))
+  (let [system-info (find-python-info options)
+        python-home (find-python-home system-info options)
+        java-lib-path (java-library-path-addendum system-info options)
+        [ver-maj ver-med _ver-min] (:version system-info)
+        lib-version                (format "%s.%s" ver-maj ver-med)
+        libname                    (or library-path
+                                       (when (seq lib-version)
+                                         (str "python" lib-version "m")))
+        libnames                   (concat [libname]
+                                           ;;Make sure we try without the 'm' suffix
+                                           (when lib-version
+                                             [(str "python" lib-version)]))]
+    (merge
+     system-info
+     {:python-home                python-home
+      :lib-version                lib-version
+      :libname                    libname
+      :libnames                   libnames}
+     (when java-lib-path
+       {:java-library-path-addendum java-lib-path}))))
diff --git a/src/libpython_clj2/python/io_redirect.clj b/src/libpython_clj2/python/io_redirect.clj
new file mode 100644
index 0000000..5849275
--- /dev/null
+++ b/src/libpython_clj2/python/io_redirect.clj
@@ -0,0 +1,55 @@
+(ns libpython-clj2.python.io-redirect
+  "Implementation of optional io redirection."
+  (:require [libpython-clj2.python.class :as py-class]
+            [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python.bridge-as-python :as py-bridge-py]
+            [libpython-clj2.python.base :as py-base]
+            [libpython-clj2.python.protocols :as py-proto]
+            [libpython-clj2.python.gc :as pygc]
+            [libpython-clj2.python.jvm-handle :as jvm-handle]
+            [clojure.tools.logging :as log])
+  (:import [java.io Writer]))
+
+
+(defn self->writer
+  ^Writer [self]
+  (deref (jvm-handle/py-self->jvm-obj self)))
+
+
+(def writer-cls*
+  (jvm-handle/py-global-delay
+   (py-class/create-class
+    "jvm_io_bridge"
+    nil
+    {"__init__" (py-class/wrapped-jvm-constructor)
+     "__del__" (py-class/wrapped-jvm-destructor)
+     "write" (py-class/make-tuple-instance-fn
+              (fn [self & args]
+                (when (seq args)
+                  (.write (self->writer self) (str
+                                               (py-base/->jvm
+                                                (first args)))))
+                (py-ffi/py-none))
+              {:arg-converter identity})
+     "flush" (py-class/make-tuple-instance-fn
+              (constantly (py-ffi/py-none)))
+     "isatty" (py-class/make-tuple-instance-fn
+               (constantly (py-ffi/py-false)))})))
+
+
+(defn setup-std-writer
+  [writer-var sys-mod-attname]
+  (assert (instance? Writer (deref writer-var)))
+  (py-ffi/with-gil
+    (pygc/with-stack-context
+      (let [sys-module (py-ffi/import-module "sys")
+            std-out-writer (@writer-cls* (jvm-handle/make-jvm-object-handle
+                                          writer-var))]
+        (py-proto/set-attr! sys-module sys-mod-attname std-out-writer)
+        :ok))))
+
+
+(defn redirect-io!
+  []
+  (setup-std-writer #'*err* "stderr")
+  (setup-std-writer #'*out* "stdout"))
diff --git a/src/libpython_clj2/python/jvm_handle.clj b/src/libpython_clj2/python/jvm_handle.clj
new file mode 100644
index 0000000..ec0b153
--- /dev/null
+++ b/src/libpython_clj2/python/jvm_handle.clj
@@ -0,0 +1,69 @@
+(ns libpython-clj2.python.jvm-handle
+  "Conversion of a jvm object into an integer and back.  Used for storing handles
+  on python proxies."
+  (:require [libpython-clj2.python.protocols :as py-proto]
+            [libpython-clj2.python.gc :as pygc])
+  (:import [java.util.concurrent ConcurrentHashMap]
+           [java.util UUID]))
+
+
+(defonce ^{:private true
+           :tag ConcurrentHashMap}
+  jvm-handle-map (ConcurrentHashMap.))
+
+
+(defn identity-hash-code
+  ^long [obj]
+  (long (System/identityHashCode obj)))
+
+
+(defn make-jvm-object-handle
+  ^long [item]
+  (let [^ConcurrentHashMap hash-map jvm-handle-map]
+    (loop [handle (identity-hash-code item)]
+      (if (not (.containsKey hash-map handle))
+        (do
+          (.put hash-map handle item)
+          handle)
+        (recur (.hashCode (UUID/randomUUID)))))))
+
+
+(defn get-jvm-object
+  [handle]
+  (.get ^ConcurrentHashMap jvm-handle-map (long handle)))
+
+
+(defn remove-jvm-object
+  [handle]
+  (.remove ^ConcurrentHashMap jvm-handle-map (long handle))
+  nil)
+
+
+(defn py-self->jvm-handle
+  ^long [self]
+  (long (py-proto/get-attr self "jvm_handle")))
+
+
+(defn py-self->jvm-obj
+  ^Object [self]
+  (-> (py-self->jvm-handle self)
+      get-jvm-object))
+
+
+(defn py-self-set-jvm-handle!
+  [self hdl]
+  (py-proto/set-attr! self "jvm_handle" (long hdl))
+  nil)
+
+
+(defmacro py-global-delay
+  "Create a delay object that uses only gc reference semantics.  If stack reference
+  semantics happen to be in effect when this delay executes the object may still be
+  reachable by your program when it's reference counts are released leading to
+  bad/crashy behavior.  This ensures that can't happen at the cost of possibly an object
+  sticking around."
+  [& body]
+  `(delay
+     (py-ffi/with-gil
+       (with-bindings {#'pygc/*stack-gc-context* nil}
+         ~@body))))
diff --git a/src/libpython_clj2/python/np_array.clj b/src/libpython_clj2/python/np_array.clj
new file mode 100644
index 0000000..51e09f2
--- /dev/null
+++ b/src/libpython_clj2/python/np_array.clj
@@ -0,0 +1,198 @@
+(ns libpython-clj2.python.np-array
+  "Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  allows seamless usage of numpy arrays in datatype and tensor functionality such as
+  enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
+  zero copying when possible.
+
+  All users need to do is call require this namespace; then as-jvm will convert a numpy
+  array into a tech tensor in-place."
+  (:require [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python.fn :as py-fn]
+            [libpython-clj2.python.protocols :as py-proto]
+            [libpython-clj2.python.copy :as py-copy]
+            [libpython-clj2.python.bridge-as-jvm :as py-bridge]
+            [libpython-clj2.python.base :as py-base]
+            [libpython-clj2.python.gc :as pygc]
+            [tech.v3.tensor :as dtt]
+            [tech.v3.datatype.protocols :as dtype-proto]
+            [tech.v3.datatype.casting :as casting]
+            [tech.v3.datatype.argops :as argops]
+            [tech.v3.datatype :as dtype]
+            [clojure.set :as set])
+  (:import [tech.v3.datatype NDBuffer]))
+
+
+(def py-dtype->dtype-map
+  (->> (concat (for [bit-width [8 16 32 64]
+                     unsigned? [true false]]
+                 (str (if unsigned?
+                        "uint"
+                        "int")
+                      bit-width))
+               ["float32" "float64"])
+       (map (juxt identity keyword))
+       (into {})))
+
+
+(def dtype->py-dtype-map
+  (set/map-invert py-dtype->dtype-map))
+
+
+(defn obj-dtype->dtype
+  [py-dtype]
+  (when-let [fields (py-proto/get-attr py-dtype "fields")]
+    (throw (ex-info (format "Cannot convert numpy object with fields: %s"
+                            (py-fn/call-attr fields "__str__" nil))
+                    {})))
+  (if-let [retval (->> (py-proto/get-attr py-dtype "name")
+                       (get py-dtype->dtype-map))]
+    retval
+    (throw (ex-info (format "Unable to find datatype: %s"
+                            (py-proto/get-attr py-dtype "name"))
+                    {}))))
+
+
+(defn numpy->desc
+  [np-obj]
+  (py-ffi/with-gil
+    (let [ctypes (py-proto/as-jvm (py-proto/get-attr np-obj "ctypes") {})
+          np-dtype (-> (py-proto/as-jvm (py-proto/get-attr np-obj "dtype") {})
+                       (obj-dtype->dtype))
+          shape (-> (py-proto/get-attr ctypes "shape")
+                    (py-bridge/generic-python-as-list)
+                    vec)
+          strides (-> (py-proto/get-attr ctypes "strides")
+                      (py-bridge/generic-python-as-list)
+                      vec)
+          long-addr (py-proto/get-attr ctypes "data")]
+      {:ptr long-addr
+       :elemwise-datatype np-dtype
+       :shape shape
+       :strides strides
+       :type :numpy
+       :ctypes ctypes})))
+
+
+(defmethod py-proto/pyobject->jvm :ndarray
+  [pyobj opts]
+  (pygc/with-stack-context
+    (-> (numpy->desc pyobj)
+        (dtt/nd-buffer-descriptor->tensor)
+        (dtt/clone))))
+
+
+(defmethod py-proto/pyobject-as-jvm :ndarray
+  [pyobj opts]
+  (py-bridge/bridge-pyobject
+   pyobj
+   Iterable
+   (iterator [this] (py-bridge/python->jvm-iterator pyobj py-base/as-jvm))
+   dtype-proto/PToTensor
+   (as-tensor [item]
+              (-> (numpy->desc item)
+                  (dtt/nd-buffer-descriptor->tensor)))
+   dtype-proto/PElemwiseDatatype
+   (elemwise-datatype
+    [this]
+    (py-ffi/with-gil
+      (-> (py-proto/get-attr pyobj "dtype")
+          (py-proto/as-jvm {})
+          (obj-dtype->dtype))))
+   dtype-proto/PECount
+   (ecount [this] (apply * (dtype-proto/shape this)))
+
+   dtype-proto/PShape
+   (shape
+    [this]
+    (py-ffi/with-gil
+      (-> (py-proto/get-attr pyobj "shape")
+          (py-proto/->jvm {}))))
+
+   dtype-proto/PToNativeBuffer
+   (convertible-to-native-buffer? [item] true)
+   (->native-buffer
+    [item]
+    (py-ffi/with-gil
+      (dtype-proto/->native-buffer
+       (dtype-proto/as-tensor item))))
+
+   dtype-proto/PSubBuffer
+   (sub-buffer
+    [buffer offset length]
+    (py-ffi/with-gil
+      (-> (dtype-proto/as-tensor buffer)
+          (dtype-proto/sub-buffer offset length))))
+
+   dtype-proto/PToNDBufferDesc
+   (convertible-to-nd-buffer-desc? [item] true)
+   (->nd-buffer-descriptor
+    [item]
+    (py-ffi/with-gil
+      (numpy->desc item)))))
+
+
+(defn datatype->ptr-type-name
+  [dtype]
+  (case dtype
+    :int8 "c_byte"
+    :uint8 "c_ubyte"
+    :int16 "c_short"
+    :uint16 "c_ushort"
+    :int32 "c_long"
+    :uint32 "c_ulong"
+    :int64 "c_longlong"
+    :uint64 "c_ulonglong"
+    :float32 "c_float"
+    :float64 "c_double"))
+
+
+(defn descriptor->numpy
+  [{:keys [ptr shape strides elemwise-datatype] :as buffer-desc}]
+  (py-ffi/with-gil
+    (let [stride-tricks (-> (py-ffi/import-module "numpy.lib.stride_tricks")
+                            (py-base/as-jvm))
+          ctypes (-> (py-ffi/import-module "ctypes")
+                     (py-base/as-jvm))
+          np-ctypes (-> (py-ffi/import-module "numpy.ctypeslib")
+                        (py-base/as-jvm))
+          dtype-size (casting/numeric-byte-width elemwise-datatype)
+          max-stride-idx (argops/argmax strides)
+          buffer-len (* (long (dtype/get-value shape max-stride-idx))
+                        (long (dtype/get-value strides max-stride-idx)))
+          n-elems (quot buffer-len dtype-size)
+          lvalue (long ptr)
+          void-p (py-fn/call-attr ctypes "c_void_p" [lvalue])
+          actual-ptr (py-fn/call-attr
+                      ctypes "cast"
+                      [void-p
+                       (py-fn/call-attr
+                        ctypes "POINTER"
+                        [(py-proto/get-attr
+                          ctypes
+                          (datatype->ptr-type-name elemwise-datatype))])])
+
+          initial-buffer (py-fn/call-attr
+                          np-ctypes "as_array"
+                          [actual-ptr (py-copy/->py-tuple [n-elems])])
+
+          retval (py-fn/call-attr stride-tricks "as_strided"
+                                  [initial-buffer
+                                   (py-copy/->py-tuple shape)
+                                   (py-copy/->py-tuple strides)])]
+      ;;Ensure we have metadata that allows the GC to track both buffer
+      ;;desc and retval
+      (vary-meta retval assoc
+                 :nd-buffer-descriptor buffer-desc))))
+
+
+;;Efficient conversion from jvm to python
+(extend-type NDBuffer
+  py-proto/PCopyToPython
+  (->python [item opts]
+    (-> (dtt/ensure-nd-buffer-descriptor item)
+        (descriptor->numpy)))
+  py-proto/PBridgeToJVM
+  (as-python [item opts]
+    (when (dtype-proto/convertible-to-nd-buffer-desc? item)
+      (-> (dtype-proto/->nd-buffer-descriptor item)
+          (descriptor->numpy)))))
diff --git a/src/libpython_clj2/python/protocols.clj b/src/libpython_clj2/python/protocols.clj
new file mode 100644
index 0000000..77e3233
--- /dev/null
+++ b/src/libpython_clj2/python/protocols.clj
@@ -0,0 +1,91 @@
+(ns libpython-clj2.python.protocols
+  "Internal protocols to libpython-clj.  These allow a dual system where raw pointers
+  work with copying pathways and bridged objects work with bridging pathways."
+  (:require [libpython-clj2.python.ffi :as py-ffi]
+            [tech.v3.datatype :as dtype]))
+
+
+(defprotocol PPythonType
+  (get-python-type [item]
+    "Return a keyword that describes the python datatype of this object."))
+
+
+(defn python-type
+  "Return a keyword that describes the python datatype of this object."
+  ([item]
+   (if item
+     (get-python-type item)
+     :none-type))
+  ([item options]
+   (python-type item)))
+
+
+(defmulti pyobject-as-jvm
+  "Convert (possibly bridge) a pyobject to the jvm"
+  python-type)
+
+
+(defprotocol PCopyToPython
+  (->python [item options]
+    "Copy this item into a python representation.  Must never return nil.
+Items may fallback to as-python if copying is untenable."))
+
+
+(defprotocol PBridgeToPython
+  (as-python [item options]
+    "Aside from atom types, this means the object represented by a zero copy python
+    mirror.  May return nil.  This convertible to pointers get converted
+    to numpy implementations that share the backing store."))
+
+
+(defprotocol PCopyToJVM
+  (->jvm [item options]
+    "Copy the python object into the jvm leaving no references.  This not copying
+are converted into a {:type :pyobject-address} pairs."))
+
+
+(defprotocol PBridgeToJVM
+  (as-jvm [item options]
+    "Return a pyobject implementation that wraps the python object."))
+
+
+(defprotocol PPyDir
+  (dir [item]
+    "Get sorted list of all attribute names."))
+
+
+(defprotocol PPyAttr
+  (has-attr? [item item-name] "Return true of object has attribute")
+  (get-attr [item item-name] "Get attribute from object")
+  (set-attr! [item item-name item-value] "Set attribute on object"))
+
+
+(defprotocol PPyCallable
+  (callable? [item] "Return true if object is a python callable object."))
+
+
+(defprotocol PyCall
+  (call [callable arglist kw-arg-map])
+  (marshal-return [callable retval]))
+
+
+(defprotocol PPyItem
+  (has-item? [item item-name] "Return true of object has item")
+  (get-item [item item-name] "Get an item of a given name from an object")
+  (set-item! [item item-name item-value] "Set an item of to a value"))
+
+
+(defmulti pyobject->jvm
+  "Copy a python object to the jvm based on its python type"
+  python-type)
+
+
+(defmulti pyobject-as-jvm
+  "Bridge a python object to the jvm based on its python type"
+  python-type)
+
+
+(defmulti pydatafy
+  "Datafy a python object.  The metadata namespace must be loaded in order
+  to datafy a python object."
+  python-type)
diff --git a/src/libpython_clj/python/windows.clj b/src/libpython_clj2/python/windows.clj
similarity index 83%
rename from src/libpython_clj/python/windows.clj
rename to src/libpython_clj2/python/windows.clj
index d9ad4bf..60f88ec 100644
--- a/src/libpython_clj/python/windows.clj
+++ b/src/libpython_clj2/python/windows.clj
@@ -1,6 +1,6 @@
-(ns libpython-clj.python.windows
-  (:require [libpython-clj.python.interop :refer [run-simple-string]]
-            [clojure.java.shell :refer [sh]]
+(ns libpython-clj2.python.windows
+  "Windows-specific functionality so that the system works with Anaconda."
+  (:require [clojure.java.shell :refer [sh]]
             [clojure.java.io :as io]
             [clojure.string :as s]))
 
@@ -31,7 +31,8 @@
       "path = '" quoted "';\n"
       "os.environ['PATH'] = path;\n")))
 
-(defn setup-windows-conda! [windows-conda-activate-bat]
+(defn setup-windows-conda! [windows-conda-activate-bat
+                            run-simple-string]
   "Setup python PATH environment variable like in anaconda to be able to load native dlls for numpy etc. like anaconda does."
   (let [echo-bat (create-echo-path-bat!)]
     (->> (get-windows-anaconda-env-path
@@ -40,4 +41,3 @@
          generate-python-set-env-path
          run-simple-string)
     (delete-echo-path-bat! echo-bat)))
-
diff --git a/src/libpython_clj2/python/with.clj b/src/libpython_clj2/python/with.clj
new file mode 100644
index 0000000..6b45dce
--- /dev/null
+++ b/src/libpython_clj2/python/with.clj
@@ -0,0 +1,63 @@
+(ns libpython-clj2.python.with
+  "Implementation of the python 'with' keyword"
+  (:require [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python.protocols :as py-proto]
+            [libpython-clj2.python.fn :as py-fn]
+            [tech.v3.datatype.ffi :as dt-ffi])
+  (:import [tech.v3.datatype.ffi Pointer]))
+
+
+(defn python-pyerr-fetch-error-handler
+  "Utility code used in with macro"
+  []
+  (py-ffi/check-gil)
+  (throw (ex-info "python error in flight"
+                  (py-ffi/fetch-normalize-exception))))
+
+
+(defn with-exit-error-handler
+  "Utility code used in with macro"
+  [with-var error]
+  (let [einfo (ex-data error)]
+    (if (every? #(contains? einfo %) [:type :value :traceback])
+      (let [{^Pointer ptype :type
+             ^Pointer pvalue :value
+             ^Pointer ptraceback :traceback} einfo
+            suppress-error? (py-fn/call-attr with-var "__exit__"
+                                             [ptype
+                                              pvalue
+                                              ptraceback])]
+        (if (and ptype pvalue ptraceback (not suppress-error?))
+          (do
+            ;;Manual incref here because we cannot detach the object
+            ;;from our gc decref hook added during earlier pyerr-fetch handler.
+            (py-ffi/PyErr_Restore ptype pvalue ptraceback)
+            (py-ffi/check-error-throw))
+          (do
+            (when ptype (py-ffi/Py_DecRef ptype))
+            (when pvalue (py-ffi/Py_DecRef pvalue))
+            (when ptraceback (py-ffi/Py_DecRef ptraceback)))))
+      (do
+        (py-fn/call-attr with-var "__exit__" [nil nil nil])
+        (throw error)))))
+
+
+(defmacro with
+  "Support for the 'with' statement in python:
+  (py/with [item (py/call-attr testcode-module \"WithObjClass\" true fn-list)]
+      (py/call-attr item \"doit_err\"))"
+  [bind-vec & body]
+  (when-not (= 2 (count bind-vec))
+    (throw (Exception. "Bind vector must have 2 items")))
+  (let [varname (first bind-vec)]
+    `(py-ffi/with-gil
+       (let [~@bind-vec]
+         (with-bindings
+           {#'py-ffi/*python-error-handler* python-pyerr-fetch-error-handler}
+           (py-fn/call-attr ~varname "__enter__" nil)
+           (try
+             (let [retval# (do ~@body)]
+               (py-fn/call-attr ~varname "__exit__" [nil nil nil])
+               retval#)
+             (catch Throwable e#
+               (with-exit-error-handler ~varname e#))))))))
diff --git a/src/libpython_clj/require.clj b/src/libpython_clj2/require.clj
similarity index 92%
rename from src/libpython_clj/require.clj
rename to src/libpython_clj2/require.clj
index 606dc86..e60657c 100644
--- a/src/libpython_clj/require.clj
+++ b/src/libpython_clj2/require.clj
@@ -1,20 +1,12 @@
-(ns libpython-clj.require
+(ns libpython-clj2.require
   "Namespace implementing requiring python modules as Clojure namespaces.  This works via
   scanning the module for metadata and dynamically building the Clojure namespace."
   (:refer-clojure :exclude [fn? doc])
-  (:require [libpython-clj.python :as py]
-            [libpython-clj.metadata :as pymeta]
+  (:require [libpython-clj2.python :as py]
+            [libpython-clj2.metadata :as pymeta]
             [clojure.datafy :refer [datafy nav]]
-            ;;Binds datafy/nav to python objects
-            [libpython-clj.metadata :as metadata]
             [clojure.tools.logging :as log]
-            [libpython-clj.python.protocols :as py-proto]
-            [clojure.core.protocols :as clj-proto])
-  (:import [libpython_clj.python.protocols PPyObject PBridgeToJVM]))
-
-;; for hot reloading multimethod in development
-(ns-unmap 'libpython-clj.require 'intern-ns-class)
-(ns-unmap *ns* 'pydafy)
+            [clojure.core.protocols :as clj-proto]))
 
 
 (defn- parse-flags
@@ -130,7 +122,7 @@
         (intern
          (symbol (str *ns*))
          (with-meta (symbol import-name)
-           {:file (metadata/find-file pyobj)
+           {:file (pymeta/find-file pyobj)
             :line 1})
          pyobj)))
 
@@ -270,16 +262,17 @@
 
    (require-python '[operators :refer :*])"
   ([req]
-   (cond
-     (list? req) ;; prefix list
-     (let [prefix-lists (req-transform req)]
-       (doseq [req prefix-lists] (require-python req)))
-     (symbol? req)
-     (require-python (vector req))
-     (vector? req)
-     (do-require-python req)
-     :else
-     (throw (Exception. "Invalid argument: %s" req)))
+   (py/with-gil
+     (cond
+       (list? req) ;; prefix list
+       (let [prefix-lists (req-transform req)]
+         (doseq [req prefix-lists] (require-python req)))
+       (symbol? req)
+       (require-python (vector req))
+       (vector? req)
+       (do-require-python req)
+       :else
+       (throw (Exception. "Invalid argument: %s" req))))
    :ok)
   ([req & reqs]
    (require-python req)
@@ -335,25 +328,25 @@
 
 
 (defmethod pydafy :default [x]
-  (if (metadata/pyclass? x)
-    (metadata/datafy-module x)
+  (if (pymeta/pyclass? x)
+    (pymeta/datafy-module-or-class x)
     (throw (ex-info (str "datafy not implemented for " (pytype x))
                     {:type (pytype x)}))))
 
 
 (defmethod pynav :default [x]
-  (if (metadata/pyclass? x)
-    (metadata/nav-module x)
+  (if (pymeta/pyclass? x)
+    (pymeta/nav-module x)
     (throw (ex-info (str "nav not implemented for " (pytype x))
                     {:type (pytype x)}))))
 
 
 (defmethod pydafy 'builtins.module [m]
-  (metadata/datafy-module m))
+  (pymeta/datafy-module-or-class m))
 
 
 (defmethod pynav 'builtins.module [coll k v]
-  (metadata/nav-module coll k v))
+  (pymeta/nav-module coll k v))
 
 
 (defmethod pydafy 'builtins.dict [x]
@@ -397,6 +390,3 @@
               (datafy [item#] (py-datafy item#))
               clj-proto/Navigable
               (nav [coll# k# v#] (py-nav coll# k# v#))))))
-
-
-(pydatafy PPyObject PBridgeToJVM)
diff --git a/src/libpython_clj/sugar.clj b/src/libpython_clj2/sugar.clj
similarity index 90%
rename from src/libpython_clj/sugar.clj
rename to src/libpython_clj2/sugar.clj
index 5972ca5..6d2fa0f 100644
--- a/src/libpython_clj/sugar.clj
+++ b/src/libpython_clj2/sugar.clj
@@ -1,5 +1,7 @@
-(ns libpython-clj.sugar
-  (:require [libpython-clj.python :as py]))
+(ns libpython-clj2.sugar
+  (:require [libpython-clj2.python :as py]))
+
+(py/initialize!)
 
 
 (let [{{:strs [pyxfn]} :globals}
diff --git a/test/libpython_clj/classes_test.clj b/test/libpython_clj/classes_test.clj
deleted file mode 100644
index 9ce4a32..0000000
--- a/test/libpython_clj/classes_test.clj
+++ /dev/null
@@ -1,52 +0,0 @@
-(ns libpython-clj.classes-test
-  (:require [libpython-clj.python :as py]
-            [clojure.test :refer :all]
-            [clojure.edn :as edn]))
-
-
-(py/initialize!)
-
-
-(deftest new-cls-test
-  ;;The crux of this is making instance functions.  The make-tuple-instance-fn pathway
-  ;;is pretty close to the metal and as such it does no marshalling of parameters by
-  ;;default.  You can turn on marshalling of all parameters adding `arg-converter`
-  ;;optional argument (this may make your life easier) or you can marshal just the
-  ;;parameter you have to (self in the examples below).
-  (let [cls-obj (py/create-class
-                 "Stock" nil
-                 {"__init__" (py/make-tuple-instance-fn
-                              (fn [self name shares price]
-                                ;;Because we did not use an arg-converter, all the
-                                ;;arguments above are raw jna Pointers - borrowed
-                                ;;references.
-                                (py/set-attrs! self {"name" name
-                                                     "shares" shares
-                                                     "price" price})
-                                ;;If you don't return nil from __init__ that is an
-                                ;;error.
-                                nil))
-                  "cost" (py/make-tuple-instance-fn
-                          (fn [self]
-                            (* (py/$. self shares)
-                               (py/$. self price)))
-
-                          ;;Convert self to something that auto-marshals things.
-                          ;;This pathway will autoconvert all arguments to the function.
-                          :arg-converter py/as-jvm
-                          :method-name "cost")
-                  "__str__" (py/make-tuple-instance-fn
-                             (fn [self]
-                               ;;Alternative to using arg-converter.  This way you can
-                               ;;explicitly control which arguments are converted.
-                               (let [self (py/as-jvm self)]
-                                 (pr-str {"name" (py/$. self name)
-                                          "shares" (py/$. self shares)
-                                          "price" (py/$. self price)}))))
-                  "clsattr" 55})
-        new-instance (cls-obj "ACME" 50 90)]
-    (is (= 4500
-           (py/$a new-instance cost)))
-    (is (= 55 (py/$. new-instance clsattr)))
-    (is (= {"name" "ACME", "shares" 50, "price" 90}
-           (edn/read-string (.toString new-instance))))))
diff --git a/test/libpython_clj2/classes_test.clj b/test/libpython_clj2/classes_test.clj
new file mode 100644
index 0000000..600229d
--- /dev/null
+++ b/test/libpython_clj2/classes_test.clj
@@ -0,0 +1,42 @@
+(ns libpython-clj2.classes-test
+  (:require [libpython-clj2.python :as py]
+            [clojure.test :refer :all]
+            [clojure.edn :as edn]))
+
+
+(py/initialize!)
+
+
+(deftest new-cls-test
+  ;;The crux of this is making instance functions to get the 'self' parameter
+  ;;passed in.
+  (let [cls-obj (py/create-class
+                 "Stock" nil
+                 {"__init__" (py/make-instance-fn
+                              (fn [self name shares price]
+                                ;;Because we did not use an arg-converter, all the
+                                ;;arguments above are raw jna Pointers - borrowed
+                                ;;references.
+                                (py/set-attrs! self {"name" name
+                                                     "shares" shares
+                                                     "price" price})
+                                ;;If you don't return nil from __init__ that is an
+                                ;;error.
+                                nil))
+                  "cost" (py/make-instance-fn
+                          (fn [self]
+                            (* (py/py.- self shares)
+                               (py/py.- self price)))
+                          {:name "cost"})
+                  "__str__" (py/make-instance-fn
+                             (fn [self]
+                               (pr-str {"name" (py/py.- self name)
+                                        "shares" (py/py.- self shares)
+                                        "price" (py/py.- self price)})))
+                  "clsattr" 55})
+        new-instance (cls-obj "ACME" 50 90)]
+    (is (= 4500
+           (py/$a new-instance cost)))
+    (is (= 55 (py/py.- new-instance clsattr)))
+    (is (= {"name" "ACME", "shares" 50, "price" 90}
+           (edn/read-string (.toString new-instance))))))
diff --git a/test/libpython_clj2/ffi_test.clj b/test/libpython_clj2/ffi_test.clj
new file mode 100644
index 0000000..f28f83c
--- /dev/null
+++ b/test/libpython_clj2/ffi_test.clj
@@ -0,0 +1,36 @@
+(ns libpython-clj2.ffi-test
+  "Short low level tests used to verify specific aspects of ffi integration"
+  (:require [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python :as py]
+            [libpython-clj2.python.protocols :as py-proto]
+            [libpython-clj2.python.fn :as py-fn]
+            [clojure.test :refer [deftest is]]))
+
+
+(py/initialize!)
+
+
+(deftest module-type-name-test
+  (py-ffi/with-gil
+    (let [main-mod (py-ffi/PyImport_AddModule "__main__")
+          mod-type (py-ffi/pyobject-type main-mod)
+          mod-name (py-ffi/pytype-name mod-type)]
+      (is (= "module" mod-name)))))
+
+
+(deftest pydir-basic
+  (py-ffi/with-gil
+   (let [main-mod (py-ffi/PyImport_AddModule "__main__")
+         dirdata (py-proto/dir main-mod)]
+     (is (>= (count dirdata) 7)))))
+
+
+(deftest error-handling
+  (py-ffi/with-gil
+    (is (thrown? Exception (py-ffi/run-simple-string "data = 1 +")))))
+
+
+(deftest clj-fn
+  (py-ffi/with-gil
+    (let [pfn (py-fn/make-tuple-fn #(+ %1 %2))]
+      (is (= 3 (py-fn/call pfn 1 2))))))
diff --git a/test/libpython_clj/fncall_test.clj b/test/libpython_clj2/fncall_test.clj
similarity index 82%
rename from test/libpython_clj/fncall_test.clj
rename to test/libpython_clj2/fncall_test.clj
index aa43dfd..974b697 100644
--- a/test/libpython_clj/fncall_test.clj
+++ b/test/libpython_clj2/fncall_test.clj
@@ -1,17 +1,13 @@
-(ns libpython-clj.fncall-test
-  (:require [libpython-clj.python :as py]
+(ns libpython-clj2.fncall-test
+  (:require [libpython-clj2.python :as py]
             [clojure.test :refer :all]))
 
 
 (py/initialize!)
 
-
-(py/import-as testcode testmod)
-(py/from-import inspect getfullargspec)
-
 (deftest complex-fn-test
   (let [testmod (py/import-module "testcode")
-        testcases (py/$. testmod complex_fn_testcases)]
+        testcases (py/py.- testmod complex_fn_testcases)]
     (is (= (-> (get testcases "complex_fn(1, 2, c=10, d=10, e=10)")
                (py/->jvm))
            (-> (py/$a testmod complex_fn 1 2 :c 10 :d 10 :e 10)
@@ -20,7 +16,6 @@
                (py/->jvm))
            (-> (py/$a testmod complex_fn 1 2 10 11 12 :d 10 :e 10)
                (py/->jvm))))
-
     (is (= (-> (get testcases "complex_fn(1, 2, c=10, d=10, e=10)")
                (py/->jvm))
            (-> (apply py/afn testmod "complex_fn" [1 2 :c 10 :d 10 :e 10])
diff --git a/test/libpython_clj/iter_gen_seq_test.clj b/test/libpython_clj2/iter_gen_seq_test.clj
similarity index 83%
rename from test/libpython_clj/iter_gen_seq_test.clj
rename to test/libpython_clj2/iter_gen_seq_test.clj
index dfa8006..4976885 100644
--- a/test/libpython_clj/iter_gen_seq_test.clj
+++ b/test/libpython_clj2/iter_gen_seq_test.clj
@@ -1,8 +1,8 @@
-(ns libpython-clj.iter-gen-seq-test
+(ns libpython-clj2.iter-gen-seq-test
   "Iterators/sequences and such are crucial to handling lots of forms
   of data and thus they have to work correctly between the languages."
-  (:require [libpython-clj.python :as py]
-            [libpython-clj.require :refer [require-python]]
+  (:require [libpython-clj2.python :as py]
+            [libpython-clj2.require :refer [require-python]]
             [clojure.test :refer :all]))
 
 
diff --git a/test/libpython_clj/python/numpy_test.clj b/test/libpython_clj2/numpy_test.clj
similarity index 79%
rename from test/libpython_clj/python/numpy_test.clj
rename to test/libpython_clj2/numpy_test.clj
index f6856ae..91d409c 100644
--- a/test/libpython_clj/python/numpy_test.clj
+++ b/test/libpython_clj2/numpy_test.clj
@@ -1,10 +1,9 @@
-(ns libpython-clj.python.numpy-test
+(ns libpython-clj2.numpy-test
   (:require [clojure.test :refer [deftest is]]
-            [libpython-clj.python :as py]
+            [libpython-clj2.python :as py]
             [tech.v3.datatype :as dtype]
             [tech.v3.datatype.functional :as dfn]
-            [tech.v3.tensor :as dtt])
-  (:import [com.sun.jna Pointer]))
+            [tech.v3.tensor :as dtt]))
 
 (py/initialize!)
 
diff --git a/test/libpython_clj/python_test.clj b/test/libpython_clj2/python_test.clj
similarity index 79%
rename from test/libpython_clj/python_test.clj
rename to test/libpython_clj2/python_test.clj
index 6a4cb0a..e12766e 100644
--- a/test/libpython_clj/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -1,16 +1,25 @@
-(ns libpython-clj.python-test
-  (:require [libpython-clj.python :as py :refer [py. py.. py.- py* py**]]
-            [libpython-clj.jna :as libpy]
+(ns libpython-clj2.python-test
+  (:require [libpython-clj2.python :as py :refer [py. py.. py.- py* py**]]
+            ;;support for tensor/numpy integration
+            [libpython-clj2.python.np-array]
+            [libpython-clj2.python.ffi :as py-ffi]
             [tech.v3.datatype :as dtype]
             [tech.v3.datatype.functional :as dfn]
+            [tech.v3.datatype.ffi :as dt-ffi]
             [tech.v3.tensor :as dtt]
-            [tech.v3.jna :as jna]
             [clojure.test :refer :all])
   (:import [java.io StringWriter]
            [java.util Map List]
-           [com.sun.jna Pointer]))
+           [tech.v3.datatype.ffi Pointer]))
+
 
 (py/initialize!)
+;; Useful to see how many times we convert a string to a python object.
+;; (dt-ffi/enable-string->c-stats!)
+;; (.addShutdownHook (Runtime/getRuntime) (Thread.
+;;                                         (fn []
+;;                                           (clojure.pprint/pprint
+;;                                            (dt-ffi/string->c-data-histogram)))))
 
 (deftest stdout-and-stderr
   (is (= "hey\n" (with-out-str
@@ -23,27 +32,27 @@
   (is (thrown? Throwable (py/run-simple-string "import sys\nprint('hey', stderr"))))
 
 (deftest dicts
-  (let [py-dict (py/->python {:a 1 :b 2})]
-    (is (= :dict (py/python-type py-dict)))
-    (is (= 2 (-> (py/call-attr py-dict "__len__")
-                 (py/->jvm))))
-    (is (= {"a" 1 "b" 2}
-           (->> (py/->jvm py-dict)
-                (into {}))))
-    (let [bridge-dict (py/as-jvm py-dict)]
-      (is (instance? Map bridge-dict))
-      (is (= #{"a" "b"} (->> (keys bridge-dict)
-                             set)))
-      (is (= #{1 2} (->> (vals bridge-dict)
-                         set)))
+  (py/with-gil-stack-rc-context
+    (let [py-dict (py/->python {:a 1 :b 2})]
+      (is (= :dict (py/python-type py-dict)))
+      (is (= 2 (-> (py/call-attr py-dict "__len__")
+                   (py/->jvm))))
       (is (= {"a" 1 "b" 2}
-             (into {} bridge-dict))))))
+             (->> (py/->jvm py-dict)
+                  (into {}))))
+      (let [bridge-dict (py/as-jvm py-dict)]
+        (is (instance? Map bridge-dict))
+        (is (= #{"a" "b"} (->> (keys bridge-dict)
+                               set)))
+        (is (= #{1 2} (->> (vals bridge-dict)
+                           set)))
+        (is (= {"a" 1 "b" 2}
+               (into {} bridge-dict)))))))
 
 (deftest lists
   (let [py-list (py/->py-list [4 3 2 1])]
     (is (= :list (py/python-type py-list)))
-    (is (= 4 (-> (py/call-attr py-list "__len__")
-                 (py/->jvm))))
+    (is (= 4 (py/call-attr py-list "__len__")))
     (is (= [4 3 2 1]
            (->> (py/->jvm py-list)
                 (into []))))
@@ -67,14 +76,12 @@
     (py/run-simple-string "item3 = item + item2")
     (is (= 300 (globals "item3")))))
 
+
 (deftest numpy-and-back
   (let [jvm-tens (dtt/->tensor (->> (range 9)
                                     (partition 3))
                                :datatype :float64)]
-    ;;zero-copy can't work on jvm datastructures with current JNA tech.
-    ;;IT would require 'pinning' which isn't yet available.
-    (is (nil? (py/as-numpy jvm-tens)))
-    (let [py-tens (py/->numpy jvm-tens)]
+    (let [py-tens (py/->python jvm-tens)]
       (is (= [[0.0 1.0 2.0] [3.0 4.0 5.0] [6.0 7.0 8.0]]
              (-> (dtt/as-tensor py-tens)
                  dtt/->jvm)))
@@ -192,41 +199,6 @@
         bridged (py/as-jvm dict)]
     (is (= nil (bridged nil)))))
 
-(deftest custom-clojure-item
-  (let [att-map {"clojure_fn" (py/->python #(vector 1 2 3))}
-        my-python-item (py/create-bridge-from-att-map
-                        ;;First is the jvm object that this bridge stands for.  If this
-                        ;;gets garbage collected then the python side will be removed
-                        ;;also.
-                        att-map
-                        ;;second is the list of attributes.  In this case, since this
-                        ;;object isn't iterable or anything, this function will do.
-                        att-map)
-        py-mod (py/import-module "testcode")]
-    (is (= [1 2 3]
-           (py/call-attr py-mod "calling_custom_clojure_fn" my-python-item)))
-
-    ;;Now this case is harder.  Let's say we have something that is iterable and we
-    ;;want this to be reflected in python.  In that case we have to call 'as-python'
-    ;;on the iterator and that 'should' work.
-
-    (let [my-obj (reify
-                   Iterable
-                   (iterator [this] (.iterator [4 5 6])))
-          ;;Note that attributes themselves have to be python objects and wrapping
-          ;;this with as-python makes that function wrap whatever it returns in a
-          ;;bridging python object also.
-          att-map {"__iter__" (py/as-python #(.iterator my-obj))}
-          my-python-item (py/create-bridge-from-att-map
-                          my-obj
-                          ;;second is the list of attributes.  In this case, since this
-                          ;;object isn't iterable or anything, this function will do.
-                          att-map)]
-      (is (= [4 5 6]
-             (vec my-obj)))
-      (is (= [4 5 6]
-             (vec (py/call-attr py-mod "for_iter" my-python-item)))))))
-
 (deftest bridged-dict-to-jvm
   (let [py-dict (py/->py-dict {:a 1 :b 2})
         bridged (py/as-jvm py-dict)
@@ -235,21 +207,21 @@
 
 (deftest calling-conventions
   (let [np (py/import-module "numpy")
-        linspace (py/$. np linspace)]
+        linspace (py/py.. np -linspace)]
 
     (is (dfn/equals [2.000 2.250 2.500 2.750 3.000]
                     (dtt/as-tensor (linspace 2 3 :num 5))))
     (is (dfn/equals [2.000 2.250 2.500 2.750 3.000]
-                    (dtt/as-tensor (py/c$ linspace 2 3 :num 5))))
+                    (dtt/as-tensor (py/$c linspace 2 3 :num 5))))
     (is (dfn/equals [2.000 2.250 2.500 2.750 3.000]
-                    (dtt/as-tensor (py/a$ np linspace 2 3 :num 5))))))
+                    (dtt/as-tensor (py/$a np linspace 2 3 :num 5))))))
 
 (deftest syntax-sugar
   (py/initialize!)
   (let [np (py/import-module "numpy")]
-    (is (= (str (py/$. np linspace))
+    (is (= (str (py/py.- np linspace))
            (str (py/get-attr np "linspace"))))
-    (is (= (str (py/$.. np random shuffle))
+    (is (= (str (py/py.. np -random -shuffle))
            (str (-> (py/get-attr np "random")
                     (py/get-attr "shuffle"))))))
 
@@ -337,8 +309,8 @@ class Foo:
       (py.. (**update {:c 3}))
       (py.. (**update [[:d 4]] {:e 5})))
 
-    (is (= d {"a" 1 "b" 2 "c" 3 "d" 4 "e" 5})))
-  )
+    (is (= d {"a" 1 "b" 2 "c" 3 "d" 4 "e" 5}))))
+
 
 (deftest infinite-seq
   (let [islice (-> (py/import-module "itertools")
@@ -378,13 +350,13 @@ class Foo:
                     (dtt/as-tensor ary-data)))))
 
 (deftest false-is-always-py-false
-  (let [py-false (libpy/Py_False)
+  (let [py-false (py-ffi/py-false)
         ->false (py/->python false)
         as-false (py/as-python false)]
-    (is (= (Pointer/nativeValue (jna/as-ptr py-false))
-           (Pointer/nativeValue (jna/as-ptr ->false))))
-    (is (= (Pointer/nativeValue (jna/as-ptr py-false))
-           (Pointer/nativeValue (jna/as-ptr as-false))))))
+    (is (= (dt-ffi/->pointer py-false)
+           (dt-ffi/->pointer ->false)))
+    (is (= (dt-ffi/->pointer py-false)
+           (dt-ffi/->pointer as-false)))))
 
 (deftest instance-abc-classes
   (let [py-dict (py/->python {"a" 1 "b" 2})
diff --git a/test/libpython_clj/require_python_test.clj b/test/libpython_clj2/require_python_test.clj
similarity index 93%
rename from test/libpython_clj/require_python_test.clj
rename to test/libpython_clj2/require_python_test.clj
index 42afbea..89954b3 100644
--- a/test/libpython_clj/require_python_test.clj
+++ b/test/libpython_clj2/require_python_test.clj
@@ -1,8 +1,8 @@
-(ns libpython-clj.require-python-test
-  (:require [libpython-clj.require :as req
+(ns libpython-clj2.require-python-test
+  (:require [libpython-clj2.require :as req
              :refer [require-python pydafy pynav]
              :reload true]
-            [libpython-clj.python :as py]
+            [libpython-clj2.python :as py]
             [clojure.test :refer :all]
             [clojure.datafy :refer [datafy nav]]))
 
@@ -15,7 +15,7 @@
                   :as pymath])
 
 (deftest base-require-test
-  (let [publics (ns-publics (find-ns 'libpython-clj.require-python-test))]
+  (let [publics (ns-publics (find-ns 'libpython-clj2.require-python-test))]
     (is (not (contains? publics 'sin)))
     (is (= 10.0 (double (floor 10.1))))
     (is (thrown? Throwable (require-python '[math :refer [blah]])))))
@@ -47,6 +47,7 @@
     (is (= #{:b} (parse-flags #{:a :b} '[:b :a false])))
     (is (= #{:b :a} (parse-flags #{:a :b} '[:b :a false :a true])))))
 
+
 (require-python '[builtins :as python]
                 '[builtins.list :as python.pylist])
 
@@ -76,7 +77,7 @@
   (is csv.DictWriter/writerows))
 
 (deftest test-req-transform
-  (let [req-transform #'libpython-clj.require/req-transform]
+  (let [req-transform #'libpython-clj2.require/req-transform]
 
     (is (= (req-transform 'a) 'a))
 
@@ -115,7 +116,7 @@
   (is (set? (datafy (python/frozenset [1 2 3])))))
 
 (deftest import-python-test
-  (is (= :ok (libpython-clj.require/import-python))))
+  (is (= :ok (libpython-clj2.require/import-python))))
 
 (require-python '[socket :bind-ns true])
 (require-python 'socket.SocketIO)
@@ -145,4 +146,3 @@
           "Methods have line numbers")
       (is (string? file)
           "Methods have file paths"))))
-
diff --git a/test/libpython_clj/stress_test.clj b/test/libpython_clj2/stress_test.clj
similarity index 74%
rename from test/libpython_clj/stress_test.clj
rename to test/libpython_clj2/stress_test.clj
index 73b5356..aae3893 100644
--- a/test/libpython_clj/stress_test.clj
+++ b/test/libpython_clj2/stress_test.clj
@@ -1,9 +1,8 @@
-(ns libpython-clj.stress-test
+(ns libpython-clj2.stress-test
   "A set of tests meant to crash the system or just run the system out of
   memory if it isn't setup correctly."
-  (:require [libpython-clj.python :as py]
-            [libpython-clj.jna :as libpy]
-            [libpython-clj.python.object :as pyobject]
+  (:require [libpython-clj2.python :as py]
+            [libpython-clj2.python.class :as py-class]
             [clojure.test :refer :all]
             [clojure.edn :as edn]))
 
@@ -56,11 +55,6 @@ def getmultidata():
     (gd-fn)))
 
 
-;;Ensure that failure to open resource context before tracking for stack
-;;related things causes immediate failure.  Unless you feel like being pedantic,
-;;this isn't necessary.  The python library automatically switches to normal gc-only
-;;mode if a resource context is open.
-
 (deftest forever-test
   (doseq [items (take 10 (partition 999 (get-data)))]
     ;;One way is to use the GC
@@ -115,31 +109,31 @@ def getmultidata():
 (deftest new-cls-stress-test
   (dotimes [iter 100]
     (py/with-gil-stack-rc-context
-      (let [test-cls (py/create-class "testcls" nil
-                                      {"__init__" (py/make-tuple-instance-fn
-                                                   (fn [self name shares price]
-                                                     (py/set-attr! self "name" name)
-                                                     (py/set-attr! self "shares" shares)
-                                                     (py/set-attr! self "price" price)
-                                                     nil))
-                                       "cost" (py/make-tuple-instance-fn
-                                               (fn [self]
-                                                 (let [self (py/as-jvm self)]
-                                                   (* (py/$. self shares)
-                                                      (py/$. self price)))))
-                                       "__str__" (py/make-tuple-instance-fn
-                                                  (fn [self]
-                                                    (let [self (py/as-jvm self)]
-                                                      ;;Self is just a dict so it converts to a hashmap
-                                                      (pr-str {"name" (py/$. self name)
-                                                               "shares" (py/$. self shares)
-                                                               "price" (py/$. self price)}))))
-                                       "testvar" 55}
-                                      )
+      (let [test-cls (py-class/create-class
+                      "testcls" nil
+                      {"__init__" (py-class/make-tuple-instance-fn
+                                   (fn [self name shares price]
+                                     (py/set-attr! self "name" name)
+                                     (py/set-attr! self "shares" shares)
+                                     (py/set-attr! self "price" price)
+                                     nil))
+                       "cost" (py-class/make-tuple-instance-fn
+                               (fn [self]
+                                 (let [self (py/as-jvm self)]
+                                   (* (py/py.- self shares)
+                                      (py/py.- self price)))))
+                       "__str__" (py-class/make-tuple-instance-fn
+                                  (fn [self]
+                                    (let [self (py/as-jvm self)]
+                                      ;;Self is just a dict so it converts to a hashmap
+                                      (pr-str {"name" (py/py.- self name)
+                                               "shares" (py/py.- self shares)
+                                               "price" (py/py.- self price)}))))
+                       "testvar" 55})
             new-inst (test-cls "ACME" 50 90)]
         (is (= 4500
                (py/$a new-inst cost)))
-        (is (= 55 (py/$. new-inst testvar)))
+        (is (= 55 (py/py.- new-inst testvar)))
 
         (is (= {"name" "ACME", "shares" 50, "price" 90}
                (edn/read-string (.toString new-inst))))))))
diff --git a/test/libpython_clj/sugar_test.clj b/test/libpython_clj2/sugar_test.clj
similarity index 93%
rename from test/libpython_clj/sugar_test.clj
rename to test/libpython_clj2/sugar_test.clj
index 00adf24..eee36c2 100644
--- a/test/libpython_clj/sugar_test.clj
+++ b/test/libpython_clj2/sugar_test.clj
@@ -1,7 +1,7 @@
-(ns libpython-clj.sugar-test
-  (:require [libpython-clj.sugar :as pysug :reload true]
+(ns libpython-clj2.sugar-test
+  (:require [libpython-clj2.sugar :as pysug :reload true]
             [clojure.test :refer :all]
-            [libpython-clj.python :as py]))
+            [libpython-clj2.python :as py]))
 
 (deftest test-pyxfn
   (let [{{:strs [addem addx addxkwargs stringify addbang]} :globals}
@@ -76,4 +76,3 @@ def addbang(xs):
                (conj result input)))
             []
             (range 4))))))
-

From 777787081328f64fe0b1f1fd180584590791c433 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 2 Mar 2021 08:38:22 -0700
Subject: [PATCH 263/456] 2.00-beta-1

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index a65f78c..3ca1edd 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-alpha-8-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-beta-1"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 13266aee503b69dab5c0b3f87473823c3a61532e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 2 Mar 2021 08:38:40 -0700
Subject: [PATCH 264/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 3ca1edd..c513b4b 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-1"
+(defproject clj-python/libpython-clj "2.00-beta-2-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From bbe5f7ad11c460f585733df01bbaa455d1df988c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 2 Mar 2021 08:45:16 -0700
Subject: [PATCH 265/456] Updating a few docs.

---
 CHANGELOG.md |  5 +++--
 README.md    | 22 +++++++++++++++++-----
 2 files changed, 20 insertions(+), 7 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9156885..00f42ac 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,10 +1,11 @@
 # Time for a ChangeLog!
 
-## 2.00
+## 2.00-beta-1
 * Major upgrade of tech system - moved to dtype-next.  This release is only compatible with
   tech.ml.dataset versions 5.+.  There are many changes but there should be very few user visible
   ones.  Please see [cnuernber/dtype-next](https://cnuernber.github.io/dtype-next/) for more
-  information.
+  information.  This brings a total refactor removing about 1/2 the code, 32bit support and
+  and JDK-16 support.
 
 ## 1.45
  * tech.datatype - 5.0 release
diff --git a/README.md b/README.md
index be785e1..b24f2c1 100644
--- a/README.md
+++ b/README.md
@@ -5,14 +5,26 @@
 [![Clojars Project](https://img.shields.io/clojars/v/clj-python/libpython-clj.svg)](https://clojars.org/clj-python/libpython-clj)
 [![travis integration](https://travis-ci.com/clj-python/libpython-clj.svg?branch=master)](https://travis-ci.com/clj-python/libpython-clj)
 
- - Note - Please avoid deprecated versions such as `[cnuernber/libpython-clj "1.36"]` (***note name change***).
+
+ ## BETA 1 Is OUT!
+
+ 
+ This brings JDK-16 support as well as 32 bit support using a brand new 
+ [ffi interface](https://cnuernber.github.io/dtype-next/tech.v3.datatype.ffi.html) and
+ removing about 1/2 of the existing code.  The library's API has not changed majorly 
+ aside from deprecated methods have been removed.
  
+ * Main namespace is now `libpython-clj2` -- docs have not been updated.
+ * **32 bit support**!!
+ * Partial support for JDK-16 - The tests pass for core Python functionality but numpy
+   failed to load - the JDK-16 dynamic library loading path is different than JNA and of
+   course this causes issues.
+ * 20-30% better performance.
+ * - Note - Please avoid deprecated versions such as `[cnuernber/libpython-clj "1.36"]` (***note name change***).
  * [API Documentation](https://clj-python.github.io/libpython-clj/)
  * This library, which has received the efforts of many excellent people, is built mainly upon
-   [cnuernber/dtype-next](https://github.com/cnuernber/dtype-next/) and 
-   [techascent/tech.jna](https://github.com/techascent/tech.jna).  It supports zerocopy transfer
-   of data to/from numpy, dynamically creating Clojure namespaces from Python modules, and has
-   a deep intergration with the Clojure language.
+   [cnuernber/dtype-next](https://github.com/cnuernber/dtype-next/) and the 
+   [JNA library](https://github.com/java-native-access/jna).
 
 ## libpython-clj features
 

From f4fd7855a47e758deec98ce630e1d75425f0d4f4 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 2 Mar 2021 13:46:38 -0700
Subject: [PATCH 266/456] Updating docs for beta-1

---
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.python.html          | 31 +++++++++++++++++-------
 docs/libpython-clj2.python.np-array.html |  4 +--
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 project.clj                              |  2 +-
 9 files changed, 31 insertions(+), 18 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index 63a8655..fc54834 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 13bca35..d34b232 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index 53464ed..a4bd378 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-alpha-8-SNAPSHOT</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-alpha-8-SNAPSHOT"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-1</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-beta-1"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index e5dfadf..13eab1e 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,8 +1,21 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L429">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L440">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L216">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L287">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L275">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L281">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L124">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L410">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L222">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L210">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L147">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L153">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L258">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L399">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<p>Example:</p>
+<p><code>clojure
+user&gt; (require '[libpython-clj2.python :as py])
+nil
+user&gt; (py/initialize!)
+;;  ... (logging)
+:ok
+user&gt; (def np (py/import-module "numpy"))
+#'user/np
+user&gt; (py/py. np linspace 2 3 :num 10)
+[2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
+ 2.66666667 2.77777778 2.88888889 3.        ]
+</code></p></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L448">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L459">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L235">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L306">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L294">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L300">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L143">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L429">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L241">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L253">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L229">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L166">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L172">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L277">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L418">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -26,7 +39,7 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L364">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L142">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L158">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L184">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L178">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L113">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; [{:keys [windows-anaconda-activate-bat library-path no-io-redirect?]} options])</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L383">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L161">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L203">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; [{:keys [windows-anaconda-activate-bat library-path no-io-redirect?]} options])</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -41,12 +54,12 @@
       <li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
     </ul>
   </li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L23">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L246">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L326">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L350">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L133">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L42">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L265">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L345">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L369">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L152">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L464">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L486">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L457">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L450">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L505">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L476">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L469">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -56,8 +69,8 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L521">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L240">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L540">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L259">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L293">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L164">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L171">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L190">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L77">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L421">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L90">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L99">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L312">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L183">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L190">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L209">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L96">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L440">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L109">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L118">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index d1a5aef..e7b9716 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows somewhat more seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays (as zero copying when possible).</p>
-<p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L36">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L54">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L40">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L24">view source</a></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L134">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L149">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 29f7a7d..bc5705a 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 1495a8b..c92972a 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index b3088e9..e38e10b 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-alpha-8-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index c513b4b..3ca1edd 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-2-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-beta-1"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From e35f02b9d6298e9f9b61fc5ad4734194bd2af1c9 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 2 Mar 2021 14:01:59 -0700
Subject: [PATCH 267/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 3ca1edd..c513b4b 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-1"
+(defproject clj-python/libpython-clj "2.00-beta-2-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 18a7b01bcc8fc9de78db28c6372cb706623f170f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 2 Mar 2021 14:03:09 -0700
Subject: [PATCH 268/456] snap

---
 docs/libpython-clj2.python.html | 5 ++---
 src/libpython_clj2/python.clj   | 2 +-
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 13eab1e..cf1d373 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -2,8 +2,7 @@
     "">
 <html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
-<p><code>clojure
-user&gt; (require '[libpython-clj2.python :as py])
+<pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
 user&gt; (py/initialize!)
 ;;  ... (logging)
@@ -13,7 +12,7 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></p></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L448">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L459">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L235">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L306">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L294">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L300">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L143">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L448">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L459">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L235">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L306">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L294">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L300">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L143">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L429">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L241">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L253">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L229">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L166">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L172">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L277">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L418">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 99587dd..ee033df 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -6,7 +6,7 @@
 
 Example:
 
-  ```clojure
+```clojure
 user> (require '[libpython-clj2.python :as py])
 nil
 user> (py/initialize!)

From 021c97cd4ed5b5e05af2f6ad6aaf255f679c0c50 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 3 Mar 2021 10:37:57 -0700
Subject: [PATCH 269/456] Fixes #148

---
 src/libpython_clj2/python/base.clj  | 6 +++---
 src/libpython_clj2/python/ffi.clj   | 3 +--
 src/libpython_clj2/python/fn.clj    | 6 +++++-
 test/libpython_clj2/python_test.clj | 6 ++++++
 4 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/src/libpython_clj2/python/base.clj b/src/libpython_clj2/python/base.clj
index 0eec110..e7e6282 100644
--- a/src/libpython_clj2/python/base.clj
+++ b/src/libpython_clj2/python/base.clj
@@ -10,10 +10,10 @@
 (defn ->jvm
   "Copying conversion to the jvm."
   ([obj]
-   (when obj
+   (when-not (nil? obj)
      (py-proto/->jvm obj nil)))
   ([obj opts]
-   (when obj
+   (when-not (nil? obj)
      (py-proto/->jvm obj opts))))
 
 
@@ -22,7 +22,7 @@
   ([obj]
    (as-jvm obj nil))
   ([obj opts]
-   (when obj
+   (when-not (nil? obj)
      (py-proto/as-jvm obj opts))))
 
 
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index 80ab939..b79bd83 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -876,8 +876,7 @@ Object's refcount is bad.  Crash is imminent"
         :str (with-decref [pyobj pyobj]
                (pystr->str pyobj))
         :bool (with-decref [pyobj pyobj]
-                (= (dt-ffi/->pointer pyobj)
-                   (py-true)))
+                (== 1 (long (PyObject_IsTrue pyobj))))
         ;;maybe copy, maybe bridge - in any case we have to decref the item
         (track-pyobject pyobj)))
     (check-error-throw)))
diff --git a/src/libpython_clj2/python/fn.clj b/src/libpython_clj2/python/fn.clj
index 5d7dc98..3f8a86a 100644
--- a/src/libpython_clj2/python/fn.clj
+++ b/src/libpython_clj2/python/fn.clj
@@ -115,7 +115,8 @@
   py-proto/PyCall
   (call [callable arglist kw-arg-map]
     (call-py-fn callable arglist kw-arg-map py-base/->python))
-  (marshal-return [callable retval] retval))
+  (marshal-return [callable retval]
+    retval))
 
 
 (defn call
@@ -137,11 +138,14 @@
   (py-ffi/with-gil
     (if (string? att-name)
       (py-ffi/with-decref [attval (py-ffi/PyObject_GetAttrString item att-name)]
+        (when-not attval (py-ffi/check-error-throw))
         (->> (call-py-fn attval arglist kw-map arg-converter)
              (py-proto/marshal-return item)))
       (py-ffi/with-decref
         [att-name (py-ffi/untracked->python att-name py-base/->python)
          att-val (py-ffi/untracked->python att-name py-base/->python)]
+        (when (or (nil? att-name) (nil? att-val))
+          (py-ffi/check-error-throw))
         (->> (call-py-fn att-val arglist kw-map arg-converter)
              (py-proto/marshal-return item))))))
 
diff --git a/test/libpython_clj2/python_test.clj b/test/libpython_clj2/python_test.clj
index e12766e..6103e9b 100644
--- a/test/libpython_clj2/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -384,6 +384,12 @@ class Foo:
          (py/->jvm (py/->python \c)))))
 
 
+(deftest numpy-all
+  (let [np (py/import-module "numpy")]
+    (is (= true (py/call-attr np "all" (py/call-attr np "array" [true true true]))))
+    (is (= false (py/call-attr np "all" (py/call-attr np "array" [true false true]))))))
+
+
 (comment
   (require '[libpython-clj.require :refer [require-python]])
 

From 60b31d35ec4c050d1ff43cc79a5c2d1ddb803bc6 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 3 Mar 2021 10:39:16 -0700
Subject: [PATCH 270/456] 2.00-beta-2

---
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 project.clj                              | 2 +-
 9 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index fc54834..2378e1b 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index d34b232..fcba998 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index a4bd378..a633094 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-1</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-beta-1"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-2</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-beta-2"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index cf1d373..3a28b38 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index e7b9716..47bfe67 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L134">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L149">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index bc5705a..903c445 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index c92972a..c975391 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index e38e10b..3145ae6 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-1</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index c513b4b..a13e93b 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-2-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-beta-2"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 44df0f4c83f981bc646c19d8cfb5097f1fd55893 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 3 Mar 2021 10:39:26 -0700
Subject: [PATCH 271/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index a13e93b..7b01349 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-2"
+(defproject clj-python/libpython-clj "2.00-beta-3-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 08505c357497df2b010d73e1bd42a51b309c138a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 3 Mar 2021 10:40:21 -0700
Subject: [PATCH 272/456] Updated changelog

---
 CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 00f42ac..8d7b4a0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,8 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-2
+ * Fix for [numpy.all returns false](https://github.com/clj-python/libpython-clj/issues/148)
+
 ## 2.00-beta-1
 * Major upgrade of tech system - moved to dtype-next.  This release is only compatible with
   tech.ml.dataset versions 5.+.  There are many changes but there should be very few user visible

From 450e8bafc4203820e9563a7f322c18b7616fc911 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 3 Mar 2021 10:49:41 -0700
Subject: [PATCH 273/456] There is no more java in this project :-).

---
 java/libpython_clj/jna/CFunction.java     |  75 -----
 java/libpython_clj/jna/DirectMapped.java  |  48 ---
 java/libpython_clj/jna/JVMBridge.java     |  17 --
 java/libpython_clj/jna/JVMBridgeType.java |  24 --
 java/libpython_clj/jna/PyBuffer.java      |  46 ---
 java/libpython_clj/jna/PyComplex.java     |  26 --
 java/libpython_clj/jna/PyFunction.java    |  11 -
 java/libpython_clj/jna/PyGetSetDef.java   |  25 --
 java/libpython_clj/jna/PyMemberDef.java   |  24 --
 java/libpython_clj/jna/PyMethodDef.java   |  29 --
 java/libpython_clj/jna/PyModuleDef.java   |  45 ---
 java/libpython_clj/jna/PyObject.java      |  19 --
 java/libpython_clj/jna/PyProtocols.java   |  21 --
 java/libpython_clj/jna/PyTypeObject.java  | 348 ----------------------
 java/libpython_clj/jna/PyTypeSlot.java    |  18 --
 java/libpython_clj/jna/PyTypeSpec.java    |  20 --
 project.clj                               |   1 -
 17 files changed, 797 deletions(-)
 delete mode 100644 java/libpython_clj/jna/CFunction.java
 delete mode 100644 java/libpython_clj/jna/DirectMapped.java
 delete mode 100644 java/libpython_clj/jna/JVMBridge.java
 delete mode 100644 java/libpython_clj/jna/JVMBridgeType.java
 delete mode 100644 java/libpython_clj/jna/PyBuffer.java
 delete mode 100644 java/libpython_clj/jna/PyComplex.java
 delete mode 100644 java/libpython_clj/jna/PyFunction.java
 delete mode 100644 java/libpython_clj/jna/PyGetSetDef.java
 delete mode 100644 java/libpython_clj/jna/PyMemberDef.java
 delete mode 100644 java/libpython_clj/jna/PyMethodDef.java
 delete mode 100644 java/libpython_clj/jna/PyModuleDef.java
 delete mode 100644 java/libpython_clj/jna/PyObject.java
 delete mode 100644 java/libpython_clj/jna/PyProtocols.java
 delete mode 100644 java/libpython_clj/jna/PyTypeObject.java
 delete mode 100644 java/libpython_clj/jna/PyTypeSlot.java
 delete mode 100644 java/libpython_clj/jna/PyTypeSpec.java

diff --git a/java/libpython_clj/jna/CFunction.java b/java/libpython_clj/jna/CFunction.java
deleted file mode 100644
index d1d38ba..0000000
--- a/java/libpython_clj/jna/CFunction.java
+++ /dev/null
@@ -1,75 +0,0 @@
-package libpython_clj.jna;
-
-
-import com.sun.jna.*;
-
-
-public class CFunction {
-  public static interface KeyWordFunction extends Callback {
-    Pointer pyinvoke(Pointer self, Pointer tuple_args, Pointer kw_args);
-  }
-
-  public static interface TupleFunction extends Callback {
-    Pointer pyinvoke(Pointer self, Pointer tuple_args);
-  }
-
-  public static interface NoArgFunction extends Callback {
-    Pointer pyinvoke(Pointer self);
-  }
-
-  public static interface tp_new extends Callback {
-    Pointer pyinvoke(PyTypeObject type, Pointer args, Pointer kwds);
-  }
-
-  public static interface tp_init extends Callback {
-    Pointer pyinvoke(Pointer self, Pointer tuple_args, Pointer kw_args);
-  }
-
-  public static interface tp_dealloc extends Callback {
-    void pyinvoke(Pointer self);
-  }
-
-  public static interface tp_free extends Callback {
-    void pyinvoke(Pointer item);
-  }
-
-  public static interface tp_att_getter extends Callback {
-    Pointer pyinvoke(Pointer self, Pointer closure);
-  }
-
-  public static interface tp_att_setter extends Callback {
-    Pointer pyinvoke(Pointer self, Pointer value, Pointer closure);
-  }
-
-  public static interface tp_getattr extends Callback {
-    Pointer pyinvoke(Pointer self, String attr_name);
-  }
-
-  public static interface tp_setattr extends Callback {
-    int pyinvoke(Pointer self, String attr_name, Pointer val);
-  }
-
-  public static interface tp_getattro extends Callback {
-    Pointer pyinvoke(Pointer self, Pointer attr_name);
-  }
-
-  public static interface tp_setattro extends Callback {
-    int pyinvoke(Pointer self, Pointer attr_name, Pointer val);
-  }
-
-  public static interface tp_richcompare extends Callback {
-    Pointer pyinvoke(Pointer self, Pointer other, int comp_type);
-  }
-
-  public static interface tp_hash extends Callback {
-    long pyinvoke(Pointer self );
-  }
-
-  public static interface bf_getbuffer extends Callback {
-    int pyinvoke(Pointer self, PyBuffer item, int flags);
-  }
-
-  public static interface bf_releasebuffer extends Callback {
-    void pyinvoke(Pointer self, PyBuffer item);
-  }
-}
diff --git a/java/libpython_clj/jna/DirectMapped.java b/java/libpython_clj/jna/DirectMapped.java
deleted file mode 100644
index 718ab90..0000000
--- a/java/libpython_clj/jna/DirectMapped.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package libpython_clj.jna;
-
-import com.sun.jna.Pointer;
-import com.sun.jna.ptr.LongByReference;
-import com.sun.jna.ptr.PointerByReference;
-import java.nio.ByteBuffer;
-
-
-public class DirectMapped
-{
-  public static native void Py_IncRef(Pointer ptr);
-  public static native void Py_DecRef(Pointer ptr);
-  public static native int PyGILState_Ensure();
-  public static native void PyGILState_Release(int gilState);
-  public static native int PyGILState_Check();
-  public static native void PyEval_RestoreThread(Pointer tstate);
-  public static native Pointer PyEval_SaveThread();
-  public static native Pointer PyFloat_FromDouble(double y);
-  public static native double PyFloat_AsDouble(Pointer val);
-  public static native Pointer PyLong_FromLongLong(long v);
-  public static native long PyLong_AsLongLong(Pointer v);
-  public static native int PyDict_Next(Pointer p, LongByReference ppos,
-				       PointerByReference pkey,
-				       PointerByReference pvalue);
-  //FIXME - how to change signatures if 32 bit.
-  public static native Pointer PyTuple_New(long size);
-  public static native Pointer PyTuple_GetItem(Pointer p, long size);
-  public static native int PyTuple_SetItem(Pointer p, long pos, Pointer o);
-  public static native Pointer PyErr_Occurred();
-  public static native Pointer PyObject_CallObject(Pointer callable, Pointer argtuple);
-  public static native Pointer PyObject_Call(Pointer callable,
-					     Pointer argtuple,
-					     Pointer kwargs);
-  public static native int PyObject_HasAttrString(Pointer obj, String attrName);
-  public static native Pointer PyObject_GetAttrString(Pointer obj, String attrName);
-  public static native int PyCallable_Check(Pointer p);
-  public static native Pointer PyUnicode_AsUTF8AndSize(Pointer pyobj,
-						       LongByReference reference);
-  public static native Pointer PyUnicode_Decode(ByteBuffer bytedata,
-						long numchars, //size-t
-						String encoding,
-						String flags);
-  public static native int PySequence_Check(Pointer val);
-  //returns size-t
-  public static native long PySequence_Length(Pointer val);
-  //takes size-t
-  public static native Pointer PySequence_GetItem(Pointer val, long idx);
-}
diff --git a/java/libpython_clj/jna/JVMBridge.java b/java/libpython_clj/jna/JVMBridge.java
deleted file mode 100644
index 5906057..0000000
--- a/java/libpython_clj/jna/JVMBridge.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package libpython_clj.jna;
-
-
-import com.sun.jna.*;
-
-
-public interface JVMBridge extends AutoCloseable
-{
-  public Pointer getAttr(String name);
-  public void setAttr(String name, Pointer val);
-  public String[] dir();
-  public Object interpreter();
-  public Object wrappedObject();
-  // Called from python when the python mirror is deleted.
-  // This had better not throw anything.
-  public default void close() {}
-}
diff --git a/java/libpython_clj/jna/JVMBridgeType.java b/java/libpython_clj/jna/JVMBridgeType.java
deleted file mode 100644
index 51bcb10..0000000
--- a/java/libpython_clj/jna/JVMBridgeType.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package libpython_clj.jna;
-
-
-import com.sun.jna.*;
-import java.util.*;
-
-
-public class JVMBridgeType extends PyObject {
-  //Instance data
-  public long jvm_interpreter_handle;
-  public long jvm_handle;
-
-
-  public static class ByReference extends JVMBridgeType implements Structure.ByReference {}
-  public static class ByValue extends JVMBridgeType implements Structure.ByValue {}
-  public JVMBridgeType () {}
-  public JVMBridgeType (Pointer p ) { super(p); read(); }
-  protected List getFieldOrder() {
-    List retval = new ArrayList(super.getFieldOrder());
-    retval.addAll( Arrays.asList(new String[]
-      { "jvm_interpreter_handle", "jvm_handle" }));
-    return retval;
-  }
-}
diff --git a/java/libpython_clj/jna/PyBuffer.java b/java/libpython_clj/jna/PyBuffer.java
deleted file mode 100644
index 1366911..0000000
--- a/java/libpython_clj/jna/PyBuffer.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package libpython_clj.jna;
-
-
-import com.sun.jna.*;
-import java.util.*;
-
-
-// typedef struct bufferinfo {
-//     void *buf;
-//     PyObject *obj;        /* owned reference */
-//     Py_ssize_t len;
-//     Py_ssize_t itemsize;  /* This is Py_ssize_t so it can be
-//                              pointed to by strides in simple case.*/
-//     int readonly;
-//     int ndim;
-//     char *format;
-//     Py_ssize_t *shape;
-//     Py_ssize_t *strides;
-//     Py_ssize_t *suboffsets;
-//     void *internal;
-// } Py_buffer;
-
-
-public class PyBuffer extends Structure {
-  public Pointer buf;
-  public Pointer obj;
-  public long len;
-  public long itemsize;
-
-
-  public int readonly;
-  public int ndim;
-  public Pointer format;
-  public Pointer shape;
-  public Pointer strides;
-  public Pointer suboffsets;
-  public Pointer internal;
-
-  public static class ByReference extends PyBuffer implements Structure.ByReference {}
-  public static class ByValue extends PyBuffer implements Structure.ByValue {}
-  public PyBuffer () {}
-  public PyBuffer (Pointer p ) { super(p); read(); }
-  protected List getFieldOrder() { return Arrays.asList(new String[]
-    { "buf", "obj", "len", "itemsize", "readonly", "ndim", "format",
-      "shape", "strides", "suboffsets", "internal"}); }
-}
diff --git a/java/libpython_clj/jna/PyComplex.java b/java/libpython_clj/jna/PyComplex.java
deleted file mode 100644
index 134dc11..0000000
--- a/java/libpython_clj/jna/PyComplex.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package libpython_clj.jna;
-
-
-import com.sun.jna.*;
-import java.util.*;
-
-
-public class PyComplex extends Structure {
-
-  public double real;
-  public double imag;
-
-  public static class ByReference extends PyComplex implements Structure.ByReference {}
-  public static class ByValue extends PyComplex implements Structure.ByValue
-  {
-    ByValue() {}
-    ByValue(PyComplex p) {
-      real = p.real;
-      imag = p.imag;
-    }
-  }
-  public PyComplex () {}
-  public PyComplex (Pointer p ) { super(p); read(); }
-  protected List getFieldOrder() { return Arrays.asList(new String[]
-    { "real", "imag" }); }
-}
diff --git a/java/libpython_clj/jna/PyFunction.java b/java/libpython_clj/jna/PyFunction.java
deleted file mode 100644
index 3ef0ecc..0000000
--- a/java/libpython_clj/jna/PyFunction.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package libpython_clj.jna;
-
-
-import java.util.*;
-import clojure.lang.IFn;
-
-
-public interface PyFunction
-{
-  Object invokeKeyWords(List tupleArgs, Map keywordArgs);
-}
diff --git a/java/libpython_clj/jna/PyGetSetDef.java b/java/libpython_clj/jna/PyGetSetDef.java
deleted file mode 100644
index 698cd57..0000000
--- a/java/libpython_clj/jna/PyGetSetDef.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package libpython_clj.jna;
-
-import com.sun.jna.*;
-import java.util.*;
-
-
-public class PyGetSetDef extends Structure {
-
-  // We keep these as pointers because the memberdef has to live forever
-  // so we have to manually ensure the name and doc ptrs also live forever.
-
-  public Pointer name;
-  public CFunction.tp_att_getter get;
-  public CFunction.tp_att_setter set;
-  public Pointer doc;
-  public Pointer closure; //void*
-
-
-  public static class ByReference extends PyGetSetDef implements Structure.ByReference {}
-  public static class ByValue extends PyGetSetDef implements Structure.ByValue {}
-  public PyGetSetDef () {}
-  public PyGetSetDef (Pointer p ) { super(p); read(); }
-  protected List getFieldOrder() { return Arrays.asList(new String[]
-    { "name", "get", "set", "doc", "closure" }); }
-}
diff --git a/java/libpython_clj/jna/PyMemberDef.java b/java/libpython_clj/jna/PyMemberDef.java
deleted file mode 100644
index 5d52179..0000000
--- a/java/libpython_clj/jna/PyMemberDef.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package libpython_clj.jna;
-
-import com.sun.jna.*;
-import java.util.*;
-
-
-public class PyMemberDef extends Structure {
-
-  // We keep these as pointers because the memberdef has to live forever
-  // so we have to manually ensure the name and doc ptrs also live forever.
-  public Pointer name;
-  public int type;
-  public long offset;
-  public int flags;
-  public Pointer doc;
-
-
-  public static class ByReference extends PyMemberDef implements Structure.ByReference {}
-  public static class ByValue extends PyMemberDef implements Structure.ByValue {}
-  public PyMemberDef () {}
-  public PyMemberDef (Pointer p ) { super(p); read(); }
-  protected List getFieldOrder() { return Arrays.asList(new String[]
-    { "name", "type", "offset", "flags", "doc" }); }
-}
diff --git a/java/libpython_clj/jna/PyMethodDef.java b/java/libpython_clj/jna/PyMethodDef.java
deleted file mode 100644
index 75e74e1..0000000
--- a/java/libpython_clj/jna/PyMethodDef.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package libpython_clj.jna;
-
-import com.sun.jna.*;
-import java.util.*;
-
-
-public class PyMethodDef extends Structure {
-
-  // We keep these as pointers because the methoddef has to live forever
-  // so we have to manually ensure the name and doc ptrs also live forever.
-  public Pointer ml_name;
-  // This is callback but because it can be several different distinct classes
-  // it has to be opaque on the object.  Thus marshalling it to the actual function
-  // is a dynamic process that needs to look at the ml_flags to work.
-  public Pointer ml_meth;
-  public int ml_flags;
-  public Pointer ml_doc;
-
-
-  public static class ByReference extends PyMethodDef implements Structure.ByReference
-  {
-    public ByReference (Pointer p) { super(p); read(); }
-  }
-  public static class ByValue extends PyMethodDef implements Structure.ByValue {}
-  public PyMethodDef () {}
-  public PyMethodDef (Pointer p ) { super(p); read(); }
-  protected List getFieldOrder() { return Arrays.asList(new String[]
-    { "ml_name", "ml_meth", "ml_flags", "ml_doc" }); }
-}
diff --git a/java/libpython_clj/jna/PyModuleDef.java b/java/libpython_clj/jna/PyModuleDef.java
deleted file mode 100644
index 770fead..0000000
--- a/java/libpython_clj/jna/PyModuleDef.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package libpython_clj.jna;
-
-
-import com.sun.jna.*;
-import java.util.*;
-
-
-public class PyModuleDef extends Structure {
-  // obj-HEAD
-  public long ob_refcnt;
-  public Pointer ob_type;
-  // module base
-  public Pointer m_init;
-  public long m_index;
-  public Pointer m_copy;
-  //Instance data
-  public Pointer m_name;
-  public Pointer m_doc;
-  public long m_size;
-  public Pointer m_methods;
-  public Pointer m_slots;
-  public Pointer m_traverse;
-  public Pointer m_clear;
-  public Pointer m_free;
-
-
-  public static class ByReference extends PyModuleDef implements Structure.ByReference {}
-  public static class ByValue extends PyModuleDef implements Structure.ByValue {}
-  public PyModuleDef () {}
-  public PyModuleDef (Pointer p ) { super(p); read(); }
-  protected List getFieldOrder() { return Arrays.asList(new String[]
-    { "obj_refcnt", "ob_type",
-      "m_init",
-      "m_index",
-      "m_copy",
-      "m_name",
-      "m_doc",
-      "m_size",
-      "m_methods",
-      "m_slots",
-      "m_traverse",
-      "m_clear",
-      "m_free"
-       }); }
-}
diff --git a/java/libpython_clj/jna/PyObject.java b/java/libpython_clj/jna/PyObject.java
deleted file mode 100644
index 72b1bb6..0000000
--- a/java/libpython_clj/jna/PyObject.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package libpython_clj.jna;
-
-
-import com.sun.jna.*;
-import java.util.*;
-
-
-public class PyObject extends Structure {
-  public long ob_refcnt;
-  // The Type object is kept opaque to avoid too much unnecessary marshalling
-  public Pointer ob_type;
-
-  public static class ByReference extends PyObject implements Structure.ByReference {}
-  public static class ByValue extends PyObject implements Structure.ByValue {}
-  public PyObject () {}
-  public PyObject (Pointer p ) { super(p); read(); }
-  protected List getFieldOrder() { return Arrays.asList(new String[]
-    { "ob_refcnt", "ob_type" }); }
-}
diff --git a/java/libpython_clj/jna/PyProtocols.java b/java/libpython_clj/jna/PyProtocols.java
deleted file mode 100644
index 7d80431..0000000
--- a/java/libpython_clj/jna/PyProtocols.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package libpython_clj.jna;
-
-
-import com.sun.jna.*;
-import java.util.*;
-
-
-public class PyProtocols
-{
-  public static class PyBufferProtocol extends Structure {
-    public CFunction.bf_getbuffer bf_getbuffer;
-    public CFunction.bf_releasebuffer bf_releasebuffer;
-
-    public static class ByReference extends PyBufferProtocol implements Structure.ByReference {}
-    public static class ByValue extends PyBufferProtocol implements Structure.ByValue {}
-    public PyBufferProtocol () {}
-    public PyBufferProtocol (Pointer p ) { super(p); read(); }
-    protected List getFieldOrder() { return Arrays.asList(new String[]
-      { "bf_getbuffer", "buf_releasebuffer"}); }
-  }
-}
diff --git a/java/libpython_clj/jna/PyTypeObject.java b/java/libpython_clj/jna/PyTypeObject.java
deleted file mode 100644
index b31cde2..0000000
--- a/java/libpython_clj/jna/PyTypeObject.java
+++ /dev/null
@@ -1,348 +0,0 @@
-package libpython_clj.jna;
-
-
-import com.sun.jna.*;
-import java.util.*;
-
-// typedef PyObject * (*unaryfunc)(PyObject *);
-// typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);
-// typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);
-// typedef int (*inquiry)(PyObject *);
-// typedef Py_ssize_t (*lenfunc)(PyObject *);
-// typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);
-// typedef PyObject *(*ssizessizeargfunc)(PyObject *, Py_ssize_t, Py_ssize_t);
-// typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);
-// typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *);
-// typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);
-// typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
-// typedef void (*releasebufferproc)(PyObject *, Py_buffer *);
-/* Maximum number of dimensions */
-// #define PyBUF_MAX_NDIM 64
-
-// /* Flags for getting buffers */
-// #define PyBUF_SIMPLE 0
-// #define PyBUF_WRITABLE 0x0001
-// /*  we used to include an E, backwards compatible alias  */
-// #define PyBUF_WRITEABLE PyBUF_WRITABLE
-// #define PyBUF_FORMAT 0x0004
-// #define PyBUF_ND 0x0008
-// #define PyBUF_STRIDES (0x0010 | PyBUF_ND)
-// #define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES)
-// #define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES)
-// #define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES)
-// #define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES)
-
-// #define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE)
-// #define PyBUF_CONTIG_RO (PyBUF_ND)
-
-// #define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE)
-// #define PyBUF_STRIDED_RO (PyBUF_STRIDES)
-
-// #define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT)
-// #define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT)
-
-// #define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT)
-// #define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT)
-
-
-// #define PyBUF_READ  0x100
-// #define PyBUF_WRITE 0x200
-
-// /* End buffer interface */
-// #endif /* Py_LIMITED_API */
-
-// typedef int (*objobjproc)(PyObject *, PyObject *);
-// typedef int (*visitproc)(PyObject *, void *);
-// typedef int (*traverseproc)(PyObject *, visitproc, void *);
-
-// typedef struct {
-//     /* Number implementations must check *both*
-//        arguments for proper type and implement the necessary conversions
-//        in the slot functions themselves. */
-
-//     binaryfunc nb_add;
-//     binaryfunc nb_subtract;
-//     binaryfunc nb_multiply;
-//     binaryfunc nb_remainder;
-//     binaryfunc nb_divmod;
-//     ternaryfunc nb_power;
-//     unaryfunc nb_negative;
-//     unaryfunc nb_positive;
-//     unaryfunc nb_absolute;
-//     inquiry nb_bool;
-//     unaryfunc nb_invert;
-//     binaryfunc nb_lshift;
-//     binaryfunc nb_rshift;
-//     binaryfunc nb_and;
-//     binaryfunc nb_xor;
-//     binaryfunc nb_or;
-//     unaryfunc nb_int;
-//     void *nb_reserved;  /* the slot formerly known as nb_long */
-//     unaryfunc nb_float;
-
-//     binaryfunc nb_inplace_add;
-//     binaryfunc nb_inplace_subtract;
-//     binaryfunc nb_inplace_multiply;
-//     binaryfunc nb_inplace_remainder;
-//     ternaryfunc nb_inplace_power;
-//     binaryfunc nb_inplace_lshift;
-//     binaryfunc nb_inplace_rshift;
-//     binaryfunc nb_inplace_and;
-//     binaryfunc nb_inplace_xor;
-//     binaryfunc nb_inplace_or;
-
-//     binaryfunc nb_floor_divide;
-//     binaryfunc nb_true_divide;
-//     binaryfunc nb_inplace_floor_divide;
-//     binaryfunc nb_inplace_true_divide;
-
-//     unaryfunc nb_index;
-
-//     binaryfunc nb_matrix_multiply;
-//     binaryfunc nb_inplace_matrix_multiply;
-// } PyNumberMethods;
-
-// typedef struct {
-//     lenfunc sq_length;
-//     binaryfunc sq_concat;
-//     ssizeargfunc sq_repeat;
-//     ssizeargfunc sq_item;
-//     void *was_sq_slice;
-//     ssizeobjargproc sq_ass_item;
-//     void *was_sq_ass_slice;
-//     objobjproc sq_contains;
-
-//     binaryfunc sq_inplace_concat;
-//     ssizeargfunc sq_inplace_repeat;
-// } PySequenceMethods;
-
-// typedef struct {
-//     lenfunc mp_length;
-//     binaryfunc mp_subscript;
-//     objobjargproc mp_ass_subscript;
-// } PyMappingMethods;
-
-// typedef struct {
-//     unaryfunc am_await;
-//     unaryfunc am_aiter;
-//     unaryfunc am_anext;
-// } PyAsyncMethods;
-
-// typedef struct {
-//      getbufferproc bf_getbuffer;
-//      releasebufferproc bf_releasebuffer;
-// } PyBufferProcs;
-// #endif /* Py_LIMITED_API */
-
-// typedef void (*freefunc)(void *);
-// typedef void (*destructor)(PyObject *);
-// #ifndef Py_LIMITED_API
-// /* We can't provide a full compile-time check that limited-API
-//    users won't implement tp_print. However, not defining printfunc
-//    and making tp_print of a different function pointer type
-//    should at least cause a warning in most cases. */
-// typedef int (*printfunc)(PyObject *, FILE *, int);
-// #endif
-// typedef PyObject *(*getattrfunc)(PyObject *, char *);
-// typedef PyObject *(*getattrofunc)(PyObject *, PyObject *);
-// typedef int (*setattrfunc)(PyObject *, char *, PyObject *);
-// typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);
-// typedef PyObject *(*reprfunc)(PyObject *);
-// typedef Py_hash_t (*hashfunc)(PyObject *);
-// typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);
-// typedef PyObject *(*getiterfunc) (PyObject *);
-// typedef PyObject *(*iternextfunc) (PyObject *);
-// typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *);
-// typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *);
-// typedef int (*initproc)(PyObject *, PyObject *, PyObject *);
-// typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *);
-// typedef PyObject *(*allocfunc)(struct _typeobject *, Py_ssize_t);
-
-
-/**
-PyObject size: 16
-PyTypeObject size: 400
-type.tp_basicsize: 32
-type.tp_as_number: 96
-type.tp_as_buffer: 160
-type.tp_finalize: 392
-**/
-
-
-public class PyTypeObject extends PyObject
-{
-  public long ob_size;
-  public Pointer tp_name; /* For printing, in format "<module>.<name>" */
-
-  /* For allocation */
-  public long tp_basicsize;
-  public long tp_itemsize;
-
-  /* Methods to implement standard operations */
-
-  public CFunction.tp_dealloc tp_dealloc;
-  public Pointer tp_print;
-  public CFunction.tp_getattr tp_getattr;
-  public CFunction.tp_setattr tp_setattr;
-  public Pointer tp_as_async; /* formerly known as tp_compare (Python 2)
-				 or tp_reserved (Python 3) */
-  public CFunction.NoArgFunction tp_repr;
-
-    /* Method suites for standard classes */
-
-  public Pointer tp_as_number;
-  public Pointer tp_as_sequence;
-  public Pointer tp_as_mapping;
-
-  /* More standard operations (here for binary compatibility) */
-
-  public CFunction.tp_hash tp_hash;
-  public CFunction.KeyWordFunction tp_call;
-  public CFunction.NoArgFunction tp_str;
-  public CFunction.tp_getattro tp_getattro;
-  public CFunction.tp_setattro tp_setattro;
-
-  /* Functions to access object as input/output buffer */
-  public Pointer tp_as_buffer;
-
-  /* Flags to define presence of optional/expanded features */
-  public int tp_flags;
-
-  public Pointer tp_doc; /* Documentation string */
-
-  /* Assigned meaning in release 2.0 */
-  /* call function for all accessible objects */
-  public Pointer tp_traverse;
-
-  /* delete references to contained objects */
-  public Pointer tp_clear;
-
-  /* Assigned meaning in release 2.1 */
-  /* rich comparisons */
-  public CFunction.tp_richcompare tp_richcompare;
-
-    /* weak reference enabler */
-  public long tp_weaklistoffset;
-
-  /* Iterators */
-  public CFunction.NoArgFunction tp_iter;
-  public CFunction.NoArgFunction tp_iternext;
-
-  /* Attribute descriptor and subclassing stuff */
-  public PyMethodDef.ByReference tp_methods;
-  public PyMemberDef.ByReference tp_members;
-  public PyGetSetDef.ByReference tp_getset;
-  public Pointer tp_base;
-  public Pointer tp_dict;
-  public Pointer tp_descr_get;
-  public Pointer tp_descr_set;
-  public long tp_dictoffset;
-  public CFunction.tp_init tp_init;
-  public Pointer tp_alloc;
-  public CFunction.tp_new tp_new;
-  public CFunction.tp_free tp_free; /* Low-level free-memory routine */
-  public Pointer tp_is_gc; /* For PyObject_IS_GC */
-  public Pointer _bases;
-  public Pointer tp_mro; /* method resolution order */
-  public Pointer tp_cache;
-  public Pointer tp_subclasses;
-  public Pointer tp_weaklist;
-  public Pointer tp_del;
-
-  /* Type attribute cache version tag. Added in version 2.6 */
-  public int tp_version_tag;
-
-  public Pointer tp_finalize;
-
-  public static class ByReference extends PyTypeObject implements Structure.ByReference {}
-  public static class ByValue extends PyTypeObject implements Structure.ByValue {}
-  public PyTypeObject () {}
-  public PyTypeObject (Pointer p ) { super(p); read(); }
-  protected List getFieldOrder() { return Arrays.asList(new String[]
-    {
-      "ob_refcnt",
-      "ob_type",
-      "ob_size",
-      "tp_name", /* For printing, in format "<module>.<name>" */
-
-      /* For allocation */
-      "tp_basicsize",
-      "tp_itemsize",
-
-      /* Methods to implement standard operations */
-
-      "tp_dealloc",
-      "tp_print",
-      "tp_getattr",
-      "tp_setattr",
-      "tp_as_async", /* formerly known as tp_compare (Python 2)
-			or tp_reserved (Python 3) */
-      "tp_repr",
-
-      /* Method suites for standard classes */
-
-      "tp_as_number",
-      "tp_as_sequence",
-      "tp_as_mapping",
-
-      /* More standard operations (here for binary compatibility) */
-
-      "tp_hash",
-      "tp_call",
-      "tp_str",
-      "tp_getattro",
-      "tp_setattro",
-
-      /* Functions to access object as input/output buffer */
-      "tp_as_buffer",
-
-      /* Flags to define presence of optional/expanded features */
-      "tp_flags",
-
-      "tp_doc", /* Documentation string */
-
-      /* Assigned meaning in release 2.0 */
-      /* call function for all accessible objects */
-      "tp_traverse",
-
-      /* delete references to contained objects */
-      "tp_clear",
-
-      /* Assigned meaning in release 2.1 */
-      /* rich comparisons */
-      "tp_richcompare",
-
-      /* weak reference enabler */
-      "tp_weaklistoffset",
-
-      /* Iterators */
-      "tp_iter",
-      "tp_iternext",
-
-      /* Attribute descriptor and subclassing stuff */
-      "tp_methods",
-      "tp_members",
-      "tp_getset",
-      "tp_base",
-      "tp_dict",
-      "tp_descr_get",
-      "tp_descr_set",
-      "tp_dictoffset",
-      "tp_init",
-      "tp_alloc",
-      "tp_new",
-      "tp_free", /* Low-level free-memory routine */
-      "tp_is_gc", /* For PyObject_IS_GC */
-      "_bases",
-      "tp_mro", /* method resolution order */
-      "tp_cache",
-      "tp_subclasses",
-      "tp_weaklist",
-      "tp_del",
-
-      /* Type attribute cache version tag. Added in version 2.6 */
-      "tp_version_tag",
-
-      "tp_finalize"
-    }); }
-}
diff --git a/java/libpython_clj/jna/PyTypeSlot.java b/java/libpython_clj/jna/PyTypeSlot.java
deleted file mode 100644
index 08ec9cf..0000000
--- a/java/libpython_clj/jna/PyTypeSlot.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package libpython_clj.jna;
-
-
-import com.sun.jna.*;
-import java.util.*;
-
-
-public class PyTypeSlot extends Structure {
-  public int slot;
-  public Pointer pfunc;
-
-  public static class ByReference extends PyTypeSlot implements Structure.ByReference {}
-  public static class ByValue extends PyTypeSlot implements Structure.ByValue {}
-  public PyTypeSlot () {}
-  public PyTypeSlot (Pointer p ) { super(p); read(); }
-  protected List getFieldOrder() { return Arrays.asList(new String[]
-    { "slot", "pfunc"}); }
-}
diff --git a/java/libpython_clj/jna/PyTypeSpec.java b/java/libpython_clj/jna/PyTypeSpec.java
deleted file mode 100644
index 799fe1e..0000000
--- a/java/libpython_clj/jna/PyTypeSpec.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package libpython_clj.jna;
-
-
-import com.sun.jna.*;
-import java.util.*;
-
-
-public class PyTypeSpec extends Structure {
-  public String name; /* const char* */
-  public int basicsize;
-  public int itemsize;
-  public int flags;
-  public PyTypeSlot slots; /* PyType_Slot *, terminated by slot==0. */
-  public static class ByReference extends PyTypeSpec implements Structure.ByReference {}
-  public static class ByValue extends PyTypeSpec implements Structure.ByValue {}
-  public PyTypeSpec () {}
-  public PyTypeSpec (Pointer p ) { super(p); read(); }
-  protected List getFieldOrder() { return Arrays.asList(new String[]
-    { "name", "basicsize", "itemsize", "flags", "slots"}); }
-}
diff --git a/project.clj b/project.clj
index 7b01349..c0328c2 100644
--- a/project.clj
+++ b/project.clj
@@ -26,7 +26,6 @@
                       :namespaces [libpython-clj2.python
                                    libpython-clj2.require
                                    libpython-clj2.python.np-array]}}}
-  :java-source-paths ["java"]
   :aliases {"codox" ["with-profile" "codox,dev" "codox"]}
 
   )

From b0f372ca1c2ac52c2926d1085e33105e9b2eab07 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 4 Mar 2021 09:31:22 -0700
Subject: [PATCH 274/456] Adding a funding button.

---
 .github/FUNDING.yml | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 .github/FUNDING.yml

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..75e3266
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+github: cnuernber

From 4fcdac1ebc266d967bbad76f597f0dc2e3761556 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 4 Mar 2021 09:32:30 -0700
Subject: [PATCH 275/456] Create FUNDING.yml

---
 .github/.github/FUNDING.yml | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 .github/.github/FUNDING.yml

diff --git a/.github/.github/FUNDING.yml b/.github/.github/FUNDING.yml
new file mode 100644
index 0000000..cfbe5b0
--- /dev/null
+++ b/.github/.github/FUNDING.yml
@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: cnuernber

From 5b096aea613e41e383c5105cf20bf41002fa4028 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 4 Mar 2021 09:33:32 -0700
Subject: [PATCH 276/456] Nested .github seems superfluous.

---
 .github/.github/FUNDING.yml | 3 ---
 1 file changed, 3 deletions(-)
 delete mode 100644 .github/.github/FUNDING.yml

diff --git a/.github/.github/FUNDING.yml b/.github/.github/FUNDING.yml
deleted file mode 100644
index cfbe5b0..0000000
--- a/.github/.github/FUNDING.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-github: cnuernber

From 5c18b25d0a64743433150f10b7e049375e754745 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 4 Mar 2021 12:31:09 -0700
Subject: [PATCH 277/456] Conda fixes && ensuring we copy datastructures most
 of the time.

---
 project.clj                                 |  2 +-
 src/libpython_clj2/python.clj               | 10 +++++-----
 src/libpython_clj2/python/bridge_as_jvm.clj |  8 ++++----
 src/libpython_clj2/python/ffi.clj           | 21 +++++++++++++++++----
 4 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/project.clj b/project.clj
index c0328c2..2ce6849 100644
--- a/project.clj
+++ b/project.clj
@@ -5,7 +5,7 @@
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2" :scope "provided"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.05"]
+                 [cnuernber/dtype-next   "6.06"]
                  [net.java.dev.jna/jna "5.7.0"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index ee033df..4f48320 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -77,11 +77,11 @@ user> (py/py. np linspace 2 3 :num 10)
                                   (catch Throwable e false)))
                        (first))]
       (log/infof "Loading python library: %s" libname)
-      (py-ffi/initialize! libname (:python-home info)
-                          (assoc options :program-name
-                                 (or (:program-name options)
-                                     (:executable info)
-                                     "")))
+      (py-ffi/initialize!
+       libname (:python-home info)
+       (assoc options
+              :program-name (:program-name options (:executable info))
+              :python-home (:python-home options (:python-home info))))
 
       (when-not (nil? windows-anaconda-activate-bat)
         (win/setup-windows-conda! windows-anaconda-activate-bat
diff --git a/src/libpython_clj2/python/bridge_as_jvm.clj b/src/libpython_clj2/python/bridge_as_jvm.clj
index 0cb2a84..58a6166 100644
--- a/src/libpython_clj2/python/bridge_as_jvm.clj
+++ b/src/libpython_clj2/python/bridge_as_jvm.clj
@@ -179,7 +179,7 @@
          (set-attr! [item# item-name# item-value#]
            (with-gil
              (py-ffi/with-decref [item-value# (py-ffi/untracked->python
-                                               item-value# py-base/as-python)]
+                                               item-value# py-base/->python)]
                (py-proto/set-attr! pyobj# item-name# item-value#))))
          py-proto/PPyItem
          (has-item? [item# item-name#]
@@ -192,11 +192,11 @@
          (set-item! [item# item-name# item-value#]
            (with-gil
              (py-ffi/with-decref [item-value# (py-ffi/untracked->python
-                                               item-value# py-base/as-python)]
+                                               item-value# py-base/->python)]
                (py-proto/set-item! pyobj# item-name# item-value#))))
          py-proto/PyCall
          (call [callable# arglist# kw-arg-map#]
-           (-> (py-fn/call-py-fn pyobj# arglist# kw-arg-map# py-base/as-python)
+           (-> (py-fn/call-py-fn pyobj# arglist# kw-arg-map# py-base/->python)
                (py-base/as-jvm)))
          (marshal-return [callable# retval#]
            (py-base/as-jvm retval#))
@@ -235,7 +235,7 @@
   (if-let [py-fn* (get att-map fn-name)]
     ;;laziness is carefully constructed here in order to allow the arguments to
     ;;be released within the context of the function call during fn.clj call-py-fn.
-    (-> (py-fn/call-py-fn @py-fn* args nil py-base/as-python)
+    (-> (py-fn/call-py-fn @py-fn* args nil py-base/->python)
         (py-base/as-jvm))
     (throw (UnsupportedOperationException.
             (format "Python object has no attribute: %s"
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index b79bd83..fcfb1bb 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -65,6 +65,10 @@ Required for some python modules"}
                        :requires-gil? false
                        :argtypes [['program-name-wideptr :pointer]]
                        :doc "Set the program name"}
+   :Py_SetPythonHome {:rettype :void
+                      :requires-gil? false
+                      :argtypes [['python-home-wideptr :pointer]]
+                      :doc "Set the program name"}
    :PyEval_SaveThread {:rettype :pointer
                        :requires-gil? false
                        :doc "Release the GIL on the current thread"}
@@ -525,16 +529,25 @@ Each call must be matched with PyGILState_Release"}
 
 
 (defn initialize!
-  [libpath python-home & [{:keys [signals? program-name]
+  [libpath python-home & [{:keys [signals? program-name python-home]
                            :or {signals? true
-                                program-name ""}}]]
+                                program-name ""}
+                           :as opts}]]
   (set-library! libpath)
   (when-not (= 1 (Py_IsInitialized))
     (log/debug "Initializing Python C Layer")
-    (let [program-name (retain-forever :program-name
+    ;;platform specific encoding
+    (let [encoding-options {:encoding :wchar-t}
+          program-name (retain-forever :program-name
                                        (-> (or program-name "")
-                                           (dt-ffi/string->c {:encoding :utf-16})))]
+                                           (dt-ffi/string->c encoding-options)))]
       (Py_SetProgramName program-name)
+      (when python-home
+        (let [python-home (retain-forever :python-home
+                                          (dt-ffi/string->c python-home
+                                                            encoding-options))]
+          (log/debugf "Python Home: %s" (:python-home opts))
+          (Py_SetPythonHome python-home)))
       (Py_InitializeEx (if signals? 1 0))
       (PySys_SetArgvEx 0 program-name 1)
       ;;return value ignored :-)

From 1e60dedebc6dfe5b19b5a94e5d42894d728bf33a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 4 Mar 2021 12:51:47 -0700
Subject: [PATCH 278/456] 2.00-beta-3

---
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 project.clj                              | 2 +-
 9 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index 2378e1b..c33ad27 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index fcba998..7d3516a 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index a633094..4cc26f4 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-2</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-beta-2"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-3</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-beta-3"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 3a28b38..7a52a91 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 47bfe67..8342cce 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L134">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L149">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 903c445..c85f8fb 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index c975391..5c28049 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 3145ae6..0d59294 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-2</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 2ce6849..56487e3 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-3-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-beta-3"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 7704521f7a9ec3c273a75296a678d6838d22fbbe Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 4 Mar 2021 12:51:58 -0700
Subject: [PATCH 279/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 56487e3..4d8509b 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-3"
+(defproject clj-python/libpython-clj "2.00-beta-4-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 4f1e91530070b91b6c886f34a9c70c145cd06cee Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 4 Mar 2021 13:12:31 -0700
Subject: [PATCH 280/456] Updating readme with new namespace.

---
 README.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index b24f2c1..e18f1f7 100644
--- a/README.md
+++ b/README.md
@@ -54,8 +54,8 @@ This code is a concrete example that generates an
 
 ```clojure
 (ns facial-rec.face-feature
-  (:require [libpython-clj.require :refer [require-python]]
-            [libpython-clj.python :refer [py. py.. py.-] :as py]
+  (:require [libpython-clj2.require :refer [require-python]]
+            [libpython-clj2.python :refer [py. py.. py.-] :as py]
             [tech.v2.datatype :as dtype]))
 
 
@@ -106,7 +106,7 @@ This code is a concrete example that generates an
 #### Config namespace
 ```clojure
 (ns my-py-clj.config
-  (:require [libpython-clj.python :as py]))
+  (:require [libpython-clj2.python :as py]))
 
 ;; When you use conda, it should look like this.
 (py/initialize! :python-executable "/opt/anaconda3/envs/my_env/bin/python3.7"
@@ -123,7 +123,7 @@ This code is a concrete example that generates an
 
 
 ```clojure
-user> (require '[libpython-clj.require :refer [require-python]])
+user> (require '[libpython-clj2.require :refer [require-python]])
 ...logging info....
 nil
 user> (require-python '[numpy :as np])

From 4186ce31a185dfa0833af018225f45e7ed202870 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 5 Mar 2021 13:09:11 -0700
Subject: [PATCH 281/456] Adding the ability to generate an AOT compatible
 Clojure namespace on disk.

---
 docs/Usage.html                             |     2 +-
 docs/design.html                            |     2 +-
 docs/index.html                             |     2 +-
 docs/libpython-clj2.codegen.html            |    37 +
 docs/libpython-clj2.python.html             |     8 +-
 docs/libpython-clj2.python.np-array.html    |     2 +-
 docs/new-to-clojure.html                    |     2 +-
 docs/python.builtins.html                   |   151 +
 docs/scopes-and-gc.html                     |     2 +-
 docs/slicing.html                           |     2 +-
 project.clj                                 |    10 +-
 src/libpython_clj2/codegen.clj              |   200 +
 src/libpython_clj2/metadata.clj             |    49 +-
 src/libpython_clj2/python.clj               |    43 +-
 src/libpython_clj2/python/bridge_as_jvm.clj |   121 +-
 src/libpython_clj2/python/jvm_handle.clj    |     3 +-
 src/libpython_clj2/require.clj              |     2 +-
 src/python/builtins.clj                     |   975 +
 src/python/numpy.clj                        | 29133 ++++++++++++++++++
 19 files changed, 30634 insertions(+), 112 deletions(-)
 create mode 100644 docs/libpython-clj2.codegen.html
 create mode 100644 docs/python.builtins.html
 create mode 100644 src/libpython_clj2/codegen.clj
 create mode 100644 src/python/builtins.clj
 create mode 100644 src/python/numpy.clj

diff --git a/docs/Usage.html b/docs/Usage.html
index c33ad27..ac3b93e 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 7d3516a..b2c322c 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index 4cc26f4..659570e 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-3</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-beta-3"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-4-SNAPSHOT</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-beta-4-SNAPSHOT"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
new file mode 100644
index 0000000..22b6dd8
--- /dev/null
+++ b/docs/libpython-clj2.codegen.html
@@ -0,0 +1,37 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>Once generated this namespace is safe to be used for AOT,</p>
+<p>Options:</p>
+<ul>
+  <li><code>:output-fname</code> - override the autogenerated file path.</li>
+  <li><code>:output-dir</code> - Defaults “src”. Set the output directory. The final filename, if <code>:output-fname</code> is not provided, is built up from <code>:ns-prefix and
+</code>py-mod-or-cls`.</li>
+  <li><code>:ns-symbol</code> - The fully qualified namespace symbol. If not provided is built from <code>:ns-prefix</code> and <code>py-mod-or-cls</code>.</li>
+  <li><code>:ns-prefix</code> - The prefix used for all python namespaces. Defaults to “python”.</li>
+  <li><code>:symbol-name-remaps</code> - A list of remaps used to avoid name clashes with  clojure.core or builtin java symbols.</li>
+  <li><code>:exclude</code> - List of symbols used like <code>(:refer-clojure :exclude %s)</code>. You can see the default list as <code>codegen/default-exclude</code>.</li>
+</ul>
+<p>Example:</p>
+<pre><code class="clojure">user&gt; (require '[libpython-clj2.codegen :as codegen])
+nil
+user&gt; (codegen/write-namespace!
+       "builtins" {:symbol-name-remaps {"AssertionError" "PyAssertionError"
+                                          "Exception" "PyException"}})
+:ok
+user&gt; (require '[python.builtins :as python])
+nil
+user&gt; (doc python/list)
+-------------------------
+python.builtins/list
+[[self &amp; [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&gt; (doto (python/list)
+        (.add 1)
+        (.add 2))
+[1, 2]
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/codegen.clj#L85">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 7a52a91..81c289e 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -54,7 +54,11 @@
     </ul>
   </li>
 </ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L42">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L265">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L345">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L369">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L152">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L345">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L369">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L152">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+<p>Options:</p>
+<ul>
+  <li><code>:reload</code> - Reload the module.</li>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L594">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 8342cce..c8d9e6e 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L134">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L149">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index c85f8fb..d8059b3 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
new file mode 100644
index 0000000..8eabc86
--- /dev/null
+++ b/docs/python.builtins.html
@@ -0,0 +1,151 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
+<p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
+<p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
+empty list to emulate</code>import name’’. When importing a module from a package, note that <strong>import</strong>(‘A.B’, …) returns package A when fromlist is empty, but its submodule B when fromlist is not empty. The level argument is used to determine whether to perform absolute or relative imports: 0 is absolute, while a positive number is the number of parent directories to search relative to the current module.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L848">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"><code>(__loader__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Meta path import for built-in modules.</p>
+<p>All methods are either class or static methods to avoid the need to instantiate the class.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L232">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L886">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L933">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
+<p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
+<p><code>name</code> is the absolute name of the module. <code>loader</code> is the loader to use when loading the module. <code>parent</code> is the name of the package the module is in. The parent is derived from the name.</p>
+<p><code>is_package</code> determines if the module is considered a package or not. On modules this is reflected by the <code>__path__</code> attribute.</p>
+<p><code>origin</code> is the specific location used by the loader from which to load the module, if that information is available. When filename is set, origin will match.</p>
+<p><code>has_location</code> indicates that a spec’s “origin” reflects a location. When this is True, <code>__file__</code> attribute of the module is set.</p>
+<p><code>cached</code> is the location of the cached bytecode file, if any. It corresponds to the <code>__cached__</code> attribute.</p>
+<p><code>submodule_search_locations</code> is the sequence of path entries to search when importing submodules. If set, is_package should be True–and False otherwise.</p>
+<p>Packages are simply modules that (may) have submodules. If a spec has a non-None value in <code>submodule_search_locations</code>, the import system will consider modules loaded from the spec as packages.</p>
+<p>Only finders (see importlib.abc.MetaPathFinder and importlib.abc.PathEntryFinder) should modify ModuleSpec instances.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L432">view source</a></div></div><div class="public anchor" id="var-abs"><h3>abs</h3><div class="usage"><code>(abs x)</code></div><div class="doc"><div class="markdown"><p>Return the absolute value of the argument.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L623">view source</a></div></div><div class="public anchor" id="var-all"><h3>all</h3><div class="usage"><code>(all iterable)</code></div><div class="doc"><div class="markdown"><p>Return True if bool(x) is True for all values x in the iterable.</p>
+<p>If the iterable is empty, return True.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L687">view source</a></div></div><div class="public anchor" id="var-any"><h3>any</h3><div class="usage"><code>(any iterable)</code></div><div class="doc"><div class="markdown"><p>Return True if bool(x) is True for any x in the iterable.</p>
+<p>If the iterable is empty, return False.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L312">view source</a></div></div><div class="public anchor" id="var-ArithmeticError"><h3>ArithmeticError</h3><div class="usage"><code>(ArithmeticError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for arithmetic errors.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L121">view source</a></div></div><div class="public anchor" id="var-ascii"><h3>ascii</h3><div class="usage"><code>(ascii obj)</code></div><div class="doc"><div class="markdown"><p>Return an ASCII-only representation of an object.</p>
+<p>As repr(), return a string containing a printable representation of an object, but escape the non-ASCII characters in the string returned by repr() using \x, \u or \U escapes. This generates a string similar to that returned by repr() in Python 2.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L101">view source</a></div></div><div class="public anchor" id="var-AttributeError"><h3>AttributeError</h3><div class="usage"><code>(AttributeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Attribute not found.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L958">view source</a></div></div><div class="public anchor" id="var-BaseException"><h3>BaseException</h3><div class="usage"><code>(BaseException self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Common base class for all exceptions</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L583">view source</a></div></div><div class="public anchor" id="var-bin"><h3>bin</h3><div class="usage"><code>(bin number)</code></div><div class="doc"><div class="markdown"><p>Return the binary representation of an integer.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>bin(2796202) ‘0b1010101010101010101010’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L426">view source</a></div></div><div class="public anchor" id="var-BlockingIOError"><h3>BlockingIOError</h3><div class="usage"><code>(BlockingIOError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>I/O operation would block.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L124">view source</a></div></div><div class="public anchor" id="var-bool"><h3>bool</h3><div class="usage"><code>(bool self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bool(x) -&gt; bool</p>
+<p>Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L386">view source</a></div></div><div class="public anchor" id="var-breakpoint"><h3>breakpoint</h3><div class="usage"><code>(breakpoint self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>breakpoint(*args, **kws)</p>
+<p>Call sys.breakpointhook(*args, **kws). sys.breakpointhook() must accept whatever arguments are passed.</p>
+<p>By default, this drops you into the pdb debugger.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L213">view source</a></div></div><div class="public anchor" id="var-BrokenPipeError"><h3>BrokenPipeError</h3><div class="usage"><code>(BrokenPipeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Broken pipe.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L684">view source</a></div></div><div class="public anchor" id="var-BufferError"><h3>BufferError</h3><div class="usage"><code>(BufferError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Buffer error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L543">view source</a></div></div><div class="public anchor" id="var-bytearray"><h3>bytearray</h3><div class="usage"><code>(bytearray self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bytearray(iterable_of_ints) -&gt; bytearray bytearray(string, encoding[, errors]) -&gt; bytearray bytearray(bytes_or_buffer) -&gt; mutable copy of bytes_or_buffer bytearray(int) -&gt; bytes array of size given by the parameter initialized with null bytes bytearray() -&gt; empty bytes array</p>
+<p>Construct a mutable bytearray object from:  - an iterable yielding integers in range(256)  - a text string encoded using the specified encoding  - a bytes or a buffer object  - any object implementing the buffer API.  - an integer</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L546">view source</a></div></div><div class="public anchor" id="var-bytes"><h3>bytes</h3><div class="usage"><code>(bytes self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bytes(iterable_of_ints) -&gt; bytes bytes(string, encoding[, errors]) -&gt; bytes bytes(bytes_or_buffer) -&gt; immutable copy of bytes_or_buffer bytes(int) -&gt; bytes object of size given by the parameter initialized with null bytes bytes() -&gt; empty bytes object</p>
+<p>Construct an immutable array of bytes from:  - an iterable yielding integers in range(256)  - a text string encoded using the specified encoding  - any object implementing the buffer API.  - an integer</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L468">view source</a></div></div><div class="public anchor" id="var-BytesWarning"><h3>BytesWarning</h3><div class="usage"><code>(BytesWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about bytes and buffer related problems, mostly related to conversion from str or comparing to str.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L72">view source</a></div></div><div class="public anchor" id="var-callable"><h3>callable</h3><div class="usage"><code>(callable obj)</code></div><div class="doc"><div class="markdown"><p>Return whether the object is callable (i.e., some kind of function).</p>
+<p>Note that classes are callable, as are instances of classes with a <strong>call</strong>() method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L402">view source</a></div></div><div class="public anchor" id="var-ChildProcessError"><h3>ChildProcessError</h3><div class="usage"><code>(ChildProcessError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Child process error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L704">view source</a></div></div><div class="public anchor" id="var-chr"><h3>chr</h3><div class="usage"><code>(chr i)</code></div><div class="doc"><div class="markdown"><p>Return a Unicode string of one character with ordinal i; 0 &lt;= i &lt;= 0x10ffff.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L118">view source</a></div></div><div class="public anchor" id="var-classmethod"><h3>classmethod</h3><div class="usage"><code>(classmethod self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>classmethod(function) -&gt; method</p>
+<p>Convert a function to be a class method.</p>
+<p>A class method receives the class as implicit first argument, just like an instance method receives the instance. To declare a class method, use this idiom:</p>
+<p>class C:  @classmethod  def f(cls, arg1, arg2, …):  …</p>
+<p>It can be called either on the class (e.g. C.f()) or on an instance (e.g. C().f()). The instance is ignored except for its class. If a class method is called for a derived class, the derived class object is passed as the implied first argument.</p>
+<p>Class methods are different than C++ or Java static methods. If you want those, see the staticmethod builtin.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L157">view source</a></div></div><div class="public anchor" id="var-compile"><h3>compile</h3><div class="usage"><code>(compile source filename mode &amp; [{flags :flags, dont_inherit :dont_inherit, optimize :optimize, _feature_version :_feature_version}])</code><code>(compile source filename mode &amp; [{flags :flags, dont_inherit :dont_inherit, _feature_version :_feature_version}])</code><code>(compile source filename mode &amp; [{flags :flags, _feature_version :_feature_version}])</code><code>(compile source filename mode &amp; [{_feature_version :_feature_version}])</code></div><div class="doc"><div class="markdown"><p>Compile source into a code object that can be executed by exec() or eval().</p>
+<p>The source code may represent a Python module, statement or expression. The filename will be used for run-time error messages. The mode must be ‘exec’ to compile a module, ‘single’ to compile a single (interactive) statement, or ‘eval’ to compile an expression. The flags argument, if present, controls which future statements influence the compilation of the code. The dont_inherit argument, if true, stops the compilation inheriting the effects of any future statements in effect in the code calling compile; if absent or false these statements do influence the compilation, in addition to any features explicitly specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L560">view source</a></div></div><div class="public anchor" id="var-complex"><h3>complex</h3><div class="usage"><code>(complex self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create a complex number from a real part and an optional imaginary part.</p>
+<p>This is equivalent to (real + imag*1j) where imag defaults to 0.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L877">view source</a></div></div><div class="public anchor" id="var-ConnectionAbortedError"><h3>ConnectionAbortedError</h3><div class="usage"><code>(ConnectionAbortedError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Connection aborted.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L291">view source</a></div></div><div class="public anchor" id="var-ConnectionError"><h3>ConnectionError</h3><div class="usage"><code>(ConnectionError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Connection error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L868">view source</a></div></div><div class="public anchor" id="var-ConnectionRefusedError"><h3>ConnectionRefusedError</h3><div class="usage"><code>(ConnectionRefusedError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Connection refused.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L626">view source</a></div></div><div class="public anchor" id="var-ConnectionResetError"><h3>ConnectionResetError</h3><div class="usage"><code>(ConnectionResetError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Connection reset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L13">view source</a></div></div><div class="public anchor" id="var-copyright"><h3>copyright</h3><div class="usage"><code>(copyright self name data &amp; [{files :files, dirs :dirs}])</code><code>(copyright self name data &amp; [{files :files}])</code><code>(copyright self name data)</code></div><div class="doc"><div class="markdown"><p>interactive prompt objects for printing the license text, a list of contributors and the copyright notice.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L599">view source</a></div></div><div class="public anchor" id="var-credits"><h3>credits</h3><div class="usage"><code>(credits self name data &amp; [{files :files, dirs :dirs}])</code><code>(credits self name data &amp; [{files :files}])</code><code>(credits self name data)</code></div><div class="doc"><div class="markdown"><p>interactive prompt objects for printing the license text, a list of contributors and the copyright notice.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L942">view source</a></div></div><div class="public anchor" id="var-delattr"><h3>delattr</h3><div class="usage"><code>(delattr obj name)</code></div><div class="doc"><div class="markdown"><p>Deletes the named attribute from the given object.</p>
+<p>delattr(x, ‘y’) is equivalent to ``del x.y’’</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L280">view source</a></div></div><div class="public anchor" id="var-DeprecationWarning"><h3>DeprecationWarning</h3><div class="usage"><code>(DeprecationWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about deprecated features.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L420">view source</a></div></div><div class="public anchor" id="var-dict"><h3>dict</h3><div class="usage"><code>(dict self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L348">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>dir([object]) -&gt; list of strings</p>
+<p>If called without an argument, return the names in the current scope. Else, return an alphabetized list of names comprising (some of) the attributes of the given object, and of attributes reachable from it. If the object supplies a method named <strong>dir</strong>, it will be used; otherwise the default dir() logic is used and returns:  for a module object: the module’s attributes.  for a class object: its attributes, and recursively the attributes  of its bases.  for any other object: its attributes, its class’s attributes, and  recursively the attributes of its class’s base classes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L481">view source</a></div></div><div class="public anchor" id="var-divmod"><h3>divmod</h3><div class="usage"><code>(divmod x y)</code></div><div class="doc"><div class="markdown"><p>Return the tuple (x//y, x%y). Invariant: div*y + mod == x.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L309">view source</a></div></div><div class="public anchor" id="var-Ellipsis"><h3>Ellipsis</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L724">view source</a></div></div><div class="public anchor" id="var-enumerate"><h3>enumerate</h3><div class="usage"><code>(enumerate self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an enumerate object.</p>
+<p>iterable  an object supporting iteration</p>
+<p>The enumerate object yields pairs containing a count (from start, which defaults to zero) and a value yielded by the iterable argument.</p>
+<p>enumerate is useful for obtaining an indexed list:  (0, seq[0]), (1, seq[1]), (2, seq[2]), …</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L336">view source</a></div></div><div class="public anchor" id="var-EnvironmentError"><h3>EnvironmentError</h3><div class="usage"><code>(EnvironmentError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for I/O related errors.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L408">view source</a></div></div><div class="public anchor" id="var-EOFError"><h3>EOFError</h3><div class="usage"><code>(EOFError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Read beyond end of file.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L664">view source</a></div></div><div class="public anchor" id="var-eval"><h3>eval</h3><div class="usage"><code>(eval source &amp; [{globals :globals, locals :locals}])</code><code>(eval source &amp; [{globals :globals}])</code><code>(eval source)</code></div><div class="doc"><div class="markdown"><p>Evaluate the given source in the context of globals and locals.</p>
+<p>The source may be a string representing a Python expression or a code object as returned by compile(). The globals must be a dictionary and locals can be any mapping, defaulting to the current globals and locals. If only globals is given, locals defaults to it.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L377">view source</a></div></div><div class="public anchor" id="var-exec"><h3>exec</h3><div class="usage"><code>(exec source &amp; [{globals :globals, locals :locals}])</code><code>(exec source &amp; [{globals :globals}])</code><code>(exec source)</code></div><div class="doc"><div class="markdown"><p>Execute the given source in the context of globals and locals.</p>
+<p>The source may be a string representing one or more Python statements or a code object as returned by compile(). The globals must be a dictionary and locals can be any mapping, defaulting to the current globals and locals. If only globals is given, locals defaults to it.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L300">view source</a></div></div><div class="public anchor" id="var-exit"><h3>exit</h3><div class="usage"><code>(exit self name eof)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L661">view source</a></div></div><div class="public anchor" id="var-FileExistsError"><h3>FileExistsError</h3><div class="usage"><code>(FileExistsError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>File already exists.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L368">view source</a></div></div><div class="public anchor" id="var-FileNotFoundError"><h3>FileNotFoundError</h3><div class="usage"><code>(FileNotFoundError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>File not found.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L85">view source</a></div></div><div class="public anchor" id="var-filter"><h3>filter</h3><div class="usage"><code>(filter self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>filter(function or None, iterable) –&gt; filter object</p>
+<p>Return an iterator yielding those items of iterable for which function(item) is true. If function is None, return the items that are true.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L495">view source</a></div></div><div class="public anchor" id="var-float"><h3>float</h3><div class="usage"><code>(float self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Convert a string or number to a floating point number, if possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L10">view source</a></div></div><div class="public anchor" id="var-FloatingPointError"><h3>FloatingPointError</h3><div class="usage"><code>(FloatingPointError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Floating point operation failed.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L285">view source</a></div></div><div class="public anchor" id="var-format"><h3>format</h3><div class="usage"><code>(format value &amp; [{format_spec :format_spec}])</code><code>(format value)</code></div><div class="doc"><div class="markdown"><p>Return value.__format__(format_spec)</p>
+<p>format_spec defaults to the empty string. See the Format Specification Mini-Language section of help(‘FORMATTING’) for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L935">view source</a></div></div><div class="public anchor" id="var-frozenset"><h3>frozenset</h3><div class="usage"><code>(frozenset self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>frozenset() -&gt; empty frozenset object frozenset(iterable) -&gt; frozenset object</p>
+<p>Build an immutable unordered collection of unique elements.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L952">view source</a></div></div><div class="public anchor" id="var-FutureWarning"><h3>FutureWarning</h3><div class="usage"><code>(FutureWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about constructs that will change semantically in the future.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L150">view source</a></div></div><div class="public anchor" id="var-GeneratorExit"><h3>GeneratorExit</h3><div class="usage"><code>(GeneratorExit self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Request that a generator exit.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L288">view source</a></div></div><div class="public anchor" id="var-getattr"><h3>getattr</h3><div class="usage"><code>(getattr self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>getattr(object, name[, default]) -&gt; value</p>
+<p>Get a named attribute from an object; getattr(x, ‘y’) is equivalent to x.y. When a default argument is given, it is returned when the attribute doesn’t exist; without it, an exception is raised in that case.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L904">view source</a></div></div><div class="public anchor" id="var-globals"><h3>globals</h3><div class="usage"><code>(globals)</code></div><div class="doc"><div class="markdown"><p>Return the dictionary containing the current scope’s global variables.</p>
+<p>NOTE: Updates to this dictionary <em>will</em> affect name lookups in the current global scope and vice-versa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L614">view source</a></div></div><div class="public anchor" id="var-hasattr"><h3>hasattr</h3><div class="usage"><code>(hasattr obj name)</code></div><div class="doc"><div class="markdown"><p>Return whether the object has an attribute with the given name.</p>
+<p>This is done by calling getattr(obj, name) and catching AttributeError.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L670">view source</a></div></div><div class="public anchor" id="var-hash"><h3>hash</h3><div class="usage"><code>(hash obj)</code></div><div class="doc"><div class="markdown"><p>Return the hash value for the given object.</p>
+<p>Two objects that compare equal must also have the same hash value, but the reverse is not necessarily true.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L207">view source</a></div></div><div class="public anchor" id="var-help"><h3>help</h3><div class="usage"><code>(help self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Define the builtin ‘help’.</p>
+<p>This is a wrapper around pydoc.help that provides a helpful message when ‘help’ is typed at the Python interactive prompt.</p>
+<p>Calling help() at the Python prompt starts an interactive help session. Calling help(thing) prints help for the python object ‘thing’.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L629">view source</a></div></div><div class="public anchor" id="var-hex"><h3>hex</h3><div class="usage"><code>(hex number)</code></div><div class="doc"><div class="markdown"><p>Return the hexadecimal representation of an integer.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>hex(12648430) ‘0xc0ffee’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L182">view source</a></div></div><div class="public anchor" id="var-id"><h3>id</h3><div class="usage"><code>(id obj)</code></div><div class="doc"><div class="markdown"><p>Return the identity of an object.</p>
+<p>This is guaranteed to be unique among simultaneously existing objects. (CPython uses the object’s memory address.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L265">view source</a></div></div><div class="public anchor" id="var-ImportError"><h3>ImportError</h3><div class="usage"><code>(ImportError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Import can’t find module, or can’t find name in module.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L586">view source</a></div></div><div class="public anchor" id="var-ImportWarning"><h3>ImportWarning</h3><div class="usage"><code>(ImportWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about probable mistakes in module imports</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L147">view source</a></div></div><div class="public anchor" id="var-IndentationError"><h3>IndentationError</h3><div class="usage"><code>(IndentationError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Improper indentation.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L927">view source</a></div></div><div class="public anchor" id="var-IndexError"><h3>IndexError</h3><div class="usage"><code>(IndexError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Sequence index out of range.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L179">view source</a></div></div><div class="public anchor" id="var-input"><h3>input</h3><div class="usage"><code>(input &amp; [{prompt :prompt}])</code><code>(input)</code></div><div class="doc"><div class="markdown"><p>Read a string from standard input. The trailing newline is stripped.</p>
+<p>The prompt string, if given, is printed to standard output without a trailing newline before reading input.</p>
+<p>If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError. On *nix systems, readline is used if available.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L574">view source</a></div></div><div class="public anchor" id="var-int"><h3>int</h3><div class="usage"><code>(int self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>int([x]) -&gt; integer int(x, base=10) -&gt; integer</p>
+<p>Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.</p>
+<p>If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by ‘+’ or ‘-’ and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>int(‘0b100’, base=0) 4</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L25">view source</a></div></div><div class="public anchor" id="var-InterruptedError"><h3>InterruptedError</h3><div class="usage"><code>(InterruptedError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Interrupted by signal.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L371">view source</a></div></div><div class="public anchor" id="var-IOError"><h3>IOError</h3><div class="usage"><code>(IOError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for I/O related errors.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L540">view source</a></div></div><div class="public anchor" id="var-IsADirectoryError"><h3>IsADirectoryError</h3><div class="usage"><code>(IsADirectoryError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Operation doesn’t work on directories.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L967">view source</a></div></div><div class="public anchor" id="var-isinstance"><h3>isinstance</h3><div class="usage"><code>(isinstance obj class_or_tuple)</code></div><div class="doc"><div class="markdown"><p>Return whether an object is an instance of a class or of a subclass thereof.</p>
+<p>A tuple, as in <code>isinstance(x, (A, B, ...))</code>, may be given as the target to check against. This is equivalent to <code>isinstance(x, A) or isinstance(x, B)
+or ...</code> etc.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L258">view source</a></div></div><div class="public anchor" id="var-issubclass"><h3>issubclass</h3><div class="usage"><code>(issubclass cls class_or_tuple)</code></div><div class="doc"><div class="markdown"><p>Return whether ‘cls’ is a derived from another class or is the same class.</p>
+<p>A tuple, as in <code>issubclass(x, (A, B, ...))</code>, may be given as the target to check against. This is equivalent to <code>issubclass(x, A) or issubclass(x, B)
+or ...</code> etc.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L970">view source</a></div></div><div class="public anchor" id="var-iter"><h3>iter</h3><div class="usage"><code>(iter self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>iter(iterable) -&gt; iterator iter(callable, sentinel) -&gt; iterator</p>
+<p>Get an iterator from an object. In the first form, the argument must supply its own iterator, or be a sequence. In the second form, the callable is called until it returns the sentinel.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L716">view source</a></div></div><div class="public anchor" id="var-KeyboardInterrupt"><h3>KeyboardInterrupt</h3><div class="usage"><code>(KeyboardInterrupt self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Program interrupted by user.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L69">view source</a></div></div><div class="public anchor" id="var-KeyError"><h3>KeyError</h3><div class="usage"><code>(KeyError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Mapping key not found.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L535">view source</a></div></div><div class="public anchor" id="var-len"><h3>len</h3><div class="usage"><code>(len obj)</code></div><div class="doc"><div class="markdown"><p>Return the number of items in a container.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L675">view source</a></div></div><div class="public anchor" id="var-license"><h3>license</h3><div class="usage"><code>(license self name data &amp; [{files :files, dirs :dirs}])</code><code>(license self name data &amp; [{files :files}])</code><code>(license self name data)</code></div><div class="doc"><div class="markdown"><p>interactive prompt objects for printing the license text, a list of contributors and the copyright notice.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L97">view source</a></div></div><div class="public anchor" id="var-list"><h3>list</h3><div class="usage"><code>(list self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L91">view source</a></div></div><div class="public anchor" id="var-locals"><h3>locals</h3><div class="usage"><code>(locals)</code></div><div class="doc"><div class="markdown"><p>Return a dictionary containing the current scope’s local variables.</p>
+<p>NOTE: Whether or not updates to this dictionary will affect name lookups in the local scope and vice-versa is <em>implementation dependent</em> and not covered by any backwards compatibility guarantees.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L894">view source</a></div></div><div class="public anchor" id="var-LookupError"><h3>LookupError</h3><div class="usage"><code>(LookupError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for lookup errors.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L608">view source</a></div></div><div class="public anchor" id="var-map"><h3>map</h3><div class="usage"><code>(map self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>map(func, *iterables) –&gt; map object</p>
+<p>Make an iterator that computes the function using arguments from each of the iterables. Stops when the shortest iterable is exhausted.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L16">view source</a></div></div><div class="public anchor" id="var-max"><h3>max</h3><div class="usage"><code>(max self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>max(iterable, *[, default=obj, key=func]) -&gt; value max(arg1, arg2, *args, *[, key=func]) -&gt; value</p>
+<p>With a single iterable argument, return its biggest item. The default keyword-only argument specifies an object to return if the provided iterable is empty. With two or more arguments, return the largest argument.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L243">view source</a></div></div><div class="public anchor" id="var-MemoryError"><h3>MemoryError</h3><div class="usage"><code>(MemoryError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Out of memory.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L66">view source</a></div></div><div class="public anchor" id="var-memoryview"><h3>memoryview</h3><div class="usage"><code>(memoryview self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create a new memoryview object which references the given object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L333">view source</a></div></div><div class="public anchor" id="var-min"><h3>min</h3><div class="usage"><code>(min self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>min(iterable, *[, default=obj, key=func]) -&gt; value min(arg1, arg2, *args, *[, key=func]) -&gt; value</p>
+<p>With a single iterable argument, return its smallest item. The default keyword-only argument specifies an object to return if the provided iterable is empty. With two or more arguments, return the smallest argument.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L76">view source</a></div></div><div class="public anchor" id="var-ModuleNotFoundError"><h3>ModuleNotFoundError</h3><div class="usage"><code>(ModuleNotFoundError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Module not found.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L710">view source</a></div></div><div class="public anchor" id="var-NameError"><h3>NameError</h3><div class="usage"><code>(NameError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Name not found globally.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L417">view source</a></div></div><div class="public anchor" id="var-next"><h3>next</h3><div class="usage"><code>(next self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>next(iterator[, default])</p>
+<p>Return the next item from the iterator. If default is given and the iterator is exhausted, it is returned instead of raising StopIteration.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L109">view source</a></div></div><div class="public anchor" id="var-NotADirectoryError"><h3>NotADirectoryError</h3><div class="usage"><code>(NotADirectoryError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Operation only works on directories.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L240">view source</a></div></div><div class="public anchor" id="var-NotImplemented"><h3>NotImplemented</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L48">view source</a></div></div><div class="public anchor" id="var-NotImplementedError"><h3>NotImplementedError</h3><div class="usage"><code>(NotImplementedError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Method or function hasn’t been implemented yet.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L901">view source</a></div></div><div class="public anchor" id="var-object"><h3>object</h3><div class="usage"><code>(object self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>The base class of the class hierarchy.</p>
+<p>When called, it accepts no arguments and returns a new featureless instance that has no instance attributes and cannot be given any.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L41">view source</a></div></div><div class="public anchor" id="var-oct"><h3>oct</h3><div class="usage"><code>(oct number)</code></div><div class="doc"><div class="markdown"><p>Return the octal representation of an integer.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>oct(342391) ‘0o1234567’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L888">view source</a></div></div><div class="public anchor" id="var-open"><h3>open</h3><div class="usage"><code>(open file &amp; [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline, closefd :closefd, opener :opener}])</code><code>(open file &amp; [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline, closefd :closefd}])</code><code>(open file &amp; [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline}])</code><code>(open file &amp; [{mode :mode, buffering :buffering, encoding :encoding, errors :errors}])</code><code>(open file &amp; [{mode :mode, buffering :buffering, encoding :encoding}])</code><code>(open file &amp; [{mode :mode, buffering :buffering}])</code><code>(open file &amp; [{mode :mode}])</code><code>(open file)</code></div><div class="doc"><div class="markdown"><p>Open file and return a stream. Raise OSError upon failure.</p>
+<p>file is either a text or byte string giving the name (and the path if the file isn’t in the current working directory) of the file to be opened or an integer file descriptor of the file to be wrapped. (If a file descriptor is given, it is closed when the returned I/O object is closed, unless closefd is set to False.)</p>
+<p>mode is an optional string that specifies the mode in which the file is opened. It defaults to ‘r’ which means open for reading in text mode. Other common values are ‘w’ for writing (truncating the file if it already exists), ‘x’ for creating and writing to a new file, and ‘a’ for appending (which on some Unix systems, means that all writes append to the end of the file regardless of the current seek position). In text mode, if encoding is not specified the encoding used is platform dependent: locale.getpreferredencoding(False) is called to get the current locale encoding. (For reading and writing raw bytes use binary mode and leave encoding unspecified.) The available modes are:</p>
+<p>========= =============================================================== Character Meaning ——— ————————————————————— ‘r’ open for reading (default) ‘w’ open for writing, truncating the file first ‘x’ create a new file and open it for writing ‘a’ open for writing, appending to the end of the file if it exists ‘b’ binary mode ‘t’ text mode (default) ‘+’ open a disk file for updating (reading and writing) ‘U’ universal newline mode (deprecated) ========= ===============================================================</p>
+<p>The default mode is ‘rt’ (open for reading text). For binary random access, the mode ‘w+b’ opens and truncates the file to 0 bytes, while ‘r+b’ opens the file without truncation. The ‘x’ mode implies ‘w’ and raises an <code>FileExistsError</code> if the file already exists.</p>
+<p>Python distinguishes between files opened in binary and text modes, even when the underlying operating system doesn’t. Files opened in binary mode (appending ‘b’ to the mode argument) return contents as bytes objects without any decoding. In text mode (the default, or when ‘t’ is appended to the mode argument), the contents of the file are returned as strings, the bytes having been first decoded using a platform-dependent encoding or using the specified encoding if given.</p>
+<p>‘U’ mode is deprecated and will raise an exception in future versions of Python. It has no effect in Python 3. Use newline to control universal newlines mode.</p>
+<p>buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable in text mode), and an integer &gt; 1 to indicate the size of a fixed-size chunk buffer. When no buffering argument is given, the default buffering policy works as follows:</p>
+<ul>
+  <li>
+  <p>Binary files are buffered in fixed-size chunks; the size of the buffer  is chosen using a heuristic trying to determine the underlying device’s  “block size” and falling back on <code>io.DEFAULT_BUFFER_SIZE</code>.  On many systems, the buffer will typically be 4096 or 8192 bytes long.</p></li>
+  <li>
+  <p>“Interactive” text files (files for which isatty() returns True)  use line buffering. Other text files use the policy described above  for binary files.</p></li>
+</ul>
+<p>encoding is the name of the encoding used to decode or encode the file. This should only be used in text mode. The default encoding is platform dependent, but any encoding supported by Python can be passed. See the codecs module for the list of supported encodings.</p>
+<p>errors is an optional string that specifies how encoding errors are to be handled—this argument should not be used in binary mode. Pass ‘strict’ to raise a ValueError exception if there is an encoding error (the default of None has the same effect), or pass ‘ignore’ to ignore errors. (Note that ignoring encoding errors can lead to data loss.) See the documentation for codecs.register or run ‘help(codecs.Codec)’ for a list of the permitted encoding error strings.</p>
+<p>newline controls how universal newlines works (it only applies to text mode). It can be None, ’‘, ’\n’, ‘\r’, and ‘\r\n’. It works as follows:</p>
+<ul>
+  <li>
+  <p>On input, if newline is None, universal newlines mode is  enabled. Lines in the input can end in ‘\n’, ‘\r’, or ‘\r\n’, and  these are translated into ‘\n’ before being returned to the  caller. If it is ’’, universal newline mode is enabled, but line  endings are returned to the caller untranslated. If it has any of  the other legal values, input lines are only terminated by the given  string, and the line ending is returned to the caller untranslated.</p></li>
+  <li>
+  <p>On output, if newline is None, any ‘\n’ characters written are  translated to the system default line separator, os.linesep. If  newline is ’‘ or ’\n’, no translation takes place. If newline is any  of the other legal values, any ‘\n’ characters written are translated  to the given string.</p></li>
+</ul>
+<p>If closefd is False, the underlying file descriptor will be kept open when the file is closed. This does not work when a file name is given and must be True in that case.</p>
+<p>A custom opener can be used by passing a callable as <em>opener</em>. The underlying file descriptor for the file object is then obtained by calling <em>opener</em> with (*file*, <em>flags</em>). <em>opener</em> must return an open file descriptor (passing os.open as <em>opener</em> results in functionality similar to passing None).</p>
+<p>open() returns a file object whose type depends on the mode, and through which the standard file operations such as reading and writing are performed. When open() is used to open a file in a text mode (‘w’, ‘r’, ‘wt’, ‘rt’, etc.), it returns a TextIOWrapper. When used to open a file in a binary mode, the returned class varies: in read binary mode, it returns a BufferedReader; in write binary and append binary modes, it returns a BufferedWriter, and in read/write mode, it returns a BufferedRandom.</p>
+<p>It is also possible to use a string or bytearray as a file for both reading and writing. For strings StringIO can be used like a file opened in a text mode, and for bytes a BytesIO can be used like a file opened in a binary mode.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L726">view source</a></div></div><div class="public anchor" id="var-ord"><h3>ord</h3><div class="usage"><code>(ord c)</code></div><div class="doc"><div class="markdown"><p>Return the Unicode code point for a one-character string.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L399">view source</a></div></div><div class="public anchor" id="var-OSError"><h3>OSError</h3><div class="usage"><code>(OSError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for I/O related errors.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L359">view source</a></div></div><div class="public anchor" id="var-OverflowError"><h3>OverflowError</h3><div class="usage"><code>(OverflowError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Result too large to be represented.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L620">view source</a></div></div><div class="public anchor" id="var-PendingDeprecationWarning"><h3>PendingDeprecationWarning</h3><div class="usage"><code>(PendingDeprecationWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about features which will be deprecated in the future.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L692">view source</a></div></div><div class="public anchor" id="var-PermissionError"><h3>PermissionError</h3><div class="usage"><code>(PermissionError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Not enough permissions.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L63">view source</a></div></div><div class="public anchor" id="var-pow"><h3>pow</h3><div class="usage"><code>(pow base exp &amp; [{mod :mod}])</code><code>(pow base exp)</code></div><div class="doc"><div class="markdown"><p>Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments</p>
+<p>Some types, such as ints, are able to use a more efficient algorithm when invoked using the three argument form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L271">view source</a></div></div><div class="public anchor" id="var-print"><h3>print</h3><div class="usage"><code>(print self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>print(value, …, sep=‘ ’, end=‘\n’, file=sys.stdout, flush=False)</p>
+<p>Prints the values to a stream, or to sys.stdout by default. Optional keyword arguments: file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space. end: string appended after the last value, default a newline. flush: whether to forcibly flush the stream.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L651">view source</a></div></div><div class="public anchor" id="var-ProcessLookupError"><h3>ProcessLookupError</h3><div class="usage"><code>(ProcessLookupError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Process not found.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L423">view source</a></div></div><div class="public anchor" id="var-property"><h3>property</h3><div class="usage"><code>(property self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Property attribute.</p>
+<p>fget  function to be used for getting an attribute value  fset  function to be used for setting an attribute value  fdel  function to be used for del’ing an attribute  doc  docstring</p>
+<p>Typical use is to define a managed attribute x:</p>
+<p>class C(object):  def getx(self): return self._x  def setx(self, value): self._x = value  def delx(self): del self._x  x = property(getx, setx, delx, “I’m the ‘x’ property.”)</p>
+<p>Decorators make defining new properties or modifying existing ones easy:</p>
+<p>class C(object):  @property  def x(self):  “I am the ‘x’ property.”  return self._x  @x.setter  def x(self, value):  self._x = value  @x.deleter  def x(self):  del self._x</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L501">view source</a></div></div><div class="public anchor" id="var-PyAssertionError"><h3>PyAssertionError</h3><div class="usage"><code>(PyAssertionError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Assertion failed.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L667">view source</a></div></div><div class="public anchor" id="var-PyException"><h3>PyException</h3><div class="usage"><code>(PyException self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Common base class for all non-exit exceptions.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L924">view source</a></div></div><div class="public anchor" id="var-quit"><h3>quit</h3><div class="usage"><code>(quit self name eof)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L414">view source</a></div></div><div class="public anchor" id="var-range"><h3>range</h3><div class="usage"><code>(range self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>range(stop) -&gt; range object range(start, stop[, step]) -&gt; range object</p>
+<p>Return an object that produces a sequence of integers from start (inclusive) to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, …, j-1. start defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3. These are exactly the valid indices for a list of 4 elements. When step is given, it specifies the increment (or decrement).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L50">view source</a></div></div><div class="public anchor" id="var-RecursionError"><h3>RecursionError</h3><div class="usage"><code>(RecursionError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Recursion limit exceeded.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L22">view source</a></div></div><div class="public anchor" id="var-ReferenceError"><h3>ReferenceError</h3><div class="usage"><code>(ReferenceError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Weak ref proxy used after referent went away.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L362">view source</a></div></div><div class="public anchor" id="var-repr"><h3>repr</h3><div class="usage"><code>(repr obj)</code></div><div class="doc"><div class="markdown"><p>Return the canonical string representation of the object.</p>
+<p>For many object types, including most builtins, eval(repr(obj)) == obj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L227">view source</a></div></div><div class="public anchor" id="var-ResourceWarning"><h3>ResourceWarning</h3><div class="usage"><code>(ResourceWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about resource usage.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L154">view source</a></div></div><div class="public anchor" id="var-reversed"><h3>reversed</h3><div class="usage"><code>(reversed self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a reverse iterator over the values of the given sequence.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L88">view source</a></div></div><div class="public anchor" id="var-round"><h3>round</h3><div class="usage"><code>(round number &amp; [{ndigits :ndigits}])</code><code>(round number)</code></div><div class="doc"><div class="markdown"><p>Round a number to a given precision in decimal digits.</p>
+<p>The return value is an integer if ndigits is omitted or None. Otherwise the return value has the same type as the number. ndigits may be negative.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L871">view source</a></div></div><div class="public anchor" id="var-RuntimeError"><h3>RuntimeError</h3><div class="usage"><code>(RuntimeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unspecified run-time error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L930">view source</a></div></div><div class="public anchor" id="var-RuntimeWarning"><h3>RuntimeWarning</h3><div class="usage"><code>(RuntimeWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about dubious runtime behavior.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L411">view source</a></div></div><div class="public anchor" id="var-set"><h3>set</h3><div class="usage"><code>(set self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>set() -&gt; new empty set object set(iterable) -&gt; new set object</p>
+<p>Build an unordered collection of unique elements.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L678">view source</a></div></div><div class="public anchor" id="var-setattr"><h3>setattr</h3><div class="usage"><code>(setattr obj name value)</code></div><div class="doc"><div class="markdown"><p>Sets the named attribute on the given object to the specified value.</p>
+<p>setattr(x, ‘y’, v) is equivalent to ``x.y = v’’</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L589">view source</a></div></div><div class="public anchor" id="var-slice"><h3>slice</h3><div class="usage"><code>(slice self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>slice(stop) slice(start, stop[, step])</p>
+<p>Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L642">view source</a></div></div><div class="public anchor" id="var-sorted"><h3>sorted</h3><div class="usage"><code>(sorted iterable &amp; [{key :key, reverse :reverse}])</code></div><div class="doc"><div class="markdown"><p>Return a new list containing all items from the iterable in ascending order.</p>
+<p>A custom key function can be supplied to customize the sort order, and the reverse flag can be set to request the result in descending order.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L221">view source</a></div></div><div class="public anchor" id="var-staticmethod"><h3>staticmethod</h3><div class="usage"><code>(staticmethod self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>staticmethod(function) -&gt; method</p>
+<p>Convert a function to be a static method.</p>
+<p>A static method does not receive an implicit first argument. To declare a static method, use this idiom:</p>
+<pre><code> class C:
+     @staticmethod
+     def f(arg1, arg2, ...):
+         ...
+</code></pre>
+<p>It can be called either on the class (e.g. C.f()) or on an instance (e.g. C().f()). Both the class and the instance are ignored, and neither is passed implicitly as the first argument to the method.</p>
+<p>Static methods in Python are similar to those found in Java or C++. For a more advanced concept, see the classmethod builtin.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L127">view source</a></div></div><div class="public anchor" id="var-StopAsyncIteration"><h3>StopAsyncIteration</h3><div class="usage"><code>(StopAsyncIteration self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signal the end from iterator.__anext__().</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L949">view source</a></div></div><div class="public anchor" id="var-StopIteration"><h3>StopIteration</h3><div class="usage"><code>(StopIteration self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signal the end from iterator.__next__().</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L946">view source</a></div></div><div class="public anchor" id="var-str"><h3>str</h3><div class="usage"><code>(str self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>str(object=’’) -&gt; str str(bytes_or_buffer[, encoding[, errors]]) -&gt; str</p>
+<p>Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to ‘strict’.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L195">view source</a></div></div><div class="public anchor" id="var-sum"><h3>sum</h3><div class="usage"><code>(sum iterable &amp; [{start :start}])</code><code>(sum iterable)</code></div><div class="doc"><div class="markdown"><p>Return the sum of a ‘start’ value (default: 0) plus an iterable of numbers</p>
+<p>When the iterable is empty, return the start value. This function is intended specifically for use with numeric values and may reject non-numeric types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L188">view source</a></div></div><div class="public anchor" id="var-super"><h3>super</h3><div class="usage"><code>(super self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>super() -&gt; same as super(__class__, <first argument="">) super(type) -&gt; unbound super object super(type, obj) -&gt; bound super object; requires isinstance(obj, type) super(type, type2) -&gt; bound super object; requires issubclass(type2, type) Typical use to call a cooperative superclass method: class C(B):  def meth(self, arg):  super().meth(arg) This works for class methods too: class C(B):  @classmethod  def cmeth(cls, arg):  super().cmeth(arg)</first></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L317">view source</a></div></div><div class="public anchor" id="var-SyntaxError"><h3>SyntaxError</h3><div class="usage"><code>(SyntaxError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Invalid syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L393">view source</a></div></div><div class="public anchor" id="var-SyntaxWarning"><h3>SyntaxWarning</h3><div class="usage"><code>(SyntaxWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about dubious syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L115">view source</a></div></div><div class="public anchor" id="var-SystemError"><h3>SystemError</h3><div class="usage"><code>(SystemError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Internal error in the Python interpreter.</p>
+<p>Please report this to the Python maintainer, along with the traceback, the Python version, and the hardware/OS platform and version.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L252">view source</a></div></div><div class="public anchor" id="var-SystemExit"><h3>SystemExit</h3><div class="usage"><code>(SystemExit self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Request to exit from the interpreter.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L865">view source</a></div></div><div class="public anchor" id="var-TabError"><h3>TabError</h3><div class="usage"><code>(TabError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Improper mixture of spaces and tabs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L648">view source</a></div></div><div class="public anchor" id="var-TimeoutError"><h3>TimeoutError</h3><div class="usage"><code>(TimeoutError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Timeout expired.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L277">view source</a></div></div><div class="public anchor" id="var-True"><h3>True</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L911">view source</a></div></div><div class="public anchor" id="var-tuple"><h3>tuple</h3><div class="usage"><code>(tuple self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Built-in immutable sequence.</p>
+<p>If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.</p>
+<p>If the argument is a tuple, the return value is the same object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L696">view source</a></div></div><div class="public anchor" id="var-type"><h3>type</h3><div class="usage"><code>(type self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>type(object_or_name, bases, dict) type(object) -&gt; the object’s type type(name, bases, dict) -&gt; a new type</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L603">view source</a></div></div><div class="public anchor" id="var-TypeError"><h3>TypeError</h3><div class="usage"><code>(TypeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Inappropriate argument type.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L60">view source</a></div></div><div class="public anchor" id="var-UnboundLocalError"><h3>UnboundLocalError</h3><div class="usage"><code>(UnboundLocalError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Local name referenced but not bound to a value.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L707">view source</a></div></div><div class="public anchor" id="var-UnicodeDecodeError"><h3>UnicodeDecodeError</h3><div class="usage"><code>(UnicodeDecodeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unicode decoding error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L297">view source</a></div></div><div class="public anchor" id="var-UnicodeEncodeError"><h3>UnicodeEncodeError</h3><div class="usage"><code>(UnicodeEncodeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unicode encoding error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L396">view source</a></div></div><div class="public anchor" id="var-UnicodeError"><h3>UnicodeError</h3><div class="usage"><code>(UnicodeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unicode related error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L365">view source</a></div></div><div class="public anchor" id="var-UnicodeTranslateError"><h3>UnicodeTranslateError</h3><div class="usage"><code>(UnicodeTranslateError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unicode translation error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L294">view source</a></div></div><div class="public anchor" id="var-UnicodeWarning"><h3>UnicodeWarning</h3><div class="usage"><code>(UnicodeWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about Unicode related problems, mostly related to conversion problems.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L882">view source</a></div></div><div class="public anchor" id="var-UserWarning"><h3>UserWarning</h3><div class="usage"><code>(UserWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings generated by user code.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L639">view source</a></div></div><div class="public anchor" id="var-ValueError"><h3>ValueError</h3><div class="usage"><code>(ValueError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Inappropriate argument value (of correct type).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L713">view source</a></div></div><div class="public anchor" id="var-vars"><h3>vars</h3><div class="usage"><code>(vars self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>vars([object]) -&gt; dictionary</p>
+<p>Without arguments, equivalent to locals(). With an argument, equivalent to object.__dict__.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L961">view source</a></div></div><div class="public anchor" id="var-Warning"><h3>Warning</h3><div class="usage"><code>(Warning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warning categories.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L374">view source</a></div></div><div class="public anchor" id="var-ZeroDivisionError"><h3>ZeroDivisionError</h3><div class="usage"><code>(ZeroDivisionError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Second argument to a division or modulo operation was zero.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L611">view source</a></div></div><div class="public anchor" id="var-zip"><h3>zip</h3><div class="usage"><code>(zip self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>zip(*iterables) –&gt; A zip object yielding tuples until an input is exhausted.</p>
+<p>&gt;&gt;&gt; list(zip(‘abcdefg’, range(3), range(4)))  [(‘a’, 0, 0), (‘b’, 1, 1), (‘c’, 2, 2)]</p>
+<p>The zip object yields n-length tuples, where n is the number of iterables passed as positional arguments to zip(). The i-th element in every tuple comes from the i-th iterable argument to zip(). This continues until the shortest argument is exhausted.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L913">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 5c28049..3808ecd 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 0d59294..83259d3 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-3</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 4d8509b..c5ac013 100644
--- a/project.clj
+++ b/project.clj
@@ -24,8 +24,8 @@
                       :doc-paths ["topics"]
                       :source-uri "https://github.com/clj-python/libpython-clj/blob/master/{filepath}#L{line}"
                       :namespaces [libpython-clj2.python
-                                   libpython-clj2.require
-                                   libpython-clj2.python.np-array]}}}
-  :aliases {"codox" ["with-profile" "codox,dev" "codox"]}
-
-  )
+                                   libpython-clj2.codegen
+                                   libpython-clj2.python.np-array
+                                   python.builtins
+                                   python.numpy]}}}
+  :aliases {"codox" ["with-profile" "codox,dev" "codox"]})
diff --git a/src/libpython_clj2/codegen.clj b/src/libpython_clj2/codegen.clj
new file mode 100644
index 0000000..541d97d
--- /dev/null
+++ b/src/libpython_clj2/codegen.clj
@@ -0,0 +1,200 @@
+(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 %s (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* \"%s\"))))
+(alter-meta! #'%s assoc :doc \"%s\" :arglists '%s)"
+                  clj-name
+                  k
+                  clj-name
+                  (get-docs v)
+                  (:arglists v))))
+
+
+(defn- output-module-generic
+  [^Writer writer clj-name k v]
+  (.write writer
+          (format "
+
+(def ^{:doc \"%s\"} %s (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* \"%s\"))))"
+                  (get-docs v)
+                  clj-name
+                  k)))
+
+
+(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])
+
+
+(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 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)
+                        (map? v)
+                        (py/has-attr? target k))
+               (let [clj-name (get symbol-name-remaps k k)]
+                 ;;If the value is atomic
+                 (if (or (string? v)
+                         (number? v)
+                         (boolean? v))
+                   (.write writer (format "\n\n(def ^{:doc %s} %s %s)"
+                                          (escape-quotes (:doc v "No documentation"))
+                                          clj-name
+                                          (if (string? v)
+                                            (str "\"" (escape-quotes v) "\"")
+                                            v)))
+                   (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))))))))
+         :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")
+    )
+  )
diff --git a/src/libpython_clj2/metadata.clj b/src/libpython_clj2/metadata.clj
index a4fdc3f..6cfa8d1 100644
--- a/src/libpython_clj2/metadata.clj
+++ b/src/libpython_clj2/metadata.clj
@@ -130,13 +130,15 @@
                               (drop n-pos-args)
                               (map symbol)
                               (into []))
-         or-map          (->> (concat
-                               (interleave kw-default-args defaults)
-                               (flatten (seq kwonlydefaults)))
-                              (partition-all 2)
-                              (map vec)
-                              (map (fn [[k v]] [(symbol k) v]))
-                              (into {}))
+
+         ;;These sometimes have actual python symbols in them so we can't use them
+         ;; or-map          (->> (concat
+         ;;                       (interleave kw-default-args defaults)
+         ;;                       (flatten (seq kwonlydefaults)))
+         ;;                      (partition-all 2)
+         ;;                      (map vec)
+         ;;                      (map (fn [[k v]] [(symbol k) v]))
+         ;;                      (into {}))
          as-varkw    (when (not (nil? varkw))
                        {:as (symbol varkw)})
          default-map (->> (concat
@@ -148,8 +150,6 @@
                           (into {}))
 
          kwargs-map (merge default-map
-                           (when (not-empty or-map)
-                             {:or or-map})
                            (when (not-empty as-varkw)
                              as-varkw))
          opt-args
@@ -311,37 +311,6 @@
       val)))
 
 
-(defn module-path-string
-  "Given a.b, return a
-   Given a.b.c, return a.b
-   Given a.b.c.d, return a.b.c  etc."
-  [x]
-  (clojure.string/join
-   "."
-   (pop (clojure.string/split (str x) #"[.]"))))
-
-
-(defn module-path-last-string
-  "Given a.b.c.d, return d"
-  [x]
-  (last (clojure.string/split (str x) #"[.]")))
-
-
-(defn path->py-obj
-  [item-path & {:keys [reload?]}]
-  (when (seq item-path)
-    (if-let [module-retval (try
-                             (import-module item-path)
-                             (catch Throwable e nil))]
-      (if reload?
-        (reload-module module-retval)
-        module-retval)
-      (let [butlast (module-path-string item-path)]
-        (if-let [parent-mod (path->py-obj butlast :reload? reload?)]
-          (get-attr parent-mod (module-path-last-string item-path))
-          (throw (Exception. (format "Failed to find module or class %s"
-                                     item-path))))))))
-
 
 (defn metadata-map->py-obj
   [metadata-map]
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 4f48320..3fe6570 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -247,13 +247,13 @@ user> (py/py. np linspace 2 3 :num 10)
 (defn as-map
   "Make a python object appear as a map of it's items"
   ^Map [pobj]
-  (py-bridge-jvm/generic-python-as-map pobj))
+  (py-bridge-jvm/generic-python-as-map (delay pobj)))
 
 
 (defn as-list
   "Make a python object appear as a list"
   ^List [pobj]
-  (py-bridge-jvm/generic-python-as-list pobj))
+  (py-bridge-jvm/generic-python-as-list (delay pobj)))
 
 
 (defn python-type
@@ -573,3 +573,42 @@ user> (py/call-attr inst \"addarg\" 10)
   Python."
   [x & args]
   (apply handle-pydotdot x args))
+
+
+(defn- module-path-string
+  "Given a.b, return a
+   Given a.b.c, return a.b
+   Given a.b.c.d, return a.b.c  etc."
+  [x]
+  (clojure.string/join
+   "."
+   (pop (clojure.string/split (str x) #"[.]"))))
+
+
+(defn- module-path-last-string
+  "Given a.b.c.d, return d"
+  [x]
+  (last (clojure.string/split (str x) #"[.]")))
+
+
+(defn path->py-obj
+  "Given a string such as \"builtins\" or \"builtins.list\", load the module or
+  the class object in the module.
+
+  Options:
+
+  * `:reload` - Reload the module."
+  [item-path & {:keys [reload?]}]
+  (when (seq item-path)
+    (if-let [module-retval (try
+                             (import-module item-path)
+                             (catch Throwable e nil))]
+      (if reload?
+        (let [import-lib (import-module "importlib")]
+          (call-attr import-lib "reload" item-path))
+        module-retval)
+      (let [butlast (module-path-string item-path)]
+        (if-let [parent-mod (path->py-obj butlast :reload? reload?)]
+          (get-attr parent-mod (module-path-last-string item-path))
+          (throw (Exception. (format "Failed to find module or class %s"
+                                     item-path))))))))
diff --git a/src/libpython_clj2/python/bridge_as_jvm.clj b/src/libpython_clj2/python/bridge_as_jvm.clj
index 58a6166..d0329e4 100644
--- a/src/libpython_clj2/python/bridge_as_jvm.clj
+++ b/src/libpython_clj2/python/bridge_as_jvm.clj
@@ -146,57 +146,57 @@
 
 (defmacro bridge-pyobject
   [pyobj & body]
-  `(let [pyobj# ~pyobj]
+  `(let [pyobj*# ~pyobj]
      (with-meta
        (reify
          dt-ffi/PToPointer
          (convertible-to-pointer? [item#] true)
-         (->pointer [item#] (dt-ffi/->pointer pyobj#))
+         (->pointer [item#] (dt-ffi/->pointer @pyobj*#))
          py-proto/PPythonType
          (get-python-type [item]
-           (with-gil (py-proto/get-python-type pyobj#)))
+           (with-gil (py-proto/get-python-type @pyobj*#)))
          py-proto/PCopyToPython
-         (py-base/->python [item# options#] pyobj#)
+         (py-base/->python [item# options#] @pyobj*#)
          py-proto/PBridgeToPython
-         (py-base/as-python [item# options#] pyobj#)
+         (py-base/as-python [item# options#] @pyobj*#)
          py-proto/PBridgeToJVM
          (py-base/as-jvm [item# options#] item#)
          py-proto/PCopyToJVM
          (->jvm [item# options#]
            (with-gil
-             (py-base/->jvm pyobj# options#)))
+             (py-base/->jvm @pyobj*# options#)))
          py-proto/PPyDir
          (dir [item#]
-           (with-gil (py-proto/dir pyobj#)))
+           (with-gil (py-proto/dir @pyobj*#)))
          py-proto/PPyAttr
          (has-attr? [item# item-name#]
            (with-gil
-             (py-proto/has-attr? pyobj# item-name#)))
+             (py-proto/has-attr? @pyobj*# item-name#)))
          (get-attr [item# item-name#]
            (with-gil
-             (-> (py-proto/get-attr pyobj# item-name#)
+             (-> (py-proto/get-attr @pyobj*# item-name#)
                  py-base/as-jvm)))
          (set-attr! [item# item-name# item-value#]
            (with-gil
              (py-ffi/with-decref [item-value# (py-ffi/untracked->python
                                                item-value# py-base/->python)]
-               (py-proto/set-attr! pyobj# item-name# item-value#))))
+               (py-proto/set-attr! @pyobj*# item-name# item-value#))))
          py-proto/PPyItem
          (has-item? [item# item-name#]
            (with-gil
-             (py-proto/has-item? pyobj# item-name#)))
+             (py-proto/has-item? @pyobj*# item-name#)))
          (get-item [item# item-name#]
            (with-gil
-             (-> (py-proto/get-item pyobj# item-name#)
+             (-> (py-proto/get-item @pyobj*# item-name#)
                  py-base/as-jvm)))
          (set-item! [item# item-name# item-value#]
            (with-gil
              (py-ffi/with-decref [item-value# (py-ffi/untracked->python
                                                item-value# py-base/->python)]
-               (py-proto/set-item! pyobj# item-name# item-value#))))
+               (py-proto/set-item! @pyobj*# item-name# item-value#))))
          py-proto/PyCall
          (call [callable# arglist# kw-arg-map#]
-           (-> (py-fn/call-py-fn pyobj# arglist# kw-arg-map# py-base/->python)
+           (-> (py-fn/call-py-fn @pyobj*# arglist# kw-arg-map# py-base/->python)
                (py-base/as-jvm)))
          (marshal-return [callable# retval#]
            (py-base/as-jvm retval#))
@@ -206,19 +206,19 @@
          (toString [this#]
            (with-gil
              (pygc/with-stack-context
-               (if (= 1 (py-ffi/PyObject_IsInstance pyobj# (py-ffi/py-type-type)))
+               (if (= 1 (py-ffi/PyObject_IsInstance @pyobj*# (py-ffi/py-type-type)))
                  (format "%s.%s"
-                         (if (py-proto/has-attr? pyobj# "__module__")
-                           (py-base/->jvm (py-proto/get-attr pyobj# "__module__"))
+                         (if (py-proto/has-attr? @pyobj*# "__module__")
+                           (py-base/->jvm (py-proto/get-attr @pyobj*# "__module__"))
                            "__no_module__")
-                         (if (py-proto/has-attr? pyobj# "__name__")
-                           (py-base/->jvm (py-proto/get-attr pyobj# "__name__"))
+                         (if (py-proto/has-attr? @pyobj*# "__name__")
+                           (py-base/->jvm (py-proto/get-attr @pyobj*# "__name__"))
                            "__unnamed__"))
-                 (py-base/->jvm (py-fn/call-attr pyobj# "__str__" nil))))))
+                 (py-base/->jvm (py-fn/call-attr @pyobj*# "__str__" nil))))))
          (equals [this# other#]
            (boolean
             (when (dt-ffi/convertible-to-pointer? other#)
-              (py-base/equals? pyobj# other#))))
+              (py-base/equals? @pyobj*# other#))))
          (hashCode [this#]
            (.hashCode ^Object (py-base/hash-code this#)))
          ~@body)
@@ -243,35 +243,35 @@
 
 
 (defn make-dict-att-map
-  [pyobj attnames]
+  [pyobj* attnames]
   (let [dict-atts (set attnames)
         gc-ctx (pygc/gc-context)]
-    (->> (py-proto/dir pyobj)
+    (->> (py-proto/dir @pyobj*)
          (filter dict-atts)
          (map (juxt identity #(delay
                                 (pygc/with-gc-context gc-ctx
-                                  (py-proto/get-attr pyobj %)))))
+                                  (py-proto/get-attr @pyobj* %)))))
          (into {}))))
 
 
 (defn make-instance-pycall
-  [pyobj attnames]
-  (let [dict-att-map (make-dict-att-map pyobj attnames)]
+  [pyobj* attnames]
+  (let [dict-att-map (make-dict-att-map pyobj* attnames)]
     (fn [fn-name & args]
       (py-ffi/with-gil (call-impl-fn fn-name dict-att-map args)))))
 
 
 
 (defn generic-python-as-map
-  [pyobj]
+  [pyobj*]
   (with-gil
     (let [py-call
           (make-instance-pycall
-           pyobj
+           pyobj*
            #{"__len__" "__getitem__" "__setitem__" "__iter__" "__contains__"
              "__eq__" "__hash__" "clear" "keys" "values" "__delitem__"})]
       (bridge-pyobject
-       pyobj
+       pyobj*
        Map
        (clear [item] (py-call "clear"))
        (containsKey [item k] (boolean (py-call "__contains__" k)))
@@ -306,7 +306,7 @@
        (iterator
         [this]
         (let [mapentry-seq
-              (->> (python->jvm-iterator pyobj nil)
+              (->> (python->jvm-iterator @pyobj* nil)
                    iterator-seq
                    (map (fn [pyobj-key]
                           (with-gil
@@ -327,19 +327,19 @@
 
 (defmethod py-proto/pyobject-as-jvm :dict
   [pyobj & [opts]]
-  (generic-python-as-map pyobj))
+  (generic-python-as-map (delay pyobj)))
 
 
 (defn generic-python-as-list
-  [pyobj]
+  [pyobj*]
   (with-gil
     (let [py-call (make-instance-pycall
-                  pyobj
+                  pyobj*
                   #{"__len__" "__getitem__" "__setitem__" "__iter__" "__contains__"
                     "__eq__" "__hash__" "clear" "insert" "pop" "append"
                     "__delitem__" "sort"})]
       (bridge-pyobject
-       pyobj
+       pyobj*
        ObjectBuffer
        (lsize [reader]
               (long (py-call "__len__")))
@@ -352,21 +352,24 @@
        (writeObject [writer idx value]
               (py-call "__setitem__" idx value))
        (remove [writer ^int idx]
-               (py-call "__delitem__" idx))
+               (py-call "__delitem__" idx)
+               true)
        (add [mutable idx value]
-            (py-call "insert" idx value))
+            (py-call "insert" idx value)
+            true)
        (add [mutable value]
-            (.add mutable (.size mutable) value))))))
+            (.add mutable (.size mutable) value)
+            true)))))
 
 
 (defmethod py-proto/pyobject-as-jvm :list
   [pyobj & [opts]]
-  (generic-python-as-list pyobj))
+  (generic-python-as-list (delay pyobj)))
 
 
 (defmethod py-proto/pyobject-as-jvm :tuple
   [pyobj & [opts]]
-  (generic-python-as-list pyobj))
+  (generic-python-as-list (delay pyobj)))
 
 
 ;;utility fn to generate IFn arities
@@ -399,37 +402,47 @@
    If caller supplies an implementation for clojure.lang.IFn or aliased
    Fn, the macro will use that instead (allowing more control but
    requiring caller to specify implementations for all desired arities)."
-  [pyobj interpreter & body]
+  [pyobj* interpreter & body]
   (let [fn-specs (when-not (some #{'IFn 'clojure.lang.IFn} body)
                    `(~'IFn
                      ~@(emit-py-args)
                      (~'applyTo [~'this ~'arglist]
                       (~'apply py-fn/cfn ~'this ~'arglist))))]
-    `(bridge-pyobject ~pyobj ~interpreter
+    `(bridge-pyobject ~pyobj* ~interpreter
                       ~@fn-specs
                       ~@body)))
 
 
+(defn generic-callable-pyobject
+  [pyobj*]
+  (bridge-callable-pyobject
+   pyobj*
+   Iterable
+   (iterator [this] (python->jvm-iterator @pyobj* py-base/as-jvm))
+   Fn))
+
+
+(defn generic-pyobject
+  [pyobj*]
+  (bridge-pyobject
+   pyobj*
+   Iterable
+   (iterator [this] (python->jvm-iterator @pyobj*  py-base/as-jvm))))
+
+
 (defn generic-python-as-jvm
   "Given a generic pyobject, wrap it in a read-only map interface
   where the keys are the attributes."
-  [pyobj]
+  [pyobj*]
   (with-gil
-    (if (= :none-type (py-ffi/pyobject-type-kwd pyobj))
+    (if (= :none-type (py-ffi/pyobject-type-kwd @pyobj*))
       nil
-      (if (py-proto/callable? pyobj)
-        (bridge-callable-pyobject
-         pyobj
-         Iterable
-         (iterator [this] (python->jvm-iterator pyobj py-base/as-jvm))
-         Fn)
-        (bridge-pyobject
-         pyobj
-         Iterable
-         (iterator [this] (python->jvm-iterator pyobj  py-base/as-jvm)))))))
+      (if (py-proto/callable? @pyobj*)
+        (generic-callable-pyobject pyobj*)
+        (generic-pyobject pyobj*)))))
 
 
 
 (defmethod py-proto/pyobject-as-jvm :default
   [pyobj & [opts]]
-  (generic-python-as-jvm pyobj))
+  (generic-python-as-jvm (delay pyobj)))
diff --git a/src/libpython_clj2/python/jvm_handle.clj b/src/libpython_clj2/python/jvm_handle.clj
index ec0b153..f67fe1c 100644
--- a/src/libpython_clj2/python/jvm_handle.clj
+++ b/src/libpython_clj2/python/jvm_handle.clj
@@ -2,7 +2,8 @@
   "Conversion of a jvm object into an integer and back.  Used for storing handles
   on python proxies."
   (:require [libpython-clj2.python.protocols :as py-proto]
-            [libpython-clj2.python.gc :as pygc])
+            [libpython-clj2.python.gc :as pygc]
+            [libpython-clj2.python.ffi :as py-ffi])
   (:import [java.util.concurrent ConcurrentHashMap]
            [java.util UUID]))
 
diff --git a/src/libpython_clj2/require.clj b/src/libpython_clj2/require.clj
index e60657c..08fe66d 100644
--- a/src/libpython_clj2/require.clj
+++ b/src/libpython_clj2/require.clj
@@ -106,7 +106,7 @@
                               (= :all (:refer etc)) #{:all}
                               (= :* (:refer etc))   #{:*}
                               :else                 (into #{} (:refer etc)))
-        pyobj               (pymeta/path->py-obj (str module-name) :reload? reload?)
+        pyobj               (py/path->py-obj (str module-name) :reload? reload?)
         existing-py-ns?     (find-ns module-name)]
     (create-ns module-name)
 
diff --git a/src/python/builtins.clj b/src/python/builtins.clj
new file mode 100644
index 0000000..98c03f0
--- /dev/null
+++ b/src/python/builtins.clj
@@ -0,0 +1,975 @@
+(ns python.builtins
+"No documentation provided"
+(: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 [+ - * / 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]))
+
+(defonce ^:private src-obj* (py-global-delay (py/path->py-obj "builtins")))
+
+(def float (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float"))))
+(alter-meta! #'float assoc :doc "Convert a string or number to a floating point number, if possible." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ConnectionResetError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ConnectionResetError"))))
+(alter-meta! #'ConnectionResetError assoc :doc "Connection reset." :arglists '[[self & [args {:as kwargs}]]])
+
+(def map (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "map"))))
+(alter-meta! #'map assoc :doc "map(func, *iterables) --> map object
+
+Make an iterator that computes the function using arguments from
+each of the iterables.  Stops when the shortest iterable is exhausted." :arglists '[[self & [args {:as kwargs}]]])
+
+(def RecursionError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "RecursionError"))))
+(alter-meta! #'RecursionError assoc :doc "Recursion limit exceeded." :arglists '[[self & [args {:as kwargs}]]])
+
+(def int (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int"))))
+(alter-meta! #'int assoc :doc "int([x]) -> integer
+int(x, base=10) -> integer
+
+Convert a number or string to an integer, or return 0 if no arguments
+are given.  If x is a number, return x.__int__().  For floating point
+numbers, this truncates towards zero.
+
+If x is not a number or if base is given, then x must be a string,
+bytes, or bytearray instance representing an integer literal in the
+given base.  The literal can be preceded by '+' or '-' and be surrounded
+by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
+Base 0 means to interpret the base from the string as an integer literal.
+>>> int('0b100', base=0)
+4" :arglists '[[self & [args {:as kwargs}]]])
+
+(def object (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "object"))))
+(alter-meta! #'object assoc :doc "The base class of the class hierarchy.
+
+When called, it accepts no arguments and returns a new featureless
+instance that has no instance attributes and cannot be given any.
+" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} NotImplemented (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "NotImplemented"))))
+
+(def range (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "range"))))
+(alter-meta! #'range assoc :doc "range(stop) -> range object
+range(start, stop[, step]) -> range object
+
+Return an object that produces a sequence of integers from start (inclusive)
+to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
+start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
+These are exactly the valid indices for a list of 4 elements.
+When step is given, it specifies the increment (or decrement)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def TypeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "TypeError"))))
+(alter-meta! #'TypeError assoc :doc "Inappropriate argument type." :arglists '[[self & [args {:as kwargs}]]])
+
+(def PermissionError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "PermissionError"))))
+(alter-meta! #'PermissionError assoc :doc "Not enough permissions." :arglists '[[self & [args {:as kwargs}]]])
+
+(def MemoryError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "MemoryError"))))
+(alter-meta! #'MemoryError assoc :doc "Out of memory." :arglists '[[self & [args {:as kwargs}]]])
+
+(def KeyboardInterrupt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "KeyboardInterrupt"))))
+(alter-meta! #'KeyboardInterrupt assoc :doc "Program interrupted by user." :arglists '[[self & [args {:as kwargs}]]])
+
+(def BytesWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "BytesWarning"))))
+(alter-meta! #'BytesWarning assoc :doc "Base class for warnings about bytes and buffer related problems, mostly
+related to conversion from str or comparing to str." :arglists '[[self & [args {:as kwargs}]]])
+
+(def min (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "min"))))
+(alter-meta! #'min assoc :doc "min(iterable, *[, default=obj, key=func]) -> value
+min(arg1, arg2, *args, *[, key=func]) -> value
+
+With a single iterable argument, return its smallest item. The
+default keyword-only argument specifies an object to return if
+the provided iterable is empty.
+With two or more arguments, return the smallest argument." :arglists '[[self & [args {:as kwargs}]]])
+
+(def FileNotFoundError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "FileNotFoundError"))))
+(alter-meta! #'FileNotFoundError assoc :doc "File not found." :arglists '[[self & [args {:as kwargs}]]])
+
+(def reversed (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "reversed"))))
+(alter-meta! #'reversed assoc :doc "Return a reverse iterator over the values of the given sequence." :arglists '[[self & [args {:as kwargs}]]])
+
+(def list (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "list"))))
+(alter-meta! #'list assoc :doc "Built-in mutable sequence.
+
+If no argument is given, the constructor creates a new empty list.
+The argument must be an iterable if specified." :arglists '[[self & [args {:as kwargs}]]])
+
+(def license (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "license"))))
+(alter-meta! #'license assoc :doc "interactive prompt objects for printing the license text, a list of
+    contributors and the copyright notice." :arglists '[[self name data & [{files :files, dirs :dirs}]] [self name data & [{files :files}]] [self name data]])
+
+(def ascii (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ascii"))))
+(alter-meta! #'ascii assoc :doc "Return an ASCII-only representation of an object.
+
+As repr(), return a string containing a printable representation of an
+object, but escape the non-ASCII characters in the string returned by
+repr() using \\\\x, \\\\u or \\\\U escapes. This generates a string similar
+to that returned by repr() in Python 2." :arglists '[[obj]])
+
+(def next (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "next"))))
+(alter-meta! #'next assoc :doc "next(iterator[, default])
+
+Return the next item from the iterator. If default is given and the iterator
+is exhausted, it is returned instead of raising StopIteration." :arglists '[[self & [args {:as kwargs}]]])
+
+(def SyntaxWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "SyntaxWarning"))))
+(alter-meta! #'SyntaxWarning assoc :doc "Base class for warnings about dubious syntax." :arglists '[[self & [args {:as kwargs}]]])
+
+(def chr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "chr"))))
+(alter-meta! #'chr assoc :doc "Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff." :arglists '[[i]])
+
+(def ArithmeticError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ArithmeticError"))))
+(alter-meta! #'ArithmeticError assoc :doc "Base class for arithmetic errors." :arglists '[[self & [args {:as kwargs}]]])
+
+(def BlockingIOError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "BlockingIOError"))))
+(alter-meta! #'BlockingIOError assoc :doc "I/O operation would block." :arglists '[[self & [args {:as kwargs}]]])
+
+(def staticmethod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "staticmethod"))))
+(alter-meta! #'staticmethod assoc :doc "staticmethod(function) -> method
+
+Convert a function to be a static method.
+
+A static method does not receive an implicit first argument.
+To declare a static method, use this idiom:
+
+     class C:
+         @staticmethod
+         def f(arg1, arg2, ...):
+             ...
+
+It can be called either on the class (e.g. C.f()) or on an instance
+(e.g. C().f()). Both the class and the instance are ignored, and
+neither is passed implicitly as the first argument to the method.
+
+Static methods in Python are similar to those found in Java or C++.
+For a more advanced concept, see the classmethod builtin." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ImportWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ImportWarning"))))
+(alter-meta! #'ImportWarning assoc :doc "Base class for warnings about probable mistakes in module imports" :arglists '[[self & [args {:as kwargs}]]])
+
+(def FutureWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "FutureWarning"))))
+(alter-meta! #'FutureWarning assoc :doc "Base class for warnings about constructs that will change semantically
+in the future." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ResourceWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ResourceWarning"))))
+(alter-meta! #'ResourceWarning assoc :doc "Base class for warnings about resource usage." :arglists '[[self & [args {:as kwargs}]]])
+
+(def classmethod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "classmethod"))))
+(alter-meta! #'classmethod assoc :doc "classmethod(function) -> method
+
+Convert a function to be a class method.
+
+A class method receives the class as implicit first argument,
+just like an instance method receives the instance.
+To declare a class method, use this idiom:
+
+  class C:
+      @classmethod
+      def f(cls, arg1, arg2, ...):
+          ...
+
+It can be called either on the class (e.g. C.f()) or on an instance
+(e.g. C().f()).  The instance is ignored except for its class.
+If a class method is called for a derived class, the derived class
+object is passed as the implied first argument.
+
+Class methods are different than C++ or Java static methods.
+If you want those, see the staticmethod builtin." :arglists '[[self & [args {:as kwargs}]]])
+
+(def IndexError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "IndexError"))))
+(alter-meta! #'IndexError assoc :doc "Sequence index out of range." :arglists '[[self & [args {:as kwargs}]]])
+
+(def hex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hex"))))
+(alter-meta! #'hex assoc :doc "Return the hexadecimal representation of an integer.
+
+   >>> hex(12648430)
+   '0xc0ffee'" :arglists '[[number]])
+
+(def sum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sum"))))
+(alter-meta! #'sum assoc :doc "Return the sum of a 'start' value (default: 0) plus an iterable of numbers
+
+When the iterable is empty, return the start value.
+This function is intended specifically for use with numeric values and may
+reject non-numeric types." :arglists '[[iterable & [{start :start}]] [iterable]])
+
+(def str (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "str"))))
+(alter-meta! #'str assoc :doc "str(object='') -> str
+str(bytes_or_buffer[, encoding[, errors]]) -> str
+
+Create a new string object from the given object. If encoding or
+errors is specified, then the object must expose a data buffer
+that will be decoded using the given encoding and error handler.
+Otherwise, returns the result of object.__str__() (if defined)
+or repr(object).
+encoding defaults to sys.getdefaultencoding().
+errors defaults to 'strict'." :arglists '[[self & [args {:as kwargs}]]])
+
+(def hash (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hash"))))
+(alter-meta! #'hash assoc :doc "Return the hash value for the given object.
+
+Two objects that compare equal must also have the same hash value, but the
+reverse is not necessarily true." :arglists '[[obj]])
+
+(def breakpoint (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "breakpoint"))))
+(alter-meta! #'breakpoint assoc :doc "breakpoint(*args, **kws)
+
+Call sys.breakpointhook(*args, **kws).  sys.breakpointhook() must accept
+whatever arguments are passed.
+
+By default, this drops you into the pdb debugger." :arglists '[[self & [args {:as kwargs}]]])
+
+(def sorted (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sorted"))))
+(alter-meta! #'sorted assoc :doc "Return a new list containing all items from the iterable in ascending order.
+
+A custom key function can be supplied to customize the sort order, and the
+reverse flag can be set to request the result in descending order." :arglists '[[iterable & [{key :key, reverse :reverse}]]])
+
+(def repr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "repr"))))
+(alter-meta! #'repr assoc :doc "Return the canonical string representation of the object.
+
+For many object types, including most builtins, eval(repr(obj)) == obj." :arglists '[[obj]])
+
+(def __loader__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__loader__"))))
+(alter-meta! #'__loader__ assoc :doc "Meta path import for built-in modules.
+
+    All methods are either class or static methods to avoid the need to
+    instantiate the class.
+
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def NotADirectoryError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "NotADirectoryError"))))
+(alter-meta! #'NotADirectoryError assoc :doc "Operation only works on directories." :arglists '[[self & [args {:as kwargs}]]])
+
+(def max (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "max"))))
+(alter-meta! #'max assoc :doc "max(iterable, *[, default=obj, key=func]) -> value
+max(arg1, arg2, *args, *[, key=func]) -> value
+
+With a single iterable argument, return its biggest item. The
+default keyword-only argument specifies an object to return if
+the provided iterable is empty.
+With two or more arguments, return the largest argument." :arglists '[[self & [args {:as kwargs}]]])
+
+(def SystemError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "SystemError"))))
+(alter-meta! #'SystemError assoc :doc "Internal error in the Python interpreter.
+
+Please report this to the Python maintainer, along with the traceback,
+the Python version, and the hardware/OS platform and version." :arglists '[[self & [args {:as kwargs}]]])
+
+(def isinstance (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isinstance"))))
+(alter-meta! #'isinstance assoc :doc "Return whether an object is an instance of a class or of a subclass thereof.
+
+A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
+check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
+or ...`` etc." :arglists '[[obj class_or_tuple]])
+
+(def id (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "id"))))
+(alter-meta! #'id assoc :doc "Return the identity of an object.
+
+This is guaranteed to be unique among simultaneously existing objects.
+(CPython uses the object's memory address.)" :arglists '[[obj]])
+
+(def pow (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "pow"))))
+(alter-meta! #'pow assoc :doc "Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
+
+Some types, such as ints, are able to use a more efficient algorithm when
+invoked using the three argument form." :arglists '[[base exp & [{mod :mod}]] [base exp]])
+
+(def TimeoutError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "TimeoutError"))))
+(alter-meta! #'TimeoutError assoc :doc "Timeout expired." :arglists '[[self & [args {:as kwargs}]]])
+
+(def delattr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "delattr"))))
+(alter-meta! #'delattr assoc :doc "Deletes the named attribute from the given object.
+
+delattr(x, 'y') is equivalent to ``del x.y''" :arglists '[[obj name]])
+
+(def FloatingPointError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "FloatingPointError"))))
+(alter-meta! #'FloatingPointError assoc :doc "Floating point operation failed." :arglists '[[self & [args {:as kwargs}]]])
+
+(def GeneratorExit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "GeneratorExit"))))
+(alter-meta! #'GeneratorExit assoc :doc "Request that a generator exit." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ConnectionAbortedError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ConnectionAbortedError"))))
+(alter-meta! #'ConnectionAbortedError assoc :doc "Connection aborted." :arglists '[[self & [args {:as kwargs}]]])
+
+(def UnicodeTranslateError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnicodeTranslateError"))))
+(alter-meta! #'UnicodeTranslateError assoc :doc "Unicode translation error." :arglists '[[self & [args {:as kwargs}]]])
+
+(def UnicodeDecodeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnicodeDecodeError"))))
+(alter-meta! #'UnicodeDecodeError assoc :doc "Unicode decoding error." :arglists '[[self & [args {:as kwargs}]]])
+
+(def exec (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "exec"))))
+(alter-meta! #'exec assoc :doc "Execute the given source in the context of globals and locals.
+
+The source may be a string representing one or more Python statements
+or a code object as returned by compile().
+The globals must be a dictionary and locals can be any mapping,
+defaulting to the current globals and locals.
+If only globals is given, locals defaults to it." :arglists '[[source & [{globals :globals, locals :locals}]] [source & [{globals :globals}]] [source]])
+
+(def divmod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "divmod"))))
+(alter-meta! #'divmod assoc :doc "Return the tuple (x//y, x%y).  Invariant: div*y + mod == x." :arglists '[[x y]])
+
+(def any (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "any"))))
+(alter-meta! #'any assoc :doc "Return True if bool(x) is True for any x in the iterable.
+
+If the iterable is empty, return False." :arglists '[[iterable]])
+
+(def super (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "super"))))
+(alter-meta! #'super assoc :doc "super() -> same as super(__class__, <first argument>)
+super(type) -> unbound super object
+super(type, obj) -> bound super object; requires isinstance(obj, type)
+super(type, type2) -> bound super object; requires issubclass(type2, type)
+Typical use to call a cooperative superclass method:
+class C(B):
+    def meth(self, arg):
+        super().meth(arg)
+This works for class methods too:
+class C(B):
+    @classmethod
+    def cmeth(cls, arg):
+        super().cmeth(arg)
+" :arglists '[[self & [args {:as kwargs}]]])
+
+(def memoryview (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "memoryview"))))
+(alter-meta! #'memoryview assoc :doc "Create a new memoryview object which references the given object." :arglists '[[self & [args {:as kwargs}]]])
+
+(def enumerate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "enumerate"))))
+(alter-meta! #'enumerate assoc :doc "Return an enumerate object.
+
+  iterable
+    an object supporting iteration
+
+The enumerate object yields pairs containing a count (from start, which
+defaults to zero) and a value yielded by the iterable argument.
+
+enumerate is useful for obtaining an indexed list:
+    (0, seq[0]), (1, seq[1]), (2, seq[2]), ..." :arglists '[[self & [args {:as kwargs}]]])
+
+(def dict (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dict"))))
+(alter-meta! #'dict assoc :doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)" :arglists '[[self & [args {:as kwargs}]]])
+
+(def OSError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "OSError"))))
+(alter-meta! #'OSError assoc :doc "Base class for I/O related errors." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ReferenceError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ReferenceError"))))
+(alter-meta! #'ReferenceError assoc :doc "Weak ref proxy used after referent went away." :arglists '[[self & [args {:as kwargs}]]])
+
+(def UnicodeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnicodeError"))))
+(alter-meta! #'UnicodeError assoc :doc "Unicode related error." :arglists '[[self & [args {:as kwargs}]]])
+
+(def FileExistsError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "FileExistsError"))))
+(alter-meta! #'FileExistsError assoc :doc "File already exists." :arglists '[[self & [args {:as kwargs}]]])
+
+(def InterruptedError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "InterruptedError"))))
+(alter-meta! #'InterruptedError assoc :doc "Interrupted by signal." :arglists '[[self & [args {:as kwargs}]]])
+
+(def Warning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "Warning"))))
+(alter-meta! #'Warning assoc :doc "Base class for warning categories." :arglists '[[self & [args {:as kwargs}]]])
+
+(def eval (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "eval"))))
+(alter-meta! #'eval assoc :doc "Evaluate the given source in the context of globals and locals.
+
+The source may be a string representing a Python expression
+or a code object as returned by compile().
+The globals must be a dictionary and locals can be any mapping,
+defaulting to the current globals and locals.
+If only globals is given, locals defaults to it." :arglists '[[source & [{globals :globals, locals :locals}]] [source & [{globals :globals}]] [source]])
+
+(def bool (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bool"))))
+(alter-meta! #'bool assoc :doc "bool(x) -> bool
+
+Returns True when the argument x is true, False otherwise.
+The builtins True and False are the only two instances of the class bool.
+The class bool is a subclass of the class int, and cannot be subclassed." :arglists '[[self & [args {:as kwargs}]]])
+
+(def SyntaxError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "SyntaxError"))))
+(alter-meta! #'SyntaxError assoc :doc "Invalid syntax." :arglists '[[self & [args {:as kwargs}]]])
+
+(def UnicodeEncodeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnicodeEncodeError"))))
+(alter-meta! #'UnicodeEncodeError assoc :doc "Unicode encoding error." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ord (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ord"))))
+(alter-meta! #'ord assoc :doc "Return the Unicode code point for a one-character string." :arglists '[[c]])
+
+(def callable (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "callable"))))
+(alter-meta! #'callable assoc :doc "Return whether the object is callable (i.e., some kind of function).
+
+Note that classes are callable, as are instances of classes with a
+__call__() method." :arglists '[[obj]])
+
+(def EnvironmentError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "EnvironmentError"))))
+(alter-meta! #'EnvironmentError assoc :doc "Base class for I/O related errors." :arglists '[[self & [args {:as kwargs}]]])
+
+(def RuntimeWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "RuntimeWarning"))))
+(alter-meta! #'RuntimeWarning assoc :doc "Base class for warnings about dubious runtime behavior." :arglists '[[self & [args {:as kwargs}]]])
+
+(def quit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "quit"))))
+(alter-meta! #'quit assoc :doc "" :arglists '[[self name eof]])
+
+(def NameError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "NameError"))))
+(alter-meta! #'NameError assoc :doc "Name not found globally." :arglists '[[self & [args {:as kwargs}]]])
+
+(def DeprecationWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "DeprecationWarning"))))
+(alter-meta! #'DeprecationWarning assoc :doc "Base class for warnings about deprecated features." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ProcessLookupError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ProcessLookupError"))))
+(alter-meta! #'ProcessLookupError assoc :doc "Process not found." :arglists '[[self & [args {:as kwargs}]]])
+
+(def bin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bin"))))
+(alter-meta! #'bin assoc :doc "Return the binary representation of an integer.
+
+   >>> bin(2796202)
+   '0b1010101010101010101010'" :arglists '[[number]])
+
+(def ^{:doc "The specification for a module, used for loading.
+
+    A module's spec is the source for information about the module.  For
+    data associated with the module, including source, use the spec's
+    loader.
+
+    `name` is the absolute name of the module.  `loader` is the loader
+    to use when loading the module.  `parent` is the name of the
+    package the module is in.  The parent is derived from the name.
+
+    `is_package` determines if the module is considered a package or
+    not.  On modules this is reflected by the `__path__` attribute.
+
+    `origin` is the specific location used by the loader from which to
+    load the module, if that information is available.  When filename is
+    set, origin will match.
+
+    `has_location` indicates that a spec's \"origin\" reflects a location.
+    When this is True, `__file__` attribute of the module is set.
+
+    `cached` is the location of the cached bytecode file, if any.  It
+    corresponds to the `__cached__` attribute.
+
+    `submodule_search_locations` is the sequence of path entries to
+    search when importing submodules.  If set, is_package should be
+    True--and False otherwise.
+
+    Packages are simply modules that (may) have submodules.  If a spec
+    has a non-None value in `submodule_search_locations`, the import
+    system will consider modules loaded from the spec as packages.
+
+    Only finders (see importlib.abc.MetaPathFinder and
+    importlib.abc.PathEntryFinder) should modify ModuleSpec instances.
+
+    "} __spec__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__spec__"))))
+
+(def bytes (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bytes"))))
+(alter-meta! #'bytes assoc :doc "bytes(iterable_of_ints) -> bytes
+bytes(string, encoding[, errors]) -> bytes
+bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
+bytes(int) -> bytes object of size given by the parameter initialized with null bytes
+bytes() -> empty bytes object
+
+Construct an immutable array of bytes from:
+  - an iterable yielding integers in range(256)
+  - a text string encoded using the specified encoding
+  - any object implementing the buffer API.
+  - an integer" :arglists '[[self & [args {:as kwargs}]]])
+
+(def dir (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dir"))))
+(alter-meta! #'dir assoc :doc "dir([object]) -> list of strings
+
+If called without an argument, return the names in the current scope.
+Else, return an alphabetized list of names comprising (some of) the attributes
+of the given object, and of attributes reachable from it.
+If the object supplies a method named __dir__, it will be used; otherwise
+the default dir() logic is used and returns:
+  for a module object: the module's attributes.
+  for a class object:  its attributes, and recursively the attributes
+    of its bases.
+  for any other object: its attributes, its class's attributes, and
+    recursively the attributes of its class's base classes." :arglists '[[self & [args {:as kwargs}]]])
+
+(def filter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "filter"))))
+(alter-meta! #'filter assoc :doc "filter(function or None, iterable) --> filter object
+
+Return an iterator yielding those items of iterable for which function(item)
+is true. If function is None, return the items that are true." :arglists '[[self & [args {:as kwargs}]]])
+
+(def property (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "property"))))
+(alter-meta! #'property assoc :doc "Property attribute.
+
+  fget
+    function to be used for getting an attribute value
+  fset
+    function to be used for setting an attribute value
+  fdel
+    function to be used for del'ing an attribute
+  doc
+    docstring
+
+Typical use is to define a managed attribute x:
+
+class C(object):
+    def getx(self): return self._x
+    def setx(self, value): self._x = value
+    def delx(self): del self._x
+    x = property(getx, setx, delx, \"I'm the 'x' property.\")
+
+Decorators make defining new properties or modifying existing ones easy:
+
+class C(object):
+    @property
+    def x(self):
+        \"I am the 'x' property.\"
+        return self._x
+    @x.setter
+    def x(self, value):
+        self._x = value
+    @x.deleter
+    def x(self):
+        del self._x" :arglists '[[self & [args {:as kwargs}]]])
+
+(def KeyError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "KeyError"))))
+(alter-meta! #'KeyError assoc :doc "Mapping key not found." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} __debug__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__debug__"))))
+
+(def IOError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "IOError"))))
+(alter-meta! #'IOError assoc :doc "Base class for I/O related errors." :arglists '[[self & [args {:as kwargs}]]])
+
+(def BufferError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "BufferError"))))
+(alter-meta! #'BufferError assoc :doc "Buffer error." :arglists '[[self & [args {:as kwargs}]]])
+
+(def bytearray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bytearray"))))
+(alter-meta! #'bytearray assoc :doc "bytearray(iterable_of_ints) -> bytearray
+bytearray(string, encoding[, errors]) -> bytearray
+bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
+bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
+bytearray() -> empty bytes array
+
+Construct a mutable bytearray object from:
+  - an iterable yielding integers in range(256)
+  - a text string encoded using the specified encoding
+  - a bytes or a buffer object
+  - any object implementing the buffer API.
+  - an integer" :arglists '[[self & [args {:as kwargs}]]])
+
+(def compile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "compile"))))
+(alter-meta! #'compile assoc :doc "Compile source into a code object that can be executed by exec() or eval().
+
+The source code may represent a Python module, statement or expression.
+The filename will be used for run-time error messages.
+The mode must be 'exec' to compile a module, 'single' to compile a
+single (interactive) statement, or 'eval' to compile an expression.
+The flags argument, if present, controls which future statements influence
+the compilation of the code.
+The dont_inherit argument, if true, stops the compilation inheriting
+the effects of any future statements in effect in the code calling
+compile; if absent or false these statements do influence the compilation,
+in addition to any features explicitly specified." :arglists '[[source filename mode & [{flags :flags, dont_inherit :dont_inherit, optimize :optimize, _feature_version :_feature_version}]] [source filename mode & [{flags :flags, dont_inherit :dont_inherit, _feature_version :_feature_version}]] [source filename mode & [{flags :flags, _feature_version :_feature_version}]] [source filename mode & [{_feature_version :_feature_version}]]])
+
+(def input (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "input"))))
+(alter-meta! #'input assoc :doc "Read a string from standard input.  The trailing newline is stripped.
+
+The prompt string, if given, is printed to standard output without a
+trailing newline before reading input.
+
+If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
+On *nix systems, readline is used if available." :arglists '[[& [{prompt :prompt}]] []])
+
+(def BaseException (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "BaseException"))))
+(alter-meta! #'BaseException assoc :doc "Common base class for all exceptions" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ImportError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ImportError"))))
+(alter-meta! #'ImportError assoc :doc "Import can't find module, or can't find name in module." :arglists '[[self & [args {:as kwargs}]]])
+
+(def setattr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "setattr"))))
+(alter-meta! #'setattr assoc :doc "Sets the named attribute on the given object to the specified value.
+
+setattr(x, 'y', v) is equivalent to ``x.y = v''" :arglists '[[obj name value]])
+
+(def __build_class__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__build_class__"))))
+(alter-meta! #'__build_class__ assoc :doc "__build_class__(func, name, /, *bases, [metaclass], **kwds) -> class
+
+Internal helper function used by the class statement." :arglists '[[self & [args {:as kwargs}]]])
+
+(def copyright (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "copyright"))))
+(alter-meta! #'copyright assoc :doc "interactive prompt objects for printing the license text, a list of
+    contributors and the copyright notice." :arglists '[[self name data & [{files :files, dirs :dirs}]] [self name data & [{files :files}]] [self name data]])
+
+(def type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "type"))))
+(alter-meta! #'type assoc :doc "type(object_or_name, bases, dict)
+type(object) -> the object's type
+type(name, bases, dict) -> a new type" :arglists '[[self & [args {:as kwargs}]]])
+
+(def LookupError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "LookupError"))))
+(alter-meta! #'LookupError assoc :doc "Base class for lookup errors." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ZeroDivisionError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ZeroDivisionError"))))
+(alter-meta! #'ZeroDivisionError assoc :doc "Second argument to a division or modulo operation was zero." :arglists '[[self & [args {:as kwargs}]]])
+
+(def globals (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "globals"))))
+(alter-meta! #'globals assoc :doc "Return the dictionary containing the current scope's global variables.
+
+NOTE: Updates to this dictionary *will* affect name lookups in the current
+global scope and vice-versa." :arglists '[[]])
+
+(def OverflowError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "OverflowError"))))
+(alter-meta! #'OverflowError assoc :doc "Result too large to be represented." :arglists '[[self & [args {:as kwargs}]]])
+
+(def abs (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "abs"))))
+(alter-meta! #'abs assoc :doc "Return the absolute value of the argument." :arglists '[[x]])
+
+(def ConnectionRefusedError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ConnectionRefusedError"))))
+(alter-meta! #'ConnectionRefusedError assoc :doc "Connection refused." :arglists '[[self & [args {:as kwargs}]]])
+
+(def help (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "help"))))
+(alter-meta! #'help assoc :doc "Define the builtin 'help'.
+
+    This is a wrapper around pydoc.help that provides a helpful message
+    when 'help' is typed at the Python interactive prompt.
+
+    Calling help() at the Python prompt starts an interactive help session.
+    Calling help(thing) prints help for the python object 'thing'.
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def UserWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UserWarning"))))
+(alter-meta! #'UserWarning assoc :doc "Base class for warnings generated by user code." :arglists '[[self & [args {:as kwargs}]]])
+
+(def slice (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "slice"))))
+(alter-meta! #'slice assoc :doc "slice(stop)
+slice(start, stop[, step])
+
+Create a slice object.  This is used for extended slicing (e.g. a[0:10:2])." :arglists '[[self & [args {:as kwargs}]]])
+
+(def TabError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "TabError"))))
+(alter-meta! #'TabError assoc :doc "Improper mixture of spaces and tabs." :arglists '[[self & [args {:as kwargs}]]])
+
+(def print (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "print"))))
+(alter-meta! #'print assoc :doc "print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)
+
+Prints the values to a stream, or to sys.stdout by default.
+Optional keyword arguments:
+file:  a file-like object (stream); defaults to the current sys.stdout.
+sep:   string inserted between values, default a space.
+end:   string appended after the last value, default a newline.
+flush: whether to forcibly flush the stream." :arglists '[[self & [args {:as kwargs}]]])
+
+(def exit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "exit"))))
+(alter-meta! #'exit assoc :doc "" :arglists '[[self name eof]])
+
+(def EOFError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "EOFError"))))
+(alter-meta! #'EOFError assoc :doc "Read beyond end of file." :arglists '[[self & [args {:as kwargs}]]])
+
+(def PyAssertionError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "AssertionError"))))
+(alter-meta! #'PyAssertionError assoc :doc "Assertion failed." :arglists '[[self & [args {:as kwargs}]]])
+
+(def hasattr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hasattr"))))
+(alter-meta! #'hasattr assoc :doc "Return whether the object has an attribute with the given name.
+
+This is done by calling getattr(obj, name) and catching AttributeError." :arglists '[[obj name]])
+
+(def len (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "len"))))
+(alter-meta! #'len assoc :doc "Return the number of items in a container." :arglists '[[obj]])
+
+(def set (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "set"))))
+(alter-meta! #'set assoc :doc "set() -> new empty set object
+set(iterable) -> new set object
+
+Build an unordered collection of unique elements." :arglists '[[self & [args {:as kwargs}]]])
+
+(def BrokenPipeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "BrokenPipeError"))))
+(alter-meta! #'BrokenPipeError assoc :doc "Broken pipe." :arglists '[[self & [args {:as kwargs}]]])
+
+(def all (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "all"))))
+(alter-meta! #'all assoc :doc "Return True if bool(x) is True for all values x in the iterable.
+
+If the iterable is empty, return True." :arglists '[[iterable]])
+
+(def PendingDeprecationWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "PendingDeprecationWarning"))))
+(alter-meta! #'PendingDeprecationWarning assoc :doc "Base class for warnings about features which will be deprecated
+in the future." :arglists '[[self & [args {:as kwargs}]]])
+
+(def tuple (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tuple"))))
+(alter-meta! #'tuple assoc :doc "Built-in immutable sequence.
+
+If no argument is given, the constructor returns an empty tuple.
+If iterable is specified the tuple is initialized from iterable's items.
+
+If the argument is a tuple, the return value is the same object." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ChildProcessError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ChildProcessError"))))
+(alter-meta! #'ChildProcessError assoc :doc "Child process error." :arglists '[[self & [args {:as kwargs}]]])
+
+(def UnboundLocalError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnboundLocalError"))))
+(alter-meta! #'UnboundLocalError assoc :doc "Local name referenced but not bound to a value." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ModuleNotFoundError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ModuleNotFoundError"))))
+(alter-meta! #'ModuleNotFoundError assoc :doc "Module not found." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ValueError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ValueError"))))
+(alter-meta! #'ValueError assoc :doc "Inappropriate argument value (of correct type)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def iter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iter"))))
+(alter-meta! #'iter assoc :doc "iter(iterable) -> iterator
+iter(callable, sentinel) -> iterator
+
+Get an iterator from an object.  In the first form, the argument must
+supply its own iterator, or be a sequence.
+In the second form, the callable is called until it returns the sentinel." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} Ellipsis (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "Ellipsis"))))
+
+(def open (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "open"))))
+(alter-meta! #'open assoc :doc "Open file and return a stream.  Raise OSError upon failure.
+
+file is either a text or byte string giving the name (and the path
+if the file isn't in the current working directory) of the file to
+be opened or an integer file descriptor of the file to be
+wrapped. (If a file descriptor is given, it is closed when the
+returned I/O object is closed, unless closefd is set to False.)
+
+mode is an optional string that specifies the mode in which the file
+is opened. It defaults to 'r' which means open for reading in text
+mode.  Other common values are 'w' for writing (truncating the file if
+it already exists), 'x' for creating and writing to a new file, and
+'a' for appending (which on some Unix systems, means that all writes
+append to the end of the file regardless of the current seek position).
+In text mode, if encoding is not specified the encoding used is platform
+dependent: locale.getpreferredencoding(False) is called to get the
+current locale encoding. (For reading and writing raw bytes use binary
+mode and leave encoding unspecified.) The available modes are:
+
+========= ===============================================================
+Character Meaning
+--------- ---------------------------------------------------------------
+'r'       open for reading (default)
+'w'       open for writing, truncating the file first
+'x'       create a new file and open it for writing
+'a'       open for writing, appending to the end of the file if it exists
+'b'       binary mode
+'t'       text mode (default)
+'+'       open a disk file for updating (reading and writing)
+'U'       universal newline mode (deprecated)
+========= ===============================================================
+
+The default mode is 'rt' (open for reading text). For binary random
+access, the mode 'w+b' opens and truncates the file to 0 bytes, while
+'r+b' opens the file without truncation. The 'x' mode implies 'w' and
+raises an `FileExistsError` if the file already exists.
+
+Python distinguishes between files opened in binary and text modes,
+even when the underlying operating system doesn't. Files opened in
+binary mode (appending 'b' to the mode argument) return contents as
+bytes objects without any decoding. In text mode (the default, or when
+'t' is appended to the mode argument), the contents of the file are
+returned as strings, the bytes having been first decoded using a
+platform-dependent encoding or using the specified encoding if given.
+
+'U' mode is deprecated and will raise an exception in future versions
+of Python.  It has no effect in Python 3.  Use newline to control
+universal newlines mode.
+
+buffering is an optional integer used to set the buffering policy.
+Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
+line buffering (only usable in text mode), and an integer > 1 to indicate
+the size of a fixed-size chunk buffer.  When no buffering argument is
+given, the default buffering policy works as follows:
+
+* Binary files are buffered in fixed-size chunks; the size of the buffer
+  is chosen using a heuristic trying to determine the underlying device's
+  \"block size\" and falling back on `io.DEFAULT_BUFFER_SIZE`.
+  On many systems, the buffer will typically be 4096 or 8192 bytes long.
+
+* \"Interactive\" text files (files for which isatty() returns True)
+  use line buffering.  Other text files use the policy described above
+  for binary files.
+
+encoding is the name of the encoding used to decode or encode the
+file. This should only be used in text mode. The default encoding is
+platform dependent, but any encoding supported by Python can be
+passed.  See the codecs module for the list of supported encodings.
+
+errors is an optional string that specifies how encoding errors are to
+be handled---this argument should not be used in binary mode. Pass
+'strict' to raise a ValueError exception if there is an encoding error
+(the default of None has the same effect), or pass 'ignore' to ignore
+errors. (Note that ignoring encoding errors can lead to data loss.)
+See the documentation for codecs.register or run 'help(codecs.Codec)'
+for a list of the permitted encoding error strings.
+
+newline controls how universal newlines works (it only applies to text
+mode). It can be None, '', '\\n', '\\r', and '\\r\\n'.  It works as
+follows:
+
+* On input, if newline is None, universal newlines mode is
+  enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and
+  these are translated into '\\n' before being returned to the
+  caller. If it is '', universal newline mode is enabled, but line
+  endings are returned to the caller untranslated. If it has any of
+  the other legal values, input lines are only terminated by the given
+  string, and the line ending is returned to the caller untranslated.
+
+* On output, if newline is None, any '\\n' characters written are
+  translated to the system default line separator, os.linesep. If
+  newline is '' or '\\n', no translation takes place. If newline is any
+  of the other legal values, any '\\n' characters written are translated
+  to the given string.
+
+If closefd is False, the underlying file descriptor will be kept open
+when the file is closed. This does not work when a file name is given
+and must be True in that case.
+
+A custom opener can be used by passing a callable as *opener*. The
+underlying file descriptor for the file object is then obtained by
+calling *opener* with (*file*, *flags*). *opener* must return an open
+file descriptor (passing os.open as *opener* results in functionality
+similar to passing None).
+
+open() returns a file object whose type depends on the mode, and
+through which the standard file operations such as reading and writing
+are performed. When open() is used to open a file in a text mode ('w',
+'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
+a file in a binary mode, the returned class varies: in read binary
+mode, it returns a BufferedReader; in write binary and append binary
+modes, it returns a BufferedWriter, and in read/write mode, it returns
+a BufferedRandom.
+
+It is also possible to use a string or bytearray as a file for both
+reading and writing. For strings StringIO can be used like a file
+opened in a text mode, and for bytes a BytesIO can be used like a file
+opened in a binary mode." :arglists '[[file & [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline, closefd :closefd, opener :opener}]] [file & [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline, closefd :closefd}]] [file & [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline}]] [file & [{mode :mode, buffering :buffering, encoding :encoding, errors :errors}]] [file & [{mode :mode, buffering :buffering, encoding :encoding}]] [file & [{mode :mode, buffering :buffering}]] [file & [{mode :mode}]] [file]])
+
+(def ^{:doc ""} __doc__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__doc__"))))
+
+(def __import__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__import__"))))
+(alter-meta! #'__import__ assoc :doc "__import__(name, globals=None, locals=None, fromlist=(), level=0) -> module
+
+Import a module. Because this function is meant for use by the Python
+interpreter and not for general use, it is better to use
+importlib.import_module() to programmatically import a module.
+
+The globals argument is only used to determine the context;
+they are not modified.  The locals argument is unused.  The fromlist
+should be a list of names to emulate ``from name import ...'', or an
+empty list to emulate ``import name''.
+When importing a module from a package, note that __import__('A.B', ...)
+returns package A when fromlist is empty, but its submodule B when
+fromlist is not empty.  The level argument is used to determine whether to
+perform absolute or relative imports: 0 is absolute, while a positive number
+is the number of parent directories to search relative to the current module." :arglists '[[self & [args {:as kwargs}]]])
+
+(def SystemExit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "SystemExit"))))
+(alter-meta! #'SystemExit assoc :doc "Request to exit from the interpreter." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ConnectionError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ConnectionError"))))
+(alter-meta! #'ConnectionError assoc :doc "Connection error." :arglists '[[self & [args {:as kwargs}]]])
+
+(def round (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "round"))))
+(alter-meta! #'round assoc :doc "Round a number to a given precision in decimal digits.
+
+The return value is an integer if ndigits is omitted or None.  Otherwise
+the return value has the same type as the number.  ndigits may be negative." :arglists '[[number & [{ndigits :ndigits}]] [number]])
+
+(def complex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex"))))
+(alter-meta! #'complex assoc :doc "Create a complex number from a real part and an optional imaginary part.
+
+This is equivalent to (real + imag*1j) where imag defaults to 0." :arglists '[[self & [args {:as kwargs}]]])
+
+(def UnicodeWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnicodeWarning"))))
+(alter-meta! #'UnicodeWarning assoc :doc "Base class for warnings about Unicode related problems, mostly
+related to conversion problems." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} __name__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__name__"))))
+
+(def oct (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "oct"))))
+(alter-meta! #'oct assoc :doc "Return the octal representation of an integer.
+
+   >>> oct(342391)
+   '0o1234567'" :arglists '[[number]])
+
+(def locals (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "locals"))))
+(alter-meta! #'locals assoc :doc "Return a dictionary containing the current scope's local variables.
+
+NOTE: Whether or not updates to this dictionary will affect name lookups in
+the local scope and vice-versa is *implementation dependent* and not
+covered by any backwards compatibility guarantees." :arglists '[[]])
+
+(def NotImplementedError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "NotImplementedError"))))
+(alter-meta! #'NotImplementedError assoc :doc "Method or function hasn't been implemented yet." :arglists '[[self & [args {:as kwargs}]]])
+
+(def getattr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "getattr"))))
+(alter-meta! #'getattr assoc :doc "getattr(object, name[, default]) -> value
+
+Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
+When a default argument is given, it is returned when the attribute doesn't
+exist; without it, an exception is raised in that case." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} True (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "True"))))
+
+(def zip (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "zip"))))
+(alter-meta! #'zip assoc :doc "zip(*iterables) --> A zip object yielding tuples until an input is exhausted.
+
+   >>> list(zip('abcdefg', range(3), range(4)))
+   [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
+
+The zip object yields n-length tuples, where n is the number of iterables
+passed as positional arguments to zip().  The i-th element in every tuple
+comes from the i-th iterable argument to zip().  This continues until the
+shortest argument is exhausted." :arglists '[[self & [args {:as kwargs}]]])
+
+(def PyException (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "Exception"))))
+(alter-meta! #'PyException assoc :doc "Common base class for all non-exit exceptions." :arglists '[[self & [args {:as kwargs}]]])
+
+(def IndentationError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "IndentationError"))))
+(alter-meta! #'IndentationError assoc :doc "Improper indentation." :arglists '[[self & [args {:as kwargs}]]])
+
+(def RuntimeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "RuntimeError"))))
+(alter-meta! #'RuntimeError assoc :doc "Unspecified run-time error." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} __package__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__package__"))))
+
+(def format (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "format"))))
+(alter-meta! #'format assoc :doc "Return value.__format__(format_spec)
+
+format_spec defaults to the empty string.
+See the Format Specification Mini-Language section of help('FORMATTING') for
+details." :arglists '[[value & [{format_spec :format_spec}]] [value]])
+
+(def credits (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "credits"))))
+(alter-meta! #'credits assoc :doc "interactive prompt objects for printing the license text, a list of
+    contributors and the copyright notice." :arglists '[[self name data & [{files :files, dirs :dirs}]] [self name data & [{files :files}]] [self name data]])
+
+(def StopIteration (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "StopIteration"))))
+(alter-meta! #'StopIteration assoc :doc "Signal the end from iterator.__next__()." :arglists '[[self & [args {:as kwargs}]]])
+
+(def StopAsyncIteration (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "StopAsyncIteration"))))
+(alter-meta! #'StopAsyncIteration assoc :doc "Signal the end from iterator.__anext__()." :arglists '[[self & [args {:as kwargs}]]])
+
+(def frozenset (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "frozenset"))))
+(alter-meta! #'frozenset assoc :doc "frozenset() -> empty frozenset object
+frozenset(iterable) -> frozenset object
+
+Build an immutable unordered collection of unique elements." :arglists '[[self & [args {:as kwargs}]]])
+
+(def AttributeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "AttributeError"))))
+(alter-meta! #'AttributeError assoc :doc "Attribute not found." :arglists '[[self & [args {:as kwargs}]]])
+
+(def vars (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vars"))))
+(alter-meta! #'vars assoc :doc "vars([object]) -> dictionary
+
+Without arguments, equivalent to locals().
+With an argument, equivalent to object.__dict__." :arglists '[[self & [args {:as kwargs}]]])
+
+(def IsADirectoryError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "IsADirectoryError"))))
+(alter-meta! #'IsADirectoryError assoc :doc "Operation doesn't work on directories." :arglists '[[self & [args {:as kwargs}]]])
+
+(def issubclass (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issubclass"))))
+(alter-meta! #'issubclass assoc :doc "Return whether 'cls' is a derived from another class or is the same class.
+
+A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to
+check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)
+or ...`` etc." :arglists '[[cls class_or_tuple]])
\ No newline at end of file
diff --git a/src/python/numpy.clj b/src/python/numpy.clj
new file mode 100644
index 0000000..95ee657
--- /dev/null
+++ b/src/python/numpy.clj
@@ -0,0 +1,29133 @@
+(ns python.numpy
+"No documentation provided"
+(: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 [+ - * / 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]))
+
+(defonce ^:private src-obj* (py-global-delay (py/path->py-obj "numpy")))
+
+(def result_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "result_type"))))
+(alter-meta! #'result_type assoc :doc "
+    result_type(*arrays_and_dtypes)
+
+    Returns the type that results from applying the NumPy
+    type promotion rules to the arguments.
+
+    Type promotion in NumPy works similarly to the rules in languages
+    like C++, with some slight differences.  When both scalars and
+    arrays are used, the array's type takes precedence and the actual value
+    of the scalar is taken into account.
+
+    For example, calculating 3*a, where a is an array of 32-bit floats,
+    intuitively should result in a 32-bit float output.  If the 3 is a
+    32-bit integer, the NumPy rules indicate it can't convert losslessly
+    into a 32-bit float, so a 64-bit float should be the result type.
+    By examining the value of the constant, '3', we see that it fits in
+    an 8-bit integer, which can be cast losslessly into the 32-bit float.
+
+    Parameters
+    ----------
+    arrays_and_dtypes : list of arrays and dtypes
+        The operands of some operation whose result type is needed.
+
+    Returns
+    -------
+    out : dtype
+        The result type.
+
+    See also
+    --------
+    dtype, promote_types, min_scalar_type, can_cast
+
+    Notes
+    -----
+    .. versionadded:: 1.6.0
+
+    The specific algorithm used is as follows.
+
+    Categories are determined by first checking which of boolean,
+    integer (int/uint), or floating point (float/complex) the maximum
+    kind of all the arrays and the scalars are.
+
+    If there are only scalars or the maximum category of the scalars
+    is higher than the maximum category of the arrays,
+    the data types are combined with :func:`promote_types`
+    to produce the return value.
+
+    Otherwise, `min_scalar_type` is called on each array, and
+    the resulting data types are all combined with :func:`promote_types`
+    to produce the return value.
+
+    The set of int values is not a subset of the uint values for types
+    with the same number of bits, something not reflected in
+    :func:`min_scalar_type`, but handled as a special case in `result_type`.
+
+    Examples
+    --------
+    >>> np.result_type(3, np.arange(7, dtype='i1'))
+    dtype('int8')
+
+    >>> np.result_type('i4', 'c8')
+    dtype('complex128')
+
+    >>> np.result_type(3.0, -2)
+    dtype('float64')
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def float (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float"))))
+(alter-meta! #'float assoc :doc "Convert a string or number to a floating point number, if possible." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ravel_multi_index (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ravel_multi_index"))))
+(alter-meta! #'ravel_multi_index assoc :doc "
+    ravel_multi_index(multi_index, dims, mode='raise', order='C')
+
+    Converts a tuple of index arrays into an array of flat
+    indices, applying boundary modes to the multi-index.
+
+    Parameters
+    ----------
+    multi_index : tuple of array_like
+        A tuple of integer arrays, one array for each dimension.
+    dims : tuple of ints
+        The shape of array into which the indices from ``multi_index`` apply.
+    mode : {'raise', 'wrap', 'clip'}, optional
+        Specifies how out-of-bounds indices are handled.  Can specify
+        either one mode or a tuple of modes, one mode per index.
+
+        * 'raise' -- raise an error (default)
+        * 'wrap' -- wrap around
+        * 'clip' -- clip to the range
+
+        In 'clip' mode, a negative index which would normally
+        wrap will clip to 0 instead.
+    order : {'C', 'F'}, optional
+        Determines whether the multi-index should be viewed as
+        indexing in row-major (C-style) or column-major
+        (Fortran-style) order.
+
+    Returns
+    -------
+    raveled_indices : ndarray
+        An array of indices into the flattened version of an array
+        of dimensions ``dims``.
+
+    See Also
+    --------
+    unravel_index
+
+    Notes
+    -----
+    .. versionadded:: 1.6.0
+
+    Examples
+    --------
+    >>> arr = np.array([[3,6,6],[4,5,1]])
+    >>> np.ravel_multi_index(arr, (7,6))
+    array([22, 41, 37])
+    >>> np.ravel_multi_index(arr, (7,6), order='F')
+    array([31, 41, 13])
+    >>> np.ravel_multi_index(arr, (4,6), mode='clip')
+    array([22, 23, 19])
+    >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap'))
+    array([12, 13, 13])
+
+    >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9))
+    1621
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def vdot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vdot"))))
+(alter-meta! #'vdot assoc :doc "
+    vdot(a, b)
+
+    Return the dot product of two vectors.
+
+    The vdot(`a`, `b`) function handles complex numbers differently than
+    dot(`a`, `b`).  If the first argument is complex the complex conjugate
+    of the first argument is used for the calculation of the dot product.
+
+    Note that `vdot` handles multidimensional arrays differently than `dot`:
+    it does *not* perform a matrix product, but flattens input arguments
+    to 1-D vectors first. Consequently, it should only be used for vectors.
+
+    Parameters
+    ----------
+    a : array_like
+        If `a` is complex the complex conjugate is taken before calculation
+        of the dot product.
+    b : array_like
+        Second argument to the dot product.
+
+    Returns
+    -------
+    output : ndarray
+        Dot product of `a` and `b`.  Can be an int, float, or
+        complex depending on the types of `a` and `b`.
+
+    See Also
+    --------
+    dot : Return the dot product without using the complex conjugate of the
+          first argument.
+
+    Examples
+    --------
+    >>> a = np.array([1+2j,3+4j])
+    >>> b = np.array([5+6j,7+8j])
+    >>> np.vdot(a, b)
+    (70-8j)
+    >>> np.vdot(b, a)
+    (70+8j)
+
+    Note that higher-dimensional arrays are flattened!
+
+    >>> a = np.array([[1, 4], [5, 6]])
+    >>> b = np.array([[4, 1], [2, 2]])
+    >>> np.vdot(a, b)
+    30
+    >>> np.vdot(b, a)
+    30
+    >>> 1*4 + 4*1 + 5*2 + 6*2
+    30
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def int16 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int16"))))
+(alter-meta! #'int16 assoc :doc "Signed integer type, compatible with C ``short``.
+    Character code: ``'h'``.
+    Canonical name: ``np.short``.
+    Alias *on this platform*: ``np.int16``: 16-bit signed integer (-32768 to 32767)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} NaN (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "NaN"))))
+
+(def MachAr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "MachAr"))))
+(alter-meta! #'MachAr assoc :doc "
+    Diagnosing machine parameters.
+
+    Attributes
+    ----------
+    ibeta : int
+        Radix in which numbers are represented.
+    it : int
+        Number of base-`ibeta` digits in the floating point mantissa M.
+    machep : int
+        Exponent of the smallest (most negative) power of `ibeta` that,
+        added to 1.0, gives something different from 1.0
+    eps : float
+        Floating-point number ``beta**machep`` (floating point precision)
+    negep : int
+        Exponent of the smallest power of `ibeta` that, subtracted
+        from 1.0, gives something different from 1.0.
+    epsneg : float
+        Floating-point number ``beta**negep``.
+    iexp : int
+        Number of bits in the exponent (including its sign and bias).
+    minexp : int
+        Smallest (most negative) power of `ibeta` consistent with there
+        being no leading zeros in the mantissa.
+    xmin : float
+        Floating point number ``beta**minexp`` (the smallest [in
+        magnitude] usable floating value).
+    maxexp : int
+        Smallest (positive) power of `ibeta` that causes overflow.
+    xmax : float
+        ``(1-epsneg) * beta**maxexp`` (the largest [in magnitude]
+        usable floating value).
+    irnd : int
+        In ``range(6)``, information on what kind of rounding is done
+        in addition, and on how underflow is handled.
+    ngrd : int
+        Number of 'guard digits' used when truncating the product
+        of two mantissas to fit the representation.
+    epsilon : float
+        Same as `eps`.
+    tiny : float
+        Same as `xmin`.
+    huge : float
+        Same as `xmax`.
+    precision : float
+        ``- int(-log10(eps))``
+    resolution : float
+        ``- 10**(-precision)``
+
+    Parameters
+    ----------
+    float_conv : function, optional
+        Function that converts an integer or integer array to a float
+        or float array. Default is `float`.
+    int_conv : function, optional
+        Function that converts a float or float array to an integer or
+        integer array. Default is `int`.
+    float_to_float : function, optional
+        Function that converts a float array to float. Default is `float`.
+        Note that this does not seem to do anything useful in the current
+        implementation.
+    float_to_str : function, optional
+        Function that converts a single float to a string. Default is
+        ``lambda v:'%24.16e' %v``.
+    title : str, optional
+        Title that is printed in the string representation of `MachAr`.
+
+    See Also
+    --------
+    finfo : Machine limits for floating point types.
+    iinfo : Machine limits for integer types.
+
+    References
+    ----------
+    .. [1] Press, Teukolsky, Vetterling and Flannery,
+           \"Numerical Recipes in C++,\" 2nd ed,
+           Cambridge University Press, 2002, p. 31.
+
+    " :arglists '[[self & [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float, float_to_str :float_to_str, title :title}]] [self & [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float, float_to_str :float_to_str}]] [self & [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float}]] [self & [{float_conv :float_conv, int_conv :int_conv}]] [self & [{float_conv :float_conv}]] [self]])
+
+(def kron (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "kron"))))
+(alter-meta! #'kron assoc :doc "
+    Kronecker product of two arrays.
+
+    Computes the Kronecker product, a composite array made of blocks of the
+    second array scaled by the first.
+
+    Parameters
+    ----------
+    a, b : array_like
+
+    Returns
+    -------
+    out : ndarray
+
+    See Also
+    --------
+    outer : The outer product
+
+    Notes
+    -----
+    The function assumes that the number of dimensions of `a` and `b`
+    are the same, if necessary prepending the smallest with ones.
+    If `a.shape = (r0,r1,..,rN)` and `b.shape = (s0,s1,...,sN)`,
+    the Kronecker product has shape `(r0*s0, r1*s1, ..., rN*SN)`.
+    The elements are products of elements from `a` and `b`, organized
+    explicitly by::
+
+        kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]
+
+    where::
+
+        kt = it * st + jt,  t = 0,...,N
+
+    In the common 2-D case (N=1), the block structure can be visualized::
+
+        [[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
+         [  ...                              ...   ],
+         [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]]
+
+
+    Examples
+    --------
+    >>> np.kron([1,10,100], [5,6,7])
+    array([  5,   6,   7, ..., 500, 600, 700])
+    >>> np.kron([5,6,7], [1,10,100])
+    array([  5,  50, 500, ...,   7,  70, 700])
+
+    >>> np.kron(np.eye(2), np.ones((2,2)))
+    array([[1.,  1.,  0.,  0.],
+           [1.,  1.,  0.,  0.],
+           [0.,  0.,  1.,  1.],
+           [0.,  0.,  1.,  1.]])
+
+    >>> a = np.arange(100).reshape((2,5,2,5))
+    >>> b = np.arange(24).reshape((2,3,4))
+    >>> c = np.kron(a,b)
+    >>> c.shape
+    (2, 10, 6, 20)
+    >>> I = (1,3,0,2)
+    >>> J = (0,2,1)
+    >>> J1 = (0,) + J             # extend to ndim=4
+    >>> S1 = (1,) + b.shape
+    >>> K = tuple(np.array(I) * np.array(S1) + np.array(J1))
+    >>> c[K] == a[I]*b[J]
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def flexible (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flexible"))))
+(alter-meta! #'flexible assoc :doc "Abstract base class of all scalar types without predefined length.
+    The actual size of these types depends on the specific `np.dtype`
+    instantiation." :arglists '[[self & [args {:as kwargs}]]])
+
+(def recfromcsv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "recfromcsv"))))
+(alter-meta! #'recfromcsv assoc :doc "
+    Load ASCII data stored in a comma-separated file.
+
+    The returned array is a record array (if ``usemask=False``, see
+    `recarray`) or a masked record array (if ``usemask=True``,
+    see `ma.mrecords.MaskedRecords`).
+
+    Parameters
+    ----------
+    fname, kwargs : For a description of input parameters, see `genfromtxt`.
+
+    See Also
+    --------
+    numpy.genfromtxt : generic function to load ASCII data.
+
+    Notes
+    -----
+    By default, `dtype` is None, which means that the data-type of the output
+    array will be determined from the data.
+
+    " :arglists '[[fname & [{:as kwargs}]]])
+
+(def inexact (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "inexact"))))
+(alter-meta! #'inexact assoc :doc "Abstract base class of all numeric scalar types with a (potentially)
+    inexact representation of the values in its range, such as
+    floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def floor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "floor"))))
+(alter-meta! #'floor assoc :doc "floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the floor of the input, element-wise.
+
+The floor of the scalar `x` is the largest integer `i`, such that
+`i <= x`.  It is often denoted as :math:`\\lfloor x \\rfloor`.
+
+Parameters
+----------
+x : array_like
+    Input data.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The floor of each element in `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+ceil, trunc, rint
+
+Notes
+-----
+Some spreadsheet programs calculate the \"floor-towards-zero\", in other
+words ``floor(-2.5) == -2``.  NumPy instead uses the definition of
+`floor` where `floor(-2.5) == -3`.
+
+Examples
+--------
+>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
+>>> np.floor(a)
+array([-2., -2., -1.,  0.,  1.,  1.,  2.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} tracemalloc_domain (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "tracemalloc_domain"))))
+
+(def compress (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "compress"))))
+(alter-meta! #'compress assoc :doc "
+    Return selected slices of an array along given axis.
+
+    When working along a given axis, a slice along that axis is returned in
+    `output` for each index where `condition` evaluates to True. When
+    working on a 1-D array, `compress` is equivalent to `extract`.
+
+    Parameters
+    ----------
+    condition : 1-D array of bools
+        Array that selects which entries to return. If len(condition)
+        is less than the size of `a` along the given axis, then output is
+        truncated to the length of the condition array.
+    a : array_like
+        Array from which to extract a part.
+    axis : int, optional
+        Axis along which to take slices. If None (default), work on the
+        flattened array.
+    out : ndarray, optional
+        Output array.  Its type is preserved and it must be of the right
+        shape to hold the output.
+
+    Returns
+    -------
+    compressed_array : ndarray
+        A copy of `a` without the slices along axis for which `condition`
+        is false.
+
+    See Also
+    --------
+    take, choose, diag, diagonal, select
+    ndarray.compress : Equivalent method in ndarray
+    np.extract: Equivalent method when working on 1-D arrays
+    ufuncs-output-type
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4], [5, 6]])
+    >>> a
+    array([[1, 2],
+           [3, 4],
+           [5, 6]])
+    >>> np.compress([0, 1], a, axis=0)
+    array([[3, 4]])
+    >>> np.compress([False, True, True], a, axis=0)
+    array([[3, 4],
+           [5, 6]])
+    >>> np.compress([False, True], a, axis=1)
+    array([[2],
+           [4],
+           [6]])
+
+    Working on the flattened array does not return slices along an axis but
+    selects elements.
+
+    >>> np.compress([False, True], a)
+    array([2])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def longfloat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longfloat"))))
+(alter-meta! #'longfloat assoc :doc "Extended-precision floating-point number type, compatible with C
+    ``long double`` but not necessarily with IEEE 754 quadruple-precision.
+    Character code: ``'g'``.
+    Canonical name: ``np.longdouble``.
+    Alias: ``np.longfloat``.
+    Alias *on this platform*: ``np.float128``: 128-bit extended-precision floating-point number type." :arglists '[[self & [args {:as kwargs}]]])
+
+(def log1p (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log1p"))))
+(alter-meta! #'log1p assoc :doc "log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the natural logarithm of one plus the input array, element-wise.
+
+Calculates ``log(1 + x)``.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    Natural logarithm of `1 + x`, element-wise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+expm1 : ``exp(x) - 1``, the inverse of `log1p`.
+
+Notes
+-----
+For real-valued input, `log1p` is accurate also for `x` so small
+that `1 + x == 1` in floating-point accuracy.
+
+Logarithm is a multivalued function: for each `x` there is an infinite
+number of `z` such that `exp(z) = 1 + x`. The convention is to return
+the `z` whose imaginary part lies in `[-pi, pi]`.
+
+For real-valued input data types, `log1p` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `log1p` is a complex analytical function that
+has a branch cut `[-inf, -1]` and is continuous from above on it.
+`log1p` handles the floating-point negative zero as an infinitesimal
+negative number, conforming to the C99 standard.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm
+
+Examples
+--------
+>>> np.log1p(1e-99)
+1e-99
+>>> np.log(1 + 1e-99)
+0.0" :arglists '[[self & [args {:as kwargs}]]])
+
+(def arctan2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arctan2"))))
+(alter-meta! #'arctan2 assoc :doc "arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.
+
+The quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is
+the signed angle in radians between the ray ending at the origin and
+passing through the point (1,0), and the ray ending at the origin and
+passing through the point (`x2`, `x1`).  (Note the role reversal: the
+\"`y`-coordinate\" is the first function parameter, the \"`x`-coordinate\"
+is the second.)  By IEEE convention, this function is defined for
+`x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see
+Notes for specific values).
+
+This function is not defined for complex-valued arguments; for the
+so-called argument of complex values, use `angle`.
+
+Parameters
+----------
+x1 : array_like, real-valued
+    `y`-coordinates.
+x2 : array_like, real-valued
+    `x`-coordinates. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+angle : ndarray
+    Array of angles in radians, in the range ``[-pi, pi]``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+arctan, tan, angle
+
+Notes
+-----
+*arctan2* is identical to the `atan2` function of the underlying
+C library.  The following special values are defined in the C
+standard: [1]_
+
+====== ====== ================
+`x1`   `x2`   `arctan2(x1,x2)`
+====== ====== ================
++/- 0  +0     +/- 0
++/- 0  -0     +/- pi
+ > 0   +/-inf +0 / +pi
+ < 0   +/-inf -0 / -pi
++/-inf +inf   +/- (pi/4)
++/-inf -inf   +/- (3*pi/4)
+====== ====== ================
+
+Note that +0 and -0 are distinct floating point numbers, as are +inf
+and -inf.
+
+References
+----------
+.. [1] ISO/IEC standard 9899:1999, \"Programming language C.\"
+
+Examples
+--------
+Consider four points in different quadrants:
+
+>>> x = np.array([-1, +1, +1, -1])
+>>> y = np.array([-1, -1, +1, +1])
+>>> np.arctan2(y, x) * 180 / np.pi
+array([-135.,  -45.,   45.,  135.])
+
+Note the order of the parameters. `arctan2` is defined also when `x2` = 0
+and at several other special points, obtaining values in
+the range ``[-pi, pi]``:
+
+>>> np.arctan2([1., -1.], [0., 0.])
+array([ 1.57079633, -1.57079633])
+>>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf])
+array([ 0.        ,  3.14159265,  0.78539816])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ceil (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ceil"))))
+(alter-meta! #'ceil assoc :doc "ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the ceiling of the input, element-wise.
+
+The ceil of the scalar `x` is the smallest integer `i`, such that
+`i >= x`.  It is often denoted as :math:`\\lceil x \\rceil`.
+
+Parameters
+----------
+x : array_like
+    Input data.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The ceiling of each element in `x`, with `float` dtype.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+floor, trunc, rint
+
+Examples
+--------
+>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
+>>> np.ceil(a)
+array([-1., -1., -0.,  1.,  2.,  2.,  2.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def int (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int"))))
+(alter-meta! #'int assoc :doc "int([x]) -> integer
+int(x, base=10) -> integer
+
+Convert a number or string to an integer, or return 0 if no arguments
+are given.  If x is a number, return x.__int__().  For floating point
+numbers, this truncates towards zero.
+
+If x is not a number or if base is given, then x must be a string,
+bytes, or bytearray instance representing an integer literal in the
+given base.  The literal can be preceded by '+' or '-' and be surrounded
+by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
+Base 0 means to interpret the base from the string as an integer literal.
+>>> int('0b100', base=0)
+4" :arglists '[[self & [args {:as kwargs}]]])
+
+(def asfortranarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asfortranarray"))))
+(alter-meta! #'asfortranarray assoc :doc "
+    Return an array (ndim >= 1) laid out in Fortran order in memory.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    dtype : str or dtype object, optional
+        By default, the data-type is inferred from the input data.
+
+    Returns
+    -------
+    out : ndarray
+        The input `a` in Fortran, or column-major, order.
+
+    See Also
+    --------
+    ascontiguousarray : Convert input to a contiguous (C order) array.
+    asanyarray : Convert input to an ndarray with either row or
+        column-major memory order.
+    require : Return an ndarray that satisfies requirements.
+    ndarray.flags : Information about the memory layout of the array.
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2,3)
+    >>> y = np.asfortranarray(x)
+    >>> x.flags['F_CONTIGUOUS']
+    False
+    >>> y.flags['F_CONTIGUOUS']
+    True
+
+    Note: This function returns an array with at least one-dimension (1-d) 
+    so it will not preserve 0-d arrays.  
+
+    " :arglists '[[a & [{dtype :dtype}]] [a]])
+
+(def logical_and (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_and"))))
+(alter-meta! #'logical_and assoc :doc "logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the truth value of x1 AND x2 element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or bool
+    Boolean result of the logical AND operation applied to the elements
+    of `x1` and `x2`; the shape is determined by broadcasting.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_or, logical_not, logical_xor
+bitwise_and
+
+Examples
+--------
+>>> np.logical_and(True, False)
+False
+>>> np.logical_and([True, False], [False, False])
+array([False, False])
+
+>>> x = np.arange(5)
+>>> np.logical_and(x>1, x<4)
+array([False, False,  True,  True, False])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def object (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "object"))))
+(alter-meta! #'object assoc :doc "The base class of the class hierarchy.
+
+When called, it accepts no arguments and returns a new featureless
+instance that has no instance attributes and cannot be given any.
+" :arglists '[[self & [args {:as kwargs}]]])
+
+(def flatnonzero (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flatnonzero"))))
+(alter-meta! #'flatnonzero assoc :doc "
+    Return indices that are non-zero in the flattened version of a.
+
+    This is equivalent to np.nonzero(np.ravel(a))[0].
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+
+    Returns
+    -------
+    res : ndarray
+        Output array, containing the indices of the elements of `a.ravel()`
+        that are non-zero.
+
+    See Also
+    --------
+    nonzero : Return the indices of the non-zero elements of the input array.
+    ravel : Return a 1-D array containing the elements of the input array.
+
+    Examples
+    --------
+    >>> x = np.arange(-2, 3)
+    >>> x
+    array([-2, -1,  0,  1,  2])
+    >>> np.flatnonzero(x)
+    array([0, 1, 3, 4])
+
+    Use the indices of the non-zero elements as an index array to extract
+    these elements:
+
+    >>> x.ravel()[np.flatnonzero(x)]
+    array([-2, -1,  1,  2])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def isscalar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isscalar"))))
+(alter-meta! #'isscalar assoc :doc "
+    Returns True if the type of `element` is a scalar type.
+
+    Parameters
+    ----------
+    element : any
+        Input argument, can be of any type and shape.
+
+    Returns
+    -------
+    val : bool
+        True if `element` is a scalar type, False if it is not.
+
+    See Also
+    --------
+    ndim : Get the number of dimensions of an array
+
+    Notes
+    -----
+    If you need a stricter way to identify a *numerical* scalar, use
+    ``isinstance(x, numbers.Number)``, as that returns ``False`` for most
+    non-numerical elements such as strings.
+
+    In most cases ``np.ndim(x) == 0`` should be used instead of this function,
+    as that will also return true for 0d arrays. This is how numpy overloads
+    functions in the style of the ``dx`` arguments to `gradient` and the ``bins``
+    argument to `histogram`. Some key differences:
+
+    +--------------------------------------+---------------+-------------------+
+    | x                                    |``isscalar(x)``|``np.ndim(x) == 0``|
+    +======================================+===============+===================+
+    | PEP 3141 numeric objects (including  | ``True``      | ``True``          |
+    | builtins)                            |               |                   |
+    +--------------------------------------+---------------+-------------------+
+    | builtin string and buffer objects    | ``True``      | ``True``          |
+    +--------------------------------------+---------------+-------------------+
+    | other builtin objects, like          | ``False``     | ``True``          |
+    | `pathlib.Path`, `Exception`,         |               |                   |
+    | the result of `re.compile`           |               |                   |
+    +--------------------------------------+---------------+-------------------+
+    | third-party objects like             | ``False``     | ``True``          |
+    | `matplotlib.figure.Figure`           |               |                   |
+    +--------------------------------------+---------------+-------------------+
+    | zero-dimensional numpy arrays        | ``False``     | ``True``          |
+    +--------------------------------------+---------------+-------------------+
+    | other numpy arrays                   | ``False``     | ``False``         |
+    +--------------------------------------+---------------+-------------------+
+    | `list`, `tuple`, and other sequence  | ``False``     | ``False``         |
+    | objects                              |               |                   |
+    +--------------------------------------+---------------+-------------------+
+
+    Examples
+    --------
+    >>> np.isscalar(3.1)
+    True
+    >>> np.isscalar(np.array(3.1))
+    False
+    >>> np.isscalar([3.1])
+    False
+    >>> np.isscalar(False)
+    True
+    >>> np.isscalar('numpy')
+    True
+
+    NumPy supports PEP 3141 numbers:
+
+    >>> from fractions import Fraction
+    >>> np.isscalar(Fraction(5, 17))
+    True
+    >>> from numbers import Number
+    >>> np.isscalar(Number())
+    True
+
+    " :arglists '[[element]])
+
+(def common_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "common_type"))))
+(alter-meta! #'common_type assoc :doc "
+    Return a scalar type which is common to the input arrays.
+
+    The return type will always be an inexact (i.e. floating point) scalar
+    type, even if all the arrays are integer arrays. If one of the inputs is
+    an integer array, the minimum precision type that is returned is a
+    64-bit floating point dtype.
+
+    All input arrays except int64 and uint64 can be safely cast to the
+    returned dtype without loss of information.
+
+    Parameters
+    ----------
+    array1, array2, ... : ndarrays
+        Input arrays.
+
+    Returns
+    -------
+    out : data type code
+        Data type code.
+
+    See Also
+    --------
+    dtype, mintypecode
+
+    Examples
+    --------
+    >>> np.common_type(np.arange(2, dtype=np.float32))
+    <class 'numpy.float32'>
+    >>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2))
+    <class 'numpy.float64'>
+    >>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0]))
+    <class 'numpy.complex128'>
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def clongdouble (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "clongdouble"))))
+(alter-meta! #'clongdouble assoc :doc "Complex number type composed of two extended-precision floating-point
+    numbers.
+    Character code: ``'G'``.
+    Canonical name: ``np.clongdouble``.
+    Alias: ``np.clongfloat``.
+    Alias: ``np.longcomplex``.
+    Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def diag (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diag"))))
+(alter-meta! #'diag assoc :doc "
+    Extract a diagonal or construct a diagonal array.
+
+    See the more detailed documentation for ``numpy.diagonal`` if you use this
+    function to extract a diagonal and wish to write to the resulting array;
+    whether it returns a copy or a view depends on what version of numpy you
+    are using.
+
+    Parameters
+    ----------
+    v : array_like
+        If `v` is a 2-D array, return a copy of its `k`-th diagonal.
+        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
+        diagonal.
+    k : int, optional
+        Diagonal in question. The default is 0. Use `k>0` for diagonals
+        above the main diagonal, and `k<0` for diagonals below the main
+        diagonal.
+
+    Returns
+    -------
+    out : ndarray
+        The extracted diagonal or constructed diagonal array.
+
+    See Also
+    --------
+    diagonal : Return specified diagonals.
+    diagflat : Create a 2-D array with the flattened input as a diagonal.
+    trace : Sum along diagonals.
+    triu : Upper triangle of an array.
+    tril : Lower triangle of an array.
+
+    Examples
+    --------
+    >>> x = np.arange(9).reshape((3,3))
+    >>> x
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+
+    >>> np.diag(x)
+    array([0, 4, 8])
+    >>> np.diag(x, k=1)
+    array([1, 5])
+    >>> np.diag(x, k=-1)
+    array([3, 7])
+
+    >>> np.diag(np.diag(x))
+    array([[0, 0, 0],
+           [0, 4, 0],
+           [0, 0, 8]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def nanmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmax"))))
+(alter-meta! #'nanmax assoc :doc "
+    Return the maximum of an array or maximum along an axis, ignoring any
+    NaNs.  When all-NaN slices are encountered a ``RuntimeWarning`` is
+    raised and NaN is returned for that slice.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose maximum is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the maximum is computed. The default is to compute
+        the maximum of the flattened array.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary. See
+        `ufuncs-output-type` for more details.
+
+        .. versionadded:: 1.8.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `max` method
+        of sub-classes of `ndarray`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+        .. versionadded:: 1.8.0
+
+    Returns
+    -------
+    nanmax : ndarray
+        An array with the same shape as `a`, with the specified axis removed.
+        If `a` is a 0-d array, or if axis is None, an ndarray scalar is
+        returned.  The same dtype as `a` is returned.
+
+    See Also
+    --------
+    nanmin :
+        The minimum value of an array along a given axis, ignoring any NaNs.
+    amax :
+        The maximum value of an array along a given axis, propagating any NaNs.
+    fmax :
+        Element-wise maximum of two arrays, ignoring any NaNs.
+    maximum :
+        Element-wise maximum of two arrays, propagating any NaNs.
+    isnan :
+        Shows which elements are Not a Number (NaN).
+    isfinite:
+        Shows which elements are neither NaN nor infinity.
+
+    amin, fmin, minimum
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+    Positive infinity is treated as a very large number and negative
+    infinity is treated as a very small (i.e. negative) number.
+
+    If the input has a integer type the function is equivalent to np.max.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nanmax(a)
+    3.0
+    >>> np.nanmax(a, axis=0)
+    array([3.,  2.])
+    >>> np.nanmax(a, axis=1)
+    array([2.,  3.])
+
+    When positive infinity and negative infinity are present:
+
+    >>> np.nanmax([1, 2, np.nan, np.NINF])
+    2.0
+    >>> np.nanmax([1, 2, np.nan, np.inf])
+    inf
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def generic (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "generic"))))
+(alter-meta! #'generic assoc :doc "Base class for numpy scalar types.
+
+    Class from which most (all?) numpy scalar types are derived.  For
+    consistency, exposes the same API as `ndarray`, despite many
+    consequent attributes being either \"get-only,\" or completely irrelevant.
+    This is the class from which it is strongly suggested users should derive
+    custom scalar types." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} __cached__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__cached__"))))
+
+(def digitize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "digitize"))))
+(alter-meta! #'digitize assoc :doc "
+    Return the indices of the bins to which each value in input array belongs.
+
+    =========  =============  ============================
+    `right`    order of bins  returned index `i` satisfies
+    =========  =============  ============================
+    ``False``  increasing     ``bins[i-1] <= x < bins[i]``
+    ``True``   increasing     ``bins[i-1] < x <= bins[i]``
+    ``False``  decreasing     ``bins[i-1] > x >= bins[i]``
+    ``True``   decreasing     ``bins[i-1] >= x > bins[i]``
+    =========  =============  ============================
+
+    If values in `x` are beyond the bounds of `bins`, 0 or ``len(bins)`` is
+    returned as appropriate.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array to be binned. Prior to NumPy 1.10.0, this array had to
+        be 1-dimensional, but can now have any shape.
+    bins : array_like
+        Array of bins. It has to be 1-dimensional and monotonic.
+    right : bool, optional
+        Indicating whether the intervals include the right or the left bin
+        edge. Default behavior is (right==False) indicating that the interval
+        does not include the right edge. The left bin end is open in this
+        case, i.e., bins[i-1] <= x < bins[i] is the default behavior for
+        monotonically increasing bins.
+
+    Returns
+    -------
+    indices : ndarray of ints
+        Output array of indices, of same shape as `x`.
+
+    Raises
+    ------
+    ValueError
+        If `bins` is not monotonic.
+    TypeError
+        If the type of the input is complex.
+
+    See Also
+    --------
+    bincount, histogram, unique, searchsorted
+
+    Notes
+    -----
+    If values in `x` are such that they fall outside the bin range,
+    attempting to index `bins` with the indices that `digitize` returns
+    will result in an IndexError.
+
+    .. versionadded:: 1.10.0
+
+    `np.digitize` is  implemented in terms of `np.searchsorted`. This means
+    that a binary search is used to bin the values, which scales much better
+    for larger number of bins than the previous linear search. It also removes
+    the requirement for the input array to be 1-dimensional.
+
+    For monotonically _increasing_ `bins`, the following are equivalent::
+
+        np.digitize(x, bins, right=True)
+        np.searchsorted(bins, x, side='left')
+
+    Note that as the order of the arguments are reversed, the side must be too.
+    The `searchsorted` call is marginally faster, as it does not do any
+    monotonicity checks. Perhaps more importantly, it supports all dtypes.
+
+    Examples
+    --------
+    >>> x = np.array([0.2, 6.4, 3.0, 1.6])
+    >>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])
+    >>> inds = np.digitize(x, bins)
+    >>> inds
+    array([1, 4, 3, 2])
+    >>> for n in range(x.size):
+    ...   print(bins[inds[n]-1], \"<=\", x[n], \"<\", bins[inds[n]])
+    ...
+    0.0 <= 0.2 < 1.0
+    4.0 <= 6.4 < 10.0
+    2.5 <= 3.0 < 4.0
+    1.0 <= 1.6 < 2.5
+
+    >>> x = np.array([1.2, 10.0, 12.4, 15.5, 20.])
+    >>> bins = np.array([0, 5, 10, 15, 20])
+    >>> np.digitize(x,bins,right=True)
+    array([1, 2, 3, 4, 4])
+    >>> np.digitize(x,bins,right=False)
+    array([1, 3, 3, 4, 5])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def array_split (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_split"))))
+(alter-meta! #'array_split assoc :doc "
+    Split an array into multiple sub-arrays.
+
+    Please refer to the ``split`` documentation.  The only difference
+    between these functions is that ``array_split`` allows
+    `indices_or_sections` to be an integer that does *not* equally
+    divide the axis. For an array of length l that should be split
+    into n sections, it returns l % n sub-arrays of size l//n + 1
+    and the rest of size l//n.
+
+    See Also
+    --------
+    split : Split array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> x = np.arange(8.0)
+    >>> np.array_split(x, 3)
+        [array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.])]
+
+    >>> x = np.arange(7.0)
+    >>> np.array_split(x, 3)
+        [array([0.,  1.,  2.]), array([3.,  4.]), array([5.,  6.])]
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "
+========================
+Random Number Generation
+========================
+
+Use ``default_rng()`` to create a `Generator` and call its methods.
+
+=============== =========================================================
+Generator
+--------------- ---------------------------------------------------------
+Generator       Class implementing all of the random number distributions
+default_rng     Default constructor for ``Generator``
+=============== =========================================================
+
+============================================= ===
+BitGenerator Streams that work with Generator
+--------------------------------------------- ---
+MT19937
+PCG64
+Philox
+SFC64
+============================================= ===
+
+============================================= ===
+Getting entropy to initialize a BitGenerator
+--------------------------------------------- ---
+SeedSequence
+============================================= ===
+
+
+Legacy
+------
+
+For backwards compatibility with previous versions of numpy before 1.17, the
+various aliases to the global `RandomState` methods are left alone and do not
+use the new `Generator` API.
+
+==================== =========================================================
+Utility functions
+-------------------- ---------------------------------------------------------
+random               Uniformly distributed floats over ``[0, 1)``
+bytes                Uniformly distributed random bytes.
+permutation          Randomly permute a sequence / generate a random sequence.
+shuffle              Randomly permute a sequence in place.
+choice               Random sample from 1-D array.
+==================== =========================================================
+
+==================== =========================================================
+Compatibility
+functions - removed
+in the new API
+-------------------- ---------------------------------------------------------
+rand                 Uniformly distributed values.
+randn                Normally distributed values.
+ranf                 Uniformly distributed floating point numbers.
+random_integers      Uniformly distributed integers in a given range.
+                     (deprecated, use ``integers(..., closed=True)`` instead)
+random_sample        Alias for `random_sample`
+randint              Uniformly distributed integers in a given range
+seed                 Seed the legacy random number generator.
+==================== =========================================================
+
+==================== =========================================================
+Univariate
+distributions
+-------------------- ---------------------------------------------------------
+beta                 Beta distribution over ``[0, 1]``.
+binomial             Binomial distribution.
+chisquare            :math:`\\chi^2` distribution.
+exponential          Exponential distribution.
+f                    F (Fisher-Snedecor) distribution.
+gamma                Gamma distribution.
+geometric            Geometric distribution.
+gumbel               Gumbel distribution.
+hypergeometric       Hypergeometric distribution.
+laplace              Laplace distribution.
+logistic             Logistic distribution.
+lognormal            Log-normal distribution.
+logseries            Logarithmic series distribution.
+negative_binomial    Negative binomial distribution.
+noncentral_chisquare Non-central chi-square distribution.
+noncentral_f         Non-central F distribution.
+normal               Normal / Gaussian distribution.
+pareto               Pareto distribution.
+poisson              Poisson distribution.
+power                Power distribution.
+rayleigh             Rayleigh distribution.
+triangular           Triangular distribution.
+uniform              Uniform distribution.
+vonmises             Von Mises circular distribution.
+wald                 Wald (inverse Gaussian) distribution.
+weibull              Weibull distribution.
+zipf                 Zipf's distribution over ranked data.
+==================== =========================================================
+
+==================== ==========================================================
+Multivariate
+distributions
+-------------------- ----------------------------------------------------------
+dirichlet            Multivariate generalization of Beta distribution.
+multinomial          Multivariate generalization of the binomial distribution.
+multivariate_normal  Multivariate generalization of the normal distribution.
+==================== ==========================================================
+
+==================== =========================================================
+Standard
+distributions
+-------------------- ---------------------------------------------------------
+standard_cauchy      Standard Cauchy-Lorentz distribution.
+standard_exponential Standard exponential distribution.
+standard_gamma       Standard Gamma distribution.
+standard_normal      Standard normal distribution.
+standard_t           Standard Student's t-distribution.
+==================== =========================================================
+
+==================== =========================================================
+Internal functions
+-------------------- ---------------------------------------------------------
+get_state            Get tuple representing internal state of generator.
+set_state            Set state of generator.
+==================== =========================================================
+
+
+"} random (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "random"))))
+
+(def get_include (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "get_include"))))
+(alter-meta! #'get_include assoc :doc "
+    Return the directory that contains the NumPy \\*.h header files.
+
+    Extension modules that need to compile against NumPy should use this
+    function to locate the appropriate include directory.
+
+    Notes
+    -----
+    When using ``distutils``, for example in ``setup.py``.
+    ::
+
+        import numpy as np
+        ...
+        Extension('extension_name', ...
+                include_dirs=[np.get_include()])
+        ...
+
+    " :arglists '[[]])
+
+(def ^{:doc ""} MAY_SHARE_BOUNDS (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "MAY_SHARE_BOUNDS"))))
+
+(def ^{:doc ""} UFUNC_BUFSIZE_DEFAULT (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "UFUNC_BUFSIZE_DEFAULT"))))
+
+(def ^{:doc ""} __config__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__config__"))))
+
+(def alen (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "alen"))))
+(alter-meta! #'alen assoc :doc "
+    Return the length of the first dimension of the input array.
+
+    Parameters
+    ----------
+    a : array_like
+       Input array.
+
+    Returns
+    -------
+    alen : int
+       Length of the first dimension of `a`.
+
+    See Also
+    --------
+    shape, size
+
+    Examples
+    --------
+    >>> a = np.zeros((7,4,5))
+    >>> a.shape[0]
+    7
+    >>> np.alen(a)
+    7
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def save (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "save"))))
+(alter-meta! #'save assoc :doc "
+    Save an array to a binary file in NumPy ``.npy`` format.
+
+    Parameters
+    ----------
+    file : file, str, or pathlib.Path
+        File or filename to which the data is saved.  If file is a file-object,
+        then the filename is unchanged.  If file is a string or Path, a ``.npy``
+        extension will be appended to the filename if it does not already
+        have one.
+    arr : array_like
+        Array data to be saved.
+    allow_pickle : bool, optional
+        Allow saving object arrays using Python pickles. Reasons for disallowing
+        pickles include security (loading pickled data can execute arbitrary
+        code) and portability (pickled objects may not be loadable on different
+        Python installations, for example if the stored objects require libraries
+        that are not available, and not all pickled data is compatible between
+        Python 2 and Python 3).
+        Default: True
+    fix_imports : bool, optional
+        Only useful in forcing objects in object arrays on Python 3 to be
+        pickled in a Python 2 compatible way. If `fix_imports` is True, pickle
+        will try to map the new Python 3 names to the old module names used in
+        Python 2, so that the pickle data stream is readable with Python 2.
+
+    See Also
+    --------
+    savez : Save several arrays into a ``.npz`` archive
+    savetxt, load
+
+    Notes
+    -----
+    For a description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.
+
+    Any data saved to the file is appended to the end of the file.
+
+    Examples
+    --------
+    >>> from tempfile import TemporaryFile
+    >>> outfile = TemporaryFile()
+
+    >>> x = np.arange(10)
+    >>> np.save(outfile, x)
+
+    >>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file
+    >>> np.load(outfile)
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+
+    >>> with open('test.npy', 'wb') as f:
+    ...     np.save(f, np.array([1, 2]))
+    ...     np.save(f, np.array([1, 3]))
+    >>> with open('test.npy', 'rb') as f:
+    ...     a = np.load(f)
+    ...     b = np.load(f)
+    >>> print(a, b)
+    # [1 2] [1 3]
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def cosh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cosh"))))
+(alter-meta! #'cosh assoc :doc "cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Hyperbolic cosine, element-wise.
+
+Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array of same shape as `x`.
+    This is a scalar if `x` is a scalar.
+
+Examples
+--------
+>>> np.cosh(0)
+1.0
+
+The hyperbolic cosine describes the shape of a hanging cable:
+
+>>> import matplotlib.pyplot as plt
+>>> x = np.linspace(-4, 4, 1000)
+>>> plt.plot(x, np.cosh(x))
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ix_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ix_"))))
+(alter-meta! #'ix_ assoc :doc "
+    Construct an open mesh from multiple sequences.
+
+    This function takes N 1-D sequences and returns N outputs with N
+    dimensions each, such that the shape is 1 in all but one dimension
+    and the dimension with the non-unit shape value cycles through all
+    N dimensions.
+
+    Using `ix_` one can quickly construct index arrays that will index
+    the cross product. ``a[np.ix_([1,3],[2,5])]`` returns the array
+    ``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``.
+
+    Parameters
+    ----------
+    args : 1-D sequences
+        Each sequence should be of integer or boolean type.
+        Boolean sequences will be interpreted as boolean masks for the
+        corresponding dimension (equivalent to passing in
+        ``np.nonzero(boolean_sequence)``).
+
+    Returns
+    -------
+    out : tuple of ndarrays
+        N arrays with N dimensions each, with N the number of input
+        sequences. Together these arrays form an open mesh.
+
+    See Also
+    --------
+    ogrid, mgrid, meshgrid
+
+    Examples
+    --------
+    >>> a = np.arange(10).reshape(2, 5)
+    >>> a
+    array([[0, 1, 2, 3, 4],
+           [5, 6, 7, 8, 9]])
+    >>> ixgrid = np.ix_([0, 1], [2, 4])
+    >>> ixgrid
+    (array([[0],
+           [1]]), array([[2, 4]]))
+    >>> ixgrid[0].shape, ixgrid[1].shape
+    ((2, 1), (1, 2))
+    >>> a[ixgrid]
+    array([[2, 4],
+           [7, 9]])
+
+    >>> ixgrid = np.ix_([True, True], [2, 4])
+    >>> a[ixgrid]
+    array([[2, 4],
+           [7, 9]])
+    >>> ixgrid = np.ix_([True, True], [False, False, True, False, True])
+    >>> a[ixgrid]
+    array([[2, 4],
+           [7, 9]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} NINF (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "NINF"))))
+
+(def int_asbuffer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int_asbuffer"))))
+(alter-meta! #'int_asbuffer assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ufunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ufunc"))))
+(alter-meta! #'ufunc assoc :doc "Functions that operate element by element on whole arrays.
+
+    To see the documentation for a specific ufunc, use `info`.  For
+    example, ``np.info(np.sin)``.  Because ufuncs are written in C
+    (for speed) and linked into Python with NumPy's ufunc facility,
+    Python's help() function finds this page whenever help() is called
+    on a ufunc.
+
+    A detailed explanation of ufuncs can be found in the docs for :ref:`ufuncs`.
+
+    Calling ufuncs:
+    ===============
+
+    op(*x[, out], where=True, **kwargs)
+    Apply `op` to the arguments `*x` elementwise, broadcasting the arguments.
+
+    The broadcasting rules are:
+
+    * Dimensions of length 1 may be prepended to either array.
+    * Arrays may be repeated along dimensions of length 1.
+
+    Parameters
+    ----------
+    *x : array_like
+        Input arrays.
+    out : ndarray, None, or tuple of ndarray and None, optional
+        Alternate array object(s) in which to put the result; if provided, it
+        must have a shape that the inputs broadcast to. A tuple of arrays
+        (possible only as a keyword argument) must have length equal to the
+        number of outputs; use None for uninitialized outputs to be
+        allocated by the ufunc.
+    where : array_like, optional
+        This condition is broadcast over the input. At locations where the
+        condition is True, the `out` array will be set to the ufunc result.
+        Elsewhere, the `out` array will retain its original value.
+        Note that if an uninitialized `out` array is created via the default
+        ``out=None``, locations within it where the condition is False will
+        remain uninitialized.
+    **kwargs
+        For other keyword-only arguments, see the :ref:`ufunc docs <ufuncs.kwargs>`.
+
+    Returns
+    -------
+    r : ndarray or tuple of ndarray
+        `r` will have the shape that the arrays in `x` broadcast to; if `out` is
+        provided, it will be returned. If not, `r` will be allocated and
+        may contain uninitialized values. If the function has more than one
+        output, then the result will be a tuple of arrays." :arglists '[[self & [args {:as kwargs}]]])
+
+(def TooHardError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "TooHardError"))))
+(alter-meta! #'TooHardError assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def sctype2char (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sctype2char"))))
+(alter-meta! #'sctype2char assoc :doc "
+    Return the string representation of a scalar dtype.
+
+    Parameters
+    ----------
+    sctype : scalar dtype or object
+        If a scalar dtype, the corresponding string character is
+        returned. If an object, `sctype2char` tries to infer its scalar type
+        and then return the corresponding string character.
+
+    Returns
+    -------
+    typechar : str
+        The string character corresponding to the scalar type.
+
+    Raises
+    ------
+    ValueError
+        If `sctype` is an object for which the type can not be inferred.
+
+    See Also
+    --------
+    obj2sctype, issctype, issubsctype, mintypecode
+
+    Examples
+    --------
+    >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]:
+    ...     print(np.sctype2char(sctype))
+    l # may vary
+    d
+    D
+    S
+    O
+
+    >>> x = np.array([1., 2-1.j])
+    >>> np.sctype2char(x)
+    'D'
+    >>> np.sctype2char(list)
+    'O'
+
+    " :arglists '[[sctype]])
+
+(def unique (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unique"))))
+(alter-meta! #'unique assoc :doc "
+    Find the unique elements of an array.
+
+    Returns the sorted unique elements of an array. There are three optional
+    outputs in addition to the unique elements:
+
+    * the indices of the input array that give the unique values
+    * the indices of the unique array that reconstruct the input array
+    * the number of times each unique value comes up in the input array
+
+    Parameters
+    ----------
+    ar : array_like
+        Input array. Unless `axis` is specified, this will be flattened if it
+        is not already 1-D.
+    return_index : bool, optional
+        If True, also return the indices of `ar` (along the specified axis,
+        if provided, or in the flattened array) that result in the unique array.
+    return_inverse : bool, optional
+        If True, also return the indices of the unique array (for the specified
+        axis, if provided) that can be used to reconstruct `ar`.
+    return_counts : bool, optional
+        If True, also return the number of times each unique item appears
+        in `ar`.
+
+        .. versionadded:: 1.9.0
+
+    axis : int or None, optional
+        The axis to operate on. If None, `ar` will be flattened. If an integer,
+        the subarrays indexed by the given axis will be flattened and treated
+        as the elements of a 1-D array with the dimension of the given axis,
+        see the notes for more details.  Object arrays or structured arrays
+        that contain objects are not supported if the `axis` kwarg is used. The
+        default is None.
+
+        .. versionadded:: 1.13.0
+
+    Returns
+    -------
+    unique : ndarray
+        The sorted unique values.
+    unique_indices : ndarray, optional
+        The indices of the first occurrences of the unique values in the
+        original array. Only provided if `return_index` is True.
+    unique_inverse : ndarray, optional
+        The indices to reconstruct the original array from the
+        unique array. Only provided if `return_inverse` is True.
+    unique_counts : ndarray, optional
+        The number of times each of the unique values comes up in the
+        original array. Only provided if `return_counts` is True.
+
+        .. versionadded:: 1.9.0
+
+    See Also
+    --------
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Notes
+    -----
+    When an axis is specified the subarrays indexed by the axis are sorted.
+    This is done by making the specified axis the first dimension of the array
+    (move the axis to the first dimension to keep the order of the other axes)
+    and then flattening the subarrays in C order. The flattened subarrays are
+    then viewed as a structured type with each element given a label, with the
+    effect that we end up with a 1-D array of structured types that can be
+    treated in the same way as any other 1-D array. The result is that the
+    flattened subarrays are sorted in lexicographic order starting with the
+    first element.
+
+    Examples
+    --------
+    >>> np.unique([1, 1, 2, 2, 3, 3])
+    array([1, 2, 3])
+    >>> a = np.array([[1, 1], [2, 3]])
+    >>> np.unique(a)
+    array([1, 2, 3])
+
+    Return the unique rows of a 2D array
+
+    >>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
+    >>> np.unique(a, axis=0)
+    array([[1, 0, 0], [2, 3, 4]])
+
+    Return the indices of the original array that give the unique values:
+
+    >>> a = np.array(['a', 'b', 'b', 'c', 'a'])
+    >>> u, indices = np.unique(a, return_index=True)
+    >>> u
+    array(['a', 'b', 'c'], dtype='<U1')
+    >>> indices
+    array([0, 1, 3])
+    >>> a[indices]
+    array(['a', 'b', 'c'], dtype='<U1')
+
+    Reconstruct the input array from the unique values:
+
+    >>> a = np.array([1, 2, 6, 4, 2, 3, 2])
+    >>> u, indices = np.unique(a, return_inverse=True)
+    >>> u
+    array([1, 2, 3, 4, 6])
+    >>> indices
+    array([0, 1, 4, ..., 1, 2, 1])
+    >>> u[indices]
+    array([1, 2, 6, ..., 2, 3, 2])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def min (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "min"))))
+(alter-meta! #'min assoc :doc "
+    Return the minimum of an array or minimum along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to operate.  By default, flattened input is
+        used.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, the minimum is selected over multiple axes,
+        instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternative output array in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+        See `ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `amin` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    initial : scalar, optional
+        The maximum value of an output element. Must be present to allow
+        computation on empty slice. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to compare for the minimum. See `~numpy.ufunc.reduce`
+        for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    amin : ndarray or scalar
+        Minimum of `a`. If `axis` is None, the result is a scalar value.
+        If `axis` is given, the result is an array of dimension
+        ``a.ndim - 1``.
+
+    See Also
+    --------
+    amax :
+        The maximum value of an array along a given axis, propagating any NaNs.
+    nanmin :
+        The minimum value of an array along a given axis, ignoring any NaNs.
+    minimum :
+        Element-wise minimum of two arrays, propagating any NaNs.
+    fmin :
+        Element-wise minimum of two arrays, ignoring any NaNs.
+    argmin :
+        Return the indices of the minimum values.
+
+    nanmax, maximum, fmax
+
+    Notes
+    -----
+    NaN values are propagated, that is if at least one item is NaN, the
+    corresponding min value will be NaN as well. To ignore NaN values
+    (MATLAB behavior), please use nanmin.
+
+    Don't use `amin` for element-wise comparison of 2 arrays; when
+    ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than
+    ``amin(a, axis=0)``.
+
+    Examples
+    --------
+    >>> a = np.arange(4).reshape((2,2))
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> np.amin(a)           # Minimum of the flattened array
+    0
+    >>> np.amin(a, axis=0)   # Minima along the first axis
+    array([0, 1])
+    >>> np.amin(a, axis=1)   # Minima along the second axis
+    array([0, 2])
+    >>> np.amin(a, where=[False, True], initial=10, axis=0)
+    array([10,  1])
+
+    >>> b = np.arange(5, dtype=float)
+    >>> b[2] = np.NaN
+    >>> np.amin(b)
+    nan
+    >>> np.amin(b, where=~np.isnan(b), initial=10)
+    0.0
+    >>> np.nanmin(b)
+    0.0
+
+    >>> np.min([[-50], [10]], axis=-1, initial=0)
+    array([-50,   0])
+
+    Notice that the initial value is used as one of the elements for which the
+    minimum is determined, unlike for the default argument Python's max
+    function, which is only used for empty iterables.
+
+    Notice that this isn't the same as Python's ``default`` argument.
+
+    >>> np.min([6], initial=5)
+    5
+    >>> min([6], default=5)
+    6
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def histogram2d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogram2d"))))
+(alter-meta! #'histogram2d assoc :doc "
+    Compute the bi-dimensional histogram of two data samples.
+
+    Parameters
+    ----------
+    x : array_like, shape (N,)
+        An array containing the x coordinates of the points to be
+        histogrammed.
+    y : array_like, shape (N,)
+        An array containing the y coordinates of the points to be
+        histogrammed.
+    bins : int or array_like or [int, int] or [array, array], optional
+        The bin specification:
+
+          * If int, the number of bins for the two dimensions (nx=ny=bins).
+          * If array_like, the bin edges for the two dimensions
+            (x_edges=y_edges=bins).
+          * If [int, int], the number of bins in each dimension
+            (nx, ny = bins).
+          * If [array, array], the bin edges in each dimension
+            (x_edges, y_edges = bins).
+          * A combination [int, array] or [array, int], where int
+            is the number of bins and array is the bin edges.
+
+    range : array_like, shape(2,2), optional
+        The leftmost and rightmost edges of the bins along each dimension
+        (if not specified explicitly in the `bins` parameters):
+        ``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range
+        will be considered outliers and not tallied in the histogram.
+    density : bool, optional
+        If False, the default, returns the number of samples in each bin.
+        If True, returns the probability *density* function at the bin,
+        ``bin_count / sample_count / bin_area``.
+    normed : bool, optional
+        An alias for the density argument that behaves identically. To avoid
+        confusion with the broken normed argument to `histogram`, `density`
+        should be preferred.
+    weights : array_like, shape(N,), optional
+        An array of values ``w_i`` weighing each sample ``(x_i, y_i)``.
+        Weights are normalized to 1 if `normed` is True. If `normed` is
+        False, the values of the returned histogram are equal to the sum of
+        the weights belonging to the samples falling into each bin.
+
+    Returns
+    -------
+    H : ndarray, shape(nx, ny)
+        The bi-dimensional histogram of samples `x` and `y`. Values in `x`
+        are histogrammed along the first dimension and values in `y` are
+        histogrammed along the second dimension.
+    xedges : ndarray, shape(nx+1,)
+        The bin edges along the first dimension.
+    yedges : ndarray, shape(ny+1,)
+        The bin edges along the second dimension.
+
+    See Also
+    --------
+    histogram : 1D histogram
+    histogramdd : Multidimensional histogram
+
+    Notes
+    -----
+    When `normed` is True, then the returned histogram is the sample
+    density, defined such that the sum over bins of the product
+    ``bin_value * bin_area`` is 1.
+
+    Please note that the histogram does not follow the Cartesian convention
+    where `x` values are on the abscissa and `y` values on the ordinate
+    axis.  Rather, `x` is histogrammed along the first dimension of the
+    array (vertical), and `y` along the second dimension of the array
+    (horizontal).  This ensures compatibility with `histogramdd`.
+
+    Examples
+    --------
+    >>> from matplotlib.image import NonUniformImage
+    >>> import matplotlib.pyplot as plt
+
+    Construct a 2-D histogram with variable bin width. First define the bin
+    edges:
+
+    >>> xedges = [0, 1, 3, 5]
+    >>> yedges = [0, 2, 3, 4, 6]
+
+    Next we create a histogram H with random bin content:
+
+    >>> x = np.random.normal(2, 1, 100)
+    >>> y = np.random.normal(1, 1, 100)
+    >>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges))
+    >>> H = H.T  # Let each row list bins with common y range.
+
+    :func:`imshow <matplotlib.pyplot.imshow>` can only display square bins:
+
+    >>> fig = plt.figure(figsize=(7, 3))
+    >>> ax = fig.add_subplot(131, title='imshow: square bins')
+    >>> plt.imshow(H, interpolation='nearest', origin='low',
+    ...         extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])
+    <matplotlib.image.AxesImage object at 0x...>
+
+    :func:`pcolormesh <matplotlib.pyplot.pcolormesh>` can display actual edges:
+
+    >>> ax = fig.add_subplot(132, title='pcolormesh: actual edges',
+    ...         aspect='equal')
+    >>> X, Y = np.meshgrid(xedges, yedges)
+    >>> ax.pcolormesh(X, Y, H)
+    <matplotlib.collections.QuadMesh object at 0x...>
+
+    :class:`NonUniformImage <matplotlib.image.NonUniformImage>` can be used to
+    display actual bin edges with interpolation:
+
+    >>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated',
+    ...         aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])
+    >>> im = NonUniformImage(ax, interpolation='bilinear')
+    >>> xcenters = (xedges[:-1] + xedges[1:]) / 2
+    >>> ycenters = (yedges[:-1] + yedges[1:]) / 2
+    >>> im.set_data(xcenters, ycenters, H)
+    >>> ax.images.append(im)
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def array_str (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_str"))))
+(alter-meta! #'array_str assoc :doc "
+    Return a string representation of the data in an array.
+
+    The data in the array is returned as a single string.  This function is
+    similar to `array_repr`, the difference being that `array_repr` also
+    returns information on the kind of array and its data type.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input array.
+    max_line_width : int, optional
+        Inserts newlines if text is longer than `max_line_width`.
+        Defaults to ``numpy.get_printoptions()['linewidth']``.
+    precision : int, optional
+        Floating point precision.
+        Defaults to ``numpy.get_printoptions()['precision']``.
+    suppress_small : bool, optional
+        Represent numbers \"very close\" to zero as zero; default is False.
+        Very close is defined by precision: if the precision is 8, e.g.,
+        numbers smaller (in absolute value) than 5e-9 are represented as
+        zero.
+        Defaults to ``numpy.get_printoptions()['suppress']``.
+
+    See Also
+    --------
+    array2string, array_repr, set_printoptions
+
+    Examples
+    --------
+    >>> np.array_str(np.arange(3))
+    '[0 1 2]'
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} SHIFT_INVALID (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "SHIFT_INVALID"))))
+
+(def zeros (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "zeros"))))
+(alter-meta! #'zeros assoc :doc "zeros(shape, dtype=float, order='C')
+
+    Return a new array of given shape and type, filled with zeros.
+
+    Parameters
+    ----------
+    shape : int or tuple of ints
+        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
+    dtype : data-type, optional
+        The desired data-type for the array, e.g., `numpy.int8`.  Default is
+        `numpy.float64`.
+    order : {'C', 'F'}, optional, default: 'C'
+        Whether to store multi-dimensional data in row-major
+        (C-style) or column-major (Fortran-style) order in
+        memory.
+
+    Returns
+    -------
+    out : ndarray
+        Array of zeros with the given shape, dtype, and order.
+
+    See Also
+    --------
+    zeros_like : Return an array of zeros with shape and type of input.
+    empty : Return a new uninitialized array.
+    ones : Return a new array setting values to one.
+    full : Return a new array of given shape filled with value.
+
+    Examples
+    --------
+    >>> np.zeros(5)
+    array([ 0.,  0.,  0.,  0.,  0.])
+
+    >>> np.zeros((5,), dtype=int)
+    array([0, 0, 0, 0, 0])
+
+    >>> np.zeros((2, 1))
+    array([[ 0.],
+           [ 0.]])
+
+    >>> s = (2,2)
+    >>> np.zeros(s)
+    array([[ 0.,  0.],
+           [ 0.,  0.]])
+
+    >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
+    array([(0, 0), (0, 0)],
+          dtype=[('x', '<i4'), ('y', '<i4')])" :arglists '[[self & [args {:as kwargs}]]])
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} sctypes (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "sctypes")))) 
+
+(def invert (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "invert"))))
+(alter-meta! #'invert assoc :doc "invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute bit-wise inversion, or bit-wise NOT, element-wise.
+
+Computes the bit-wise NOT of the underlying binary representation of
+the integers in the input arrays. This ufunc implements the C/Python
+operator ``~``.
+
+For signed integer inputs, the two's complement is returned.  In a
+two's-complement system negative numbers are represented by the two's
+complement of the absolute value. This is the most common method of
+representing signed integers on computers [1]_. A N-bit
+two's-complement system can represent every integer in the range
+:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
+
+Parameters
+----------
+x : array_like
+    Only integer and boolean types are handled.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Result.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+bitwise_and, bitwise_or, bitwise_xor
+logical_not
+binary_repr :
+    Return the binary representation of the input number as a string.
+
+Notes
+-----
+`bitwise_not` is an alias for `invert`:
+
+>>> np.bitwise_not is np.invert
+True
+
+References
+----------
+.. [1] Wikipedia, \"Two's complement\",
+    https://en.wikipedia.org/wiki/Two's_complement
+
+Examples
+--------
+We've seen that 13 is represented by ``00001101``.
+The invert or bit-wise NOT of 13 is then:
+
+>>> x = np.invert(np.array(13, dtype=np.uint8))
+>>> x
+242
+>>> np.binary_repr(x, width=8)
+'11110010'
+
+The result depends on the bit-width:
+
+>>> x = np.invert(np.array(13, dtype=np.uint16))
+>>> x
+65522
+>>> np.binary_repr(x, width=16)
+'1111111111110010'
+
+When using signed integer types the result is the two's complement of
+the result for the unsigned type:
+
+>>> np.invert(np.array([13], dtype=np.int8))
+array([-14], dtype=int8)
+>>> np.binary_repr(-14, width=8)
+'11110010'
+
+Booleans are accepted as well:
+
+>>> np.invert(np.array([True, False]))
+array([False,  True])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def floor_divide (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "floor_divide"))))
+(alter-meta! #'floor_divide assoc :doc "floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the largest integer smaller or equal to the division of the inputs.
+It is equivalent to the Python ``//`` operator and pairs with the
+Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)``
+up to roundoff.
+
+Parameters
+----------
+x1 : array_like
+    Numerator.
+x2 : array_like
+    Denominator. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    y = floor(`x1`/`x2`)
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+remainder : Remainder complementary to floor_divide.
+divmod : Simultaneous floor division and remainder.
+divide : Standard division.
+floor : Round a number to the nearest integer toward minus infinity.
+ceil : Round a number to the nearest integer toward infinity.
+
+Examples
+--------
+>>> np.floor_divide(7,3)
+2
+>>> np.floor_divide([1., 2., 3., 4.], 2.5)
+array([ 0.,  0.,  1.,  1.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def uint0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint0"))))
+(alter-meta! #'uint0 assoc :doc "Unsigned integer type, compatible with C ``unsigned long``.
+    Character code: ``'L'``.
+    Canonical name: ``np.uint``.
+    Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615).
+    Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc "
+============================
+``ctypes`` Utility Functions
+============================
+
+See Also
+---------
+load_library : Load a C library.
+ndpointer : Array restype/argtype with verification.
+as_ctypes : Create a ctypes array from an ndarray.
+as_array : Create an ndarray from a ctypes array.
+
+References
+----------
+.. [1] \"SciPy Cookbook: ctypes\", https://scipy-cookbook.readthedocs.io/items/Ctypes.html
+
+Examples
+--------
+Load the C library:
+
+>>> _lib = np.ctypeslib.load_library('libmystuff', '.')     #doctest: +SKIP
+
+Our result type, an ndarray that must be of type double, be 1-dimensional
+and is C-contiguous in memory:
+
+>>> array_1d_double = np.ctypeslib.ndpointer(
+...                          dtype=np.double,
+...                          ndim=1, flags='CONTIGUOUS')    #doctest: +SKIP
+
+Our C-function typically takes an array and updates its values
+in-place.  For example::
+
+    void foo_func(double* x, int length)
+    {
+        int i;
+        for (i = 0; i < length; i++) {
+            x[i] = i*i;
+        }
+    }
+
+We wrap it using:
+
+>>> _lib.foo_func.restype = None                      #doctest: +SKIP
+>>> _lib.foo_func.argtypes = [array_1d_double, c_int] #doctest: +SKIP
+
+Then, we're ready to call ``foo_func``:
+
+>>> out = np.empty(15, dtype=np.double)
+>>> _lib.foo_func(out, len(out))                #doctest: +SKIP
+
+"} ctypeslib (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ctypeslib"))))
+
+(def bool_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bool_"))))
+(alter-meta! #'bool_ assoc :doc "Boolean type (True or False), stored as a byte.
+    Character code: ``'?'``.
+    Alias: ``np.bool8``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def void0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "void0"))))
+(alter-meta! #'void0 assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def bytes_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bytes_"))))
+(alter-meta! #'bytes_ assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def seterr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "seterr"))))
+(alter-meta! #'seterr assoc :doc "
+    Set how floating-point errors are handled.
+
+    Note that operations on integer scalar types (such as `int16`) are
+    handled like floating point, and are affected by these settings.
+
+    Parameters
+    ----------
+    all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
+        Set treatment for all types of floating-point errors at once:
+
+        - ignore: Take no action when the exception occurs.
+        - warn: Print a `RuntimeWarning` (via the Python `warnings` module).
+        - raise: Raise a `FloatingPointError`.
+        - call: Call a function specified using the `seterrcall` function.
+        - print: Print a warning directly to ``stdout``.
+        - log: Record error in a Log object specified by `seterrcall`.
+
+        The default is not to change the current behavior.
+    divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
+        Treatment for division by zero.
+    over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
+        Treatment for floating-point overflow.
+    under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
+        Treatment for floating-point underflow.
+    invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
+        Treatment for invalid floating-point operation.
+
+    Returns
+    -------
+    old_settings : dict
+        Dictionary containing the old settings.
+
+    See also
+    --------
+    seterrcall : Set a callback function for the 'call' mode.
+    geterr, geterrcall, errstate
+
+    Notes
+    -----
+    The floating-point exceptions are defined in the IEEE 754 standard [1]_:
+
+    - Division by zero: infinite result obtained from finite numbers.
+    - Overflow: result too large to be expressed.
+    - Underflow: result so close to zero that some precision
+      was lost.
+    - Invalid operation: result is not an expressible number, typically
+      indicates that a NaN was produced.
+
+    .. [1] https://en.wikipedia.org/wiki/IEEE_754
+
+    Examples
+    --------
+    >>> old_settings = np.seterr(all='ignore')  #seterr to known value
+    >>> np.seterr(over='raise')
+    {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
+    >>> np.seterr(**old_settings)  # reset to default
+    {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'}
+
+    >>> np.int16(32000) * np.int16(3)
+    30464
+    >>> old_settings = np.seterr(all='warn', over='raise')
+    >>> np.int16(32000) * np.int16(3)
+    Traceback (most recent call last):
+      File \"<stdin>\", line 1, in <module>
+    FloatingPointError: overflow encountered in short_scalars
+
+    >>> from collections import OrderedDict
+    >>> old_settings = np.seterr(all='print')
+    >>> OrderedDict(np.geterr())
+    OrderedDict([('divide', 'print'), ('over', 'print'), ('under', 'print'), ('invalid', 'print')])
+    >>> np.int16(32000) * np.int16(3)
+    30464
+
+    " :arglists '[[& [{all :all, divide :divide, over :over, under :under, invalid :invalid}]] [& [{all :all, divide :divide, over :over, under :under}]] [& [{all :all, divide :divide, over :over}]] [& [{all :all, divide :divide}]] [& [{all :all}]] []])
+
+(def ^{:doc ""} ERR_CALL (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_CALL"))))
+
+(def isinf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isinf"))))
+(alter-meta! #'isinf assoc :doc "isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Test element-wise for positive or negative infinity.
+
+Returns a boolean array of the same shape as `x`, True where ``x ==
++/-inf``, otherwise False.
+
+Parameters
+----------
+x : array_like
+    Input values
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : bool (scalar) or boolean ndarray
+    True where ``x`` is positive or negative infinity, false otherwise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+isneginf, isposinf, isnan, isfinite
+
+Notes
+-----
+NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+(IEEE 754).
+
+Errors result if the second argument is supplied when the first
+argument is a scalar, or if the first and second arguments have
+different shapes.
+
+Examples
+--------
+>>> np.isinf(np.inf)
+True
+>>> np.isinf(np.nan)
+False
+>>> np.isinf(np.NINF)
+True
+>>> np.isinf([np.inf, -np.inf, 1.0, np.nan])
+array([ True,  True, False, False])
+
+>>> x = np.array([-np.inf, 0., np.inf])
+>>> y = np.array([2, 2, 2])
+>>> np.isinf(x, y)
+array([1, 0, 1])
+>>> y
+array([1, 0, 1])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def spacing (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "spacing"))))
+(alter-meta! #'spacing assoc :doc "spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the distance between x and the nearest adjacent number.
+
+Parameters
+----------
+x : array_like
+    Values to find the spacing of.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    The spacing of values of `x`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+It can be considered as a generalization of EPS:
+``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there
+should not be any representable number between ``x + spacing(x)`` and
+x for any finite x.
+
+Spacing of +- inf and NaN is NaN.
+
+Examples
+--------
+>>> np.spacing(1) == np.finfo(np.float64).eps
+True" :arglists '[[self & [args {:as kwargs}]]])
+
+(def float_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float_"))))
+(alter-meta! #'float_ assoc :doc "Double-precision floating-point number type, compatible with Python `float`
+    and C ``double``.
+    Character code: ``'d'``.
+    Canonical name: ``np.double``.
+    Alias: ``np.float_``.
+    Alias *on this platform*: ``np.float64``: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
+
+(def RankWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "RankWarning"))))
+(alter-meta! #'RankWarning assoc :doc "
+    Issued by `polyfit` when the Vandermonde matrix is rank deficient.
+
+    For more information, a way to suppress the warning, and an example of
+    `RankWarning` being issued, see `polyfit`.
+
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def polyval (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyval"))))
+(alter-meta! #'polyval assoc :doc "
+    Evaluate a polynomial at specific values.
+
+    If `p` is of length N, this function returns the value:
+
+        ``p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]``
+
+    If `x` is a sequence, then `p(x)` is returned for each element of `x`.
+    If `x` is another polynomial then the composite polynomial `p(x(t))`
+    is returned.
+
+    Parameters
+    ----------
+    p : array_like or poly1d object
+       1D array of polynomial coefficients (including coefficients equal
+       to zero) from highest degree to the constant term, or an
+       instance of poly1d.
+    x : array_like or poly1d object
+       A number, an array of numbers, or an instance of poly1d, at
+       which to evaluate `p`.
+
+    Returns
+    -------
+    values : ndarray or poly1d
+       If `x` is a poly1d instance, the result is the composition of the two
+       polynomials, i.e., `x` is \"substituted\" in `p` and the simplified
+       result is returned. In addition, the type of `x` - array_like or
+       poly1d - governs the type of the output: `x` array_like => `values`
+       array_like, `x` a poly1d object => `values` is also.
+
+    See Also
+    --------
+    poly1d: A polynomial class.
+
+    Notes
+    -----
+    Horner's scheme [1]_ is used to evaluate the polynomial. Even so,
+    for polynomials of high degree the values may be inaccurate due to
+    rounding errors. Use carefully.
+
+    If `x` is a subtype of `ndarray` the return value will be of the same type.
+
+    References
+    ----------
+    .. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng.
+       trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand
+       Reinhold Co., 1985, pg. 720.
+
+    Examples
+    --------
+    >>> np.polyval([3,0,1], 5)  # 3 * 5**2 + 0 * 5**1 + 1
+    76
+    >>> np.polyval([3,0,1], np.poly1d(5))
+    poly1d([76.])
+    >>> np.polyval(np.poly1d([3,0,1]), 5)
+    76
+    >>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5))
+    poly1d([76.])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "
+    Translates slice objects to concatenation along the first axis.
+
+    This is a simple way to build up arrays quickly. There are two use cases.
+
+    1. If the index expression contains comma separated arrays, then stack
+       them along their first axis.
+    2. If the index expression contains slice notation or scalars then create
+       a 1-D array with a range indicated by the slice notation.
+
+    If slice notation is used, the syntax ``start:stop:step`` is equivalent
+    to ``np.arange(start, stop, step)`` inside of the brackets. However, if
+    ``step`` is an imaginary number (i.e. 100j) then its integer portion is
+    interpreted as a number-of-points desired and the start and stop are
+    inclusive. In other words ``start:stop:stepj`` is interpreted as
+    ``np.linspace(start, stop, step, endpoint=1)`` inside of the brackets.
+    After expansion of slice notation, all comma separated sequences are
+    concatenated together.
+
+    Optional character strings placed as the first element of the index
+    expression can be used to change the output. The strings 'r' or 'c' result
+    in matrix output. If the result is 1-D and 'r' is specified a 1 x N (row)
+    matrix is produced. If the result is 1-D and 'c' is specified, then a N x 1
+    (column) matrix is produced. If the result is 2-D then both provide the
+    same matrix result.
+
+    A string integer specifies which axis to stack multiple comma separated
+    arrays along. A string of two comma-separated integers allows indication
+    of the minimum number of dimensions to force each entry into as the
+    second integer (the axis to concatenate along is still the first integer).
+
+    A string with three comma-separated integers allows specification of the
+    axis to concatenate along, the minimum number of dimensions to force the
+    entries to, and which axis should contain the start of the arrays which
+    are less than the specified number of dimensions. In other words the third
+    integer allows you to specify where the 1's should be placed in the shape
+    of the arrays that have their shapes upgraded. By default, they are placed
+    in the front of the shape tuple. The third argument allows you to specify
+    where the start of the array should be instead. Thus, a third argument of
+    '0' would place the 1's at the end of the array shape. Negative integers
+    specify where in the new shape tuple the last dimension of upgraded arrays
+    should be placed, so the default is '-1'.
+
+    Parameters
+    ----------
+    Not a function, so takes no parameters
+
+
+    Returns
+    -------
+    A concatenated ndarray or matrix.
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays along an existing axis.
+    c_ : Translates slice objects to concatenation along the second axis.
+
+    Examples
+    --------
+    >>> np.r_[np.array([1,2,3]), 0, 0, np.array([4,5,6])]
+    array([1, 2, 3, ..., 4, 5, 6])
+    >>> np.r_[-1:1:6j, [0]*3, 5, 6]
+    array([-1. , -0.6, -0.2,  0.2,  0.6,  1. ,  0. ,  0. ,  0. ,  5. ,  6. ])
+
+    String integers specify the axis to concatenate along or the minimum
+    number of dimensions to force entries into.
+
+    >>> a = np.array([[0, 1, 2], [3, 4, 5]])
+    >>> np.r_['-1', a, a] # concatenate along last axis
+    array([[0, 1, 2, 0, 1, 2],
+           [3, 4, 5, 3, 4, 5]])
+    >>> np.r_['0,2', [1,2,3], [4,5,6]] # concatenate along first axis, dim>=2
+    array([[1, 2, 3],
+           [4, 5, 6]])
+
+    >>> np.r_['0,2,0', [1,2,3], [4,5,6]]
+    array([[1],
+           [2],
+           [3],
+           [4],
+           [5],
+           [6]])
+    >>> np.r_['1,2,0', [1,2,3], [4,5,6]]
+    array([[1, 4],
+           [2, 5],
+           [3, 6]])
+
+    Using 'r' or 'c' as a first string argument creates a matrix.
+
+    >>> np.r_['r',[1,2,3], [4,5,6]]
+    matrix([[1, 2, 3, 4, 5, 6]])
+
+    "} r_ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "r_"))))
+
+(def ndindex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndindex"))))
+(alter-meta! #'ndindex assoc :doc "
+    An N-dimensional iterator object to index arrays.
+
+    Given the shape of an array, an `ndindex` instance iterates over
+    the N-dimensional index of the array. At each iteration a tuple
+    of indices is returned, the last dimension is iterated over first.
+
+    Parameters
+    ----------
+    `*args` : ints
+      The size of each dimension of the array.
+
+    See Also
+    --------
+    ndenumerate, flatiter
+
+    Examples
+    --------
+    >>> for index in np.ndindex(3, 2, 1):
+    ...     print(index)
+    (0, 0, 0)
+    (0, 1, 0)
+    (1, 0, 0)
+    (1, 1, 0)
+    (2, 0, 0)
+    (2, 1, 0)
+
+    " :arglists '[[self & [shape]]])
+
+(def ^{:doc ""} infty (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "infty"))))
+
+(def deprecate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "deprecate"))))
+(alter-meta! #'deprecate assoc :doc "
+    Issues a DeprecationWarning, adds warning to `old_name`'s
+    docstring, rebinds ``old_name.__name__`` and returns the new
+    function object.
+
+    This function may also be used as a decorator.
+
+    Parameters
+    ----------
+    func : function
+        The function to be deprecated.
+    old_name : str, optional
+        The name of the function to be deprecated. Default is None, in
+        which case the name of `func` is used.
+    new_name : str, optional
+        The new name for the function. Default is None, in which case the
+        deprecation message is that `old_name` is deprecated. If given, the
+        deprecation message is that `old_name` is deprecated and `new_name`
+        should be used instead.
+    message : str, optional
+        Additional explanation of the deprecation.  Displayed in the
+        docstring after the warning.
+
+    Returns
+    -------
+    old_func : function
+        The deprecated function.
+
+    Examples
+    --------
+    Note that ``olduint`` returns a value after printing Deprecation
+    Warning:
+
+    >>> olduint = np.deprecate(np.uint)
+    DeprecationWarning: `uint64` is deprecated! # may vary
+    >>> olduint(6)
+    6
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def set_printoptions (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "set_printoptions"))))
+(alter-meta! #'set_printoptions assoc :doc "
+    Set printing options.
+
+    These options determine the way floating point numbers, arrays and
+    other NumPy objects are displayed.
+
+    Parameters
+    ----------
+    precision : int or None, optional
+        Number of digits of precision for floating point output (default 8).
+        May be None if `floatmode` is not `fixed`, to print as many digits as
+        necessary to uniquely specify the value.
+    threshold : int, optional
+        Total number of array elements which trigger summarization
+        rather than full repr (default 1000).
+        To always use the full repr without summarization, pass `sys.maxsize`.
+    edgeitems : int, optional
+        Number of array items in summary at beginning and end of
+        each dimension (default 3).
+    linewidth : int, optional
+        The number of characters per line for the purpose of inserting
+        line breaks (default 75).
+    suppress : bool, optional
+        If True, always print floating point numbers using fixed point
+        notation, in which case numbers equal to zero in the current precision
+        will print as zero.  If False, then scientific notation is used when
+        absolute value of the smallest number is < 1e-4 or the ratio of the
+        maximum absolute value to the minimum is > 1e3. The default is False.
+    nanstr : str, optional
+        String representation of floating point not-a-number (default nan).
+    infstr : str, optional
+        String representation of floating point infinity (default inf).
+    sign : string, either '-', '+', or ' ', optional
+        Controls printing of the sign of floating-point types. If '+', always
+        print the sign of positive values. If ' ', always prints a space
+        (whitespace character) in the sign position of positive values.  If
+        '-', omit the sign character of positive values. (default '-')
+    formatter : dict of callables, optional
+        If not None, the keys should indicate the type(s) that the respective
+        formatting function applies to.  Callables should return a string.
+        Types that are not specified (by their corresponding keys) are handled
+        by the default formatters.  Individual types for which a formatter
+        can be set are:
+
+        - 'bool'
+        - 'int'
+        - 'timedelta' : a `numpy.timedelta64`
+        - 'datetime' : a `numpy.datetime64`
+        - 'float'
+        - 'longfloat' : 128-bit floats
+        - 'complexfloat'
+        - 'longcomplexfloat' : composed of two 128-bit floats
+        - 'numpystr' : types `numpy.string_` and `numpy.unicode_`
+        - 'object' : `np.object_` arrays
+        - 'str' : all other strings
+
+        Other keys that can be used to set a group of types at once are:
+
+        - 'all' : sets all types
+        - 'int_kind' : sets 'int'
+        - 'float_kind' : sets 'float' and 'longfloat'
+        - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
+        - 'str_kind' : sets 'str' and 'numpystr'
+    floatmode : str, optional
+        Controls the interpretation of the `precision` option for
+        floating-point types. Can take the following values
+        (default maxprec_equal):
+
+        * 'fixed': Always print exactly `precision` fractional digits,
+                even if this would print more or fewer digits than
+                necessary to specify the value uniquely.
+        * 'unique': Print the minimum number of fractional digits necessary
+                to represent each value uniquely. Different elements may
+                have a different number of digits. The value of the
+                `precision` option is ignored.
+        * 'maxprec': Print at most `precision` fractional digits, but if
+                an element can be uniquely represented with fewer digits
+                only print it with that many.
+        * 'maxprec_equal': Print at most `precision` fractional digits,
+                but if every element in the array can be uniquely
+                represented with an equal number of fewer digits, use that
+                many digits for all elements.
+    legacy : string or `False`, optional
+        If set to the string `'1.13'` enables 1.13 legacy printing mode. This
+        approximates numpy 1.13 print output by including a space in the sign
+        position of floats and different behavior for 0d arrays. If set to
+        `False`, disables legacy mode. Unrecognized strings will be ignored
+        with a warning for forward compatibility.
+
+        .. versionadded:: 1.14.0
+
+    See Also
+    --------
+    get_printoptions, printoptions, set_string_function, array2string
+
+    Notes
+    -----
+    `formatter` is always reset with a call to `set_printoptions`.
+
+    Use `printoptions` as a context manager to set the values temporarily.
+
+    Examples
+    --------
+    Floating point precision can be set:
+
+    >>> np.set_printoptions(precision=4)
+    >>> np.array([1.123456789])
+    [1.1235]
+
+    Long arrays can be summarised:
+
+    >>> np.set_printoptions(threshold=5)
+    >>> np.arange(10)
+    array([0, 1, 2, ..., 7, 8, 9])
+
+    Small results can be suppressed:
+
+    >>> eps = np.finfo(float).eps
+    >>> x = np.arange(4.)
+    >>> x**2 - (x + eps)**2
+    array([-4.9304e-32, -4.4409e-16,  0.0000e+00,  0.0000e+00])
+    >>> np.set_printoptions(suppress=True)
+    >>> x**2 - (x + eps)**2
+    array([-0., -0.,  0.,  0.])
+
+    A custom formatter can be used to display array elements as desired:
+
+    >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})
+    >>> x = np.arange(3)
+    >>> x
+    array([int: 0, int: -1, int: -2])
+    >>> np.set_printoptions()  # formatter gets reset
+    >>> x
+    array([0, 1, 2])
+
+    To put back the default options, you can use:
+
+    >>> np.set_printoptions(edgeitems=3, infstr='inf',
+    ... linewidth=75, nanstr='nan', precision=8,
+    ... suppress=False, threshold=1000, formatter=None)
+
+    Also to temporarily override options, use `printoptions` as a context manager:
+
+    >>> with np.printoptions(precision=2, suppress=True, threshold=5):
+    ...     np.linspace(0, 10, 10)
+    array([ 0.  ,  1.11,  2.22, ...,  7.78,  8.89, 10.  ])
+
+    " :arglists '[[& [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, sign :sign, formatter :formatter, precision :precision, floatmode :floatmode, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}]] [& [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, sign :sign, formatter :formatter, precision :precision, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}]] [& [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, formatter :formatter, precision :precision, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, nanstr :nanstr, infstr :infstr, :as kwarg}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, nanstr :nanstr, :as kwarg}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, :as kwarg}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, :as kwarg}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, :as kwarg}]] [& [{precision :precision, threshold :threshold, :as kwarg}]] [& [{precision :precision, :as kwarg}]] [& [{:as kwarg}]]])
+
+(def pad (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "pad"))))
+(alter-meta! #'pad assoc :doc "
+    Pad an array.
+
+    Parameters
+    ----------
+    array : array_like of rank N
+        The array to pad.
+    pad_width : {sequence, array_like, int}
+        Number of values padded to the edges of each axis.
+        ((before_1, after_1), ... (before_N, after_N)) unique pad widths
+        for each axis.
+        ((before, after),) yields same before and after pad for each axis.
+        (pad,) or int is a shortcut for before = after = pad width for all
+        axes.
+    mode : str or function, optional
+        One of the following string values or a user supplied function.
+
+        'constant' (default)
+            Pads with a constant value.
+        'edge'
+            Pads with the edge values of array.
+        'linear_ramp'
+            Pads with the linear ramp between end_value and the
+            array edge value.
+        'maximum'
+            Pads with the maximum value of all or part of the
+            vector along each axis.
+        'mean'
+            Pads with the mean value of all or part of the
+            vector along each axis.
+        'median'
+            Pads with the median value of all or part of the
+            vector along each axis.
+        'minimum'
+            Pads with the minimum value of all or part of the
+            vector along each axis.
+        'reflect'
+            Pads with the reflection of the vector mirrored on
+            the first and last values of the vector along each
+            axis.
+        'symmetric'
+            Pads with the reflection of the vector mirrored
+            along the edge of the array.
+        'wrap'
+            Pads with the wrap of the vector along the axis.
+            The first values are used to pad the end and the
+            end values are used to pad the beginning.
+        'empty'
+            Pads with undefined values.
+
+            .. versionadded:: 1.17
+
+        <function>
+            Padding function, see Notes.
+    stat_length : sequence or int, optional
+        Used in 'maximum', 'mean', 'median', and 'minimum'.  Number of
+        values at edge of each axis used to calculate the statistic value.
+
+        ((before_1, after_1), ... (before_N, after_N)) unique statistic
+        lengths for each axis.
+
+        ((before, after),) yields same before and after statistic lengths
+        for each axis.
+
+        (stat_length,) or int is a shortcut for before = after = statistic
+        length for all axes.
+
+        Default is ``None``, to use the entire axis.
+    constant_values : sequence or scalar, optional
+        Used in 'constant'.  The values to set the padded values for each
+        axis.
+
+        ``((before_1, after_1), ... (before_N, after_N))`` unique pad constants
+        for each axis.
+
+        ``((before, after),)`` yields same before and after constants for each
+        axis.
+
+        ``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
+        all axes.
+
+        Default is 0.
+    end_values : sequence or scalar, optional
+        Used in 'linear_ramp'.  The values used for the ending value of the
+        linear_ramp and that will form the edge of the padded array.
+
+        ``((before_1, after_1), ... (before_N, after_N))`` unique end values
+        for each axis.
+
+        ``((before, after),)`` yields same before and after end values for each
+        axis.
+
+        ``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
+        all axes.
+
+        Default is 0.
+    reflect_type : {'even', 'odd'}, optional
+        Used in 'reflect', and 'symmetric'.  The 'even' style is the
+        default with an unaltered reflection around the edge value.  For
+        the 'odd' style, the extended part of the array is created by
+        subtracting the reflected values from two times the edge value.
+
+    Returns
+    -------
+    pad : ndarray
+        Padded array of rank equal to `array` with shape increased
+        according to `pad_width`.
+
+    Notes
+    -----
+    .. versionadded:: 1.7.0
+
+    For an array with rank greater than 1, some of the padding of later
+    axes is calculated from padding of previous axes.  This is easiest to
+    think about with a rank 2 array where the corners of the padded array
+    are calculated by using padded values from the first axis.
+
+    The padding function, if used, should modify a rank 1 array in-place. It
+    has the following signature::
+
+        padding_func(vector, iaxis_pad_width, iaxis, kwargs)
+
+    where
+
+        vector : ndarray
+            A rank 1 array already padded with zeros.  Padded values are
+            vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:].
+        iaxis_pad_width : tuple
+            A 2-tuple of ints, iaxis_pad_width[0] represents the number of
+            values padded at the beginning of vector where
+            iaxis_pad_width[1] represents the number of values padded at
+            the end of vector.
+        iaxis : int
+            The axis currently being calculated.
+        kwargs : dict
+            Any keyword arguments the function requires.
+
+    Examples
+    --------
+    >>> a = [1, 2, 3, 4, 5]
+    >>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6))
+    array([4, 4, 1, ..., 6, 6, 6])
+
+    >>> np.pad(a, (2, 3), 'edge')
+    array([1, 1, 1, ..., 5, 5, 5])
+
+    >>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
+    array([ 5,  3,  1,  2,  3,  4,  5,  2, -1, -4])
+
+    >>> np.pad(a, (2,), 'maximum')
+    array([5, 5, 1, 2, 3, 4, 5, 5, 5])
+
+    >>> np.pad(a, (2,), 'mean')
+    array([3, 3, 1, 2, 3, 4, 5, 3, 3])
+
+    >>> np.pad(a, (2,), 'median')
+    array([3, 3, 1, 2, 3, 4, 5, 3, 3])
+
+    >>> a = [[1, 2], [3, 4]]
+    >>> np.pad(a, ((3, 2), (2, 3)), 'minimum')
+    array([[1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1],
+           [3, 3, 3, 4, 3, 3, 3],
+           [1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1]])
+
+    >>> a = [1, 2, 3, 4, 5]
+    >>> np.pad(a, (2, 3), 'reflect')
+    array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
+
+    >>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')
+    array([-1,  0,  1,  2,  3,  4,  5,  6,  7,  8])
+
+    >>> np.pad(a, (2, 3), 'symmetric')
+    array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
+
+    >>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
+    array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
+
+    >>> np.pad(a, (2, 3), 'wrap')
+    array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])
+
+    >>> def pad_with(vector, pad_width, iaxis, kwargs):
+    ...     pad_value = kwargs.get('padder', 10)
+    ...     vector[:pad_width[0]] = pad_value
+    ...     vector[-pad_width[1]:] = pad_value
+    >>> a = np.arange(6)
+    >>> a = a.reshape((2, 3))
+    >>> np.pad(a, 2, pad_with)
+    array([[10, 10, 10, 10, 10, 10, 10],
+           [10, 10, 10, 10, 10, 10, 10],
+           [10, 10,  0,  1,  2, 10, 10],
+           [10, 10,  3,  4,  5, 10, 10],
+           [10, 10, 10, 10, 10, 10, 10],
+           [10, 10, 10, 10, 10, 10, 10]])
+    >>> np.pad(a, 2, pad_with, padder=100)
+    array([[100, 100, 100, 100, 100, 100, 100],
+           [100, 100, 100, 100, 100, 100, 100],
+           [100, 100,   0,   1,   2, 100, 100],
+           [100, 100,   3,   4,   5, 100, 100],
+           [100, 100, 100, 100, 100, 100, 100],
+           [100, 100, 100, 100, 100, 100, 100]])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} typeNA (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "typeNA"))))
+
+(def who (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "who"))))
+(alter-meta! #'who assoc :doc "
+    Print the NumPy arrays in the given dictionary.
+
+    If there is no dictionary passed in or `vardict` is None then returns
+    NumPy arrays in the globals() dictionary (all NumPy arrays in the
+    namespace).
+
+    Parameters
+    ----------
+    vardict : dict, optional
+        A dictionary possibly containing ndarrays.  Default is globals().
+
+    Returns
+    -------
+    out : None
+        Returns 'None'.
+
+    Notes
+    -----
+    Prints out the name, shape, bytes and type of all of the ndarrays
+    present in `vardict`.
+
+    Examples
+    --------
+    >>> a = np.arange(10)
+    >>> b = np.ones(20)
+    >>> np.who()
+    Name            Shape            Bytes            Type
+    ===========================================================
+    a               10               80               int64
+    b               20               160              float64
+    Upper bound on total bytes  =       240
+
+    >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',
+    ... 'idx':5}
+    >>> np.who(d)
+    Name            Shape            Bytes            Type
+    ===========================================================
+    x               2                16               float64
+    y               3                24               float64
+    Upper bound on total bytes  =       40
+
+    " :arglists '[[& [{vardict :vardict}]] []])
+
+(def histogram_bin_edges (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogram_bin_edges"))))
+(alter-meta! #'histogram_bin_edges assoc :doc "
+    Function to calculate only the edges of the bins used by the `histogram`
+    function.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data. The histogram is computed over the flattened array.
+    bins : int or sequence of scalars or str, optional
+        If `bins` is an int, it defines the number of equal-width
+        bins in the given range (10, by default). If `bins` is a
+        sequence, it defines the bin edges, including the rightmost
+        edge, allowing for non-uniform bin widths.
+
+        If `bins` is a string from the list below, `histogram_bin_edges` will use
+        the method chosen to calculate the optimal bin width and
+        consequently the number of bins (see `Notes` for more detail on
+        the estimators) from the data that falls within the requested
+        range. While the bin width will be optimal for the actual data
+        in the range, the number of bins will be computed to fill the
+        entire range, including the empty portions. For visualisation,
+        using the 'auto' option is suggested. Weighted data is not
+        supported for automated bin size selection.
+
+        'auto'
+            Maximum of the 'sturges' and 'fd' estimators. Provides good
+            all around performance.
+
+        'fd' (Freedman Diaconis Estimator)
+            Robust (resilient to outliers) estimator that takes into
+            account data variability and data size.
+
+        'doane'
+            An improved version of Sturges' estimator that works better
+            with non-normal datasets.
+
+        'scott'
+            Less robust estimator that that takes into account data
+            variability and data size.
+
+        'stone'
+            Estimator based on leave-one-out cross-validation estimate of
+            the integrated squared error. Can be regarded as a generalization
+            of Scott's rule.
+
+        'rice'
+            Estimator does not take variability into account, only data
+            size. Commonly overestimates number of bins required.
+
+        'sturges'
+            R's default method, only accounts for data size. Only
+            optimal for gaussian data and underestimates number of bins
+            for large non-gaussian datasets.
+
+        'sqrt'
+            Square root (of data size) estimator, used by Excel and
+            other programs for its speed and simplicity.
+
+    range : (float, float), optional
+        The lower and upper range of the bins.  If not provided, range
+        is simply ``(a.min(), a.max())``.  Values outside the range are
+        ignored. The first element of the range must be less than or
+        equal to the second. `range` affects the automatic bin
+        computation as well. While bin width is computed to be optimal
+        based on the actual data within `range`, the bin count will fill
+        the entire range including portions containing no data.
+
+    weights : array_like, optional
+        An array of weights, of the same shape as `a`.  Each value in
+        `a` only contributes its associated weight towards the bin count
+        (instead of 1). This is currently not used by any of the bin estimators,
+        but may be in the future.
+
+    Returns
+    -------
+    bin_edges : array of dtype float
+        The edges to pass into `histogram`
+
+    See Also
+    --------
+    histogram
+
+    Notes
+    -----
+    The methods to estimate the optimal number of bins are well founded
+    in literature, and are inspired by the choices R provides for
+    histogram visualisation. Note that having the number of bins
+    proportional to :math:`n^{1/3}` is asymptotically optimal, which is
+    why it appears in most estimators. These are simply plug-in methods
+    that give good starting points for number of bins. In the equations
+    below, :math:`h` is the binwidth and :math:`n_h` is the number of
+    bins. All estimators that compute bin counts are recast to bin width
+    using the `ptp` of the data. The final bin count is obtained from
+    ``np.round(np.ceil(range / h))``.
+
+    'auto' (maximum of the 'sturges' and 'fd' estimators)
+        A compromise to get a good value. For small datasets the Sturges
+        value will usually be chosen, while larger datasets will usually
+        default to FD.  Avoids the overly conservative behaviour of FD
+        and Sturges for small and large datasets respectively.
+        Switchover point is usually :math:`a.size \\approx 1000`.
+
+    'fd' (Freedman Diaconis Estimator)
+        .. math:: h = 2 \\frac{IQR}{n^{1/3}}
+
+        The binwidth is proportional to the interquartile range (IQR)
+        and inversely proportional to cube root of a.size. Can be too
+        conservative for small datasets, but is quite good for large
+        datasets. The IQR is very robust to outliers.
+
+    'scott'
+        .. math:: h = \\sigma \\sqrt[3]{\\frac{24 * \\sqrt{\\pi}}{n}}
+
+        The binwidth is proportional to the standard deviation of the
+        data and inversely proportional to cube root of ``x.size``. Can
+        be too conservative for small datasets, but is quite good for
+        large datasets. The standard deviation is not very robust to
+        outliers. Values are very similar to the Freedman-Diaconis
+        estimator in the absence of outliers.
+
+    'rice'
+        .. math:: n_h = 2n^{1/3}
+
+        The number of bins is only proportional to cube root of
+        ``a.size``. It tends to overestimate the number of bins and it
+        does not take into account data variability.
+
+    'sturges'
+        .. math:: n_h = \\log _{2}n+1
+
+        The number of bins is the base 2 log of ``a.size``.  This
+        estimator assumes normality of data and is too conservative for
+        larger, non-normal datasets. This is the default method in R's
+        ``hist`` method.
+
+    'doane'
+        .. math:: n_h = 1 + \\log_{2}(n) +
+                        \\log_{2}(1 + \\frac{|g_1|}{\\sigma_{g_1}})
+
+            g_1 = mean[(\\frac{x - \\mu}{\\sigma})^3]
+
+            \\sigma_{g_1} = \\sqrt{\\frac{6(n - 2)}{(n + 1)(n + 3)}}
+
+        An improved version of Sturges' formula that produces better
+        estimates for non-normal datasets. This estimator attempts to
+        account for the skew of the data.
+
+    'sqrt'
+        .. math:: n_h = \\sqrt n
+
+        The simplest and fastest estimator. Only takes into account the
+        data size.
+
+    Examples
+    --------
+    >>> arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5])
+    >>> np.histogram_bin_edges(arr, bins='auto', range=(0, 1))
+    array([0.  , 0.25, 0.5 , 0.75, 1.  ])
+    >>> np.histogram_bin_edges(arr, bins=2)
+    array([0. , 2.5, 5. ])
+
+    For consistency with histogram, an array of pre-computed bins is
+    passed through unmodified:
+
+    >>> np.histogram_bin_edges(arr, [1, 2])
+    array([1, 2])
+
+    This function allows one set of bins to be computed, and reused across
+    multiple histograms:
+
+    >>> shared_bins = np.histogram_bin_edges(arr, bins='auto')
+    >>> shared_bins
+    array([0., 1., 2., 3., 4., 5.])
+
+    >>> group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1])
+    >>> hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins)
+    >>> hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins)
+
+    >>> hist_0; hist_1
+    array([1, 1, 0, 1, 0])
+    array([2, 0, 1, 1, 2])
+
+    Which gives more easily comparable results than using separate bins for
+    each histogram:
+
+    >>> hist_0, bins_0 = np.histogram(arr[group_id == 0], bins='auto')
+    >>> hist_1, bins_1 = np.histogram(arr[group_id == 1], bins='auto')
+    >>> hist_0; hist_1
+    array([1, 1, 1])
+    array([2, 1, 1, 2])
+    >>> bins_0; bins_1
+    array([0., 1., 2., 3.])
+    array([0.  , 1.25, 2.5 , 3.75, 5.  ])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def std (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "std"))))
+(alter-meta! #'std assoc :doc "
+    Compute the standard deviation along the specified axis.
+
+    Returns the standard deviation, a measure of the spread of a distribution,
+    of the array elements. The standard deviation is computed for the
+    flattened array by default, otherwise over the specified axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Calculate the standard deviation of these values.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which the standard deviation is computed. The
+        default is to compute the standard deviation of the flattened array.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a standard deviation is performed over
+        multiple axes, instead of a single axis or all the axes as before.
+    dtype : dtype, optional
+        Type to use in computing the standard deviation. For arrays of
+        integer type the default is float64, for arrays of float types it is
+        the same as the array type.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type (of the calculated
+        values) will be cast if necessary.
+    ddof : int, optional
+        Means Delta Degrees of Freedom.  The divisor used in calculations
+        is ``N - ddof``, where ``N`` represents the number of elements.
+        By default `ddof` is zero.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `std` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    standard_deviation : ndarray, see dtype parameter above.
+        If `out` is None, return a new array containing the standard deviation,
+        otherwise return a reference to the output array.
+
+    See Also
+    --------
+    var, mean, nanmean, nanstd, nanvar
+    ufuncs-output-type
+
+    Notes
+    -----
+    The standard deviation is the square root of the average of the squared
+    deviations from the mean, i.e., ``std = sqrt(mean(abs(x - x.mean())**2))``.
+
+    The average squared deviation is normally calculated as
+    ``x.sum() / N``, where ``N = len(x)``.  If, however, `ddof` is specified,
+    the divisor ``N - ddof`` is used instead. In standard statistical
+    practice, ``ddof=1`` provides an unbiased estimator of the variance
+    of the infinite population. ``ddof=0`` provides a maximum likelihood
+    estimate of the variance for normally distributed variables. The
+    standard deviation computed in this function is the square root of
+    the estimated variance, so even with ``ddof=1``, it will not be an
+    unbiased estimate of the standard deviation per se.
+
+    Note that, for complex numbers, `std` takes the absolute
+    value before squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the *std* is computed using the same
+    precision the input has. Depending on the input data, this can cause
+    the results to be inaccurate, especially for float32 (see example below).
+    Specifying a higher-accuracy accumulator using the `dtype` keyword can
+    alleviate this issue.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> np.std(a)
+    1.1180339887498949 # may vary
+    >>> np.std(a, axis=0)
+    array([1.,  1.])
+    >>> np.std(a, axis=1)
+    array([0.5,  0.5])
+
+    In single precision, std() can be inaccurate:
+
+    >>> a = np.zeros((2, 512*512), dtype=np.float32)
+    >>> a[0, :] = 1.0
+    >>> a[1, :] = 0.1
+    >>> np.std(a)
+    0.45000005
+
+    Computing the standard deviation in float64 is more accurate:
+
+    >>> np.std(a, dtype=np.float64)
+    0.44999999925494177 # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def isneginf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isneginf"))))
+(alter-meta! #'isneginf assoc :doc "
+    Test element-wise for negative infinity, return result as bool array.
+
+    Parameters
+    ----------
+    x : array_like
+        The input array.
+    out : array_like, optional
+        A boolean array with the same shape and type as `x` to store the
+        result.
+
+    Returns
+    -------
+    out : ndarray
+        A boolean array with the same dimensions as the input.
+        If second argument is not supplied then a numpy boolean array is
+        returned with values True where the corresponding element of the
+        input is negative infinity and values False where the element of
+        the input is not negative infinity.
+
+        If a second argument is supplied the result is stored there. If the
+        type of that array is a numeric type the result is represented as
+        zeros and ones, if the type is boolean then as False and True. The
+        return value `out` is then a reference to that array.
+
+    See Also
+    --------
+    isinf, isposinf, isnan, isfinite
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754).
+
+    Errors result if the second argument is also supplied when x is a scalar
+    input, if first and second arguments have different shapes, or if the
+    first argument has complex values.
+
+    Examples
+    --------
+    >>> np.isneginf(np.NINF)
+    True
+    >>> np.isneginf(np.inf)
+    False
+    >>> np.isneginf(np.PINF)
+    False
+    >>> np.isneginf([-np.inf, 0., np.inf])
+    array([ True, False, False])
+
+    >>> x = np.array([-np.inf, 0., np.inf])
+    >>> y = np.array([2, 2, 2])
+    >>> np.isneginf(x, y)
+    array([1, 0, 0])
+    >>> y
+    array([1, 0, 0])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def fix (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fix"))))
+(alter-meta! #'fix assoc :doc "
+    Round to nearest integer towards zero.
+
+    Round an array of floats element-wise to nearest integer towards zero.
+    The rounded values are returned as floats.
+
+    Parameters
+    ----------
+    x : array_like
+        An array of floats to be rounded
+    y : ndarray, optional
+        Output array
+
+    Returns
+    -------
+    out : ndarray of floats
+        The array of rounded numbers
+
+    See Also
+    --------
+    trunc, floor, ceil
+    around : Round to given number of decimals
+
+    Examples
+    --------
+    >>> np.fix(3.14)
+    3.0
+    >>> np.fix(3)
+    3.0
+    >>> np.fix([2.1, 2.9, -2.1, -2.9])
+    array([ 2.,  2., -2., -2.])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ones (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ones"))))
+(alter-meta! #'ones assoc :doc "
+    Return a new array of given shape and type, filled with ones.
+
+    Parameters
+    ----------
+    shape : int or sequence of ints
+        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
+    dtype : data-type, optional
+        The desired data-type for the array, e.g., `numpy.int8`.  Default is
+        `numpy.float64`.
+    order : {'C', 'F'}, optional, default: C
+        Whether to store multi-dimensional data in row-major
+        (C-style) or column-major (Fortran-style) order in
+        memory.
+
+    Returns
+    -------
+    out : ndarray
+        Array of ones with the given shape, dtype, and order.
+
+    See Also
+    --------
+    ones_like : Return an array of ones with shape and type of input.
+    empty : Return a new uninitialized array.
+    zeros : Return a new array setting values to zero.
+    full : Return a new array of given shape filled with value.
+
+
+    Examples
+    --------
+    >>> np.ones(5)
+    array([1., 1., 1., 1., 1.])
+
+    >>> np.ones((5,), dtype=int)
+    array([1, 1, 1, 1, 1])
+
+    >>> np.ones((2, 1))
+    array([[1.],
+           [1.]])
+
+    >>> s = (2,2)
+    >>> np.ones(s)
+    array([[1.,  1.],
+           [1.,  1.]])
+
+    " :arglists '[[shape & [{dtype :dtype, order :order}]] [shape & [{dtype :dtype}]] [shape]])
+
+(def squeeze (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "squeeze"))))
+(alter-meta! #'squeeze assoc :doc "
+    Remove single-dimensional entries from the shape of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        .. versionadded:: 1.7.0
+
+        Selects a subset of the single-dimensional entries in the
+        shape. If an axis is selected with shape entry greater than
+        one, an error is raised.
+
+    Returns
+    -------
+    squeezed : ndarray
+        The input array, but with all or a subset of the
+        dimensions of length 1 removed. This is always `a` itself
+        or a view into `a`.
+
+    Raises
+    ------
+    ValueError
+        If `axis` is not None, and an axis being squeezed is not of length 1
+
+    See Also
+    --------
+    expand_dims : The inverse operation, adding singleton dimensions
+    reshape : Insert, remove, and combine dimensions, and resize existing ones
+
+    Examples
+    --------
+    >>> x = np.array([[[0], [1], [2]]])
+    >>> x.shape
+    (1, 3, 1)
+    >>> np.squeeze(x).shape
+    (3,)
+    >>> np.squeeze(x, axis=0).shape
+    (3, 1)
+    >>> np.squeeze(x, axis=1).shape
+    Traceback (most recent call last):
+    ...
+    ValueError: cannot select an axis to squeeze out which has size not equal to one
+    >>> np.squeeze(x, axis=2).shape
+    (1, 3)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def format_parser (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "format_parser"))))
+(alter-meta! #'format_parser assoc :doc "
+    Class to convert formats, names, titles description to a dtype.
+
+    After constructing the format_parser object, the dtype attribute is
+    the converted data-type:
+    ``dtype = format_parser(formats, names, titles).dtype``
+
+    Attributes
+    ----------
+    dtype : dtype
+        The converted data-type.
+
+    Parameters
+    ----------
+    formats : str or list of str
+        The format description, either specified as a string with
+        comma-separated format descriptions in the form ``'f8, i4, a5'``, or
+        a list of format description strings  in the form
+        ``['f8', 'i4', 'a5']``.
+    names : str or list/tuple of str
+        The field names, either specified as a comma-separated string in the
+        form ``'col1, col2, col3'``, or as a list or tuple of strings in the
+        form ``['col1', 'col2', 'col3']``.
+        An empty list can be used, in that case default field names
+        ('f0', 'f1', ...) are used.
+    titles : sequence
+        Sequence of title strings. An empty list can be used to leave titles
+        out.
+    aligned : bool, optional
+        If True, align the fields by padding as the C-compiler would.
+        Default is False.
+    byteorder : str, optional
+        If specified, all the fields will be changed to the
+        provided byte-order.  Otherwise, the default byte-order is
+        used. For all available string specifiers, see `dtype.newbyteorder`.
+
+    See Also
+    --------
+    dtype, typename, sctype2char
+
+    Examples
+    --------
+    >>> np.format_parser(['<f8', '<i4', '<a5'], ['col1', 'col2', 'col3'],
+    ...                  ['T1', 'T2', 'T3']).dtype
+    dtype([(('T1', 'col1'), '<f8'), (('T2', 'col2'), '<i4'), (('T3', 'col3'), 'S5')])
+
+    `names` and/or `titles` can be empty lists. If `titles` is an empty list,
+    titles will simply not appear. If `names` is empty, default field names
+    will be used.
+
+    >>> np.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'],
+    ...                  []).dtype
+    dtype([('col1', '<f8'), ('col2', '<i4'), ('col3', '<S5')])
+    >>> np.format_parser(['<f8', '<i4', '<a5'], [], []).dtype
+    dtype([('f0', '<f8'), ('f1', '<i4'), ('f2', 'S5')])
+
+    " :arglists '[[self formats names titles & [{aligned :aligned, byteorder :byteorder}]] [self formats names titles & [{aligned :aligned}]] [self formats names titles]])
+
+(def add_newdoc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add_newdoc"))))
+(alter-meta! #'add_newdoc assoc :doc "
+    Add documentation to an existing object, typically one defined in C
+
+    The purpose is to allow easier editing of the docstrings without requiring
+    a re-compile. This exists primarily for internal use within numpy itself.
+
+    Parameters
+    ----------
+    place : str
+        The absolute name of the module to import from
+    obj : str
+        The name of the object to add documentation to, typically a class or
+        function name
+    doc : {str, Tuple[str, str], List[Tuple[str, str]]}
+        If a string, the documentation to apply to `obj`
+
+        If a tuple, then the first element is interpreted as an attribute of
+        `obj` and the second as the docstring to apply - ``(method, docstring)``
+
+        If a list, then each element of the list should be a tuple of length
+        two - ``[(method1, docstring1), (method2, docstring2), ...]``
+    warn_on_python : bool
+        If True, the default, emit `UserWarning` if this is used to attach
+        documentation to a pure-python object.
+
+    Notes
+    -----
+    This routine never raises an error if the docstring can't be written, but
+    will raise an error if the object being documented does not exist.
+
+    This routine cannot modify read-only docstrings, as appear
+    in new-style classes or built-in functions. Because this
+    routine never raises an error the caller must check manually
+    that the docstrings were changed.
+
+    Since this function grabs the ``char *`` from a c-level str object and puts
+    it into the ``tp_doc`` slot of the type of `obj`, it violates a number of
+    C-API best-practices, by:
+
+    - modifying a `PyTypeObject` after calling `PyType_Ready`
+    - calling `Py_INCREF` on the str and losing the reference, so the str
+      will never be released
+
+    If possible it should be avoided.
+    " :arglists '[[place obj doc & [{warn_on_python :warn_on_python}]] [place obj doc]])
+
+(def ^{:doc ""} absolute_import (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "absolute_import"))))
+
+(def ^{:doc "Sub-package containing the matrix class and related functions.
+
+"} _mat (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_mat"))))
+
+(def float32 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float32"))))
+(alter-meta! #'float32 assoc :doc "Single-precision floating-point number type, compatible with C ``float``.
+    Character code: ``'f'``.
+    Canonical name: ``np.single``.
+    Alias *on this platform*: ``np.float32``: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
+
+(def gradient (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "gradient"))))
+(alter-meta! #'gradient assoc :doc "
+    Return the gradient of an N-dimensional array.
+
+    The gradient is computed using second order accurate central differences
+    in the interior points and either first or second order accurate one-sides
+    (forward or backwards) differences at the boundaries.
+    The returned gradient hence has the same shape as the input array.
+
+    Parameters
+    ----------
+    f : array_like
+        An N-dimensional array containing samples of a scalar function.
+    varargs : list of scalar or array, optional
+        Spacing between f values. Default unitary spacing for all dimensions.
+        Spacing can be specified using:
+
+        1. single scalar to specify a sample distance for all dimensions.
+        2. N scalars to specify a constant sample distance for each dimension.
+           i.e. `dx`, `dy`, `dz`, ...
+        3. N arrays to specify the coordinates of the values along each
+           dimension of F. The length of the array must match the size of
+           the corresponding dimension
+        4. Any combination of N scalars/arrays with the meaning of 2. and 3.
+
+        If `axis` is given, the number of varargs must equal the number of axes.
+        Default: 1.
+
+    edge_order : {1, 2}, optional
+        Gradient is calculated using N-th order accurate differences
+        at the boundaries. Default: 1.
+
+        .. versionadded:: 1.9.1
+
+    axis : None or int or tuple of ints, optional
+        Gradient is calculated only along the given axis or axes
+        The default (axis = None) is to calculate the gradient for all the axes
+        of the input array. axis may be negative, in which case it counts from
+        the last to the first axis.
+
+        .. versionadded:: 1.11.0
+
+    Returns
+    -------
+    gradient : ndarray or list of ndarray
+        A set of ndarrays (or a single ndarray if there is only one dimension)
+        corresponding to the derivatives of f with respect to each dimension.
+        Each derivative has the same shape as f.
+
+    Examples
+    --------
+    >>> f = np.array([1, 2, 4, 7, 11, 16], dtype=float)
+    >>> np.gradient(f)
+    array([1. , 1.5, 2.5, 3.5, 4.5, 5. ])
+    >>> np.gradient(f, 2)
+    array([0.5 ,  0.75,  1.25,  1.75,  2.25,  2.5 ])
+
+    Spacing can be also specified with an array that represents the coordinates
+    of the values F along the dimensions.
+    For instance a uniform spacing:
+
+    >>> x = np.arange(f.size)
+    >>> np.gradient(f, x)
+    array([1. ,  1.5,  2.5,  3.5,  4.5,  5. ])
+
+    Or a non uniform one:
+
+    >>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float)
+    >>> np.gradient(f, x)
+    array([1. ,  3. ,  3.5,  6.7,  6.9,  2.5])
+
+    For two dimensional arrays, the return will be two arrays ordered by
+    axis. In this example the first array stands for the gradient in
+    rows and the second one in columns direction:
+
+    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float))
+    [array([[ 2.,  2., -1.],
+           [ 2.,  2., -1.]]), array([[1. , 2.5, 4. ],
+           [1. , 1. , 1. ]])]
+
+    In this example the spacing is also specified:
+    uniform for axis=0 and non uniform for axis=1
+
+    >>> dx = 2.
+    >>> y = [1., 1.5, 3.5]
+    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y)
+    [array([[ 1. ,  1. , -0.5],
+           [ 1. ,  1. , -0.5]]), array([[2. , 2. , 2. ],
+           [2. , 1.7, 0.5]])]
+
+    It is possible to specify how boundaries are treated using `edge_order`
+
+    >>> x = np.array([0, 1, 2, 3, 4])
+    >>> f = x**2
+    >>> np.gradient(f, edge_order=1)
+    array([1.,  2.,  4.,  6.,  7.])
+    >>> np.gradient(f, edge_order=2)
+    array([0., 2., 4., 6., 8.])
+
+    The `axis` keyword can be used to specify a subset of axes of which the
+    gradient is calculated
+
+    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0)
+    array([[ 2.,  2., -1.],
+           [ 2.,  2., -1.]])
+
+    Notes
+    -----
+    Assuming that :math:`f\\in C^{3}` (i.e., :math:`f` has at least 3 continuous
+    derivatives) and let :math:`h_{*}` be a non-homogeneous stepsize, we
+    minimize the \"consistency error\" :math:`\\eta_{i}` between the true gradient
+    and its estimate from a linear combination of the neighboring grid-points:
+
+    .. math::
+
+        \\eta_{i} = f_{i}^{\\left(1\\right)} -
+                    \\left[ \\alpha f\\left(x_{i}\\right) +
+                            \\beta f\\left(x_{i} + h_{d}\\right) +
+                            \\gamma f\\left(x_{i}-h_{s}\\right)
+                    \\right]
+
+    By substituting :math:`f(x_{i} + h_{d})` and :math:`f(x_{i} - h_{s})`
+    with their Taylor series expansion, this translates into solving
+    the following the linear system:
+
+    .. math::
+
+        \\left\\{
+            \\begin{array}{r}
+                \\alpha+\\beta+\\gamma=0 \\\\
+                \\beta h_{d}-\\gamma h_{s}=1 \\\\
+                \\beta h_{d}^{2}+\\gamma h_{s}^{2}=0
+            \\end{array}
+        \\right.
+
+    The resulting approximation of :math:`f_{i}^{(1)}` is the following:
+
+    .. math::
+
+        \\hat f_{i}^{(1)} =
+            \\frac{
+                h_{s}^{2}f\\left(x_{i} + h_{d}\\right)
+                + \\left(h_{d}^{2} - h_{s}^{2}\\right)f\\left(x_{i}\\right)
+                - h_{d}^{2}f\\left(x_{i}-h_{s}\\right)}
+                { h_{s}h_{d}\\left(h_{d} + h_{s}\\right)}
+            + \\mathcal{O}\\left(\\frac{h_{d}h_{s}^{2}
+                                + h_{s}h_{d}^{2}}{h_{d}
+                                + h_{s}}\\right)
+
+    It is worth noting that if :math:`h_{s}=h_{d}`
+    (i.e., data are evenly spaced)
+    we find the standard second order approximation:
+
+    .. math::
+
+        \\hat f_{i}^{(1)}=
+            \\frac{f\\left(x_{i+1}\\right) - f\\left(x_{i-1}\\right)}{2h}
+            + \\mathcal{O}\\left(h^{2}\\right)
+
+    With a similar procedure the forward/backward approximations used for
+    boundaries can be derived.
+
+    References
+    ----------
+    .. [1]  Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics
+            (Texts in Applied Mathematics). New York: Springer.
+    .. [2]  Durran D. R. (1999) Numerical Methods for Wave Equations
+            in Geophysical Fluid Dynamics. New York: Springer.
+    .. [3]  Fornberg B. (1988) Generation of Finite Difference Formulas on
+            Arbitrarily Spaced Grids,
+            Mathematics of Computation 51, no. 184 : 699-706.
+            `PDF <http://www.ams.org/journals/mcom/1988-51-184/
+            S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_.
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def obj2sctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "obj2sctype"))))
+(alter-meta! #'obj2sctype assoc :doc "
+    Return the scalar dtype or NumPy equivalent of Python type of an object.
+
+    Parameters
+    ----------
+    rep : any
+        The object of which the type is returned.
+    default : any, optional
+        If given, this is returned for objects whose types can not be
+        determined. If not given, None is returned for those objects.
+
+    Returns
+    -------
+    dtype : dtype or Python type
+        The data type of `rep`.
+
+    See Also
+    --------
+    sctype2char, issctype, issubsctype, issubdtype, maximum_sctype
+
+    Examples
+    --------
+    >>> np.obj2sctype(np.int32)
+    <class 'numpy.int32'>
+    >>> np.obj2sctype(np.array([1., 2.]))
+    <class 'numpy.float64'>
+    >>> np.obj2sctype(np.array([1.j]))
+    <class 'numpy.complex128'>
+
+    >>> np.obj2sctype(dict)
+    <class 'numpy.object_'>
+    >>> np.obj2sctype('string')
+
+    >>> np.obj2sctype(1, default=list)
+    <class 'list'>
+
+    " :arglists '[[rep & [{default :default}]] [rep]])
+
+(def ^{:doc "
+    Base object for a dictionary for look-up with any alias for an array dtype.
+
+    Instances of `_typedict` can not be used as dictionaries directly,
+    first they have to be populated.
+
+    "} cast (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "cast"))))
+
+(def find_common_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "find_common_type"))))
+(alter-meta! #'find_common_type assoc :doc "
+    Determine common type following standard coercion rules.
+
+    Parameters
+    ----------
+    array_types : sequence
+        A list of dtypes or dtype convertible objects representing arrays.
+    scalar_types : sequence
+        A list of dtypes or dtype convertible objects representing scalars.
+
+    Returns
+    -------
+    datatype : dtype
+        The common data type, which is the maximum of `array_types` ignoring
+        `scalar_types`, unless the maximum of `scalar_types` is of a
+        different kind (`dtype.kind`). If the kind is not understood, then
+        None is returned.
+
+    See Also
+    --------
+    dtype, common_type, can_cast, mintypecode
+
+    Examples
+    --------
+    >>> np.find_common_type([], [np.int64, np.float32, complex])
+    dtype('complex128')
+    >>> np.find_common_type([np.int64, np.float32], [])
+    dtype('float64')
+
+    The standard casting rules ensure that a scalar cannot up-cast an
+    array unless the scalar is of a fundamentally different kind of data
+    (i.e. under a different hierarchy in the data type hierarchy) then
+    the array:
+
+    >>> np.find_common_type([np.float32], [np.int64, np.float64])
+    dtype('float32')
+
+    Complex is of a different type, so it up-casts the float in the
+    `array_types` argument:
+
+    >>> np.find_common_type([np.float32], [complex])
+    dtype('complex128')
+
+    Type specifier strings are convertible to dtypes and can therefore
+    be used instead of dtypes:
+
+    >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8'])
+    dtype('complex128')
+
+    " :arglists '[[array_types scalar_types]])
+
+(def intp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "intp"))))
+(alter-meta! #'intp assoc :doc "Signed integer type, compatible with Python `int` anc C ``long``.
+    Character code: ``'l'``.
+    Canonical name: ``np.int_``.
+    Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807).
+    Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def poly (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "poly"))))
+(alter-meta! #'poly assoc :doc "
+    Find the coefficients of a polynomial with the given sequence of roots.
+
+    Returns the coefficients of the polynomial whose leading coefficient
+    is one for the given sequence of zeros (multiple roots must be included
+    in the sequence as many times as their multiplicity; see Examples).
+    A square matrix (or array, which will be treated as a matrix) can also
+    be given, in which case the coefficients of the characteristic polynomial
+    of the matrix are returned.
+
+    Parameters
+    ----------
+    seq_of_zeros : array_like, shape (N,) or (N, N)
+        A sequence of polynomial roots, or a square array or matrix object.
+
+    Returns
+    -------
+    c : ndarray
+        1D array of polynomial coefficients from highest to lowest degree:
+
+        ``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]``
+        where c[0] always equals 1.
+
+    Raises
+    ------
+    ValueError
+        If input is the wrong shape (the input must be a 1-D or square
+        2-D array).
+
+    See Also
+    --------
+    polyval : Compute polynomial values.
+    roots : Return the roots of a polynomial.
+    polyfit : Least squares polynomial fit.
+    poly1d : A one-dimensional polynomial class.
+
+    Notes
+    -----
+    Specifying the roots of a polynomial still leaves one degree of
+    freedom, typically represented by an undetermined leading
+    coefficient. [1]_ In the case of this function, that coefficient -
+    the first one in the returned array - is always taken as one. (If
+    for some reason you have one other point, the only automatic way
+    presently to leverage that information is to use ``polyfit``.)
+
+    The characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n`
+    matrix **A** is given by
+
+        :math:`p_a(t) = \\mathrm{det}(t\\, \\mathbf{I} - \\mathbf{A})`,
+
+    where **I** is the `n`-by-`n` identity matrix. [2]_
+
+    References
+    ----------
+    .. [1] M. Sullivan and M. Sullivan, III, \"Algebra and Trignometry,
+       Enhanced With Graphing Utilities,\" Prentice-Hall, pg. 318, 1996.
+
+    .. [2] G. Strang, \"Linear Algebra and Its Applications, 2nd Edition,\"
+       Academic Press, pg. 182, 1980.
+
+    Examples
+    --------
+    Given a sequence of a polynomial's zeros:
+
+    >>> np.poly((0, 0, 0)) # Multiple root example
+    array([1., 0., 0., 0.])
+
+    The line above represents z**3 + 0*z**2 + 0*z + 0.
+
+    >>> np.poly((-1./2, 0, 1./2))
+    array([ 1.  ,  0.  , -0.25,  0.  ])
+
+    The line above represents z**3 - z/4
+
+    >>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0]))
+    array([ 1.        , -0.77086955,  0.08618131,  0.        ]) # random
+
+    Given a square array object:
+
+    >>> P = np.array([[0, 1./3], [-1./2, 0]])
+    >>> np.poly(P)
+    array([1.        , 0.        , 0.16666667])
+
+    Note how in all cases the leading coefficient is always 1.
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def maximum_sctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "maximum_sctype"))))
+(alter-meta! #'maximum_sctype assoc :doc "
+    Return the scalar type of highest precision of the same kind as the input.
+
+    Parameters
+    ----------
+    t : dtype or dtype specifier
+        The input data type. This can be a `dtype` object or an object that
+        is convertible to a `dtype`.
+
+    Returns
+    -------
+    out : dtype
+        The highest precision data type of the same kind (`dtype.kind`) as `t`.
+
+    See Also
+    --------
+    obj2sctype, mintypecode, sctype2char
+    dtype
+
+    Examples
+    --------
+    >>> np.maximum_sctype(int)
+    <class 'numpy.int64'>
+    >>> np.maximum_sctype(np.uint8)
+    <class 'numpy.uint64'>
+    >>> np.maximum_sctype(complex)
+    <class 'numpy.complex256'> # may vary
+
+    >>> np.maximum_sctype(str)
+    <class 'numpy.str_'>
+
+    >>> np.maximum_sctype('i2')
+    <class 'numpy.int64'>
+    >>> np.maximum_sctype('f4')
+    <class 'numpy.float128'> # may vary
+
+    " :arglists '[[t]])
+
+(def bmat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bmat"))))
+(alter-meta! #'bmat assoc :doc "
+    Build a matrix object from a string, nested sequence, or array.
+
+    Parameters
+    ----------
+    obj : str or array_like
+        Input data. If a string, variables in the current scope may be
+        referenced by name.
+    ldict : dict, optional
+        A dictionary that replaces local operands in current frame.
+        Ignored if `obj` is not a string or `gdict` is None.
+    gdict : dict, optional
+        A dictionary that replaces global operands in current frame.
+        Ignored if `obj` is not a string.
+
+    Returns
+    -------
+    out : matrix
+        Returns a matrix object, which is a specialized 2-D array.
+
+    See Also
+    --------
+    block :
+        A generalization of this function for N-d arrays, that returns normal
+        ndarrays.
+
+    Examples
+    --------
+    >>> A = np.mat('1 1; 1 1')
+    >>> B = np.mat('2 2; 2 2')
+    >>> C = np.mat('3 4; 5 6')
+    >>> D = np.mat('7 8; 9 0')
+
+    All the following expressions construct the same block matrix:
+
+    >>> np.bmat([[A, B], [C, D]])
+    matrix([[1, 1, 2, 2],
+            [1, 1, 2, 2],
+            [3, 4, 7, 8],
+            [5, 6, 9, 0]])
+    >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]])
+    matrix([[1, 1, 2, 2],
+            [1, 1, 2, 2],
+            [3, 4, 7, 8],
+            [5, 6, 9, 0]])
+    >>> np.bmat('A,B; C,D')
+    matrix([[1, 1, 2, 2],
+            [1, 1, 2, 2],
+            [3, 4, 7, 8],
+            [5, 6, 9, 0]])
+
+    " :arglists '[[obj & [{ldict :ldict, gdict :gdict}]] [obj & [{ldict :ldict}]] [obj]])
+
+(def put_along_axis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "put_along_axis"))))
+(alter-meta! #'put_along_axis assoc :doc "
+    Put values into the destination array by matching 1d index and data slices.
+
+    This iterates over matching 1d slices oriented along the specified axis in
+    the index and data arrays, and uses the former to place values into the
+    latter. These slices can be different lengths.
+
+    Functions returning an index along an axis, like `argsort` and
+    `argpartition`, produce suitable indices for this function.
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    arr: ndarray (Ni..., M, Nk...)
+        Destination array.
+    indices: ndarray (Ni..., J, Nk...)
+        Indices to change along each 1d slice of `arr`. This must match the
+        dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast
+        against `arr`.
+    values: array_like (Ni..., J, Nk...)
+        values to insert at those indices. Its shape and dimension are
+        broadcast to match that of `indices`.
+    axis: int
+        The axis to take 1d slices along. If axis is None, the destination
+        array is treated as if a flattened 1d view had been created of it.
+
+    Notes
+    -----
+    This is equivalent to (but faster than) the following use of `ndindex` and
+    `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::
+
+        Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
+        J = indices.shape[axis]  # Need not equal M
+
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                a_1d       = a      [ii + s_[:,] + kk]
+                indices_1d = indices[ii + s_[:,] + kk]
+                values_1d  = values [ii + s_[:,] + kk]
+                for j in range(J):
+                    a_1d[indices_1d[j]] = values_1d[j]
+
+    Equivalently, eliminating the inner loop, the last two lines would be::
+
+                a_1d[indices_1d] = values_1d
+
+    See Also
+    --------
+    take_along_axis :
+        Take values from the input array by matching 1d index and data slices
+
+    Examples
+    --------
+
+    For this sample array
+
+    >>> a = np.array([[10, 30, 20], [60, 40, 50]])
+
+    We can replace the maximum values with:
+
+    >>> ai = np.expand_dims(np.argmax(a, axis=1), axis=1)
+    >>> ai
+    array([[1],
+           [0]])
+    >>> np.put_along_axis(a, ai, 99, axis=1)
+    >>> a
+    array([[10, 99, 20],
+           [99, 40, 50]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def logical_or (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_or"))))
+(alter-meta! #'logical_or assoc :doc "logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the truth value of x1 OR x2 element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Logical OR is applied to the elements of `x1` and `x2`.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or bool
+    Boolean result of the logical OR operation applied to the elements
+    of `x1` and `x2`; the shape is determined by broadcasting.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_and, logical_not, logical_xor
+bitwise_or
+
+Examples
+--------
+>>> np.logical_or(True, False)
+True
+>>> np.logical_or([True, False], [False, False])
+array([ True, False])
+
+>>> x = np.arange(5)
+>>> np.logical_or(x < 1, x > 3)
+array([ True, False, False, False,  True])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def void (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "void"))))
+(alter-meta! #'void assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} e (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "e"))))
+
+(def positive (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "positive"))))
+(alter-meta! #'positive assoc :doc "positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Numerical positive, element-wise.
+
+.. versionadded:: 1.13.0
+
+Parameters
+----------
+x : array_like or scalar
+    Input array.
+
+Returns
+-------
+y : ndarray or scalar
+    Returned array or scalar: `y = +x`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+Equivalent to `x.copy()`, but only defined for types that support
+arithmetic." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} inf (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "inf"))))
+
+(def nditer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nditer"))))
+(alter-meta! #'nditer assoc :doc "Efficient multi-dimensional iterator object to iterate over arrays.
+    To get started using this object, see the
+    :ref:`introductory guide to array iteration <arrays.nditer>`.
+
+    Parameters
+    ----------
+    op : ndarray or sequence of array_like
+        The array(s) to iterate over.
+
+    flags : sequence of str, optional
+          Flags to control the behavior of the iterator.
+
+          * ``buffered`` enables buffering when required.
+          * ``c_index`` causes a C-order index to be tracked.
+          * ``f_index`` causes a Fortran-order index to be tracked.
+          * ``multi_index`` causes a multi-index, or a tuple of indices
+            with one per iteration dimension, to be tracked.
+          * ``common_dtype`` causes all the operands to be converted to
+            a common data type, with copying or buffering as necessary.
+          * ``copy_if_overlap`` causes the iterator to determine if read
+            operands have overlap with write operands, and make temporary
+            copies as necessary to avoid overlap. False positives (needless
+            copying) are possible in some cases.
+          * ``delay_bufalloc`` delays allocation of the buffers until
+            a reset() call is made. Allows ``allocate`` operands to
+            be initialized before their values are copied into the buffers.
+          * ``external_loop`` causes the ``values`` given to be
+            one-dimensional arrays with multiple values instead of
+            zero-dimensional arrays.
+          * ``grow_inner`` allows the ``value`` array sizes to be made
+            larger than the buffer size when both ``buffered`` and
+            ``external_loop`` is used.
+          * ``ranged`` allows the iterator to be restricted to a sub-range
+            of the iterindex values.
+          * ``refs_ok`` enables iteration of reference types, such as
+            object arrays.
+          * ``reduce_ok`` enables iteration of ``readwrite`` operands
+            which are broadcasted, also known as reduction operands.
+          * ``zerosize_ok`` allows `itersize` to be zero.
+    op_flags : list of list of str, optional
+          This is a list of flags for each operand. At minimum, one of
+          ``readonly``, ``readwrite``, or ``writeonly`` must be specified.
+
+          * ``readonly`` indicates the operand will only be read from.
+          * ``readwrite`` indicates the operand will be read from and written to.
+          * ``writeonly`` indicates the operand will only be written to.
+          * ``no_broadcast`` prevents the operand from being broadcasted.
+          * ``contig`` forces the operand data to be contiguous.
+          * ``aligned`` forces the operand data to be aligned.
+          * ``nbo`` forces the operand data to be in native byte order.
+          * ``copy`` allows a temporary read-only copy if required.
+          * ``updateifcopy`` allows a temporary read-write copy if required.
+          * ``allocate`` causes the array to be allocated if it is None
+            in the ``op`` parameter.
+          * ``no_subtype`` prevents an ``allocate`` operand from using a subtype.
+          * ``arraymask`` indicates that this operand is the mask to use
+            for selecting elements when writing to operands with the
+            'writemasked' flag set. The iterator does not enforce this,
+            but when writing from a buffer back to the array, it only
+            copies those elements indicated by this mask.
+          * ``writemasked`` indicates that only elements where the chosen
+            ``arraymask`` operand is True will be written to.
+          * ``overlap_assume_elementwise`` can be used to mark operands that are
+            accessed only in the iterator order, to allow less conservative
+            copying when ``copy_if_overlap`` is present.
+    op_dtypes : dtype or tuple of dtype(s), optional
+        The required data type(s) of the operands. If copying or buffering
+        is enabled, the data will be converted to/from their original types.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Controls the iteration order. 'C' means C order, 'F' means
+        Fortran order, 'A' means 'F' order if all the arrays are Fortran
+        contiguous, 'C' order otherwise, and 'K' means as close to the
+        order the array elements appear in memory as possible. This also
+        affects the element memory order of ``allocate`` operands, as they
+        are allocated to be compatible with iteration order.
+        Default is 'K'.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur when making a copy
+        or buffering.  Setting this to 'unsafe' is not recommended,
+        as it can adversely affect accumulations.
+
+        * 'no' means the data types should not be cast at all.
+        * 'equiv' means only byte-order changes are allowed.
+        * 'safe' means only casts which can preserve values are allowed.
+        * 'same_kind' means only safe casts or casts within a kind,
+          like float64 to float32, are allowed.
+        * 'unsafe' means any data conversions may be done.
+    op_axes : list of list of ints, optional
+        If provided, is a list of ints or None for each operands.
+        The list of axes for an operand is a mapping from the dimensions
+        of the iterator to the dimensions of the operand. A value of
+        -1 can be placed for entries, causing that dimension to be
+        treated as `newaxis`.
+    itershape : tuple of ints, optional
+        The desired shape of the iterator. This allows ``allocate`` operands
+        with a dimension mapped by op_axes not corresponding to a dimension
+        of a different operand to get a value not equal to 1 for that
+        dimension.
+    buffersize : int, optional
+        When buffering is enabled, controls the size of the temporary
+        buffers. Set to 0 for the default value.
+
+    Attributes
+    ----------
+    dtypes : tuple of dtype(s)
+        The data types of the values provided in `value`. This may be
+        different from the operand data types if buffering is enabled.
+        Valid only before the iterator is closed.
+    finished : bool
+        Whether the iteration over the operands is finished or not.
+    has_delayed_bufalloc : bool
+        If True, the iterator was created with the ``delay_bufalloc`` flag,
+        and no reset() function was called on it yet.
+    has_index : bool
+        If True, the iterator was created with either the ``c_index`` or
+        the ``f_index`` flag, and the property `index` can be used to
+        retrieve it.
+    has_multi_index : bool
+        If True, the iterator was created with the ``multi_index`` flag,
+        and the property `multi_index` can be used to retrieve it.
+    index
+        When the ``c_index`` or ``f_index`` flag was used, this property
+        provides access to the index. Raises a ValueError if accessed
+        and ``has_index`` is False.
+    iterationneedsapi : bool
+        Whether iteration requires access to the Python API, for example
+        if one of the operands is an object array.
+    iterindex : int
+        An index which matches the order of iteration.
+    itersize : int
+        Size of the iterator.
+    itviews
+        Structured view(s) of `operands` in memory, matching the reordered
+        and optimized iterator access pattern. Valid only before the iterator
+        is closed.
+    multi_index
+        When the ``multi_index`` flag was used, this property
+        provides access to the index. Raises a ValueError if accessed
+        accessed and ``has_multi_index`` is False.
+    ndim : int
+        The dimensions of the iterator.
+    nop : int
+        The number of iterator operands.
+    operands : tuple of operand(s)
+        The array(s) to be iterated over. Valid only before the iterator is
+        closed.
+    shape : tuple of ints
+        Shape tuple, the shape of the iterator.
+    value
+        Value of ``operands`` at current iteration. Normally, this is a
+        tuple of array scalars, but if the flag ``external_loop`` is used,
+        it is a tuple of one dimensional arrays.
+
+    Notes
+    -----
+    `nditer` supersedes `flatiter`.  The iterator implementation behind
+    `nditer` is also exposed by the NumPy C API.
+
+    The Python exposure supplies two iteration interfaces, one which follows
+    the Python iterator protocol, and another which mirrors the C-style
+    do-while pattern.  The native Python approach is better in most cases, but
+    if you need the coordinates or index of an iterator, use the C-style pattern.
+
+    Examples
+    --------
+    Here is how we might write an ``iter_add`` function, using the
+    Python iterator protocol:
+
+    >>> def iter_add_py(x, y, out=None):
+    ...     addop = np.add
+    ...     it = np.nditer([x, y, out], [],
+    ...                 [['readonly'], ['readonly'], ['writeonly','allocate']])
+    ...     with it:
+    ...         for (a, b, c) in it:
+    ...             addop(a, b, out=c)
+    ...     return it.operands[2]
+
+    Here is the same function, but following the C-style pattern:
+
+    >>> def iter_add(x, y, out=None):
+    ...    addop = np.add
+    ...    it = np.nditer([x, y, out], [],
+    ...                [['readonly'], ['readonly'], ['writeonly','allocate']])
+    ...    with it:
+    ...        while not it.finished:
+    ...            addop(it[0], it[1], out=it[2])
+    ...            it.iternext()
+    ...        return it.operands[2]
+
+    Here is an example outer product function:
+
+    >>> def outer_it(x, y, out=None):
+    ...     mulop = np.multiply
+    ...     it = np.nditer([x, y, out], ['external_loop'],
+    ...             [['readonly'], ['readonly'], ['writeonly', 'allocate']],
+    ...             op_axes=[list(range(x.ndim)) + [-1] * y.ndim,
+    ...                      [-1] * x.ndim + list(range(y.ndim)),
+    ...                      None])
+    ...     with it:
+    ...         for (a, b, c) in it:
+    ...             mulop(a, b, out=c)
+    ...         return it.operands[2]
+
+    >>> a = np.arange(2)+1
+    >>> b = np.arange(3)+1
+    >>> outer_it(a,b)
+    array([[1, 2, 3],
+           [2, 4, 6]])
+
+    Here is an example function which operates like a \"lambda\" ufunc:
+
+    >>> def luf(lamdaexpr, *args, **kwargs):
+    ...    '''luf(lambdaexpr, op1, ..., opn, out=None, order='K', casting='safe', buffersize=0)'''
+    ...    nargs = len(args)
+    ...    op = (kwargs.get('out',None),) + args
+    ...    it = np.nditer(op, ['buffered','external_loop'],
+    ...            [['writeonly','allocate','no_broadcast']] +
+    ...                            [['readonly','nbo','aligned']]*nargs,
+    ...            order=kwargs.get('order','K'),
+    ...            casting=kwargs.get('casting','safe'),
+    ...            buffersize=kwargs.get('buffersize',0))
+    ...    while not it.finished:
+    ...        it[0] = lamdaexpr(*it[1:])
+    ...        it.iternext()
+    ...        return it.operands[0]
+
+    >>> a = np.arange(5)
+    >>> b = np.ones(5)
+    >>> luf(lambda i,j:i*i + j/2, a, b)
+    array([  0.5,   1.5,   4.5,   9.5,  16.5])
+
+    If operand flags `\"writeonly\"` or `\"readwrite\"` are used the
+    operands may be views into the original data with the
+    `WRITEBACKIFCOPY` flag. In this case `nditer` must be used as a
+    context manager or the `nditer.close` method must be called before
+    using the result. The temporary data will be written back to the
+    original data when the `__exit__` function is called but not before:
+
+    >>> a = np.arange(6, dtype='i4')[::-2]
+    >>> with np.nditer(a, [],
+    ...        [['writeonly', 'updateifcopy']],
+    ...        casting='unsafe',
+    ...        op_dtypes=[np.dtype('f4')]) as i:
+    ...    x = i.operands[0]
+    ...    x[:] = [-1, -2, -3]
+    ...    # a still unchanged here
+    >>> a, x
+    (array([-1, -2, -3], dtype=int32), array([-1., -2., -3.], dtype=float32))
+
+    It is important to note that once the iterator is exited, dangling
+    references (like `x` in the example) may or may not share data with
+    the original data `a`. If writeback semantics were active, i.e. if
+    `x.base.flags.writebackifcopy` is `True`, then exiting the iterator
+    will sever the connection between `x` and `a`, writing to `x` will
+    no longer write to `a`. If writeback semantics are not active, then
+    `x.data` will still point at some part of `a.data`, and writing to
+    one will affect the other.
+
+    Context management and the `close` method appeared in version 1.15.0." :arglists '[[self & [args {:as kwargs}]]])
+
+(def nansum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nansum"))))
+(alter-meta! #'nansum assoc :doc "
+    Return the sum of array elements over a given axis treating Not a
+    Numbers (NaNs) as zero.
+
+    In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or
+    empty. In later versions zero is returned.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose sum is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the sum is computed. The default is to compute the
+        sum of the flattened array.
+    dtype : data-type, optional
+        The type of the returned array and of the accumulator in which the
+        elements are summed.  By default, the dtype of `a` is used.  An
+        exception is when `a` has an integer type with less precision than
+        the platform (u)intp. In that case, the default will be either
+        (u)int32 or (u)int64 depending on whether the platform is 32 or 64
+        bits. For inexact inputs, dtype must be inexact.
+
+        .. versionadded:: 1.8.0
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``. If provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary.  See
+        `ufuncs-output-type` for more details. The casting of NaN to integer
+        can yield unexpected results.
+
+        .. versionadded:: 1.8.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `mean` or `sum` methods
+        of sub-classes of `ndarray`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+        .. versionadded:: 1.8.0
+
+    Returns
+    -------
+    nansum : ndarray.
+        A new array holding the result is returned unless `out` is
+        specified, in which it is returned. The result has the same
+        size as `a`, and the same shape as `a` if `axis` is not None
+        or `a` is a 1-d array.
+
+    See Also
+    --------
+    numpy.sum : Sum across array propagating NaNs.
+    isnan : Show which elements are NaN.
+    isfinite: Show which elements are not NaN or +/-inf.
+
+    Notes
+    -----
+    If both positive and negative infinity are present, the sum will be Not
+    A Number (NaN).
+
+    Examples
+    --------
+    >>> np.nansum(1)
+    1
+    >>> np.nansum([1])
+    1
+    >>> np.nansum([1, np.nan])
+    1.0
+    >>> a = np.array([[1, 1], [1, np.nan]])
+    >>> np.nansum(a)
+    3.0
+    >>> np.nansum(a, axis=0)
+    array([2.,  1.])
+    >>> np.nansum([1, np.nan, np.inf])
+    inf
+    >>> np.nansum([1, np.nan, np.NINF])
+    -inf
+    >>> from numpy.testing import suppress_warnings
+    >>> with suppress_warnings() as sup:
+    ...     sup.filter(RuntimeWarning)
+    ...     np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present
+    nan
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def nanprod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanprod"))))
+(alter-meta! #'nanprod assoc :doc "
+    Return the product of array elements over a given axis treating Not a
+    Numbers (NaNs) as ones.
+
+    One is returned for slices that are all-NaN or empty.
+
+    .. versionadded:: 1.10.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose product is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the product is computed. The default is to compute
+        the product of the flattened array.
+    dtype : data-type, optional
+        The type of the returned array and of the accumulator in which the
+        elements are summed.  By default, the dtype of `a` is used.  An
+        exception is when `a` has an integer type with less precision than
+        the platform (u)intp. In that case, the default will be either
+        (u)int32 or (u)int64 depending on whether the platform is 32 or 64
+        bits. For inexact inputs, dtype must be inexact.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``. If provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary. See
+        `ufuncs-output-type` for more details. The casting of NaN to integer
+        can yield unexpected results.
+    keepdims : bool, optional
+        If True, the axes which are reduced are left in the result as
+        dimensions with size one. With this option, the result will
+        broadcast correctly against the original `arr`.
+
+    Returns
+    -------
+    nanprod : ndarray
+        A new array holding the result is returned unless `out` is
+        specified, in which case it is returned.
+
+    See Also
+    --------
+    numpy.prod : Product across array propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> np.nanprod(1)
+    1
+    >>> np.nanprod([1])
+    1
+    >>> np.nanprod([1, np.nan])
+    1.0
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nanprod(a)
+    6.0
+    >>> np.nanprod(a, axis=0)
+    array([3., 2.])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def setxor1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "setxor1d"))))
+(alter-meta! #'setxor1d assoc :doc "
+    Find the set exclusive-or of two arrays.
+
+    Return the sorted, unique values that are in only one (not both) of the
+    input arrays.
+
+    Parameters
+    ----------
+    ar1, ar2 : array_like
+        Input arrays.
+    assume_unique : bool
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+
+    Returns
+    -------
+    setxor1d : ndarray
+        Sorted 1D array of unique values that are in only one of the input
+        arrays.
+
+    Examples
+    --------
+    >>> a = np.array([1, 2, 3, 2, 4])
+    >>> b = np.array([2, 3, 5, 7, 5])
+    >>> np.setxor1d(a,b)
+    array([1, 4, 5, 7])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def copy (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "copy"))))
+(alter-meta! #'copy assoc :doc "
+    Return an array copy of the given object.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Controls the memory layout of the copy. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible. (Note that this function and :meth:`ndarray.copy` are very
+        similar, but have different default values for their order=
+        arguments.)
+
+    Returns
+    -------
+    arr : ndarray
+        Array interpretation of `a`.
+
+    Notes
+    -----
+    This is equivalent to:
+
+    >>> np.array(a, copy=True)  #doctest: +SKIP
+
+    Examples
+    --------
+    Create an array x, with a reference y and a copy z:
+
+    >>> x = np.array([1, 2, 3])
+    >>> y = x
+    >>> z = np.copy(x)
+
+    Note that, when we modify x, y changes, but not z:
+
+    >>> x[0] = 10
+    >>> x[0] == y[0]
+    True
+    >>> x[0] == z[0]
+    False
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def in1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "in1d"))))
+(alter-meta! #'in1d assoc :doc "
+    Test whether each element of a 1-D array is also present in a second array.
+
+    Returns a boolean array the same length as `ar1` that is True
+    where an element of `ar1` is in `ar2` and False otherwise.
+
+    We recommend using :func:`isin` instead of `in1d` for new code.
+
+    Parameters
+    ----------
+    ar1 : (M,) array_like
+        Input array.
+    ar2 : array_like
+        The values against which to test each value of `ar1`.
+    assume_unique : bool, optional
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+    invert : bool, optional
+        If True, the values in the returned array are inverted (that is,
+        False where an element of `ar1` is in `ar2` and True otherwise).
+        Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
+        to (but is faster than) ``np.invert(in1d(a, b))``.
+
+        .. versionadded:: 1.8.0
+
+    Returns
+    -------
+    in1d : (M,) ndarray, bool
+        The values `ar1[in1d]` are in `ar2`.
+
+    See Also
+    --------
+    isin                  : Version of this function that preserves the
+                            shape of ar1.
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Notes
+    -----
+    `in1d` can be considered as an element-wise function version of the
+    python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
+    equivalent to ``np.array([item in b for item in a])``.
+    However, this idea fails if `ar2` is a set, or similar (non-sequence)
+    container:  As ``ar2`` is converted to an array, in those cases
+    ``asarray(ar2)`` is an object array rather than the expected array of
+    contained values.
+
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    >>> test = np.array([0, 1, 2, 5, 0])
+    >>> states = [0, 2]
+    >>> mask = np.in1d(test, states)
+    >>> mask
+    array([ True, False,  True, False,  True])
+    >>> test[mask]
+    array([0, 2, 0])
+    >>> mask = np.in1d(test, states, invert=True)
+    >>> mask
+    array([False,  True, False,  True, False])
+    >>> test[mask]
+    array([1, 5])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def complex_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex_"))))
+(alter-meta! #'complex_ assoc :doc "Complex number type composed of two double-precision floating-point
+    numbers, compatible with Python `complex`.
+    Character code: ``'D'``.
+    Canonical name: ``np.cdouble``.
+    Alias: ``np.cfloat``.
+    Alias: ``np.complex_``.
+    Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc "
+    Translates slice objects to concatenation along the second axis.
+
+    This is short-hand for ``np.r_['-1,2,0', index expression]``, which is
+    useful because of its common occurrence. In particular, arrays will be
+    stacked along their last axis after being upgraded to at least 2-D with
+    1's post-pended to the shape (column vectors made out of 1-D arrays).
+    
+    See Also
+    --------
+    column_stack : Stack 1-D arrays as columns into a 2-D array.
+    r_ : For more detailed documentation.
+
+    Examples
+    --------
+    >>> np.c_[np.array([1,2,3]), np.array([4,5,6])]
+    array([[1, 4],
+           [2, 5],
+           [3, 6]])
+    >>> np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]
+    array([[1, 2, 3, ..., 4, 5, 6]])
+
+    "} c_ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "c_"))))
+
+(def ^{:doc "
+    `nd_grid` instance which returns a dense multi-dimensional \"meshgrid\".
+
+    An instance of `numpy.lib.index_tricks.nd_grid` which returns an dense
+    (or fleshed out) mesh-grid when indexed, so that each returned argument
+    has the same shape.  The dimensions and number of the output arrays are
+    equal to the number of indexing dimensions.  If the step length is not a
+    complex number, then the stop is not inclusive.
+
+    However, if the step length is a **complex number** (e.g. 5j), then
+    the integer part of its magnitude is interpreted as specifying the
+    number of points to create between the start and stop values, where
+    the stop value **is inclusive**.
+
+    Returns
+    ----------
+    mesh-grid `ndarrays` all of the same dimensions
+
+    See Also
+    --------
+    numpy.lib.index_tricks.nd_grid : class of `ogrid` and `mgrid` objects
+    ogrid : like mgrid but returns open (not fleshed out) mesh grids
+    r_ : array concatenator
+
+    Examples
+    --------
+    >>> np.mgrid[0:5,0:5]
+    array([[[0, 0, 0, 0, 0],
+            [1, 1, 1, 1, 1],
+            [2, 2, 2, 2, 2],
+            [3, 3, 3, 3, 3],
+            [4, 4, 4, 4, 4]],
+           [[0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4]]])
+    >>> np.mgrid[-1:1:5j]
+    array([-1. , -0.5,  0. ,  0.5,  1. ])
+
+    "} mgrid (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "mgrid"))))
+
+(def trapz (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trapz"))))
+(alter-meta! #'trapz assoc :doc "
+    Integrate along the given axis using the composite trapezoidal rule.
+
+    Integrate `y` (`x`) along given axis.
+
+    Parameters
+    ----------
+    y : array_like
+        Input array to integrate.
+    x : array_like, optional
+        The sample points corresponding to the `y` values. If `x` is None,
+        the sample points are assumed to be evenly spaced `dx` apart. The
+        default is None.
+    dx : scalar, optional
+        The spacing between sample points when `x` is None. The default is 1.
+    axis : int, optional
+        The axis along which to integrate.
+
+    Returns
+    -------
+    trapz : float
+        Definite integral as approximated by trapezoidal rule.
+
+    See Also
+    --------
+    sum, cumsum
+
+    Notes
+    -----
+    Image [2]_ illustrates trapezoidal rule -- y-axis locations of points
+    will be taken from `y` array, by default x-axis distances between
+    points will be 1.0, alternatively they can be provided with `x` array
+    or with `dx` scalar.  Return value will be equal to combined area under
+    the red lines.
+
+
+    References
+    ----------
+    .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule
+
+    .. [2] Illustration image:
+           https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png
+
+    Examples
+    --------
+    >>> np.trapz([1,2,3])
+    4.0
+    >>> np.trapz([1,2,3], x=[4,6,8])
+    8.0
+    >>> np.trapz([1,2,3], dx=2)
+    8.0
+    >>> a = np.arange(6).reshape(2, 3)
+    >>> a
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.trapz(a, axis=0)
+    array([1.5, 2.5, 3.5])
+    >>> np.trapz(a, axis=1)
+    array([2.,  8.])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def float64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float64"))))
+(alter-meta! #'float64 assoc :doc "Double-precision floating-point number type, compatible with Python `float`
+    and C ``double``.
+    Character code: ``'d'``.
+    Canonical name: ``np.double``.
+    Alias: ``np.float_``.
+    Alias *on this platform*: ``np.float64``: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
+
+(def histogramdd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogramdd"))))
+(alter-meta! #'histogramdd assoc :doc "
+    Compute the multidimensional histogram of some data.
+
+    Parameters
+    ----------
+    sample : (N, D) array, or (D, N) array_like
+        The data to be histogrammed.
+
+        Note the unusual interpretation of sample when an array_like:
+
+        * When an array, each row is a coordinate in a D-dimensional space -
+          such as ``histogramgramdd(np.array([p1, p2, p3]))``.
+        * When an array_like, each element is the list of values for single
+          coordinate - such as ``histogramgramdd((X, Y, Z))``.
+
+        The first form should be preferred.
+
+    bins : sequence or int, optional
+        The bin specification:
+
+        * A sequence of arrays describing the monotonically increasing bin
+          edges along each dimension.
+        * The number of bins for each dimension (nx, ny, ... =bins)
+        * The number of bins for all dimensions (nx=ny=...=bins).
+
+    range : sequence, optional
+        A sequence of length D, each an optional (lower, upper) tuple giving
+        the outer bin edges to be used if the edges are not given explicitly in
+        `bins`.
+        An entry of None in the sequence results in the minimum and maximum
+        values being used for the corresponding dimension.
+        The default, None, is equivalent to passing a tuple of D None values.
+    density : bool, optional
+        If False, the default, returns the number of samples in each bin.
+        If True, returns the probability *density* function at the bin,
+        ``bin_count / sample_count / bin_volume``.
+    normed : bool, optional
+        An alias for the density argument that behaves identically. To avoid
+        confusion with the broken normed argument to `histogram`, `density`
+        should be preferred.
+    weights : (N,) array_like, optional
+        An array of values `w_i` weighing each sample `(x_i, y_i, z_i, ...)`.
+        Weights are normalized to 1 if normed is True. If normed is False,
+        the values of the returned histogram are equal to the sum of the
+        weights belonging to the samples falling into each bin.
+
+    Returns
+    -------
+    H : ndarray
+        The multidimensional histogram of sample x. See normed and weights
+        for the different possible semantics.
+    edges : list
+        A list of D arrays describing the bin edges for each dimension.
+
+    See Also
+    --------
+    histogram: 1-D histogram
+    histogram2d: 2-D histogram
+
+    Examples
+    --------
+    >>> r = np.random.randn(100,3)
+    >>> H, edges = np.histogramdd(r, bins = (5, 8, 4))
+    >>> H.shape, edges[0].size, edges[1].size, edges[2].size
+    ((5, 8, 4), 6, 9, 5)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def average (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "average"))))
+(alter-meta! #'average assoc :doc "
+    Compute the weighted average along the specified axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing data to be averaged. If `a` is not an array, a
+        conversion is attempted.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to average `a`.  The default,
+        axis=None, will average over all of the elements of the input array.
+        If axis is negative it counts from the last to the first axis.
+
+        .. versionadded:: 1.7.0
+
+        If axis is a tuple of ints, averaging is performed on all of the axes
+        specified in the tuple instead of a single axis or all the axes as
+        before.
+    weights : array_like, optional
+        An array of weights associated with the values in `a`. Each value in
+        `a` contributes to the average according to its associated weight.
+        The weights array can either be 1-D (in which case its length must be
+        the size of `a` along the given axis) or of the same shape as `a`.
+        If `weights=None`, then all data in `a` are assumed to have a
+        weight equal to one.  The 1-D calculation is::
+
+            avg = sum(a * weights) / sum(weights)
+
+        The only constraint on `weights` is that `sum(weights)` must not be 0.
+    returned : bool, optional
+        Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`)
+        is returned, otherwise only the average is returned.
+        If `weights=None`, `sum_of_weights` is equivalent to the number of
+        elements over which the average is taken.
+
+    Returns
+    -------
+    retval, [sum_of_weights] : array_type or double
+        Return the average along the specified axis. When `returned` is `True`,
+        return a tuple with the average as the first element and the sum
+        of the weights as the second element. `sum_of_weights` is of the
+        same type as `retval`. The result dtype follows a genereal pattern.
+        If `weights` is None, the result dtype will be that of `a` , or ``float64``
+        if `a` is integral. Otherwise, if `weights` is not None and `a` is non-
+        integral, the result type will be the type of lowest precision capable of
+        representing values of both `a` and `weights`. If `a` happens to be
+        integral, the previous rules still applies but the result dtype will
+        at least be ``float64``.
+
+    Raises
+    ------
+    ZeroDivisionError
+        When all weights along axis are zero. See `numpy.ma.average` for a
+        version robust to this type of error.
+    TypeError
+        When the length of 1D `weights` is not the same as the shape of `a`
+        along axis.
+
+    See Also
+    --------
+    mean
+
+    ma.average : average for masked arrays -- useful if your data contains
+                 \"missing\" values
+    numpy.result_type : Returns the type that results from applying the
+                        numpy type promotion rules to the arguments.
+
+    Examples
+    --------
+    >>> data = np.arange(1, 5)
+    >>> data
+    array([1, 2, 3, 4])
+    >>> np.average(data)
+    2.5
+    >>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1))
+    4.0
+
+    >>> data = np.arange(6).reshape((3,2))
+    >>> data
+    array([[0, 1],
+           [2, 3],
+           [4, 5]])
+    >>> np.average(data, axis=1, weights=[1./4, 3./4])
+    array([0.75, 2.75, 4.75])
+    >>> np.average(data, weights=[1./4, 3./4])
+    Traceback (most recent call last):
+        ...
+    TypeError: Axis must be specified when shapes of a and weights differ.
+
+    >>> a = np.ones(5, dtype=np.float128)
+    >>> w = np.ones(5, dtype=np.complex64)
+    >>> avg = np.average(a, weights=w)
+    >>> print(avg.dtype)
+    complex256
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def iscomplexobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iscomplexobj"))))
+(alter-meta! #'iscomplexobj assoc :doc "
+    Check for a complex type or an array of complex numbers.
+
+    The type of the input is checked, not the value. Even if the input
+    has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
+
+    Parameters
+    ----------
+    x : any
+        The input can be of any type and shape.
+
+    Returns
+    -------
+    iscomplexobj : bool
+        The return value, True if `x` is of a complex type or has at least
+        one complex element.
+
+    See Also
+    --------
+    isrealobj, iscomplex
+
+    Examples
+    --------
+    >>> np.iscomplexobj(1)
+    False
+    >>> np.iscomplexobj(1+0j)
+    True
+    >>> np.iscomplexobj([3, 1+0j, True])
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def logaddexp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logaddexp"))))
+(alter-meta! #'logaddexp assoc :doc "logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Logarithm of the sum of exponentiations of the inputs.
+
+Calculates ``log(exp(x1) + exp(x2))``. This function is useful in
+statistics where the calculated probabilities of events may be so small
+as to exceed the range of normal floating point numbers.  In such cases
+the logarithm of the calculated probability is stored. This function
+allows adding probabilities stored in such a fashion.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input values. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+result : ndarray
+    Logarithm of ``exp(x1) + exp(x2)``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2.
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+Examples
+--------
+>>> prob1 = np.log(1e-50)
+>>> prob2 = np.log(2.5e-50)
+>>> prob12 = np.logaddexp(prob1, prob2)
+>>> prob12
+-113.87649168120691
+>>> np.exp(prob12)
+3.5000000000000057e-50" :arglists '[[self & [args {:as kwargs}]]])
+
+(def multiply (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "multiply"))))
+(alter-meta! #'multiply assoc :doc "multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Multiply arguments element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays to be multiplied. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The product of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+Equivalent to `x1` * `x2` in terms of array broadcasting.
+
+Examples
+--------
+>>> np.multiply(2.0, 4.0)
+8.0
+
+>>> x1 = np.arange(9.0).reshape((3, 3))
+>>> x2 = np.arange(3.0)
+>>> np.multiply(x1, x2)
+array([[  0.,   1.,   4.],
+       [  0.,   4.,  10.],
+       [  0.,   7.,  16.]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def uint (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint"))))
+(alter-meta! #'uint assoc :doc "Unsigned integer type, compatible with C ``unsigned long``.
+    Character code: ``'L'``.
+    Canonical name: ``np.uint``.
+    Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615).
+    Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def nanpercentile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanpercentile"))))
+(alter-meta! #'nanpercentile assoc :doc "
+    Compute the qth percentile of the data along the specified axis,
+    while ignoring nan values.
+
+    Returns the qth percentile(s) of the array elements.
+
+    .. versionadded:: 1.9.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array, containing
+        nan values to be ignored.
+    q : array_like of float
+        Percentile or sequence of percentiles to compute, which must be between
+        0 and 100 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the percentiles are computed. The
+        default is to compute the percentile(s) along a flattened
+        version of the array.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by intermediate
+        calculations, to save memory. In this case, the contents of the input
+        `a` after this function completes is undefined.
+    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
+        This optional parameter specifies the interpolation method to
+        use when the desired percentile lies between two data points
+        ``i < j``:
+
+        * 'linear': ``i + (j - i) * fraction``, where ``fraction``
+          is the fractional part of the index surrounded by ``i``
+          and ``j``.
+        * 'lower': ``i``.
+        * 'higher': ``j``.
+        * 'nearest': ``i`` or ``j``, whichever is nearest.
+        * 'midpoint': ``(i + j) / 2``.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+        If this is anything but the default value it will be passed
+        through (in the special case of an empty array) to the
+        `mean` function of the underlying array.  If the array is
+        a sub-class and `mean` does not have the kwarg `keepdims` this
+        will raise a RuntimeError.
+
+    Returns
+    -------
+    percentile : scalar or ndarray
+        If `q` is a single percentile and `axis=None`, then the result
+        is a scalar. If multiple percentiles are given, first axis of
+        the result corresponds to the percentiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    nanmean
+    nanmedian : equivalent to ``nanpercentile(..., 50)``
+    percentile, median, mean
+    nanquantile : equivalent to nanpercentile, but with q in the range [0, 1].
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the ``q``-th percentile of
+    ``V`` is the value ``q/100`` of the way from the minimum to the
+    maximum in a sorted copy of ``V``. The values and distances of
+    the two nearest neighbors as well as the `interpolation` parameter
+    will determine the percentile if the normalized ranking does not
+    match the location of ``q`` exactly. This function is the same as
+    the median if ``q=50``, the same as the minimum if ``q=0`` and the
+    same as the maximum if ``q=100``.
+
+    Examples
+    --------
+    >>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
+    >>> a[0][1] = np.nan
+    >>> a
+    array([[10.,  nan,   4.],
+          [ 3.,   2.,   1.]])
+    >>> np.percentile(a, 50)
+    nan
+    >>> np.nanpercentile(a, 50)
+    3.0
+    >>> np.nanpercentile(a, 50, axis=0)
+    array([6.5, 2. , 2.5])
+    >>> np.nanpercentile(a, 50, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+    >>> m = np.nanpercentile(a, 50, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.nanpercentile(a, 50, axis=0, out=out)
+    array([6.5, 2. , 2.5])
+    >>> m
+    array([6.5,  2. ,  2.5])
+
+    >>> b = a.copy()
+    >>> np.nanpercentile(b, 50, axis=1, overwrite_input=True)
+    array([7., 2.])
+    >>> assert not np.all(a==b)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def intc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "intc"))))
+(alter-meta! #'intc assoc :doc "Signed integer type, compatible with C ``int``.
+    Character code: ``'i'``.
+    Canonical name: ``np.intc``.
+    Alias *on this platform*: ``np.int32``: 32-bit signed integer (-2147483648 to 2147483647)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def int32 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int32"))))
+(alter-meta! #'int32 assoc :doc "Signed integer type, compatible with C ``int``.
+    Character code: ``'i'``.
+    Canonical name: ``np.intc``.
+    Alias *on this platform*: ``np.int32``: 32-bit signed integer (-2147483648 to 2147483647)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def place (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "place"))))
+(alter-meta! #'place assoc :doc "
+    Change elements of an array based on conditional and input values.
+
+    Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that
+    `place` uses the first N elements of `vals`, where N is the number of
+    True values in `mask`, while `copyto` uses the elements where `mask`
+    is True.
+
+    Note that `extract` does the exact opposite of `place`.
+
+    Parameters
+    ----------
+    arr : ndarray
+        Array to put data into.
+    mask : array_like
+        Boolean mask array. Must have the same size as `a`.
+    vals : 1-D sequence
+        Values to put into `a`. Only the first N elements are used, where
+        N is the number of True values in `mask`. If `vals` is smaller
+        than N, it will be repeated, and if elements of `a` are to be masked,
+        this sequence must be non-empty.
+
+    See Also
+    --------
+    copyto, put, take, extract
+
+    Examples
+    --------
+    >>> arr = np.arange(6).reshape(2, 3)
+    >>> np.place(arr, arr>2, [44, 55])
+    >>> arr
+    array([[ 0,  1,  2],
+           [44, 55, 44]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def shape (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "shape"))))
+(alter-meta! #'shape assoc :doc "
+    Return the shape of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+
+    Returns
+    -------
+    shape : tuple of ints
+        The elements of the shape tuple give the lengths of the
+        corresponding array dimensions.
+
+    See Also
+    --------
+    alen
+    ndarray.shape : Equivalent array method.
+
+    Examples
+    --------
+    >>> np.shape(np.eye(3))
+    (3, 3)
+    >>> np.shape([[1, 2]])
+    (1, 2)
+    >>> np.shape([0])
+    (1,)
+    >>> np.shape(0)
+    ()
+
+    >>> a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
+    >>> np.shape(a)
+    (2,)
+    >>> a.shape
+    (2,)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "Sub-package containing the matrix class and related functions.
+
+"} matrixlib (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "matrixlib"))))
+
+(def lcm (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "lcm"))))
+(alter-meta! #'lcm assoc :doc "lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns the lowest common multiple of ``|x1|`` and ``|x2|``
+
+Parameters
+----------
+x1, x2 : array_like, int
+    Arrays of values. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+
+Returns
+-------
+y : ndarray or scalar
+    The lowest common multiple of the absolute value of the inputs
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+gcd : The greatest common divisor
+
+Examples
+--------
+>>> np.lcm(12, 20)
+60
+>>> np.lcm.reduce([3, 12, 20])
+60
+>>> np.lcm.reduce([40, 12, 20])
+120
+>>> np.lcm(np.arange(6), 20)
+array([ 0, 20, 20, 60, 20, 20])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def copysign (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "copysign"))))
+(alter-meta! #'copysign assoc :doc "copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Change the sign of x1 to that of x2, element-wise.
+
+If `x2` is a scalar, its sign will be copied to all elements of `x1`.
+
+Parameters
+----------
+x1 : array_like
+    Values to change the sign of.
+x2 : array_like
+    The sign of `x2` is copied to `x1`. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    The values of `x1` with the sign of `x2`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Examples
+--------
+>>> np.copysign(1.3, -1)
+-1.3
+>>> 1/np.copysign(0, 1)
+inf
+>>> 1/np.copysign(0, -1)
+-inf
+
+>>> np.copysign([-1, 0, 1], -1.1)
+array([-1., -0., -1.])
+>>> np.copysign([-1, 0, 1], np.arange(3)-1)
+array([-1.,  0.,  1.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def uint16 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint16"))))
+(alter-meta! #'uint16 assoc :doc "Unsigned integer type, compatible with C ``unsigned short``.
+    Character code: ``'H'``.
+    Canonical name: ``np.ushort``.
+    Alias *on this platform*: ``np.uint16``: 16-bit unsigned integer (0 to 65535)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def delete (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "delete"))))
+(alter-meta! #'delete assoc :doc "
+    Return a new array with sub-arrays along an axis deleted. For a one
+    dimensional array, this returns those entries not returned by
+    `arr[obj]`.
+
+    Parameters
+    ----------
+    arr : array_like
+      Input array.
+    obj : slice, int or array of ints
+      Indicate indices of sub-arrays to remove along the specified axis.
+    axis : int, optional
+      The axis along which to delete the subarray defined by `obj`.
+      If `axis` is None, `obj` is applied to the flattened array.
+
+    Returns
+    -------
+    out : ndarray
+        A copy of `arr` with the elements specified by `obj` removed. Note
+        that `delete` does not occur in-place. If `axis` is None, `out` is
+        a flattened array.
+
+    See Also
+    --------
+    insert : Insert elements into an array.
+    append : Append elements at the end of an array.
+
+    Notes
+    -----
+    Often it is preferable to use a boolean mask. For example:
+
+    >>> arr = np.arange(12) + 1
+    >>> mask = np.ones(len(arr), dtype=bool)
+    >>> mask[[0,2,4]] = False
+    >>> result = arr[mask,...]
+
+    Is equivalent to `np.delete(arr, [0,2,4], axis=0)`, but allows further
+    use of `mask`.
+
+    Examples
+    --------
+    >>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
+    >>> arr
+    array([[ 1,  2,  3,  4],
+           [ 5,  6,  7,  8],
+           [ 9, 10, 11, 12]])
+    >>> np.delete(arr, 1, 0)
+    array([[ 1,  2,  3,  4],
+           [ 9, 10, 11, 12]])
+
+    >>> np.delete(arr, np.s_[::2], 1)
+    array([[ 2,  4],
+           [ 6,  8],
+           [10, 12]])
+    >>> np.delete(arr, [1,3,5], None)
+    array([ 1,  3,  5,  7,  8,  9, 10, 11, 12])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def is_busday (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "is_busday"))))
+(alter-meta! #'is_busday assoc :doc "
+    is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)
+
+    Calculates which of the given dates are valid days, and which are not.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    dates : array_like of datetime64[D]
+        The array of dates to process.
+    weekmask : str or array_like of bool, optional
+        A seven-element array indicating which of Monday through Sunday are
+        valid days. May be specified as a length-seven list or array, like
+        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
+        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
+        weekdays, optionally separated by white space. Valid abbreviations
+        are: Mon Tue Wed Thu Fri Sat Sun
+    holidays : array_like of datetime64[D], optional
+        An array of dates to consider as invalid dates.  They may be
+        specified in any order, and NaT (not-a-time) dates are ignored.
+        This list is saved in a normalized form that is suited for
+        fast calculations of valid days.
+    busdaycal : busdaycalendar, optional
+        A `busdaycalendar` object which specifies the valid days. If this
+        parameter is provided, neither weekmask nor holidays may be
+        provided.
+    out : array of bool, optional
+        If provided, this array is filled with the result.
+
+    Returns
+    -------
+    out : array of bool
+        An array with the same shape as ``dates``, containing True for
+        each valid day, and False for each invalid day.
+
+    See Also
+    --------
+    busdaycalendar: An object that specifies a custom set of valid days.
+    busday_offset : Applies an offset counted in valid days.
+    busday_count : Counts how many valid days are in a half-open date range.
+
+    Examples
+    --------
+    >>> # The weekdays are Friday, Saturday, and Monday
+    ... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'],
+    ...                 holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
+    array([False, False,  True])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def savez_compressed (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "savez_compressed"))))
+(alter-meta! #'savez_compressed assoc :doc "
+    Save several arrays into a single file in compressed ``.npz`` format.
+
+    If keyword arguments are given, then filenames are taken from the keywords.
+    If arguments are passed in with no keywords, then stored filenames are
+    arr_0, arr_1, etc.
+
+    Parameters
+    ----------
+    file : str or file
+        Either the filename (string) or an open file (file-like object)
+        where the data will be saved. If file is a string or a Path, the
+        ``.npz`` extension will be appended to the filename if it is not
+        already there.
+    args : Arguments, optional
+        Arrays to save to the file. Since it is not possible for Python to
+        know the names of the arrays outside `savez`, the arrays will be saved
+        with names \"arr_0\", \"arr_1\", and so on. These arguments can be any
+        expression.
+    kwds : Keyword arguments, optional
+        Arrays to save to the file. Arrays will be saved in the file with the
+        keyword names.
+
+    Returns
+    -------
+    None
+
+    See Also
+    --------
+    numpy.save : Save a single array to a binary file in NumPy format.
+    numpy.savetxt : Save an array to a file as plain text.
+    numpy.savez : Save several arrays into an uncompressed ``.npz`` file format
+    numpy.load : Load the files created by savez_compressed.
+
+    Notes
+    -----
+    The ``.npz`` file format is a zipped archive of files named after the
+    variables they contain.  The archive is compressed with
+    ``zipfile.ZIP_DEFLATED`` and each file in the archive contains one variable
+    in ``.npy`` format. For a description of the ``.npy`` format, see 
+    :py:mod:`numpy.lib.format`.
+
+
+    When opening the saved ``.npz`` file with `load` a `NpzFile` object is
+    returned. This is a dictionary-like object which can be queried for
+    its list of arrays (with the ``.files`` attribute), and for the arrays
+    themselves.
+
+    Examples
+    --------
+    >>> test_array = np.random.rand(3, 2)
+    >>> test_vector = np.random.rand(4)
+    >>> np.savez_compressed('/tmp/123', a=test_array, b=test_vector)
+    >>> loaded = np.load('/tmp/123.npz')
+    >>> print(np.array_equal(test_array, loaded['a']))
+    True
+    >>> print(np.array_equal(test_vector, loaded['b']))
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ediff1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ediff1d"))))
+(alter-meta! #'ediff1d assoc :doc "
+    The differences between consecutive elements of an array.
+
+    Parameters
+    ----------
+    ary : array_like
+        If necessary, will be flattened before the differences are taken.
+    to_end : array_like, optional
+        Number(s) to append at the end of the returned differences.
+    to_begin : array_like, optional
+        Number(s) to prepend at the beginning of the returned differences.
+
+    Returns
+    -------
+    ediff1d : ndarray
+        The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.
+
+    See Also
+    --------
+    diff, gradient
+
+    Notes
+    -----
+    When applied to masked arrays, this function drops the mask information
+    if the `to_begin` and/or `to_end` parameters are used.
+
+    Examples
+    --------
+    >>> x = np.array([1, 2, 4, 7, 0])
+    >>> np.ediff1d(x)
+    array([ 1,  2,  3, -7])
+
+    >>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))
+    array([-99,   1,   2, ...,  -7,  88,  99])
+
+    The returned array is always 1D.
+
+    >>> y = [[1, 2, 4], [1, 6, 24]]
+    >>> np.ediff1d(y)
+    array([ 1,  2, -3,  5, 18])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def fromfile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromfile"))))
+(alter-meta! #'fromfile assoc :doc "fromfile(file, dtype=float, count=-1, sep='', offset=0)
+
+    Construct an array from data in a text or binary file.
+
+    A highly efficient way of reading binary data with a known data-type,
+    as well as parsing simply formatted text files.  Data written using the
+    `tofile` method can be read using this function.
+
+    Parameters
+    ----------
+    file : file or str or Path
+        Open file object or filename.
+
+        .. versionchanged:: 1.17.0
+            `pathlib.Path` objects are now accepted.
+
+    dtype : data-type
+        Data type of the returned array.
+        For binary files, it is used to determine the size and byte-order
+        of the items in the file.
+        Most builtin numeric types are supported and extension types may be supported.
+
+        .. versionadded:: 1.18.0
+            Complex dtypes.
+
+    count : int
+        Number of items to read. ``-1`` means all items (i.e., the complete
+        file).
+    sep : str
+        Separator between items if file is a text file.
+        Empty (\"\") separator means the file should be treated as binary.
+        Spaces (\" \") in the separator match zero or more whitespace characters.
+        A separator consisting only of spaces must match at least one
+        whitespace.
+    offset : int
+        The offset (in bytes) from the file's current position. Defaults to 0.
+        Only permitted for binary files.
+
+        .. versionadded:: 1.17.0
+
+    See also
+    --------
+    load, save
+    ndarray.tofile
+    loadtxt : More flexible way of loading data from a text file.
+
+    Notes
+    -----
+    Do not rely on the combination of `tofile` and `fromfile` for
+    data storage, as the binary files generated are not platform
+    independent.  In particular, no byte-order or data-type information is
+    saved.  Data can be stored in the platform independent ``.npy`` format
+    using `save` and `load` instead.
+
+    Examples
+    --------
+    Construct an ndarray:
+
+    >>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]),
+    ...                ('temp', float)])
+    >>> x = np.zeros((1,), dtype=dt)
+    >>> x['time']['min'] = 10; x['temp'] = 98.25
+    >>> x
+    array([((10, 0), 98.25)],
+          dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])
+
+    Save the raw data to disk:
+
+    >>> import tempfile
+    >>> fname = tempfile.mkstemp()[1]
+    >>> x.tofile(fname)
+
+    Read the raw data from disk:
+
+    >>> np.fromfile(fname, dtype=dt)
+    array([((10, 0), 98.25)],
+          dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])
+
+    The recommended way to store and load data:
+
+    >>> np.save(fname, x)
+    >>> np.load(fname + '.npy')
+    array([((10, 0), 98.25)],
+          dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def put (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "put"))))
+(alter-meta! #'put assoc :doc "
+    Replaces specified elements of an array with given values.
+
+    The indexing works on the flattened target array. `put` is roughly
+    equivalent to:
+
+    ::
+
+        a.flat[ind] = v
+
+    Parameters
+    ----------
+    a : ndarray
+        Target array.
+    ind : array_like
+        Target indices, interpreted as integers.
+    v : array_like
+        Values to place in `a` at target indices. If `v` is shorter than
+        `ind` it will be repeated as necessary.
+    mode : {'raise', 'wrap', 'clip'}, optional
+        Specifies how out-of-bounds indices will behave.
+
+        * 'raise' -- raise an error (default)
+        * 'wrap' -- wrap around
+        * 'clip' -- clip to the range
+
+        'clip' mode means that all indices that are too large are replaced
+        by the index that addresses the last element along that axis. Note
+        that this disables indexing with negative numbers. In 'raise' mode,
+        if an exception occurs the target array may still be modified.
+
+    See Also
+    --------
+    putmask, place
+    put_along_axis : Put elements by matching the array and the index arrays
+
+    Examples
+    --------
+    >>> a = np.arange(5)
+    >>> np.put(a, [0, 2], [-44, -55])
+    >>> a
+    array([-44,   1, -55,   3,   4])
+
+    >>> a = np.arange(5)
+    >>> np.put(a, 22, -5, mode='clip')
+    >>> a
+    array([ 0,  1,  2,  3, -5])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def not_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "not_equal"))))
+(alter-meta! #'not_equal assoc :doc "not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return (x1 != x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays.  If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+equal, greater, greater_equal, less, less_equal
+
+Examples
+--------
+>>> np.not_equal([1.,2.], [1., 3.])
+array([False,  True])
+>>> np.not_equal([1, 2], [[1, 3],[1, 4]])
+array([[False,  True],
+       [False,  True]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def corrcoef (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "corrcoef"))))
+(alter-meta! #'corrcoef assoc :doc "
+    Return Pearson product-moment correlation coefficients.
+
+    Please refer to the documentation for `cov` for more detail.  The
+    relationship between the correlation coefficient matrix, `R`, and the
+    covariance matrix, `C`, is
+
+    .. math:: R_{ij} = \\frac{ C_{ij} } { \\sqrt{ C_{ii} * C_{jj} } }
+
+    The values of `R` are between -1 and 1, inclusive.
+
+    Parameters
+    ----------
+    x : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `x` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same
+        shape as `x`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+    bias : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.10.0
+    ddof : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.10.0
+
+    Returns
+    -------
+    R : ndarray
+        The correlation coefficient matrix of the variables.
+
+    See Also
+    --------
+    cov : Covariance matrix
+
+    Notes
+    -----
+    Due to floating point rounding the resulting array may not be Hermitian,
+    the diagonal elements may not be 1, and the elements may not satisfy the
+    inequality abs(a) <= 1. The real and imaginary parts are clipped to the
+    interval [-1,  1] in an attempt to improve on that situation but is not
+    much help in the complex case.
+
+    This function accepts but discards arguments `bias` and `ddof`.  This is
+    for backwards compatibility with previous versions of this function.  These
+    arguments had no effect on the return values of the function and can be
+    safely ignored in this and previous versions of numpy.
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def msort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "msort"))))
+(alter-meta! #'msort assoc :doc "
+    Return a copy of an array sorted along the first axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Array to be sorted.
+
+    Returns
+    -------
+    sorted_array : ndarray
+        Array of the same type and shape as `a`.
+
+    See Also
+    --------
+    sort
+
+    Notes
+    -----
+    ``np.msort(a)`` is equivalent to  ``np.sort(a, axis=0)``.
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def csingle (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "csingle"))))
+(alter-meta! #'csingle assoc :doc "Complex number type composed of two single-precision floating-point
+    numbers.
+    Character code: ``'F'``.
+    Canonical name: ``np.csingle``.
+    Alias: ``np.singlecomplex``.
+    Alias *on this platform*: ``np.complex64``: Complex number type composed of 2 32-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def bitwise_or (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_or"))))
+(alter-meta! #'bitwise_or assoc :doc "bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the bit-wise OR of two arrays element-wise.
+
+Computes the bit-wise OR of the underlying binary representation of
+the integers in the input arrays. This ufunc implements the C/Python
+operator ``|``.
+
+Parameters
+----------
+x1, x2 : array_like
+    Only integer and boolean types are handled. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Result.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_or
+bitwise_and
+bitwise_xor
+binary_repr :
+    Return the binary representation of the input number as a string.
+
+Examples
+--------
+The number 13 has the binaray representation ``00001101``. Likewise,
+16 is represented by ``00010000``.  The bit-wise OR of 13 and 16 is
+then ``000111011``, or 29:
+
+>>> np.bitwise_or(13, 16)
+29
+>>> np.binary_repr(29)
+'11101'
+
+>>> np.bitwise_or(32, 2)
+34
+>>> np.bitwise_or([33, 4], 1)
+array([33,  5])
+>>> np.bitwise_or([33, 4], [1, 2])
+array([33,  6])
+
+>>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4]))
+array([  6,   5, 255])
+>>> np.array([2, 5, 255]) | np.array([4, 4, 4])
+array([  6,   5, 255])
+>>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32),
+...               np.array([4, 4, 4, 2147483647], dtype=np.int32))
+array([         6,          5,        255, 2147483647])
+>>> np.bitwise_or([True, True], [False, True])
+array([ True,  True])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def rad2deg (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rad2deg"))))
+(alter-meta! #'rad2deg assoc :doc "rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Convert angles from radians to degrees.
+
+Parameters
+----------
+x : array_like
+    Angle in radians.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding angle in degrees.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+deg2rad : Convert angles from degrees to radians.
+unwrap : Remove large jumps in angle by wrapping.
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+rad2deg(x) is ``180 * x / pi``.
+
+Examples
+--------
+>>> np.rad2deg(np.pi/2)
+90.0" :arglists '[[self & [args {:as kwargs}]]])
+
+(def deprecate_with_doc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "deprecate_with_doc"))))
+(alter-meta! #'deprecate_with_doc assoc :doc "" :arglists '[[msg]])
+
+(def real_if_close (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "real_if_close"))))
+(alter-meta! #'real_if_close assoc :doc "
+    If complex input returns a real array if complex parts are close to zero.
+
+    \"Close to zero\" is defined as `tol` * (machine epsilon of the type for
+    `a`).
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    tol : float
+        Tolerance in machine epsilons for the complex part of the elements
+        in the array.
+
+    Returns
+    -------
+    out : ndarray
+        If `a` is real, the type of `a` is used for the output.  If `a`
+        has complex elements, the returned type is float.
+
+    See Also
+    --------
+    real, imag, angle
+
+    Notes
+    -----
+    Machine epsilon varies from machine to machine and between data types
+    but Python floats on most platforms have a machine epsilon equal to
+    2.2204460492503131e-16.  You can use 'np.finfo(float).eps' to print
+    out the machine epsilon for floats.
+
+    Examples
+    --------
+    >>> np.finfo(float).eps
+    2.2204460492503131e-16 # may vary
+
+    >>> np.real_if_close([2.1 + 4e-14j], tol=1000)
+    array([2.1])
+    >>> np.real_if_close([2.1 + 4e-13j], tol=1000)
+    array([2.1+4.e-13j])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def fromregex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromregex"))))
+(alter-meta! #'fromregex assoc :doc "
+    Construct an array from a text file, using regular expression parsing.
+
+    The returned array is always a structured array, and is constructed from
+    all matches of the regular expression in the file. Groups in the regular
+    expression are converted to fields of the structured array.
+
+    Parameters
+    ----------
+    file : str or file
+        Filename or file object to read.
+    regexp : str or regexp
+        Regular expression used to parse the file.
+        Groups in the regular expression correspond to fields in the dtype.
+    dtype : dtype or list of dtypes
+        Dtype for the structured array.
+    encoding : str, optional
+        Encoding used to decode the inputfile. Does not apply to input streams.
+
+        .. versionadded:: 1.14.0
+
+    Returns
+    -------
+    output : ndarray
+        The output array, containing the part of the content of `file` that
+        was matched by `regexp`. `output` is always a structured array.
+
+    Raises
+    ------
+    TypeError
+        When `dtype` is not a valid dtype for a structured array.
+
+    See Also
+    --------
+    fromstring, loadtxt
+
+    Notes
+    -----
+    Dtypes for structured arrays can be specified in several forms, but all
+    forms specify at least the data type and field name. For details see
+    `doc.structured_arrays`.
+
+    Examples
+    --------
+    >>> f = open('test.dat', 'w')
+    >>> _ = f.write(\"1312 foo\\n1534  bar\\n444   qux\")
+    >>> f.close()
+
+    >>> regexp = r\"(\\d+)\\s+(...)\"  # match [digits, whitespace, anything]
+    >>> output = np.fromregex('test.dat', regexp,
+    ...                       [('num', np.int64), ('key', 'S3')])
+    >>> output
+    array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')],
+          dtype=[('num', '<i8'), ('key', 'S3')])
+    >>> output['num']
+    array([1312, 1534,  444])
+
+    " :arglists '[[file regexp dtype & [{encoding :encoding}]] [file regexp dtype]])
+
+(def ^{:doc ""} FLOATING_POINT_SUPPORT (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "FLOATING_POINT_SUPPORT"))))
+
+(def clip (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "clip"))))
+(alter-meta! #'clip assoc :doc "
+    Clip (limit) the values in an array.
+
+    Given an interval, values outside the interval are clipped to
+    the interval edges.  For example, if an interval of ``[0, 1]``
+    is specified, values smaller than 0 become 0, and values larger
+    than 1 become 1.
+
+    Equivalent to but faster than ``np.maximum(a_min, np.minimum(a, a_max))``.
+    No check is performed to ensure ``a_min < a_max``.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing elements to clip.
+    a_min : scalar or array_like or None
+        Minimum value. If None, clipping is not performed on lower
+        interval edge. Not more than one of `a_min` and `a_max` may be
+        None.
+    a_max : scalar or array_like or None
+        Maximum value. If None, clipping is not performed on upper
+        interval edge. Not more than one of `a_min` and `a_max` may be
+        None. If `a_min` or `a_max` are array_like, then the three
+        arrays will be broadcasted to match their shapes.
+    out : ndarray, optional
+        The results will be placed in this array. It may be the input
+        array for in-place clipping.  `out` must be of the right shape
+        to hold the output.  Its type is preserved.
+    **kwargs
+        For other keyword-only arguments, see the
+        :ref:`ufunc docs <ufuncs.kwargs>`.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    clipped_array : ndarray
+        An array with the elements of `a`, but where values
+        < `a_min` are replaced with `a_min`, and those > `a_max`
+        with `a_max`.
+
+    See Also
+    --------
+    ufuncs-output-type
+
+    Examples
+    --------
+    >>> a = np.arange(10)
+    >>> np.clip(a, 1, 8)
+    array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
+    >>> a
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> np.clip(a, 3, 6, out=a)
+    array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
+    >>> a = np.arange(10)
+    >>> a
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
+    array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def longdouble (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longdouble"))))
+(alter-meta! #'longdouble assoc :doc "Extended-precision floating-point number type, compatible with C
+    ``long double`` but not necessarily with IEEE 754 quadruple-precision.
+    Character code: ``'g'``.
+    Canonical name: ``np.longdouble``.
+    Alias: ``np.longfloat``.
+    Alias *on this platform*: ``np.float128``: 128-bit extended-precision floating-point number type." :arglists '[[self & [args {:as kwargs}]]])
+
+(def record (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "record"))))
+(alter-meta! #'record assoc :doc "A data-type scalar that allows field access as attribute lookup.
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def argmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argmax"))))
+(alter-meta! #'argmax assoc :doc "
+    Returns the indices of the maximum values along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        By default, the index is into the flattened array, otherwise
+        along the specified axis.
+    out : array, optional
+        If provided, the result will be inserted into this array. It should
+        be of the appropriate shape and dtype.
+
+    Returns
+    -------
+    index_array : ndarray of ints
+        Array of indices into the array. It has the same shape as `a.shape`
+        with the dimension along `axis` removed.
+
+    See Also
+    --------
+    ndarray.argmax, argmin
+    amax : The maximum value along a given axis.
+    unravel_index : Convert a flat index into an index tuple.
+    take_along_axis : Apply ``np.expand_dims(index_array, axis)`` 
+                      from argmax to an array as if by calling max.
+
+    Notes
+    -----
+    In case of multiple occurrences of the maximum values, the indices
+    corresponding to the first occurrence are returned.
+
+    Examples
+    --------
+    >>> a = np.arange(6).reshape(2,3) + 10
+    >>> a
+    array([[10, 11, 12],
+           [13, 14, 15]])
+    >>> np.argmax(a)
+    5
+    >>> np.argmax(a, axis=0)
+    array([1, 1, 1])
+    >>> np.argmax(a, axis=1)
+    array([2, 2])
+
+    Indexes of the maximal elements of a N-dimensional array:
+
+    >>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape)
+    >>> ind
+    (1, 2)
+    >>> a[ind]
+    15
+
+    >>> b = np.arange(6)
+    >>> b[1] = 5
+    >>> b
+    array([0, 5, 2, 3, 4, 5])
+    >>> np.argmax(b)  # Only the first occurrence is returned.
+    1
+
+    >>> x = np.array([[4,2,3], [1,0,3]])
+    >>> index_array = np.argmax(x, axis=-1)
+    >>> # Same as np.max(x, axis=-1, keepdims=True)
+    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
+    array([[4],
+           [3]])
+    >>> # Same as np.max(x, axis=-1)
+    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1)
+    array([4, 3])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def frexp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "frexp"))))
+(alter-meta! #'frexp assoc :doc "frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Decompose the elements of x into mantissa and twos exponent.
+
+Returns (`mantissa`, `exponent`), where `x = mantissa * 2**exponent``.
+The mantissa is lies in the open interval(-1, 1), while the twos
+exponent is a signed integer.
+
+Parameters
+----------
+x : array_like
+    Array of numbers to be decomposed.
+out1 : ndarray, optional
+    Output array for the mantissa. Must have the same shape as `x`.
+out2 : ndarray, optional
+    Output array for the exponent. Must have the same shape as `x`.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+mantissa : ndarray
+    Floating values between -1 and 1.
+    This is a scalar if `x` is a scalar.
+exponent : ndarray
+    Integer exponents of 2.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`.
+
+Notes
+-----
+Complex dtypes are not supported, they will raise a TypeError.
+
+Examples
+--------
+>>> x = np.arange(9)
+>>> y1, y2 = np.frexp(x)
+>>> y1
+array([ 0.   ,  0.5  ,  0.5  ,  0.75 ,  0.5  ,  0.625,  0.75 ,  0.875,
+        0.5  ])
+>>> y2
+array([0, 1, 2, 2, 3, 3, 3, 3, 4])
+>>> y1 * 2**y2
+array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def asmatrix (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asmatrix"))))
+(alter-meta! #'asmatrix assoc :doc "
+    Interpret the input as a matrix.
+
+    Unlike `matrix`, `asmatrix` does not make a copy if the input is already
+    a matrix or an ndarray.  Equivalent to ``matrix(data, copy=False)``.
+
+    Parameters
+    ----------
+    data : array_like
+        Input data.
+    dtype : data-type
+       Data-type of the output matrix.
+
+    Returns
+    -------
+    mat : matrix
+        `data` interpreted as a matrix.
+
+    Examples
+    --------
+    >>> x = np.array([[1, 2], [3, 4]])
+
+    >>> m = np.asmatrix(x)
+
+    >>> x[0,0] = 5
+
+    >>> m
+    matrix([[5, 2],
+            [3, 4]])
+
+    " :arglists '[[data & [{dtype :dtype}]] [data]])
+
+(def matmul (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "matmul"))))
+(alter-meta! #'matmul assoc :doc "matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Matrix product of two arrays.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays, scalars not allowed.
+out : ndarray, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not
+    provided or None, a freshly-allocated array is returned.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+    .. versionadded:: 1.16
+       Now handles ufunc kwargs
+
+Returns
+-------
+y : ndarray
+    The matrix product of the inputs.
+    This is a scalar only when both x1, x2 are 1-d vectors.
+
+Raises
+------
+ValueError
+    If the last dimension of `a` is not the same size as
+    the second-to-last dimension of `b`.
+
+    If a scalar value is passed in.
+
+See Also
+--------
+vdot : Complex-conjugating dot product.
+tensordot : Sum products over arbitrary axes.
+einsum : Einstein summation convention.
+dot : alternative matrix product with different broadcasting rules.
+
+Notes
+-----
+
+The behavior depends on the arguments in the following way.
+
+- If both arguments are 2-D they are multiplied like conventional
+  matrices.
+- If either argument is N-D, N > 2, it is treated as a stack of
+  matrices residing in the last two indexes and broadcast accordingly.
+- If the first argument is 1-D, it is promoted to a matrix by
+  prepending a 1 to its dimensions. After matrix multiplication
+  the prepended 1 is removed.
+- If the second argument is 1-D, it is promoted to a matrix by
+  appending a 1 to its dimensions. After matrix multiplication
+  the appended 1 is removed.
+
+``matmul`` differs from ``dot`` in two important ways:
+
+- Multiplication by scalars is not allowed, use ``*`` instead.
+- Stacks of matrices are broadcast together as if the matrices
+  were elements, respecting the signature ``(n,k),(k,m)->(n,m)``:
+
+  >>> a = np.ones([9, 5, 7, 4])
+  >>> c = np.ones([9, 5, 4, 3])
+  >>> np.dot(a, c).shape
+  (9, 5, 7, 9, 5, 3)
+  >>> np.matmul(a, c).shape
+  (9, 5, 7, 3)
+  >>> # n is 7, k is 4, m is 3
+
+The matmul function implements the semantics of the `@` operator introduced
+in Python 3.5 following PEP465.
+
+Examples
+--------
+For 2-D arrays it is the matrix product:
+
+>>> a = np.array([[1, 0],
+...               [0, 1]])
+>>> b = np.array([[4, 1],
+...               [2, 2]])
+>>> np.matmul(a, b)
+array([[4, 1],
+       [2, 2]])
+
+For 2-D mixed with 1-D, the result is the usual.
+
+>>> a = np.array([[1, 0],
+...               [0, 1]])
+>>> b = np.array([1, 2])
+>>> np.matmul(a, b)
+array([1, 2])
+>>> np.matmul(b, a)
+array([1, 2])
+
+
+Broadcasting is conventional for stacks of arrays
+
+>>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4))
+>>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2))
+>>> np.matmul(a,b).shape
+(2, 2, 2)
+>>> np.matmul(a, b)[0, 1, 1]
+98
+>>> sum(a[0, 1, :] * b[0 , :, 1])
+98
+
+Vector, vector returns the scalar inner product, but neither argument
+is complex-conjugated:
+
+>>> np.matmul([2j, 3j], [2j, 3j])
+(-13+0j)
+
+Scalar multiplication raises an error.
+
+>>> np.matmul([1,2], 3)
+Traceback (most recent call last):
+...
+ValueError: matmul: Input operand 1 does not have enough dimensions ...
+
+.. versionadded:: 1.10.0" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc "
+Wrapper functions to more user-friendly calling of certain math functions
+whose output data-type is different than the input data-type in certain
+domains of the input.
+
+For example, for functions like `log` with branch cuts, the versions in this
+module provide the mathematically valid answers in the complex plane::
+
+  >>> import math
+  >>> from numpy.lib import scimath
+  >>> scimath.log(-math.exp(1)) == (1+1j*math.pi)
+  True
+
+Similarly, `sqrt`, other base logarithms, `power` and trig functions are
+correctly handled.  See their respective docstrings for specific examples.
+
+"} emath (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "emath"))))
+
+(def mean (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mean"))))
+(alter-meta! #'mean assoc :doc "
+    Compute the arithmetic mean along the specified axis.
+
+    Returns the average of the array elements.  The average is taken over
+    the flattened array by default, otherwise over the specified axis.
+    `float64` intermediate and return values are used for integer inputs.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose mean is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which the means are computed. The default is to
+        compute the mean of the flattened array.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a mean is performed over multiple axes,
+        instead of a single axis or all the axes as before.
+    dtype : data-type, optional
+        Type to use in computing the mean.  For integer inputs, the default
+        is `float64`; for floating point inputs, it is the same as the
+        input dtype.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary.
+        See `ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `mean` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    m : ndarray, see dtype parameter above
+        If `out=None`, returns a new array containing the mean values,
+        otherwise a reference to the output array is returned.
+
+    See Also
+    --------
+    average : Weighted average
+    std, var, nanmean, nanstd, nanvar
+
+    Notes
+    -----
+    The arithmetic mean is the sum of the elements along the axis divided
+    by the number of elements.
+
+    Note that for floating-point input, the mean is computed using the
+    same precision the input has.  Depending on the input data, this can
+    cause the results to be inaccurate, especially for `float32` (see
+    example below).  Specifying a higher-precision accumulator using the
+    `dtype` keyword can alleviate this issue.
+
+    By default, `float16` results are computed using `float32` intermediates
+    for extra precision.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> np.mean(a)
+    2.5
+    >>> np.mean(a, axis=0)
+    array([2., 3.])
+    >>> np.mean(a, axis=1)
+    array([1.5, 3.5])
+
+    In single precision, `mean` can be inaccurate:
+
+    >>> a = np.zeros((2, 512*512), dtype=np.float32)
+    >>> a[0, :] = 1.0
+    >>> a[1, :] = 0.1
+    >>> np.mean(a)
+    0.54999924
+
+    Computing the mean in float64 is more accurate:
+
+    >>> np.mean(a, dtype=np.float64)
+    0.55000000074505806 # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def uint32 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint32"))))
+(alter-meta! #'uint32 assoc :doc "Unsigned integer type, compatible with C ``unsigned int``.
+    Character code: ``'I'``.
+    Canonical name: ``np.uintc``.
+    Alias *on this platform*: ``np.uint32``: 32-bit unsigned integer (0 to 4294967295)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def alltrue (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "alltrue"))))
+(alter-meta! #'alltrue assoc :doc "
+    Check if all elements of input array are true.
+
+    See Also
+    --------
+    numpy.all : Equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def get_array_wrap (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "get_array_wrap"))))
+(alter-meta! #'get_array_wrap assoc :doc "Find the wrapper for the array with the highest priority.
+
+    In case of ties, leftmost wins. If no wrapper is found, return None
+    " :arglists '[[& [args]]])
+
+(def loadtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "loadtxt"))))
+(alter-meta! #'loadtxt assoc :doc "
+    Load data from a text file.
+
+    Each row in the text file must have the same number of values.
+
+    Parameters
+    ----------
+    fname : file, str, or pathlib.Path
+        File, filename, or generator to read.  If the filename extension is
+        ``.gz`` or ``.bz2``, the file is first decompressed. Note that
+        generators should return byte strings.
+    dtype : data-type, optional
+        Data-type of the resulting array; default: float.  If this is a
+        structured data-type, the resulting array will be 1-dimensional, and
+        each row will be interpreted as an element of the array.  In this
+        case, the number of columns used must match the number of fields in
+        the data-type.
+    comments : str or sequence of str, optional
+        The characters or list of characters used to indicate the start of a
+        comment. None implies no comments. For backwards compatibility, byte
+        strings will be decoded as 'latin1'. The default is '#'.
+    delimiter : str, optional
+        The string used to separate values. For backwards compatibility, byte
+        strings will be decoded as 'latin1'. The default is whitespace.
+    converters : dict, optional
+        A dictionary mapping column number to a function that will parse the
+        column string into the desired value.  E.g., if column 0 is a date
+        string: ``converters = {0: datestr2num}``.  Converters can also be
+        used to provide a default value for missing data (but see also
+        `genfromtxt`): ``converters = {3: lambda s: float(s.strip() or 0)}``.
+        Default: None.
+    skiprows : int, optional
+        Skip the first `skiprows` lines, including comments; default: 0.
+    usecols : int or sequence, optional
+        Which columns to read, with 0 being the first. For example,
+        ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns.
+        The default, None, results in all columns being read.
+
+        .. versionchanged:: 1.11.0
+            When a single column has to be read it is possible to use
+            an integer instead of a tuple. E.g ``usecols = 3`` reads the
+            fourth column the same way as ``usecols = (3,)`` would.
+    unpack : bool, optional
+        If True, the returned array is transposed, so that arguments may be
+        unpacked using ``x, y, z = loadtxt(...)``.  When used with a structured
+        data-type, arrays are returned for each field.  Default is False.
+    ndmin : int, optional
+        The returned array will have at least `ndmin` dimensions.
+        Otherwise mono-dimensional axes will be squeezed.
+        Legal values: 0 (default), 1 or 2.
+
+        .. versionadded:: 1.6.0
+    encoding : str, optional
+        Encoding used to decode the inputfile. Does not apply to input streams.
+        The special value 'bytes' enables backward compatibility workarounds
+        that ensures you receive byte arrays as results if possible and passes
+        'latin1' encoded strings to converters. Override this value to receive
+        unicode arrays and pass strings as input to converters.  If set to None
+        the system default is used. The default value is 'bytes'.
+
+        .. versionadded:: 1.14.0
+    max_rows : int, optional
+        Read `max_rows` lines of content after `skiprows` lines. The default
+        is to read all the lines.
+
+        .. versionadded:: 1.16.0
+
+    Returns
+    -------
+    out : ndarray
+        Data read from the text file.
+
+    See Also
+    --------
+    load, fromstring, fromregex
+    genfromtxt : Load data with missing values handled as specified.
+    scipy.io.loadmat : reads MATLAB data files
+
+    Notes
+    -----
+    This function aims to be a fast reader for simply formatted files.  The
+    `genfromtxt` function provides more sophisticated handling of, e.g.,
+    lines with missing values.
+
+    .. versionadded:: 1.10.0
+
+    The strings produced by the Python float.hex method can be used as
+    input for floats.
+
+    Examples
+    --------
+    >>> from io import StringIO   # StringIO behaves like a file object
+    >>> c = StringIO(u\"0 1\\n2 3\")
+    >>> np.loadtxt(c)
+    array([[0., 1.],
+           [2., 3.]])
+
+    >>> d = StringIO(u\"M 21 72\\nF 35 58\")
+    >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),
+    ...                      'formats': ('S1', 'i4', 'f4')})
+    array([(b'M', 21, 72.), (b'F', 35, 58.)],
+          dtype=[('gender', 'S1'), ('age', '<i4'), ('weight', '<f4')])
+
+    >>> c = StringIO(u\"1,0,2\\n3,0,4\")
+    >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)
+    >>> x
+    array([1., 3.])
+    >>> y
+    array([2., 4.])
+
+    " :arglists '[[fname & [{max_rows :max_rows, encoding :encoding, ndmin :ndmin, dtype :dtype, comments :comments, unpack :unpack, converters :converters, delimiter :delimiter, skiprows :skiprows, usecols :usecols}]] [fname & [{encoding :encoding, ndmin :ndmin, dtype :dtype, comments :comments, unpack :unpack, converters :converters, delimiter :delimiter, skiprows :skiprows, usecols :usecols}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols, unpack :unpack, ndmin :ndmin}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols, unpack :unpack}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter}]] [fname & [{dtype :dtype, comments :comments}]] [fname & [{dtype :dtype}]] [fname]])
+
+(def var (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "var"))))
+(alter-meta! #'var assoc :doc "
+    Compute the variance along the specified axis.
+
+    Returns the variance of the array elements, a measure of the spread of a
+    distribution.  The variance is computed for the flattened array by
+    default, otherwise over the specified axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose variance is desired.  If `a` is not an
+        array, a conversion is attempted.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which the variance is computed.  The default is to
+        compute the variance of the flattened array.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a variance is performed over multiple axes,
+        instead of a single axis or all the axes as before.
+    dtype : data-type, optional
+        Type to use in computing the variance.  For arrays of integer type
+        the default is `float64`; for arrays of float types it is the same as
+        the array type.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  It must have
+        the same shape as the expected output, but the type is cast if
+        necessary.
+    ddof : int, optional
+        \"Delta Degrees of Freedom\": the divisor used in the calculation is
+        ``N - ddof``, where ``N`` represents the number of elements. By
+        default `ddof` is zero.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `var` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    variance : ndarray, see dtype parameter above
+        If ``out=None``, returns a new array containing the variance;
+        otherwise, a reference to the output array is returned.
+
+    See Also
+    --------
+    std, mean, nanmean, nanstd, nanvar
+    ufuncs-output-type
+
+    Notes
+    -----
+    The variance is the average of the squared deviations from the mean,
+    i.e.,  ``var = mean(abs(x - x.mean())**2)``.
+
+    The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``.
+    If, however, `ddof` is specified, the divisor ``N - ddof`` is used
+    instead.  In standard statistical practice, ``ddof=1`` provides an
+    unbiased estimator of the variance of a hypothetical infinite population.
+    ``ddof=0`` provides a maximum likelihood estimate of the variance for
+    normally distributed variables.
+
+    Note that for complex numbers, the absolute value is taken before
+    squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the variance is computed using the same
+    precision the input has.  Depending on the input data, this can cause
+    the results to be inaccurate, especially for `float32` (see example
+    below).  Specifying a higher-accuracy accumulator using the ``dtype``
+    keyword can alleviate this issue.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> np.var(a)
+    1.25
+    >>> np.var(a, axis=0)
+    array([1.,  1.])
+    >>> np.var(a, axis=1)
+    array([0.25,  0.25])
+
+    In single precision, var() can be inaccurate:
+
+    >>> a = np.zeros((2, 512*512), dtype=np.float32)
+    >>> a[0, :] = 1.0
+    >>> a[1, :] = 0.1
+    >>> np.var(a)
+    0.20250003
+
+    Computing the variance in float64 is more accurate:
+
+    >>> np.var(a, dtype=np.float64)
+    0.20249999932944759 # may vary
+    >>> ((1-0.55)**2 + (0.1-0.55)**2)/2
+    0.2025
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def take_along_axis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "take_along_axis"))))
+(alter-meta! #'take_along_axis assoc :doc "
+    Take values from the input array by matching 1d index and data slices.
+
+    This iterates over matching 1d slices oriented along the specified axis in
+    the index and data arrays, and uses the former to look up values in the
+    latter. These slices can be different lengths.
+
+    Functions returning an index along an axis, like `argsort` and
+    `argpartition`, produce suitable indices for this function.
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    arr: ndarray (Ni..., M, Nk...)
+        Source array
+    indices: ndarray (Ni..., J, Nk...)
+        Indices to take along each 1d slice of `arr`. This must match the
+        dimension of arr, but dimensions Ni and Nj only need to broadcast
+        against `arr`.
+    axis: int
+        The axis to take 1d slices along. If axis is None, the input array is
+        treated as if it had first been flattened to 1d, for consistency with
+        `sort` and `argsort`.
+
+    Returns
+    -------
+    out: ndarray (Ni..., J, Nk...)
+        The indexed result.
+
+    Notes
+    -----
+    This is equivalent to (but faster than) the following use of `ndindex` and
+    `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::
+
+        Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
+        J = indices.shape[axis]  # Need not equal M
+        out = np.empty(Ni + (J,) + Nk)
+
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                a_1d       = a      [ii + s_[:,] + kk]
+                indices_1d = indices[ii + s_[:,] + kk]
+                out_1d     = out    [ii + s_[:,] + kk]
+                for j in range(J):
+                    out_1d[j] = a_1d[indices_1d[j]]
+
+    Equivalently, eliminating the inner loop, the last two lines would be::
+
+                out_1d[:] = a_1d[indices_1d]
+
+    See Also
+    --------
+    take : Take along an axis, using the same indices for every 1d slice
+    put_along_axis :
+        Put values into the destination array by matching 1d index and data slices
+
+    Examples
+    --------
+
+    For this sample array
+
+    >>> a = np.array([[10, 30, 20], [60, 40, 50]])
+
+    We can sort either by using sort directly, or argsort and this function
+
+    >>> np.sort(a, axis=1)
+    array([[10, 20, 30],
+           [40, 50, 60]])
+    >>> ai = np.argsort(a, axis=1); ai
+    array([[0, 2, 1],
+           [1, 2, 0]])
+    >>> np.take_along_axis(a, ai, axis=1)
+    array([[10, 20, 30],
+           [40, 50, 60]])
+
+    The same works for max and min, if you expand the dimensions:
+
+    >>> np.expand_dims(np.max(a, axis=1), axis=1)
+    array([[30],
+           [60]])
+    >>> ai = np.expand_dims(np.argmax(a, axis=1), axis=1)
+    >>> ai
+    array([[1],
+           [0]])
+    >>> np.take_along_axis(a, ai, axis=1)
+    array([[30],
+           [60]])
+
+    If we want to get the max and min at the same time, we can stack the
+    indices first
+
+    >>> ai_min = np.expand_dims(np.argmin(a, axis=1), axis=1)
+    >>> ai_max = np.expand_dims(np.argmax(a, axis=1), axis=1)
+    >>> ai = np.concatenate([ai_min, ai_max], axis=1)
+    >>> ai
+    array([[0, 1],
+           [1, 0]])
+    >>> np.take_along_axis(a, ai, axis=1)
+    array([[10, 30],
+           [40, 60]])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def prod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "prod"))))
+(alter-meta! #'prod assoc :doc "
+    Return the product of array elements over a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a product is performed.  The default,
+        axis=None, will calculate the product of all the elements in the
+        input array. If axis is negative it counts from the last to the
+        first axis.
+
+        .. versionadded:: 1.7.0
+
+        If axis is a tuple of ints, a product is performed on all of the
+        axes specified in the tuple instead of a single axis or all the
+        axes as before.
+    dtype : dtype, optional
+        The type of the returned array, as well as of the accumulator in
+        which the elements are multiplied.  The dtype of `a` is used by
+        default unless `a` has an integer dtype of less precision than the
+        default platform integer.  In that case, if `a` is signed then the
+        platform integer is used while if `a` is unsigned then an unsigned
+        integer of the same precision as the platform integer is used.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output, but the type of the output
+        values will be cast if necessary.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in the
+        result as dimensions with size one. With this option, the result
+        will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `prod` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+    initial : scalar, optional
+        The starting value for this product. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to include in the product. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    product_along_axis : ndarray, see `dtype` parameter above.
+        An array shaped as `a` but with the specified axis removed.
+        Returns a reference to `out` if specified.
+
+    See Also
+    --------
+    ndarray.prod : equivalent method
+    ufuncs-output-type
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.  That means that, on a 32-bit platform:
+
+    >>> x = np.array([536870910, 536870910, 536870910, 536870910])
+    >>> np.prod(x)
+    16 # may vary
+
+    The product of an empty array is the neutral element 1:
+
+    >>> np.prod([])
+    1.0
+
+    Examples
+    --------
+    By default, calculate the product of all elements:
+
+    >>> np.prod([1.,2.])
+    2.0
+
+    Even when the input array is two-dimensional:
+
+    >>> np.prod([[1.,2.],[3.,4.]])
+    24.0
+
+    But we can also specify the axis over which to multiply:
+
+    >>> np.prod([[1.,2.],[3.,4.]], axis=1)
+    array([  2.,  12.])
+
+    Or select specific elements to include:
+
+    >>> np.prod([1., np.nan, 3.], where=[True, False, True])
+    3.0
+
+    If the type of `x` is unsigned, then the output type is
+    the unsigned platform integer:
+
+    >>> x = np.array([1, 2, 3], dtype=np.uint8)
+    >>> np.prod(x).dtype == np.uint
+    True
+
+    If `x` is of a signed integer type, then the output type
+    is the default platform integer:
+
+    >>> x = np.array([1, 2, 3], dtype=np.int8)
+    >>> np.prod(x).dtype == int
+    True
+
+    You can also start the product with a value other than one:
+
+    >>> np.prod([1, 2], initial=5)
+    10
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def load (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "load"))))
+(alter-meta! #'load assoc :doc "
+    Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.
+
+    .. warning:: Loading files that contain object arrays uses the ``pickle``
+                 module, which is not secure against erroneous or maliciously
+                 constructed data. Consider passing ``allow_pickle=False`` to
+                 load data that is known not to contain object arrays for the
+                 safer handling of untrusted sources.
+
+    Parameters
+    ----------
+    file : file-like object, string, or pathlib.Path
+        The file to read. File-like objects must support the
+        ``seek()`` and ``read()`` methods. Pickled files require that the
+        file-like object support the ``readline()`` method as well.
+    mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional
+        If not None, then memory-map the file, using the given mode (see
+        `numpy.memmap` for a detailed description of the modes).  A
+        memory-mapped array is kept on disk. However, it can be accessed
+        and sliced like any ndarray.  Memory mapping is especially useful
+        for accessing small fragments of large files without reading the
+        entire file into memory.
+    allow_pickle : bool, optional
+        Allow loading pickled object arrays stored in npy files. Reasons for
+        disallowing pickles include security, as loading pickled data can
+        execute arbitrary code. If pickles are disallowed, loading object
+        arrays will fail. Default: False
+
+        .. versionchanged:: 1.16.3
+            Made default False in response to CVE-2019-6446.
+
+    fix_imports : bool, optional
+        Only useful when loading Python 2 generated pickled files on Python 3,
+        which includes npy/npz files containing object arrays. If `fix_imports`
+        is True, pickle will try to map the old Python 2 names to the new names
+        used in Python 3.
+    encoding : str, optional
+        What encoding to use when reading Python 2 strings. Only useful when
+        loading Python 2 generated pickled files in Python 3, which includes
+        npy/npz files containing object arrays. Values other than 'latin1',
+        'ASCII', and 'bytes' are not allowed, as they can corrupt numerical
+        data. Default: 'ASCII'
+
+    Returns
+    -------
+    result : array, tuple, dict, etc.
+        Data stored in the file. For ``.npz`` files, the returned instance
+        of NpzFile class must be closed to avoid leaking file descriptors.
+
+    Raises
+    ------
+    IOError
+        If the input file does not exist or cannot be read.
+    ValueError
+        The file contains an object array, but allow_pickle=False given.
+
+    See Also
+    --------
+    save, savez, savez_compressed, loadtxt
+    memmap : Create a memory-map to an array stored in a file on disk.
+    lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.
+
+    Notes
+    -----
+    - If the file contains pickle data, then whatever object is stored
+      in the pickle is returned.
+    - If the file is a ``.npy`` file, then a single array is returned.
+    - If the file is a ``.npz`` file, then a dictionary-like object is
+      returned, containing ``{filename: array}`` key-value pairs, one for
+      each file in the archive.
+    - If the file is a ``.npz`` file, the returned value supports the
+      context manager protocol in a similar fashion to the open function::
+
+        with load('foo.npz') as data:
+            a = data['a']
+
+      The underlying file descriptor is closed when exiting the 'with'
+      block.
+
+    Examples
+    --------
+    Store data to disk, and load it again:
+
+    >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]]))
+    >>> np.load('/tmp/123.npy')
+    array([[1, 2, 3],
+           [4, 5, 6]])
+
+    Store compressed data to disk, and load it again:
+
+    >>> a=np.array([[1, 2, 3], [4, 5, 6]])
+    >>> b=np.array([1, 2])
+    >>> np.savez('/tmp/123.npz', a=a, b=b)
+    >>> data = np.load('/tmp/123.npz')
+    >>> data['a']
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> data['b']
+    array([1, 2])
+    >>> data.close()
+
+    Mem-map the stored array, and then access the second row
+    directly from disk:
+
+    >>> X = np.load('/tmp/123.npy', mmap_mode='r')
+    >>> X[1, :]
+    memmap([4, 5, 6])
+
+    " :arglists '[[file & [{mmap_mode :mmap_mode, allow_pickle :allow_pickle, fix_imports :fix_imports, encoding :encoding}]] [file & [{mmap_mode :mmap_mode, allow_pickle :allow_pickle, fix_imports :fix_imports}]] [file & [{mmap_mode :mmap_mode, allow_pickle :allow_pickle}]] [file & [{mmap_mode :mmap_mode}]] [file]])
+
+(def sum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sum"))))
+(alter-meta! #'sum assoc :doc "
+    Sum of array elements over a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Elements to sum.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a sum is performed.  The default,
+        axis=None, will sum all of the elements of the input array.  If
+        axis is negative it counts from the last to the first axis.
+
+        .. versionadded:: 1.7.0
+
+        If axis is a tuple of ints, a sum is performed on all of the axes
+        specified in the tuple instead of a single axis or all the axes as
+        before.
+    dtype : dtype, optional
+        The type of the returned array and of the accumulator in which the
+        elements are summed.  The dtype of `a` is used by default unless `a`
+        has an integer dtype of less precision than the default platform
+        integer.  In that case, if `a` is signed then the platform integer
+        is used while if `a` is unsigned then an unsigned integer of the
+        same precision as the platform integer is used.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output, but the type of the output
+        values will be cast if necessary.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `sum` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+    initial : scalar, optional
+        Starting value for the sum. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to include in the sum. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    sum_along_axis : ndarray
+        An array with the same shape as `a`, with the specified
+        axis removed.   If `a` is a 0-d array, or if `axis` is None, a scalar
+        is returned.  If an output array is specified, a reference to
+        `out` is returned.
+
+    See Also
+    --------
+    ndarray.sum : Equivalent method.
+
+    add.reduce : Equivalent functionality of `add`.
+
+    cumsum : Cumulative sum of array elements.
+
+    trapz : Integration of array values using the composite trapezoidal rule.
+
+    mean, average
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.
+
+    The sum of an empty array is the neutral element 0:
+
+    >>> np.sum([])
+    0.0
+
+    For floating point numbers the numerical precision of sum (and
+    ``np.add.reduce``) is in general limited by directly adding each number
+    individually to the result causing rounding errors in every step.
+    However, often numpy will use a  numerically better approach (partial
+    pairwise summation) leading to improved precision in many use-cases.
+    This improved precision is always provided when no ``axis`` is given.
+    When ``axis`` is given, it will depend on which axis is summed.
+    Technically, to provide the best speed possible, the improved precision
+    is only used when the summation is along the fast axis in memory.
+    Note that the exact precision may vary depending on other parameters.
+    In contrast to NumPy, Python's ``math.fsum`` function uses a slower but
+    more precise approach to summation.
+    Especially when summing a large number of lower precision floating point
+    numbers, such as ``float32``, numerical errors can become significant.
+    In such cases it can be advisable to use `dtype=\"float64\"` to use a higher
+    precision for the output.
+
+    Examples
+    --------
+    >>> np.sum([0.5, 1.5])
+    2.0
+    >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)
+    1
+    >>> np.sum([[0, 1], [0, 5]])
+    6
+    >>> np.sum([[0, 1], [0, 5]], axis=0)
+    array([0, 6])
+    >>> np.sum([[0, 1], [0, 5]], axis=1)
+    array([1, 5])
+    >>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1)
+    array([1., 5.])
+
+    If the accumulator is too small, overflow occurs:
+
+    >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8)
+    -128
+
+    You can also start the sum with a value other than zero:
+
+    >>> np.sum([10], initial=5)
+    15
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def str (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "str"))))
+(alter-meta! #'str assoc :doc "str(object='') -> str
+str(bytes_or_buffer[, encoding[, errors]]) -> str
+
+Create a new string object from the given object. If encoding or
+errors is specified, then the object must expose a data buffer
+that will be decoded using the given encoding and error handler.
+Otherwise, returns the result of object.__str__() (if defined)
+or repr(object).
+encoding defaults to sys.getdefaultencoding().
+errors defaults to 'strict'." :arglists '[[self & [args {:as kwargs}]]])
+
+(def int64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int64"))))
+(alter-meta! #'int64 assoc :doc "Signed integer type, compatible with Python `int` anc C ``long``.
+    Character code: ``'l'``.
+    Canonical name: ``np.int_``.
+    Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807).
+    Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def nper (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nper"))))
+(alter-meta! #'nper assoc :doc "
+    Compute the number of periodic payments.
+
+    .. deprecated:: 1.18
+
+       `nper` is deprecated; for details, see NEP 32 [1]_.
+       Use the corresponding function in the numpy-financial library,
+       https://pypi.org/project/numpy-financial.
+
+    :class:`decimal.Decimal` type is not supported.
+
+    Parameters
+    ----------
+    rate : array_like
+        Rate of interest (per period)
+    pmt : array_like
+        Payment
+    pv : array_like
+        Present value
+    fv : array_like, optional
+        Future value
+    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
+        When payments are due ('begin' (1) or 'end' (0))
+
+    Notes
+    -----
+    The number of periods ``nper`` is computed by solving the equation::
+
+     fv + pv*(1+rate)**nper + pmt*(1+rate*when)/rate*((1+rate)**nper-1) = 0
+
+    but if ``rate = 0`` then::
+
+     fv + pv + pmt*nper = 0
+
+    References
+    ----------
+    .. [1] NumPy Enhancement Proposal (NEP) 32,
+       https://numpy.org/neps/nep-0032-remove-financial-functions.html
+
+    Examples
+    --------
+    If you only had $150/month to pay towards the loan, how long would it take
+    to pay-off a loan of $8,000 at 7% annual interest?
+
+    >>> print(np.round(np.nper(0.07/12, -150, 8000), 5))
+    64.07335
+
+    So, over 64 months would be required to pay off the loan.
+
+    The same analysis could be done with several different interest rates
+    and/or payments and/or total amounts to produce an entire table.
+
+    >>> np.nper(*(np.ogrid[0.07/12: 0.08/12: 0.01/12,
+    ...                    -150   : -99     : 50    ,
+    ...                    8000   : 9001    : 1000]))
+    array([[[ 64.07334877,  74.06368256],
+            [108.07548412, 127.99022654]],
+           [[ 66.12443902,  76.87897353],
+            [114.70165583, 137.90124779]]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def issubclass_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issubclass_"))))
+(alter-meta! #'issubclass_ assoc :doc "
+    Determine if a class is a subclass of a second class.
+
+    `issubclass_` is equivalent to the Python built-in ``issubclass``,
+    except that it returns False instead of raising a TypeError if one
+    of the arguments is not a class.
+
+    Parameters
+    ----------
+    arg1 : class
+        Input class. True is returned if `arg1` is a subclass of `arg2`.
+    arg2 : class or tuple of classes.
+        Input class. If a tuple of classes, True is returned if `arg1` is a
+        subclass of any of the tuple elements.
+
+    Returns
+    -------
+    out : bool
+        Whether `arg1` is a subclass of `arg2` or not.
+
+    See Also
+    --------
+    issubsctype, issubdtype, issctype
+
+    Examples
+    --------
+    >>> np.issubclass_(np.int32, int)
+    False # True on Python 2.7
+    >>> np.issubclass_(np.int32, float)
+    False
+
+    " :arglists '[[arg1 arg2]])
+
+(def long (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "long"))))
+(alter-meta! #'long assoc :doc "int([x]) -> integer
+int(x, base=10) -> integer
+
+Convert a number or string to an integer, or return 0 if no arguments
+are given.  If x is a number, return x.__int__().  For floating point
+numbers, this truncates towards zero.
+
+If x is not a number or if base is given, then x must be a string,
+bytes, or bytearray instance representing an integer literal in the
+given base.  The literal can be preceded by '+' or '-' and be surrounded
+by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
+Base 0 means to interpret the base from the string as an integer literal.
+>>> int('0b100', base=0)
+4" :arglists '[[self & [args {:as kwargs}]]])
+
+(def longcomplex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longcomplex"))))
+(alter-meta! #'longcomplex assoc :doc "Complex number type composed of two extended-precision floating-point
+    numbers.
+    Character code: ``'G'``.
+    Canonical name: ``np.clongdouble``.
+    Alias: ``np.clongfloat``.
+    Alias: ``np.longcomplex``.
+    Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def dot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dot"))))
+(alter-meta! #'dot assoc :doc "
+    dot(a, b, out=None)
+
+    Dot product of two arrays. Specifically,
+
+    - If both `a` and `b` are 1-D arrays, it is inner product of vectors
+      (without complex conjugation).
+
+    - If both `a` and `b` are 2-D arrays, it is matrix multiplication,
+      but using :func:`matmul` or ``a @ b`` is preferred.
+
+    - If either `a` or `b` is 0-D (scalar), it is equivalent to :func:`multiply`
+      and using ``numpy.multiply(a, b)`` or ``a * b`` is preferred.
+
+    - If `a` is an N-D array and `b` is a 1-D array, it is a sum product over
+      the last axis of `a` and `b`.
+
+    - If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a
+      sum product over the last axis of `a` and the second-to-last axis of `b`::
+
+        dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
+
+    Parameters
+    ----------
+    a : array_like
+        First argument.
+    b : array_like
+        Second argument.
+    out : ndarray, optional
+        Output argument. This must have the exact kind that would be returned
+        if it was not used. In particular, it must have the right type, must be
+        C-contiguous, and its dtype must be the dtype that would be returned
+        for `dot(a,b)`. This is a performance feature. Therefore, if these
+        conditions are not met, an exception is raised, instead of attempting
+        to be flexible.
+
+    Returns
+    -------
+    output : ndarray
+        Returns the dot product of `a` and `b`.  If `a` and `b` are both
+        scalars or both 1-D arrays then a scalar is returned; otherwise
+        an array is returned.
+        If `out` is given, then it is returned.
+
+    Raises
+    ------
+    ValueError
+        If the last dimension of `a` is not the same size as
+        the second-to-last dimension of `b`.
+
+    See Also
+    --------
+    vdot : Complex-conjugating dot product.
+    tensordot : Sum products over arbitrary axes.
+    einsum : Einstein summation convention.
+    matmul : '@' operator as method with out parameter.
+
+    Examples
+    --------
+    >>> np.dot(3, 4)
+    12
+
+    Neither argument is complex-conjugated:
+
+    >>> np.dot([2j, 3j], [2j, 3j])
+    (-13+0j)
+
+    For 2-D arrays it is the matrix product:
+
+    >>> a = [[1, 0], [0, 1]]
+    >>> b = [[4, 1], [2, 2]]
+    >>> np.dot(a, b)
+    array([[4, 1],
+           [2, 2]])
+
+    >>> a = np.arange(3*4*5*6).reshape((3,4,5,6))
+    >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
+    >>> np.dot(a, b)[2,3,2,1,2,2]
+    499128
+    >>> sum(a[2,3,2,:] * b[1,2,:,2])
+    499128
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def fv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fv"))))
+(alter-meta! #'fv assoc :doc "
+    Compute the future value.
+
+    .. deprecated:: 1.18
+
+       `fv` is deprecated; for details, see NEP 32 [1]_.
+       Use the corresponding function in the numpy-financial library,
+       https://pypi.org/project/numpy-financial.
+
+    Given:
+     * a present value, `pv`
+     * an interest `rate` compounded once per period, of which
+       there are
+     * `nper` total
+     * a (fixed) payment, `pmt`, paid either
+     * at the beginning (`when` = {'begin', 1}) or the end
+       (`when` = {'end', 0}) of each period
+
+    Return:
+       the value at the end of the `nper` periods
+
+    Parameters
+    ----------
+    rate : scalar or array_like of shape(M, )
+        Rate of interest as decimal (not per cent) per period
+    nper : scalar or array_like of shape(M, )
+        Number of compounding periods
+    pmt : scalar or array_like of shape(M, )
+        Payment
+    pv : scalar or array_like of shape(M, )
+        Present value
+    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
+        When payments are due ('begin' (1) or 'end' (0)).
+        Defaults to {'end', 0}.
+
+    Returns
+    -------
+    out : ndarray
+        Future values.  If all input is scalar, returns a scalar float.  If
+        any input is array_like, returns future values for each input element.
+        If multiple inputs are array_like, they all must have the same shape.
+
+    Notes
+    -----
+    The future value is computed by solving the equation::
+
+     fv +
+     pv*(1+rate)**nper +
+     pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) == 0
+
+    or, when ``rate == 0``::
+
+     fv + pv + pmt * nper == 0
+
+    References
+    ----------
+    .. [1] NumPy Enhancement Proposal (NEP) 32,
+       https://numpy.org/neps/nep-0032-remove-financial-functions.html
+    .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).
+       Open Document Format for Office Applications (OpenDocument)v1.2,
+       Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,
+       Pre-Draft 12. Organization for the Advancement of Structured Information
+       Standards (OASIS). Billerica, MA, USA. [ODT Document].
+       Available:
+       http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula
+       OpenDocument-formula-20090508.odt
+
+
+    Examples
+    --------
+    What is the future value after 10 years of saving $100 now, with
+    an additional monthly savings of $100.  Assume the interest rate is
+    5% (annually) compounded monthly?
+
+    >>> np.fv(0.05/12, 10*12, -100, -100)
+    15692.928894335748
+
+    By convention, the negative sign represents cash flow out (i.e. money not
+    available today).  Thus, saving $100 a month at 5% annual interest leads
+    to $15,692.93 available to spend in 10 years.
+
+    If any input is array_like, returns an array of equal shape.  Let's
+    compare different interest rates from the example above.
+
+    >>> a = np.array((0.05, 0.06, 0.07))/12
+    >>> np.fv(a, 10*12, -100, -100)
+    array([ 15692.92889434,  16569.87435405,  17509.44688102]) # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def trace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trace"))))
+(alter-meta! #'trace assoc :doc "
+    Return the sum along diagonals of the array.
+
+    If `a` is 2-D, the sum along its diagonal with the given offset
+    is returned, i.e., the sum of elements ``a[i,i+offset]`` for all i.
+
+    If `a` has more than two dimensions, then the axes specified by axis1 and
+    axis2 are used to determine the 2-D sub-arrays whose traces are returned.
+    The shape of the resulting array is the same as that of `a` with `axis1`
+    and `axis2` removed.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, from which the diagonals are taken.
+    offset : int, optional
+        Offset of the diagonal from the main diagonal. Can be both positive
+        and negative. Defaults to 0.
+    axis1, axis2 : int, optional
+        Axes to be used as the first and second axis of the 2-D sub-arrays
+        from which the diagonals should be taken. Defaults are the first two
+        axes of `a`.
+    dtype : dtype, optional
+        Determines the data-type of the returned array and of the accumulator
+        where the elements are summed. If dtype has the value None and `a` is
+        of integer type of precision less than the default integer
+        precision, then the default integer precision is used. Otherwise,
+        the precision is the same as that of `a`.
+    out : ndarray, optional
+        Array into which the output is placed. Its type is preserved and
+        it must be of the right shape to hold the output.
+
+    Returns
+    -------
+    sum_along_diagonals : ndarray
+        If `a` is 2-D, the sum along the diagonal is returned.  If `a` has
+        larger dimensions, then an array of sums along diagonals is returned.
+
+    See Also
+    --------
+    diag, diagonal, diagflat
+
+    Examples
+    --------
+    >>> np.trace(np.eye(3))
+    3.0
+    >>> a = np.arange(8).reshape((2,2,2))
+    >>> np.trace(a)
+    array([6, 8])
+
+    >>> a = np.arange(24).reshape((2,2,2,3))
+    >>> np.trace(a).shape
+    (2, 3)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} BUFSIZE (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "BUFSIZE"))))
+
+(def nanargmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanargmin"))))
+(alter-meta! #'nanargmin assoc :doc "
+    Return the indices of the minimum values in the specified axis ignoring
+    NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the results
+    cannot be trusted if a slice contains only NaNs and Infs.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : int, optional
+        Axis along which to operate.  By default flattened input is used.
+
+    Returns
+    -------
+    index_array : ndarray
+        An array of indices or a single index value.
+
+    See Also
+    --------
+    argmin, nanargmax
+
+    Examples
+    --------
+    >>> a = np.array([[np.nan, 4], [2, 3]])
+    >>> np.argmin(a)
+    0
+    >>> np.nanargmin(a)
+    2
+    >>> np.nanargmin(a, axis=0)
+    array([1, 1])
+    >>> np.nanargmin(a, axis=1)
+    array([1, 0])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def cbrt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cbrt"))))
+(alter-meta! #'cbrt assoc :doc "cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the cube-root of an array, element-wise.
+
+.. versionadded:: 1.10.0
+
+Parameters
+----------
+x : array_like
+    The values whose cube-roots are required.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    An array of the same shape as `x`, containing the cube
+    cube-root of each element in `x`.
+    If `out` was provided, `y` is a reference to it.
+    This is a scalar if `x` is a scalar.
+
+
+Examples
+--------
+>>> np.cbrt([1,8,27])
+array([ 1.,  2.,  3.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def min_scalar_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "min_scalar_type"))))
+(alter-meta! #'min_scalar_type assoc :doc "
+    min_scalar_type(a)
+
+    For scalar ``a``, returns the data type with the smallest size
+    and smallest scalar kind which can hold its value.  For non-scalar
+    array ``a``, returns the vector's dtype unmodified.
+
+    Floating point values are not demoted to integers,
+    and complex values are not demoted to floats.
+
+    Parameters
+    ----------
+    a : scalar or array_like
+        The value whose minimal data type is to be found.
+
+    Returns
+    -------
+    out : dtype
+        The minimal data type.
+
+    Notes
+    -----
+    .. versionadded:: 1.6.0
+
+    See Also
+    --------
+    result_type, promote_types, dtype, can_cast
+
+    Examples
+    --------
+    >>> np.min_scalar_type(10)
+    dtype('uint8')
+
+    >>> np.min_scalar_type(-260)
+    dtype('int16')
+
+    >>> np.min_scalar_type(3.1)
+    dtype('float16')
+
+    >>> np.min_scalar_type(1e50)
+    dtype('float64')
+
+    >>> np.min_scalar_type(np.arange(4,dtype='f8'))
+    dtype('float64')
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def cross (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cross"))))
+(alter-meta! #'cross assoc :doc "
+    Return the cross product of two (arrays of) vectors.
+
+    The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular
+    to both `a` and `b`.  If `a` and `b` are arrays of vectors, the vectors
+    are defined by the last axis of `a` and `b` by default, and these axes
+    can have dimensions 2 or 3.  Where the dimension of either `a` or `b` is
+    2, the third component of the input vector is assumed to be zero and the
+    cross product calculated accordingly.  In cases where both input vectors
+    have dimension 2, the z-component of the cross product is returned.
+
+    Parameters
+    ----------
+    a : array_like
+        Components of the first vector(s).
+    b : array_like
+        Components of the second vector(s).
+    axisa : int, optional
+        Axis of `a` that defines the vector(s).  By default, the last axis.
+    axisb : int, optional
+        Axis of `b` that defines the vector(s).  By default, the last axis.
+    axisc : int, optional
+        Axis of `c` containing the cross product vector(s).  Ignored if
+        both input vectors have dimension 2, as the return is scalar.
+        By default, the last axis.
+    axis : int, optional
+        If defined, the axis of `a`, `b` and `c` that defines the vector(s)
+        and cross product(s).  Overrides `axisa`, `axisb` and `axisc`.
+
+    Returns
+    -------
+    c : ndarray
+        Vector cross product(s).
+
+    Raises
+    ------
+    ValueError
+        When the dimension of the vector(s) in `a` and/or `b` does not
+        equal 2 or 3.
+
+    See Also
+    --------
+    inner : Inner product
+    outer : Outer product.
+    ix_ : Construct index arrays.
+
+    Notes
+    -----
+    .. versionadded:: 1.9.0
+
+    Supports full broadcasting of the inputs.
+
+    Examples
+    --------
+    Vector cross-product.
+
+    >>> x = [1, 2, 3]
+    >>> y = [4, 5, 6]
+    >>> np.cross(x, y)
+    array([-3,  6, -3])
+
+    One vector with dimension 2.
+
+    >>> x = [1, 2]
+    >>> y = [4, 5, 6]
+    >>> np.cross(x, y)
+    array([12, -6, -3])
+
+    Equivalently:
+
+    >>> x = [1, 2, 0]
+    >>> y = [4, 5, 6]
+    >>> np.cross(x, y)
+    array([12, -6, -3])
+
+    Both vectors with dimension 2.
+
+    >>> x = [1,2]
+    >>> y = [4,5]
+    >>> np.cross(x, y)
+    array(-3)
+
+    Multiple vector cross-products. Note that the direction of the cross
+    product vector is defined by the `right-hand rule`.
+
+    >>> x = np.array([[1,2,3], [4,5,6]])
+    >>> y = np.array([[4,5,6], [1,2,3]])
+    >>> np.cross(x, y)
+    array([[-3,  6, -3],
+           [ 3, -6,  3]])
+
+    The orientation of `c` can be changed using the `axisc` keyword.
+
+    >>> np.cross(x, y, axisc=0)
+    array([[-3,  3],
+           [ 6, -6],
+           [-3,  3]])
+
+    Change the vector definition of `x` and `y` using `axisa` and `axisb`.
+
+    >>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]])
+    >>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]])
+    >>> np.cross(x, y)
+    array([[ -6,  12,  -6],
+           [  0,   0,   0],
+           [  6, -12,   6]])
+    >>> np.cross(x, y, axisa=0, axisb=0)
+    array([[-24,  48, -24],
+           [-30,  60, -30],
+           [-36,  72, -36]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "Capsule objects let you wrap a C \"void *\" pointer in a Python
+object.  They're a way of passing data through the Python interpreter
+without creating your own custom type.
+
+Capsules are used for communication between extension modules.
+They provide a way for an extension module to export a C interface
+to other extension modules, so that extension modules can use the
+Python import mechanism to link to one another.
+"} _UFUNC_API (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_UFUNC_API"))))
+
+(def mintypecode (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mintypecode"))))
+(alter-meta! #'mintypecode assoc :doc "
+    Return the character for the minimum-size type to which given types can
+    be safely cast.
+
+    The returned type character must represent the smallest size dtype such
+    that an array of the returned type can handle the data from an array of
+    all types in `typechars` (or if `typechars` is an array, then its
+    dtype.char).
+
+    Parameters
+    ----------
+    typechars : list of str or array_like
+        If a list of strings, each string should represent a dtype.
+        If array_like, the character representation of the array dtype is used.
+    typeset : str or list of str, optional
+        The set of characters that the returned character is chosen from.
+        The default set is 'GDFgdf'.
+    default : str, optional
+        The default character, this is returned if none of the characters in
+        `typechars` matches a character in `typeset`.
+
+    Returns
+    -------
+    typechar : str
+        The character representing the minimum-size type that was found.
+
+    See Also
+    --------
+    dtype, sctype2char, maximum_sctype
+
+    Examples
+    --------
+    >>> np.mintypecode(['d', 'f', 'S'])
+    'd'
+    >>> x = np.array([1.1, 2-3.j])
+    >>> np.mintypecode(x)
+    'D'
+
+    >>> np.mintypecode('abceh', default='G')
+    'G'
+
+    " :arglists '[[typechars & [{typeset :typeset, default :default}]] [typechars & [{typeset :typeset}]] [typechars]])
+
+(def cumprod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cumprod"))))
+(alter-meta! #'cumprod assoc :doc "
+    Return the cumulative product of elements along a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        Axis along which the cumulative product is computed.  By default
+        the input is flattened.
+    dtype : dtype, optional
+        Type of the returned array, as well as of the accumulator in which
+        the elements are multiplied.  If *dtype* is not specified, it
+        defaults to the dtype of `a`, unless `a` has an integer dtype with
+        a precision less than that of the default platform integer.  In
+        that case, the default platform integer is used instead.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type of the resulting values will be cast if necessary.
+
+    Returns
+    -------
+    cumprod : ndarray
+        A new array holding the result is returned unless `out` is
+        specified, in which case a reference to out is returned.
+
+    See Also
+    --------
+    ufuncs-output-type
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.
+
+    Examples
+    --------
+    >>> a = np.array([1,2,3])
+    >>> np.cumprod(a) # intermediate results 1, 1*2
+    ...               # total product 1*2*3 = 6
+    array([1, 2, 6])
+    >>> a = np.array([[1, 2, 3], [4, 5, 6]])
+    >>> np.cumprod(a, dtype=float) # specify type of output
+    array([   1.,    2.,    6.,   24.,  120.,  720.])
+
+    The cumulative product for each column (i.e., over the rows) of `a`:
+
+    >>> np.cumprod(a, axis=0)
+    array([[ 1,  2,  3],
+           [ 4, 10, 18]])
+
+    The cumulative product for each row (i.e. over the columns) of `a`:
+
+    >>> np.cumprod(a,axis=1)
+    array([[  1,   2,   6],
+           [  4,  20, 120]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def repeat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "repeat"))))
+(alter-meta! #'repeat assoc :doc "
+    Repeat elements of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    repeats : int or array of ints
+        The number of repetitions for each element.  `repeats` is broadcasted
+        to fit the shape of the given axis.
+    axis : int, optional
+        The axis along which to repeat values.  By default, use the
+        flattened input array, and return a flat output array.
+
+    Returns
+    -------
+    repeated_array : ndarray
+        Output array which has the same shape as `a`, except along
+        the given axis.
+
+    See Also
+    --------
+    tile : Tile an array.
+
+    Examples
+    --------
+    >>> np.repeat(3, 4)
+    array([3, 3, 3, 3])
+    >>> x = np.array([[1,2],[3,4]])
+    >>> np.repeat(x, 2)
+    array([1, 1, 2, 2, 3, 3, 4, 4])
+    >>> np.repeat(x, 3, axis=1)
+    array([[1, 1, 1, 2, 2, 2],
+           [3, 3, 3, 4, 4, 4]])
+    >>> np.repeat(x, [1, 2], axis=0)
+    array([[1, 2],
+           [3, 4],
+           [3, 4]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def matrix (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "matrix"))))
+(alter-meta! #'matrix assoc :doc "
+    matrix(data, dtype=None, copy=True)
+
+    .. note:: It is no longer recommended to use this class, even for linear
+              algebra. Instead use regular arrays. The class may be removed
+              in the future.
+
+    Returns a matrix from an array-like object, or from a string of data.
+    A matrix is a specialized 2-D array that retains its 2-D nature
+    through operations.  It has certain special operators, such as ``*``
+    (matrix multiplication) and ``**`` (matrix power).
+
+    Parameters
+    ----------
+    data : array_like or string
+       If `data` is a string, it is interpreted as a matrix with commas
+       or spaces separating columns, and semicolons separating rows.
+    dtype : data-type
+       Data-type of the output matrix.
+    copy : bool
+       If `data` is already an `ndarray`, then this flag determines
+       whether the data is copied (the default), or whether a view is
+       constructed.
+
+    See Also
+    --------
+    array
+
+    Examples
+    --------
+    >>> a = np.matrix('1 2; 3 4')
+    >>> a
+    matrix([[1, 2],
+            [3, 4]])
+
+    >>> np.matrix([[1, 2], [3, 4]])
+    matrix([[1, 2],
+            [3, 4]])
+
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def less_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "less_equal"))))
+(alter-meta! #'less_equal assoc :doc "less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the truth value of (x1 =< x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+greater, less, greater_equal, equal, not_equal
+
+Examples
+--------
+>>> np.less_equal([4, 2, 1], [2, 2, 2])
+array([False,  True,  True])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def kaiser (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "kaiser"))))
+(alter-meta! #'kaiser assoc :doc "
+    Return the Kaiser window.
+
+    The Kaiser window is a taper formed by using a Bessel function.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+    beta : float
+        Shape parameter for window.
+
+    Returns
+    -------
+    out : array
+        The window, with the maximum value normalized to one (the value
+        one appears only if the number of samples is odd).
+
+    See Also
+    --------
+    bartlett, blackman, hamming, hanning
+
+    Notes
+    -----
+    The Kaiser window is defined as
+
+    .. math::  w(n) = I_0\\left( \\beta \\sqrt{1-\\frac{4n^2}{(M-1)^2}}
+               \\right)/I_0(\\beta)
+
+    with
+
+    .. math:: \\quad -\\frac{M-1}{2} \\leq n \\leq \\frac{M-1}{2},
+
+    where :math:`I_0` is the modified zeroth-order Bessel function.
+
+    The Kaiser was named for Jim Kaiser, who discovered a simple
+    approximation to the DPSS window based on Bessel functions.  The Kaiser
+    window is a very good approximation to the Digital Prolate Spheroidal
+    Sequence, or Slepian window, which is the transform which maximizes the
+    energy in the main lobe of the window relative to total energy.
+
+    The Kaiser can approximate many other windows by varying the beta
+    parameter.
+
+    ====  =======================
+    beta  Window shape
+    ====  =======================
+    0     Rectangular
+    5     Similar to a Hamming
+    6     Similar to a Hanning
+    8.6   Similar to a Blackman
+    ====  =======================
+
+    A beta value of 14 is probably a good starting point. Note that as beta
+    gets large, the window narrows, and so the number of samples needs to be
+    large enough to sample the increasingly narrow spike, otherwise NaNs will
+    get returned.
+
+    Most references to the Kaiser window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    \"removing the foot\", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function.
+
+    References
+    ----------
+    .. [1] J. F. Kaiser, \"Digital Filters\" - Ch 7 in \"Systems analysis by
+           digital computer\", Editors: F.F. Kuo and J.F. Kaiser, p 218-285.
+           John Wiley and Sons, New York, (1966).
+    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\", The
+           University of Alberta Press, 1975, pp. 177-178.
+    .. [3] Wikipedia, \"Window function\",
+           https://en.wikipedia.org/wiki/Window_function
+
+    Examples
+    --------
+    >>> import matplotlib.pyplot as plt
+    >>> np.kaiser(12, 14)
+     array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary
+            2.29737120e-01, 5.99885316e-01, 9.45674898e-01,
+            9.45674898e-01, 5.99885316e-01, 2.29737120e-01,
+            4.65200189e-02, 3.46009194e-03, 7.72686684e-06])
+
+
+    Plot the window and the frequency response:
+
+    >>> from numpy.fft import fft, fftshift
+    >>> window = np.kaiser(51, 14)
+    >>> plt.plot(window)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Kaiser window\")
+    Text(0.5, 1.0, 'Kaiser window')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"Sample\")
+    Text(0.5, 0, 'Sample')
+    >>> plt.show()
+
+    >>> plt.figure()
+    <Figure size 640x480 with 0 Axes>
+    >>> A = fft(window, 2048) / 25.5
+    >>> mag = np.abs(fftshift(A))
+    >>> freq = np.linspace(-0.5, 0.5, len(A))
+    >>> response = 20 * np.log10(mag)
+    >>> response = np.clip(response, -100, 100)
+    >>> plt.plot(freq, response)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Frequency response of Kaiser window\")
+    Text(0.5, 1.0, 'Frequency response of Kaiser window')
+    >>> plt.ylabel(\"Magnitude [dB]\")
+    Text(0, 0.5, 'Magnitude [dB]')
+    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
+    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
+    >>> plt.axis('tight')
+    (-0.5, 0.5, -100.0, ...) # may vary
+    >>> plt.show()
+
+    " :arglists '[[M beta]])
+
+(def add_newdoc_ufunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add_newdoc_ufunc"))))
+(alter-meta! #'add_newdoc_ufunc assoc :doc "add_ufunc_docstring(ufunc, new_docstring)
+
+    Replace the docstring for a ufunc with new_docstring.
+    This method will only work if the current docstring for
+    the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)
+
+    Parameters
+    ----------
+    ufunc : numpy.ufunc
+        A ufunc whose current doc is NULL.
+    new_docstring : string
+        The new docstring for the ufunc.
+
+    Notes
+    -----
+    This method allocates memory for new_docstring on
+    the heap. Technically this creates a mempory leak, since this
+    memory will not be reclaimed until the end of the program
+    even if the ufunc itself is removed. However this will only
+    be a problem if the user is repeatedly creating ufuncs with
+    no documentation, adding documentation via add_newdoc_ufunc,
+    and then throwing away the ufunc." :arglists '[[self & [args {:as kwargs}]]])
+
+(def memmap (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "memmap"))))
+(alter-meta! #'memmap assoc :doc "Create a memory-map to an array stored in a *binary* file on disk.
+
+    Memory-mapped files are used for accessing small segments of large files
+    on disk, without reading the entire file into memory.  NumPy's
+    memmap's are array-like objects.  This differs from Python's ``mmap``
+    module, which uses file-like objects.
+
+    This subclass of ndarray has some unpleasant interactions with
+    some operations, because it doesn't quite fit properly as a subclass.
+    An alternative to using this subclass is to create the ``mmap``
+    object yourself, then create an ndarray with ndarray.__new__ directly,
+    passing the object created in its 'buffer=' parameter.
+
+    This class may at some point be turned into a factory function
+    which returns a view into an mmap buffer.
+
+    Delete the memmap instance to close the memmap file.
+
+
+    Parameters
+    ----------
+    filename : str, file-like object, or pathlib.Path instance
+        The file name or file object to be used as the array data buffer.
+    dtype : data-type, optional
+        The data-type used to interpret the file contents.
+        Default is `uint8`.
+    mode : {'r+', 'r', 'w+', 'c'}, optional
+        The file is opened in this mode:
+
+        +------+-------------------------------------------------------------+
+        | 'r'  | Open existing file for reading only.                        |
+        +------+-------------------------------------------------------------+
+        | 'r+' | Open existing file for reading and writing.                 |
+        +------+-------------------------------------------------------------+
+        | 'w+' | Create or overwrite existing file for reading and writing.  |
+        +------+-------------------------------------------------------------+
+        | 'c'  | Copy-on-write: assignments affect data in memory, but       |
+        |      | changes are not saved to disk.  The file on disk is         |
+        |      | read-only.                                                  |
+        +------+-------------------------------------------------------------+
+
+        Default is 'r+'.
+    offset : int, optional
+        In the file, array data starts at this offset. Since `offset` is
+        measured in bytes, it should normally be a multiple of the byte-size
+        of `dtype`. When ``mode != 'r'``, even positive offsets beyond end of
+        file are valid; The file will be extended to accommodate the
+        additional data. By default, ``memmap`` will start at the beginning of
+        the file, even if ``filename`` is a file pointer ``fp`` and
+        ``fp.tell() != 0``.
+    shape : tuple, optional
+        The desired shape of the array. If ``mode == 'r'`` and the number
+        of remaining bytes after `offset` is not a multiple of the byte-size
+        of `dtype`, you must specify `shape`. By default, the returned array
+        will be 1-D with the number of elements determined by file size
+        and data-type.
+    order : {'C', 'F'}, optional
+        Specify the order of the ndarray memory layout:
+        :term:`row-major`, C-style or :term:`column-major`,
+        Fortran-style.  This only has an effect if the shape is
+        greater than 1-D.  The default order is 'C'.
+
+    Attributes
+    ----------
+    filename : str or pathlib.Path instance
+        Path to the mapped file.
+    offset : int
+        Offset position in the file.
+    mode : str
+        File mode.
+
+    Methods
+    -------
+    flush
+        Flush any changes in memory to file on disk.
+        When you delete a memmap object, flush is called first to write
+        changes to disk before removing the object.
+
+
+    See also
+    --------
+    lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.
+
+    Notes
+    -----
+    The memmap object can be used anywhere an ndarray is accepted.
+    Given a memmap ``fp``, ``isinstance(fp, numpy.ndarray)`` returns
+    ``True``.
+    
+    Memory-mapped files cannot be larger than 2GB on 32-bit systems.
+
+    When a memmap causes a file to be created or extended beyond its
+    current size in the filesystem, the contents of the new part are
+    unspecified. On systems with POSIX filesystem semantics, the extended
+    part will be filled with zero bytes.
+
+    Examples
+    --------
+    >>> data = np.arange(12, dtype='float32')
+    >>> data.resize((3,4))
+
+    This example uses a temporary file so that doctest doesn't write
+    files to your directory. You would use a 'normal' filename.
+
+    >>> from tempfile import mkdtemp
+    >>> import os.path as path
+    >>> filename = path.join(mkdtemp(), 'newfile.dat')
+
+    Create a memmap with dtype and shape that matches our data:
+
+    >>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4))
+    >>> fp
+    memmap([[0., 0., 0., 0.],
+            [0., 0., 0., 0.],
+            [0., 0., 0., 0.]], dtype=float32)
+
+    Write data to memmap array:
+
+    >>> fp[:] = data[:]
+    >>> fp
+    memmap([[  0.,   1.,   2.,   3.],
+            [  4.,   5.,   6.,   7.],
+            [  8.,   9.,  10.,  11.]], dtype=float32)
+
+    >>> fp.filename == path.abspath(filename)
+    True
+
+    Deletion flushes memory changes to disk before removing the object:
+
+    >>> del fp
+
+    Load the memmap and verify data was stored:
+
+    >>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
+    >>> newfp
+    memmap([[  0.,   1.,   2.,   3.],
+            [  4.,   5.,   6.,   7.],
+            [  8.,   9.,  10.,  11.]], dtype=float32)
+
+    Read-only memmap:
+
+    >>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
+    >>> fpr.flags.writeable
+    False
+
+    Copy-on-write memmap:
+
+    >>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4))
+    >>> fpc.flags.writeable
+    True
+
+    It's possible to assign to copy-on-write array, but values are only
+    written into the memory copy of the array, and not written to disk:
+
+    >>> fpc
+    memmap([[  0.,   1.,   2.,   3.],
+            [  4.,   5.,   6.,   7.],
+            [  8.,   9.,  10.,  11.]], dtype=float32)
+    >>> fpc[0,:] = 0
+    >>> fpc
+    memmap([[  0.,   0.,   0.,   0.],
+            [  4.,   5.,   6.,   7.],
+            [  8.,   9.,  10.,  11.]], dtype=float32)
+
+    File on disk is unchanged:
+
+    >>> fpr
+    memmap([[  0.,   1.,   2.,   3.],
+            [  4.,   5.,   6.,   7.],
+            [  8.,   9.,  10.,  11.]], dtype=float32)
+
+    Offset into a memmap:
+
+    >>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16)
+    >>> fpo
+    memmap([  4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.], dtype=float32)
+
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} RAISE (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "RAISE"))))
+
+(def nonzero (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nonzero"))))
+(alter-meta! #'nonzero assoc :doc "
+    Return the indices of the elements that are non-zero.
+
+    Returns a tuple of arrays, one for each dimension of `a`,
+    containing the indices of the non-zero elements in that
+    dimension. The values in `a` are always tested and returned in
+    row-major, C-style order.
+
+    To group the indices by element, rather than dimension, use `argwhere`,
+    which returns a row for each non-zero element.
+
+    .. note::
+
+       When called on a zero-d array or scalar, ``nonzero(a)`` is treated
+       as ``nonzero(atleast1d(a))``.
+
+       .. deprecated:: 1.17.0
+
+          Use `atleast1d` explicitly if this behavior is deliberate.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+
+    Returns
+    -------
+    tuple_of_arrays : tuple
+        Indices of elements that are non-zero.
+
+    See Also
+    --------
+    flatnonzero :
+        Return indices that are non-zero in the flattened version of the input
+        array.
+    ndarray.nonzero :
+        Equivalent ndarray method.
+    count_nonzero :
+        Counts the number of non-zero elements in the input array.
+
+    Notes
+    -----
+    While the nonzero values can be obtained with ``a[nonzero(a)]``, it is
+    recommended to use ``x[x.astype(bool)]`` or ``x[x != 0]`` instead, which
+    will correctly handle 0-d arrays.
+
+    Examples
+    --------
+    >>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
+    >>> x
+    array([[3, 0, 0],
+           [0, 4, 0],
+           [5, 6, 0]])
+    >>> np.nonzero(x)
+    (array([0, 1, 2, 2]), array([0, 1, 0, 1]))
+
+    >>> x[np.nonzero(x)]
+    array([3, 4, 5, 6])
+    >>> np.transpose(np.nonzero(x))
+    array([[0, 0],
+           [1, 1],
+           [2, 0],
+           [2, 1]])
+
+    A common use for ``nonzero`` is to find the indices of an array, where
+    a condition is True.  Given an array `a`, the condition `a` > 3 is a
+    boolean array and since False is interpreted as 0, np.nonzero(a > 3)
+    yields the indices of the `a` where the condition is true.
+
+    >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    >>> a > 3
+    array([[False, False, False],
+           [ True,  True,  True],
+           [ True,  True,  True]])
+    >>> np.nonzero(a > 3)
+    (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
+
+    Using this result to index `a` is equivalent to using the mask directly:
+
+    >>> a[np.nonzero(a > 3)]
+    array([4, 5, 6, 7, 8, 9])
+    >>> a[a > 3]  # prefer this spelling
+    array([4, 5, 6, 7, 8, 9])
+
+    ``nonzero`` can also be called as a method of the array.
+
+    >>> (a > 3).nonzero()
+    (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "Concrete implementation of SourceLoader using the file system."} __loader__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__loader__"))))
+
+(def rollaxis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rollaxis"))))
+(alter-meta! #'rollaxis assoc :doc "
+    Roll the specified axis backwards, until it lies in a given position.
+
+    This function continues to be supported for backward compatibility, but you
+    should prefer `moveaxis`. The `moveaxis` function was added in NumPy
+    1.11.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input array.
+    axis : int
+        The axis to roll backwards.  The positions of the other axes do not
+        change relative to one another.
+    start : int, optional
+        The axis is rolled until it lies before this position.  The default,
+        0, results in a \"complete\" roll.
+
+    Returns
+    -------
+    res : ndarray
+        For NumPy >= 1.10.0 a view of `a` is always returned. For earlier
+        NumPy versions a view of `a` is returned only if the order of the
+        axes is changed, otherwise the input array is returned.
+
+    See Also
+    --------
+    moveaxis : Move array axes to new positions.
+    roll : Roll the elements of an array by a number of positions along a
+        given axis.
+
+    Examples
+    --------
+    >>> a = np.ones((3,4,5,6))
+    >>> np.rollaxis(a, 3, 1).shape
+    (3, 6, 4, 5)
+    >>> np.rollaxis(a, 2).shape
+    (5, 3, 4, 6)
+    >>> np.rollaxis(a, 1, 4).shape
+    (3, 5, 6, 4)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ppmt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ppmt"))))
+(alter-meta! #'ppmt assoc :doc "
+    Compute the payment against loan principal.
+
+    .. deprecated:: 1.18
+
+       `ppmt` is deprecated; for details, see NEP 32 [1]_.
+       Use the corresponding function in the numpy-financial library,
+       https://pypi.org/project/numpy-financial.
+
+    Parameters
+    ----------
+    rate : array_like
+        Rate of interest (per period)
+    per : array_like, int
+        Amount paid against the loan changes.  The `per` is the period of
+        interest.
+    nper : array_like
+        Number of compounding periods
+    pv : array_like
+        Present value
+    fv : array_like, optional
+        Future value
+    when : {{'begin', 1}, {'end', 0}}, {string, int}
+        When payments are due ('begin' (1) or 'end' (0))
+
+    See Also
+    --------
+    pmt, pv, ipmt
+
+    References
+    ----------
+    .. [1] NumPy Enhancement Proposal (NEP) 32,
+       https://numpy.org/neps/nep-0032-remove-financial-functions.html
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} ERR_RAISE (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_RAISE"))))
+
+(def isnat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isnat"))))
+(alter-meta! #'isnat assoc :doc "isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Test element-wise for NaT (not a time) and return result as a boolean array.
+
+.. versionadded:: 1.13.0
+
+Parameters
+----------
+x : array_like
+    Input array with datetime or timedelta data type.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or bool
+    True where ``x`` is NaT, false otherwise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+isnan, isinf, isneginf, isposinf, isfinite
+
+Examples
+--------
+>>> np.isnat(np.datetime64(\"NaT\"))
+True
+>>> np.isnat(np.datetime64(\"2016-01-01\"))
+False
+>>> np.isnat(np.array([\"NaT\", \"2016-01-01\"], dtype=\"datetime64[ns]\"))
+array([ True, False])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def roots (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "roots"))))
+(alter-meta! #'roots assoc :doc "
+    Return the roots of a polynomial with coefficients given in p.
+
+    The values in the rank-1 array `p` are coefficients of a polynomial.
+    If the length of `p` is n+1 then the polynomial is described by::
+
+      p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n]
+
+    Parameters
+    ----------
+    p : array_like
+        Rank-1 array of polynomial coefficients.
+
+    Returns
+    -------
+    out : ndarray
+        An array containing the roots of the polynomial.
+
+    Raises
+    ------
+    ValueError
+        When `p` cannot be converted to a rank-1 array.
+
+    See also
+    --------
+    poly : Find the coefficients of a polynomial with a given sequence
+           of roots.
+    polyval : Compute polynomial values.
+    polyfit : Least squares polynomial fit.
+    poly1d : A one-dimensional polynomial class.
+
+    Notes
+    -----
+    The algorithm relies on computing the eigenvalues of the
+    companion matrix [1]_.
+
+    References
+    ----------
+    .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*.  Cambridge, UK:
+        Cambridge University Press, 1999, pp. 146-7.
+
+    Examples
+    --------
+    >>> coeff = [3.2, 2, 1]
+    >>> np.roots(coeff)
+    array([-0.3125+0.46351241j, -0.3125-0.46351241j])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def max (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "max"))))
+(alter-meta! #'max assoc :doc "
+    Return the maximum of an array or maximum along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to operate.  By default, flattened input is
+        used.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, the maximum is selected over multiple axes,
+        instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternative output array in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+        See `ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `amax` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    initial : scalar, optional
+        The minimum value of an output element. Must be present to allow
+        computation on empty slice. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to compare for the maximum. See `~numpy.ufunc.reduce`
+        for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    amax : ndarray or scalar
+        Maximum of `a`. If `axis` is None, the result is a scalar value.
+        If `axis` is given, the result is an array of dimension
+        ``a.ndim - 1``.
+
+    See Also
+    --------
+    amin :
+        The minimum value of an array along a given axis, propagating any NaNs.
+    nanmax :
+        The maximum value of an array along a given axis, ignoring any NaNs.
+    maximum :
+        Element-wise maximum of two arrays, propagating any NaNs.
+    fmax :
+        Element-wise maximum of two arrays, ignoring any NaNs.
+    argmax :
+        Return the indices of the maximum values.
+
+    nanmin, minimum, fmin
+
+    Notes
+    -----
+    NaN values are propagated, that is if at least one item is NaN, the
+    corresponding max value will be NaN as well. To ignore NaN values
+    (MATLAB behavior), please use nanmax.
+
+    Don't use `amax` for element-wise comparison of 2 arrays; when
+    ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
+    ``amax(a, axis=0)``.
+
+    Examples
+    --------
+    >>> a = np.arange(4).reshape((2,2))
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> np.amax(a)           # Maximum of the flattened array
+    3
+    >>> np.amax(a, axis=0)   # Maxima along the first axis
+    array([2, 3])
+    >>> np.amax(a, axis=1)   # Maxima along the second axis
+    array([1, 3])
+    >>> np.amax(a, where=[False, True], initial=-1, axis=0)
+    array([-1,  3])
+    >>> b = np.arange(5, dtype=float)
+    >>> b[2] = np.NaN
+    >>> np.amax(b)
+    nan
+    >>> np.amax(b, where=~np.isnan(b), initial=-1)
+    4.0
+    >>> np.nanmax(b)
+    4.0
+
+    You can use an initial value to compute the maximum of an empty slice, or
+    to initialize it to a different value:
+
+    >>> np.max([[-50], [10]], axis=-1, initial=0)
+    array([ 0, 10])
+
+    Notice that the initial value is used as one of the elements for which the
+    maximum is determined, unlike for the default argument Python's max
+    function, which is only used for empty iterables.
+
+    >>> np.max([5], initial=6)
+    6
+    >>> max([5], default=6)
+    5
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def info (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "info"))))
+(alter-meta! #'info assoc :doc "
+    Get help information for a function, class, or module.
+
+    Parameters
+    ----------
+    object : object or str, optional
+        Input object or name to get information about. If `object` is a
+        numpy object, its docstring is given. If it is a string, available
+        modules are searched for matching objects.  If None, information
+        about `info` itself is returned.
+    maxwidth : int, optional
+        Printing width.
+    output : file like object, optional
+        File like object that the output is written to, default is
+        ``stdout``.  The object has to be opened in 'w' or 'a' mode.
+    toplevel : str, optional
+        Start search at this level.
+
+    See Also
+    --------
+    source, lookfor
+
+    Notes
+    -----
+    When used interactively with an object, ``np.info(obj)`` is equivalent
+    to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython
+    prompt.
+
+    Examples
+    --------
+    >>> np.info(np.polyval) # doctest: +SKIP
+       polyval(p, x)
+         Evaluate the polynomial p at x.
+         ...
+
+    When using a string for `object` it is possible to get multiple results.
+
+    >>> np.info('fft') # doctest: +SKIP
+         *** Found in numpy ***
+    Core FFT routines
+    ...
+         *** Found in numpy.fft ***
+     fft(a, n=None, axis=-1)
+    ...
+         *** Repeat reference found in numpy.fft.fftpack ***
+         *** Total of 3 references found. ***
+
+    " :arglists '[[& [{object :object, maxwidth :maxwidth, output :output, toplevel :toplevel}]] [& [{object :object, maxwidth :maxwidth, output :output}]] [& [{object :object, maxwidth :maxwidth}]] [& [{object :object}]] []])
+
+(def ^{:doc "
+Compatibility module.
+
+This module contains duplicated code from Python itself or 3rd party
+extensions, which may be included for the following reasons:
+
+  * compatibility
+  * we may only need a small subset of the copied library/module
+
+"} compat (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "compat"))))
+
+(def vsplit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vsplit"))))
+(alter-meta! #'vsplit assoc :doc "
+    Split an array into multiple sub-arrays vertically (row-wise).
+
+    Please refer to the ``split`` documentation.  ``vsplit`` is equivalent
+    to ``split`` with `axis=0` (default), the array is always split along the
+    first axis regardless of the array dimension.
+
+    See Also
+    --------
+    split : Split an array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> x = np.arange(16.0).reshape(4, 4)
+    >>> x
+    array([[ 0.,   1.,   2.,   3.],
+           [ 4.,   5.,   6.,   7.],
+           [ 8.,   9.,  10.,  11.],
+           [12.,  13.,  14.,  15.]])
+    >>> np.vsplit(x, 2)
+    [array([[0., 1., 2., 3.],
+           [4., 5., 6., 7.]]), array([[ 8.,  9., 10., 11.],
+           [12., 13., 14., 15.]])]
+    >>> np.vsplit(x, np.array([3, 6]))
+    [array([[ 0.,  1.,  2.,  3.],
+           [ 4.,  5.,  6.,  7.],
+           [ 8.,  9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([], shape=(0, 4), dtype=float64)]
+
+    With a higher dimensional array the split is still along the first axis.
+
+    >>> x = np.arange(8.0).reshape(2, 2, 2)
+    >>> x
+    array([[[0.,  1.],
+            [2.,  3.]],
+           [[4.,  5.],
+            [6.,  7.]]])
+    >>> np.vsplit(x, 2)
+    [array([[[0., 1.],
+            [2., 3.]]]), array([[[4., 5.],
+            [6., 7.]]])]
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def polysub (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polysub"))))
+(alter-meta! #'polysub assoc :doc "
+    Difference (subtraction) of two polynomials.
+
+    Given two polynomials `a1` and `a2`, returns ``a1 - a2``.
+    `a1` and `a2` can be either array_like sequences of the polynomials'
+    coefficients (including coefficients equal to zero), or `poly1d` objects.
+
+    Parameters
+    ----------
+    a1, a2 : array_like or poly1d
+        Minuend and subtrahend polynomials, respectively.
+
+    Returns
+    -------
+    out : ndarray or poly1d
+        Array or `poly1d` object of the difference polynomial's coefficients.
+
+    See Also
+    --------
+    polyval, polydiv, polymul, polyadd
+
+    Examples
+    --------
+    .. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2)
+
+    >>> np.polysub([2, 10, -2], [3, 10, -4])
+    array([-1,  0,  2])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def array_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_equal"))))
+(alter-meta! #'array_equal assoc :doc "
+    True if two arrays have the same shape and elements, False otherwise.
+
+    Parameters
+    ----------
+    a1, a2 : array_like
+        Input arrays.
+
+    Returns
+    -------
+    b : bool
+        Returns True if the arrays are equal.
+
+    See Also
+    --------
+    allclose: Returns True if two arrays are element-wise equal within a
+              tolerance.
+    array_equiv: Returns True if input arrays are shape consistent and all
+                 elements equal.
+
+    Examples
+    --------
+    >>> np.array_equal([1, 2], [1, 2])
+    True
+    >>> np.array_equal(np.array([1, 2]), np.array([1, 2]))
+    True
+    >>> np.array_equal([1, 2], [1, 2, 3])
+    False
+    >>> np.array_equal([1, 2], [1, 4])
+    False
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def linspace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "linspace"))))
+(alter-meta! #'linspace assoc :doc "
+    Return evenly spaced numbers over a specified interval.
+
+    Returns `num` evenly spaced samples, calculated over the
+    interval [`start`, `stop`].
+
+    The endpoint of the interval can optionally be excluded.
+
+    .. versionchanged:: 1.16.0
+        Non-scalar `start` and `stop` are now supported.
+
+    Parameters
+    ----------
+    start : array_like
+        The starting value of the sequence.
+    stop : array_like
+        The end value of the sequence, unless `endpoint` is set to False.
+        In that case, the sequence consists of all but the last of ``num + 1``
+        evenly spaced samples, so that `stop` is excluded.  Note that the step
+        size changes when `endpoint` is False.
+    num : int, optional
+        Number of samples to generate. Default is 50. Must be non-negative.
+    endpoint : bool, optional
+        If True, `stop` is the last sample. Otherwise, it is not included.
+        Default is True.
+    retstep : bool, optional
+        If True, return (`samples`, `step`), where `step` is the spacing
+        between samples.
+    dtype : dtype, optional
+        The type of the output array.  If `dtype` is not given, infer the data
+        type from the other input arguments.
+
+        .. versionadded:: 1.9.0
+
+    axis : int, optional
+        The axis in the result to store the samples.  Relevant only if start
+        or stop are array-like.  By default (0), the samples will be along a
+        new axis inserted at the beginning. Use -1 to get an axis at the end.
+
+        .. versionadded:: 1.16.0
+
+    Returns
+    -------
+    samples : ndarray
+        There are `num` equally spaced samples in the closed interval
+        ``[start, stop]`` or the half-open interval ``[start, stop)``
+        (depending on whether `endpoint` is True or False).
+    step : float, optional
+        Only returned if `retstep` is True
+
+        Size of spacing between samples.
+
+
+    See Also
+    --------
+    arange : Similar to `linspace`, but uses a step size (instead of the
+             number of samples).
+    geomspace : Similar to `linspace`, but with numbers spaced evenly on a log
+                scale (a geometric progression).
+    logspace : Similar to `geomspace`, but with the end points specified as
+               logarithms.
+
+    Examples
+    --------
+    >>> np.linspace(2.0, 3.0, num=5)
+    array([2.  , 2.25, 2.5 , 2.75, 3.  ])
+    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)
+    array([2. ,  2.2,  2.4,  2.6,  2.8])
+    >>> np.linspace(2.0, 3.0, num=5, retstep=True)
+    (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)
+
+    Graphical illustration:
+
+    >>> import matplotlib.pyplot as plt
+    >>> N = 8
+    >>> y = np.zeros(N)
+    >>> x1 = np.linspace(0, 10, N, endpoint=True)
+    >>> x2 = np.linspace(0, 10, N, endpoint=False)
+    >>> plt.plot(x1, y, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.plot(x2, y + 0.5, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.ylim([-0.5, 1])
+    (-0.5, 1)
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def mat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mat"))))
+(alter-meta! #'mat assoc :doc "
+    Interpret the input as a matrix.
+
+    Unlike `matrix`, `asmatrix` does not make a copy if the input is already
+    a matrix or an ndarray.  Equivalent to ``matrix(data, copy=False)``.
+
+    Parameters
+    ----------
+    data : array_like
+        Input data.
+    dtype : data-type
+       Data-type of the output matrix.
+
+    Returns
+    -------
+    mat : matrix
+        `data` interpreted as a matrix.
+
+    Examples
+    --------
+    >>> x = np.array([[1, 2], [3, 4]])
+
+    >>> m = np.asmatrix(x)
+
+    >>> x[0,0] = 5
+
+    >>> m
+    matrix([[5, 2],
+            [3, 4]])
+
+    " :arglists '[[data & [{dtype :dtype}]] [data]])
+
+(def frombuffer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "frombuffer"))))
+(alter-meta! #'frombuffer assoc :doc "frombuffer(buffer, dtype=float, count=-1, offset=0)
+
+    Interpret a buffer as a 1-dimensional array.
+
+    Parameters
+    ----------
+    buffer : buffer_like
+        An object that exposes the buffer interface.
+    dtype : data-type, optional
+        Data-type of the returned array; default: float.
+    count : int, optional
+        Number of items to read. ``-1`` means all data in the buffer.
+    offset : int, optional
+        Start reading the buffer from this offset (in bytes); default: 0.
+
+    Notes
+    -----
+    If the buffer has data that is not in machine byte-order, this should
+    be specified as part of the data-type, e.g.::
+
+      >>> dt = np.dtype(int)
+      >>> dt = dt.newbyteorder('>')
+      >>> np.frombuffer(buf, dtype=dt) # doctest: +SKIP
+
+    The data of the resulting array will not be byteswapped, but will be
+    interpreted correctly.
+
+    Examples
+    --------
+    >>> s = b'hello world'
+    >>> np.frombuffer(s, dtype='S1', count=5, offset=6)
+    array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1')
+
+    >>> np.frombuffer(b'\\x01\\x02', dtype=np.uint8)
+    array([1, 2], dtype=uint8)
+    >>> np.frombuffer(b'\\x01\\x02\\x03\\x04\\x05', dtype=np.uint8, count=3)
+    array([1, 2, 3], dtype=uint8)" :arglists '[[self & [args {:as kwargs}]]])
+
+(def flatiter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flatiter"))))
+(alter-meta! #'flatiter assoc :doc "Flat iterator object to iterate over arrays.
+
+    A `flatiter` iterator is returned by ``x.flat`` for any array `x`.
+    It allows iterating over the array as if it were a 1-D array,
+    either in a for-loop or by calling its `next` method.
+
+    Iteration is done in row-major, C-style order (the last
+    index varying the fastest). The iterator can also be indexed using
+    basic slicing or advanced indexing.
+
+    See Also
+    --------
+    ndarray.flat : Return a flat iterator over an array.
+    ndarray.flatten : Returns a flattened copy of an array.
+
+    Notes
+    -----
+    A `flatiter` iterator can not be constructed directly from Python code
+    by calling the `flatiter` constructor.
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2, 3)
+    >>> fl = x.flat
+    >>> type(fl)
+    <class 'numpy.flatiter'>
+    >>> for item in fl:
+    ...     print(item)
+    ...
+    0
+    1
+    2
+    3
+    4
+    5
+
+    >>> fl[2:4]
+    array([2, 3])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def setbufsize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "setbufsize"))))
+(alter-meta! #'setbufsize assoc :doc "
+    Set the size of the buffer used in ufuncs.
+
+    Parameters
+    ----------
+    size : int
+        Size of buffer.
+
+    " :arglists '[[size]])
+
+(def ^{:doc ""} PZERO (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "PZERO"))))
+
+(def ^{:doc "Built-in mutable sequence.
+
+If no argument is given, the constructor creates a new empty list.
+The argument must be an iterable if specified."} __all__ (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* "__all__")))) 
+
+(def busday_count (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "busday_count"))))
+(alter-meta! #'busday_count assoc :doc "
+    busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None)
+
+    Counts the number of valid days between `begindates` and
+    `enddates`, not including the day of `enddates`.
+
+    If ``enddates`` specifies a date value that is earlier than the
+    corresponding ``begindates`` date value, the count will be negative.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    begindates : array_like of datetime64[D]
+        The array of the first dates for counting.
+    enddates : array_like of datetime64[D]
+        The array of the end dates for counting, which are excluded
+        from the count themselves.
+    weekmask : str or array_like of bool, optional
+        A seven-element array indicating which of Monday through Sunday are
+        valid days. May be specified as a length-seven list or array, like
+        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
+        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
+        weekdays, optionally separated by white space. Valid abbreviations
+        are: Mon Tue Wed Thu Fri Sat Sun
+    holidays : array_like of datetime64[D], optional
+        An array of dates to consider as invalid dates.  They may be
+        specified in any order, and NaT (not-a-time) dates are ignored.
+        This list is saved in a normalized form that is suited for
+        fast calculations of valid days.
+    busdaycal : busdaycalendar, optional
+        A `busdaycalendar` object which specifies the valid days. If this
+        parameter is provided, neither weekmask nor holidays may be
+        provided.
+    out : array of int, optional
+        If provided, this array is filled with the result.
+
+    Returns
+    -------
+    out : array of int
+        An array with a shape from broadcasting ``begindates`` and ``enddates``
+        together, containing the number of valid days between
+        the begin and end dates.
+
+    See Also
+    --------
+    busdaycalendar: An object that specifies a custom set of valid days.
+    is_busday : Returns a boolean array indicating valid days.
+    busday_offset : Applies an offset counted in valid days.
+
+    Examples
+    --------
+    >>> # Number of weekdays in January 2011
+    ... np.busday_count('2011-01', '2011-02')
+    21
+    >>> # Number of weekdays in 2011
+    >>> np.busday_count('2011', '2012')
+    260
+    >>> # Number of Saturdays in 2011
+    ... np.busday_count('2011', '2012', weekmask='Sat')
+    53
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def polyint (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyint"))))
+(alter-meta! #'polyint assoc :doc "
+    Return an antiderivative (indefinite integral) of a polynomial.
+
+    The returned order `m` antiderivative `P` of polynomial `p` satisfies
+    :math:`\\frac{d^m}{dx^m}P(x) = p(x)` and is defined up to `m - 1`
+    integration constants `k`. The constants determine the low-order
+    polynomial part
+
+    .. math:: \\frac{k_{m-1}}{0!} x^0 + \\ldots + \\frac{k_0}{(m-1)!}x^{m-1}
+
+    of `P` so that :math:`P^{(j)}(0) = k_{m-j-1}`.
+
+    Parameters
+    ----------
+    p : array_like or poly1d
+        Polynomial to integrate.
+        A sequence is interpreted as polynomial coefficients, see `poly1d`.
+    m : int, optional
+        Order of the antiderivative. (Default: 1)
+    k : list of `m` scalars or scalar, optional
+        Integration constants. They are given in the order of integration:
+        those corresponding to highest-order terms come first.
+
+        If ``None`` (default), all constants are assumed to be zero.
+        If `m = 1`, a single scalar can be given instead of a list.
+
+    See Also
+    --------
+    polyder : derivative of a polynomial
+    poly1d.integ : equivalent method
+
+    Examples
+    --------
+    The defining property of the antiderivative:
+
+    >>> p = np.poly1d([1,1,1])
+    >>> P = np.polyint(p)
+    >>> P
+     poly1d([ 0.33333333,  0.5       ,  1.        ,  0.        ]) # may vary
+    >>> np.polyder(P) == p
+    True
+
+    The integration constants default to zero, but can be specified:
+
+    >>> P = np.polyint(p, 3)
+    >>> P(0)
+    0.0
+    >>> np.polyder(P)(0)
+    0.0
+    >>> np.polyder(P, 2)(0)
+    0.0
+    >>> P = np.polyint(p, 3, k=[6,5,3])
+    >>> P
+    poly1d([ 0.01666667,  0.04166667,  0.16666667,  3. ,  5. ,  3. ]) # may vary
+
+    Note that 3 = 6 / 2!, and that the constants are given in the order of
+    integrations. Constant of the highest-order polynomial term comes first:
+
+    >>> np.polyder(P, 2)(0)
+    6.0
+    >>> np.polyder(P, 1)(0)
+    5.0
+    >>> P(0)
+    3.0
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def maximum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "maximum"))))
+(alter-meta! #'maximum assoc :doc "maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Element-wise maximum of array elements.
+
+Compare two arrays and returns a new array containing the element-wise
+maxima. If one of the elements being compared is a NaN, then that
+element is returned. If both elements are NaNs then the first is
+returned. The latter distinction is important for complex NaNs, which
+are defined as at least one of the real or imaginary parts being a NaN.
+The net effect is that NaNs are propagated.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays holding the elements to be compared. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The maximum of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+minimum :
+    Element-wise minimum of two arrays, propagates NaNs.
+fmax :
+    Element-wise maximum of two arrays, ignores NaNs.
+amax :
+    The maximum value of an array along a given axis, propagates NaNs.
+nanmax :
+    The maximum value of an array along a given axis, ignores NaNs.
+
+fmin, amin, nanmin
+
+Notes
+-----
+The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when
+neither x1 nor x2 are nans, but it is faster and does proper
+broadcasting.
+
+Examples
+--------
+>>> np.maximum([2, 3, 4], [1, 5, 2])
+array([2, 5, 4])
+
+>>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting
+array([[ 1. ,  2. ],
+       [ 0.5,  2. ]])
+
+>>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan])
+array([nan, nan, nan])
+>>> np.maximum(np.Inf, 1)
+inf" :arglists '[[self & [args {:as kwargs}]]])
+
+(def negative (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "negative"))))
+(alter-meta! #'negative assoc :doc "negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Numerical negative, element-wise.
+
+Parameters
+----------
+x : array_like or scalar
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    Returned array or scalar: `y = -x`.
+    This is a scalar if `x` is a scalar.
+
+Examples
+--------
+>>> np.negative([1.,-1.])
+array([-1.,  1.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def diagonal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diagonal"))))
+(alter-meta! #'diagonal assoc :doc "
+    Return specified diagonals.
+
+    If `a` is 2-D, returns the diagonal of `a` with the given offset,
+    i.e., the collection of elements of the form ``a[i, i+offset]``.  If
+    `a` has more than two dimensions, then the axes specified by `axis1`
+    and `axis2` are used to determine the 2-D sub-array whose diagonal is
+    returned.  The shape of the resulting array can be determined by
+    removing `axis1` and `axis2` and appending an index to the right equal
+    to the size of the resulting diagonals.
+
+    In versions of NumPy prior to 1.7, this function always returned a new,
+    independent array containing a copy of the values in the diagonal.
+
+    In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal,
+    but depending on this fact is deprecated. Writing to the resulting
+    array continues to work as it used to, but a FutureWarning is issued.
+
+    Starting in NumPy 1.9 it returns a read-only view on the original array.
+    Attempting to write to the resulting array will produce an error.
+
+    In some future release, it will return a read/write view and writing to
+    the returned array will alter your original array.  The returned array
+    will have the same type as the input array.
+
+    If you don't write to the array returned by this function, then you can
+    just ignore all of the above.
+
+    If you depend on the current behavior, then we suggest copying the
+    returned array explicitly, i.e., use ``np.diagonal(a).copy()`` instead
+    of just ``np.diagonal(a)``. This will work with both past and future
+    versions of NumPy.
+
+    Parameters
+    ----------
+    a : array_like
+        Array from which the diagonals are taken.
+    offset : int, optional
+        Offset of the diagonal from the main diagonal.  Can be positive or
+        negative.  Defaults to main diagonal (0).
+    axis1 : int, optional
+        Axis to be used as the first axis of the 2-D sub-arrays from which
+        the diagonals should be taken.  Defaults to first axis (0).
+    axis2 : int, optional
+        Axis to be used as the second axis of the 2-D sub-arrays from
+        which the diagonals should be taken. Defaults to second axis (1).
+
+    Returns
+    -------
+    array_of_diagonals : ndarray
+        If `a` is 2-D, then a 1-D array containing the diagonal and of the
+        same type as `a` is returned unless `a` is a `matrix`, in which case
+        a 1-D array rather than a (2-D) `matrix` is returned in order to
+        maintain backward compatibility.
+
+        If ``a.ndim > 2``, then the dimensions specified by `axis1` and `axis2`
+        are removed, and a new axis inserted at the end corresponding to the
+        diagonal.
+
+    Raises
+    ------
+    ValueError
+        If the dimension of `a` is less than 2.
+
+    See Also
+    --------
+    diag : MATLAB work-a-like for 1-D and 2-D arrays.
+    diagflat : Create diagonal arrays.
+    trace : Sum along diagonals.
+
+    Examples
+    --------
+    >>> a = np.arange(4).reshape(2,2)
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> a.diagonal()
+    array([0, 3])
+    >>> a.diagonal(1)
+    array([1])
+
+    A 3-D example:
+
+    >>> a = np.arange(8).reshape(2,2,2); a
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+    >>> a.diagonal(0,  # Main diagonals of two arrays created by skipping
+    ...            0,  # across the outer(left)-most axis last and
+    ...            1)  # the \"middle\" (row) axis first.
+    array([[0, 6],
+           [1, 7]])
+
+    The sub-arrays whose main diagonals we just obtained; note that each
+    corresponds to fixing the right-most (column) axis, and that the
+    diagonals are \"packed\" in rows.
+
+    >>> a[:,:,0]  # main diagonal is [0 6]
+    array([[0, 2],
+           [4, 6]])
+    >>> a[:,:,1]  # main diagonal is [1 7]
+    array([[1, 3],
+           [5, 7]])
+
+    The anti-diagonal can be obtained by reversing the order of elements
+    using either `numpy.flipud` or `numpy.fliplr`.
+
+    >>> a = np.arange(9).reshape(3, 3)
+    >>> a
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+    >>> np.fliplr(a).diagonal()  # Horizontal flip
+    array([2, 4, 6])
+    >>> np.flipud(a).diagonal()  # Vertical flip
+    array([6, 4, 2])
+
+    Note that the order in which the diagonal is retrieved varies depending
+    on the flip function.
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ipmt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ipmt"))))
+(alter-meta! #'ipmt assoc :doc "
+    Compute the interest portion of a payment.
+
+    .. deprecated:: 1.18
+
+       `ipmt` is deprecated; for details, see NEP 32 [1]_.
+       Use the corresponding function in the numpy-financial library,
+       https://pypi.org/project/numpy-financial.
+
+    Parameters
+    ----------
+    rate : scalar or array_like of shape(M, )
+        Rate of interest as decimal (not per cent) per period
+    per : scalar or array_like of shape(M, )
+        Interest paid against the loan changes during the life or the loan.
+        The `per` is the payment period to calculate the interest amount.
+    nper : scalar or array_like of shape(M, )
+        Number of compounding periods
+    pv : scalar or array_like of shape(M, )
+        Present value
+    fv : scalar or array_like of shape(M, ), optional
+        Future value
+    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
+        When payments are due ('begin' (1) or 'end' (0)).
+        Defaults to {'end', 0}.
+
+    Returns
+    -------
+    out : ndarray
+        Interest portion of payment.  If all input is scalar, returns a scalar
+        float.  If any input is array_like, returns interest payment for each
+        input element. If multiple inputs are array_like, they all must have
+        the same shape.
+
+    See Also
+    --------
+    ppmt, pmt, pv
+
+    Notes
+    -----
+    The total payment is made up of payment against principal plus interest.
+
+    ``pmt = ppmt + ipmt``
+
+    References
+    ----------
+    .. [1] NumPy Enhancement Proposal (NEP) 32,
+       https://numpy.org/neps/nep-0032-remove-financial-functions.html
+
+    Examples
+    --------
+    What is the amortization schedule for a 1 year loan of $2500 at
+    8.24% interest per year compounded monthly?
+
+    >>> principal = 2500.00
+
+    The 'per' variable represents the periods of the loan.  Remember that
+    financial equations start the period count at 1!
+
+    >>> per = np.arange(1*12) + 1
+    >>> ipmt = np.ipmt(0.0824/12, per, 1*12, principal)
+    >>> ppmt = np.ppmt(0.0824/12, per, 1*12, principal)
+
+    Each element of the sum of the 'ipmt' and 'ppmt' arrays should equal
+    'pmt'.
+
+    >>> pmt = np.pmt(0.0824/12, 1*12, principal)
+    >>> np.allclose(ipmt + ppmt, pmt)
+    True
+
+    >>> fmt = '{0:2d} {1:8.2f} {2:8.2f} {3:8.2f}'
+    >>> for payment in per:
+    ...     index = payment - 1
+    ...     principal = principal + ppmt[index]
+    ...     print(fmt.format(payment, ppmt[index], ipmt[index], principal))
+     1  -200.58   -17.17  2299.42
+     2  -201.96   -15.79  2097.46
+     3  -203.35   -14.40  1894.11
+     4  -204.74   -13.01  1689.37
+     5  -206.15   -11.60  1483.22
+     6  -207.56   -10.18  1275.66
+     7  -208.99    -8.76  1066.67
+     8  -210.42    -7.32   856.25
+     9  -211.87    -5.88   644.38
+    10  -213.32    -4.42   431.05
+    11  -214.79    -2.96   216.26
+    12  -216.26    -1.49    -0.00
+
+    >>> interestpd = np.sum(ipmt)
+    >>> np.round(interestpd, 2)
+    -112.98
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def einsum_path (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "einsum_path"))))
+(alter-meta! #'einsum_path assoc :doc "
+    einsum_path(subscripts, *operands, optimize='greedy')
+
+    Evaluates the lowest cost contraction order for an einsum expression by
+    considering the creation of intermediate arrays.
+
+    Parameters
+    ----------
+    subscripts : str
+        Specifies the subscripts for summation.
+    *operands : list of array_like
+        These are the arrays for the operation.
+    optimize : {bool, list, tuple, 'greedy', 'optimal'}
+        Choose the type of path. If a tuple is provided, the second argument is
+        assumed to be the maximum intermediate size created. If only a single
+        argument is provided the largest input or output array size is used
+        as a maximum intermediate size.
+
+        * if a list is given that starts with ``einsum_path``, uses this as the
+          contraction path
+        * if False no optimization is taken
+        * if True defaults to the 'greedy' algorithm
+        * 'optimal' An algorithm that combinatorially explores all possible
+          ways of contracting the listed tensors and choosest the least costly
+          path. Scales exponentially with the number of terms in the
+          contraction.
+        * 'greedy' An algorithm that chooses the best pair contraction
+          at each step. Effectively, this algorithm searches the largest inner,
+          Hadamard, and then outer products at each step. Scales cubically with
+          the number of terms in the contraction. Equivalent to the 'optimal'
+          path for most contractions.
+
+        Default is 'greedy'.
+
+    Returns
+    -------
+    path : list of tuples
+        A list representation of the einsum path.
+    string_repr : str
+        A printable representation of the einsum path.
+
+    Notes
+    -----
+    The resulting path indicates which terms of the input contraction should be
+    contracted first, the result of this contraction is then appended to the
+    end of the contraction list. This list can then be iterated over until all
+    intermediate contractions are complete.
+
+    See Also
+    --------
+    einsum, linalg.multi_dot
+
+    Examples
+    --------
+
+    We can begin with a chain dot example. In this case, it is optimal to
+    contract the ``b`` and ``c`` tensors first as represented by the first
+    element of the path ``(1, 2)``. The resulting tensor is added to the end
+    of the contraction and the remaining contraction ``(0, 1)`` is then
+    completed.
+
+    >>> np.random.seed(123)
+    >>> a = np.random.rand(2, 2)
+    >>> b = np.random.rand(2, 5)
+    >>> c = np.random.rand(5, 2)
+    >>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy')
+    >>> print(path_info[0])
+    ['einsum_path', (1, 2), (0, 1)]
+    >>> print(path_info[1])
+      Complete contraction:  ij,jk,kl->il # may vary
+             Naive scaling:  4
+         Optimized scaling:  3
+          Naive FLOP count:  1.600e+02
+      Optimized FLOP count:  5.600e+01
+       Theoretical speedup:  2.857
+      Largest intermediate:  4.000e+00 elements
+    -------------------------------------------------------------------------
+    scaling                  current                                remaining
+    -------------------------------------------------------------------------
+       3                   kl,jk->jl                                ij,jl->il
+       3                   jl,ij->il                                   il->il
+
+
+    A more complex index transformation example.
+
+    >>> I = np.random.rand(10, 10, 10, 10)
+    >>> C = np.random.rand(10, 10)
+    >>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C,
+    ...                            optimize='greedy')
+
+    >>> print(path_info[0])
+    ['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)]
+    >>> print(path_info[1]) 
+      Complete contraction:  ea,fb,abcd,gc,hd->efgh # may vary
+             Naive scaling:  8
+         Optimized scaling:  5
+          Naive FLOP count:  8.000e+08
+      Optimized FLOP count:  8.000e+05
+       Theoretical speedup:  1000.000
+      Largest intermediate:  1.000e+04 elements
+    --------------------------------------------------------------------------
+    scaling                  current                                remaining
+    --------------------------------------------------------------------------
+       5               abcd,ea->bcde                      fb,gc,hd,bcde->efgh
+       5               bcde,fb->cdef                         gc,hd,cdef->efgh
+       5               cdef,gc->defg                            hd,defg->efgh
+       5               defg,hd->efgh                               efgh->efgh
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} FPE_DIVIDEBYZERO (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "FPE_DIVIDEBYZERO"))))
+
+(def require (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "require"))))
+(alter-meta! #'require assoc :doc "
+    Return an ndarray of the provided type that satisfies requirements.
+
+    This function is useful to be sure that an array with the correct flags
+    is returned for passing to compiled code (perhaps through ctypes).
+
+    Parameters
+    ----------
+    a : array_like
+       The object to be converted to a type-and-requirement-satisfying array.
+    dtype : data-type
+       The required data-type. If None preserve the current dtype. If your
+       application requires the data to be in native byteorder, include
+       a byteorder specification as a part of the dtype specification.
+    requirements : str or list of str
+       The requirements list can be any of the following
+
+       * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array
+       * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array
+       * 'ALIGNED' ('A')      - ensure a data-type aligned array
+       * 'WRITEABLE' ('W')    - ensure a writable array
+       * 'OWNDATA' ('O')      - ensure an array that owns its own data
+       * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass
+
+    Returns
+    -------
+    out : ndarray
+        Array with specified requirements and type if given.
+
+    See Also
+    --------
+    asarray : Convert input to an ndarray.
+    asanyarray : Convert to an ndarray, but pass through ndarray subclasses.
+    ascontiguousarray : Convert input to a contiguous array.
+    asfortranarray : Convert input to an ndarray with column-major
+                     memory order.
+    ndarray.flags : Information about the memory layout of the array.
+
+    Notes
+    -----
+    The returned array will be guaranteed to have the listed requirements
+    by making a copy if needed.
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2,3)
+    >>> x.flags
+      C_CONTIGUOUS : True
+      F_CONTIGUOUS : False
+      OWNDATA : False
+      WRITEABLE : True
+      ALIGNED : True
+      WRITEBACKIFCOPY : False
+      UPDATEIFCOPY : False
+
+    >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])
+    >>> y.flags
+      C_CONTIGUOUS : False
+      F_CONTIGUOUS : True
+      OWNDATA : True
+      WRITEABLE : True
+      ALIGNED : True
+      WRITEBACKIFCOPY : False
+      UPDATEIFCOPY : False
+
+    " :arglists '[[a & [{dtype :dtype, requirements :requirements}]] [a & [{dtype :dtype}]] [a]])
+
+(def nancumsum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nancumsum"))))
+(alter-meta! #'nancumsum assoc :doc "
+    Return the cumulative sum of array elements over a given axis treating Not a
+    Numbers (NaNs) as zero.  The cumulative sum does not change when NaNs are
+    encountered and leading NaNs are replaced by zeros.
+
+    Zeros are returned for slices that are all-NaN or empty.
+
+    .. versionadded:: 1.12.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        Axis along which the cumulative sum is computed. The default
+        (None) is to compute the cumsum over the flattened array.
+    dtype : dtype, optional
+        Type of the returned array and of the accumulator in which the
+        elements are summed.  If `dtype` is not specified, it defaults
+        to the dtype of `a`, unless `a` has an integer dtype with a
+        precision less than that of the default platform integer.  In
+        that case, the default platform integer is used.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary. See `ufuncs-output-type` for
+        more details.
+
+    Returns
+    -------
+    nancumsum : ndarray.
+        A new array holding the result is returned unless `out` is
+        specified, in which it is returned. The result has the same
+        size as `a`, and the same shape as `a` if `axis` is not None
+        or `a` is a 1-d array.
+
+    See Also
+    --------
+    numpy.cumsum : Cumulative sum across array propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> np.nancumsum(1)
+    array([1])
+    >>> np.nancumsum([1])
+    array([1])
+    >>> np.nancumsum([1, np.nan])
+    array([1.,  1.])
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nancumsum(a)
+    array([1.,  3.,  6.,  6.])
+    >>> np.nancumsum(a, axis=0)
+    array([[1.,  2.],
+           [4.,  2.]])
+    >>> np.nancumsum(a, axis=1)
+    array([[1.,  3.],
+           [3.,  3.]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def clongfloat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "clongfloat"))))
+(alter-meta! #'clongfloat assoc :doc "Complex number type composed of two extended-precision floating-point
+    numbers.
+    Character code: ``'G'``.
+    Canonical name: ``np.clongdouble``.
+    Alias: ``np.clongfloat``.
+    Alias: ``np.longcomplex``.
+    Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def isnan (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isnan"))))
+(alter-meta! #'isnan assoc :doc "isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Test element-wise for NaN and return result as a boolean array.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or bool
+    True where ``x`` is NaN, false otherwise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+isinf, isneginf, isposinf, isfinite, isnat
+
+Notes
+-----
+NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+(IEEE 754). This means that Not a Number is not equivalent to infinity.
+
+Examples
+--------
+>>> np.isnan(np.nan)
+True
+>>> np.isnan(np.inf)
+False
+>>> np.isnan([np.log(-1.),1.,np.log(0)])
+array([ True, False, False])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def reciprocal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "reciprocal"))))
+(alter-meta! #'reciprocal assoc :doc "reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the reciprocal of the argument, element-wise.
+
+Calculates ``1/x``.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    Return array.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+.. note::
+    This function is not designed to work with integers.
+
+For integer arguments with absolute value larger than 1 the result is
+always zero because of the way Python handles integer division.  For
+integer zero the result is an overflow.
+
+Examples
+--------
+>>> np.reciprocal(2.)
+0.5
+>>> np.reciprocal([1, 2., 3.33])
+array([ 1.       ,  0.5      ,  0.3003003])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def partition (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "partition"))))
+(alter-meta! #'partition assoc :doc "
+    Return a partitioned copy of an array.
+
+    Creates a copy of the array with its elements rearranged in such a
+    way that the value of the element in k-th position is in the
+    position it would be in a sorted array. All elements smaller than
+    the k-th element are moved before this element and all equal or
+    greater are moved behind it. The ordering of the elements in the two
+    partitions is undefined.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array to be sorted.
+    kth : int or sequence of ints
+        Element index to partition by. The k-th value of the element
+        will be in its final sorted position and all smaller elements
+        will be moved before it and all equal or greater elements behind
+        it. The order of all elements in the partitions is undefined. If
+        provided with a sequence of k-th it will partition all elements
+        indexed by k-th  of them into their sorted position at once.
+    axis : int or None, optional
+        Axis along which to sort. If None, the array is flattened before
+        sorting. The default is -1, which sorts along the last axis.
+    kind : {'introselect'}, optional
+        Selection algorithm. Default is 'introselect'.
+    order : str or list of str, optional
+        When `a` is an array with fields defined, this argument
+        specifies which fields to compare first, second, etc.  A single
+        field can be specified as a string.  Not all fields need be
+        specified, but unspecified fields will still be used, in the
+        order in which they come up in the dtype, to break ties.
+
+    Returns
+    -------
+    partitioned_array : ndarray
+        Array of the same type and shape as `a`.
+
+    See Also
+    --------
+    ndarray.partition : Method to sort an array in-place.
+    argpartition : Indirect partition.
+    sort : Full sorting
+
+    Notes
+    -----
+    The various selection algorithms are characterized by their average
+    speed, worst case performance, work space size, and whether they are
+    stable. A stable sort keeps items with the same key in the same
+    relative order. The available algorithms have the following
+    properties:
+
+    ================= ======= ============= ============ =======
+       kind            speed   worst case    work space  stable
+    ================= ======= ============= ============ =======
+    'introselect'        1        O(n)           0         no
+    ================= ======= ============= ============ =======
+
+    All the partition algorithms make temporary copies of the data when
+    partitioning along any but the last axis.  Consequently,
+    partitioning along the last axis is faster and uses less space than
+    partitioning along any other axis.
+
+    The sort order for complex numbers is lexicographic. If both the
+    real and imaginary parts are non-nan then the order is determined by
+    the real parts except when they are equal, in which case the order
+    is determined by the imaginary parts.
+
+    Examples
+    --------
+    >>> a = np.array([3, 4, 2, 1])
+    >>> np.partition(a, 3)
+    array([2, 1, 3, 4])
+
+    >>> np.partition(a, (1, 3))
+    array([1, 2, 3, 4])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def where (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "where"))))
+(alter-meta! #'where assoc :doc "
+    where(condition, [x, y])
+
+    Return elements chosen from `x` or `y` depending on `condition`.
+
+    .. note::
+        When only `condition` is provided, this function is a shorthand for
+        ``np.asarray(condition).nonzero()``. Using `nonzero` directly should be
+        preferred, as it behaves correctly for subclasses. The rest of this
+        documentation covers only the case where all three arguments are
+        provided.
+
+    Parameters
+    ----------
+    condition : array_like, bool
+        Where True, yield `x`, otherwise yield `y`.
+    x, y : array_like
+        Values from which to choose. `x`, `y` and `condition` need to be
+        broadcastable to some shape.
+
+    Returns
+    -------
+    out : ndarray
+        An array with elements from `x` where `condition` is True, and elements
+        from `y` elsewhere.
+
+    See Also
+    --------
+    choose
+    nonzero : The function that is called when x and y are omitted
+
+    Notes
+    -----
+    If all the arrays are 1-D, `where` is equivalent to::
+
+        [xv if c else yv
+         for c, xv, yv in zip(condition, x, y)]
+
+    Examples
+    --------
+    >>> a = np.arange(10)
+    >>> a
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> np.where(a < 5, a, 10*a)
+    array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])
+
+    This can be used on multidimensional arrays too:
+
+    >>> np.where([[True, False], [True, True]],
+    ...          [[1, 2], [3, 4]],
+    ...          [[9, 8], [7, 6]])
+    array([[1, 8],
+           [3, 4]])
+
+    The shapes of x, y, and the condition are broadcast together:
+
+    >>> x, y = np.ogrid[:3, :4]
+    >>> np.where(x < y, x, 10 + y)  # both x and 10+y are broadcast
+    array([[10,  0,  0,  0],
+           [10, 11,  1,  1],
+           [10, 11, 12,  2]])
+
+    >>> a = np.array([[0, 1, 2],
+    ...               [0, 2, 4],
+    ...               [0, 3, 6]])
+    >>> np.where(a < 4, a, -1)  # -1 is broadcast
+    array([[ 0,  1,  2],
+           [ 0,  2, -1],
+           [ 0,  3, -1]])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def minimum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "minimum"))))
+(alter-meta! #'minimum assoc :doc "minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Element-wise minimum of array elements.
+
+Compare two arrays and returns a new array containing the element-wise
+minima. If one of the elements being compared is a NaN, then that
+element is returned. If both elements are NaNs then the first is
+returned. The latter distinction is important for complex NaNs, which
+are defined as at least one of the real or imaginary parts being a NaN.
+The net effect is that NaNs are propagated.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays holding the elements to be compared. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The minimum of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+maximum :
+    Element-wise maximum of two arrays, propagates NaNs.
+fmin :
+    Element-wise minimum of two arrays, ignores NaNs.
+amin :
+    The minimum value of an array along a given axis, propagates NaNs.
+nanmin :
+    The minimum value of an array along a given axis, ignores NaNs.
+
+fmax, amax, nanmax
+
+Notes
+-----
+The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when
+neither x1 nor x2 are NaNs, but it is faster and does proper
+broadcasting.
+
+Examples
+--------
+>>> np.minimum([2, 3, 4], [1, 5, 2])
+array([1, 3, 2])
+
+>>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting
+array([[ 0.5,  0. ],
+       [ 0. ,  1. ]])
+
+>>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan])
+array([nan, nan, nan])
+>>> np.minimum(-np.Inf, 1)
+-inf" :arglists '[[self & [args {:as kwargs}]]])
+
+(def interp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "interp"))))
+(alter-meta! #'interp assoc :doc "
+    One-dimensional linear interpolation.
+
+    Returns the one-dimensional piecewise linear interpolant to a function
+    with given discrete data points (`xp`, `fp`), evaluated at `x`.
+
+    Parameters
+    ----------
+    x : array_like
+        The x-coordinates at which to evaluate the interpolated values.
+
+    xp : 1-D sequence of floats
+        The x-coordinates of the data points, must be increasing if argument
+        `period` is not specified. Otherwise, `xp` is internally sorted after
+        normalizing the periodic boundaries with ``xp = xp % period``.
+
+    fp : 1-D sequence of float or complex
+        The y-coordinates of the data points, same length as `xp`.
+
+    left : optional float or complex corresponding to fp
+        Value to return for `x < xp[0]`, default is `fp[0]`.
+
+    right : optional float or complex corresponding to fp
+        Value to return for `x > xp[-1]`, default is `fp[-1]`.
+
+    period : None or float, optional
+        A period for the x-coordinates. This parameter allows the proper
+        interpolation of angular x-coordinates. Parameters `left` and `right`
+        are ignored if `period` is specified.
+
+        .. versionadded:: 1.10.0
+
+    Returns
+    -------
+    y : float or complex (corresponding to fp) or ndarray
+        The interpolated values, same shape as `x`.
+
+    Raises
+    ------
+    ValueError
+        If `xp` and `fp` have different length
+        If `xp` or `fp` are not 1-D sequences
+        If `period == 0`
+
+    Notes
+    -----
+    The x-coordinate sequence is expected to be increasing, but this is not
+    explicitly enforced.  However, if the sequence `xp` is non-increasing,
+    interpolation results are meaningless.
+
+    Note that, since NaN is unsortable, `xp` also cannot contain NaNs.
+
+    A simple check for `xp` being strictly increasing is::
+
+        np.all(np.diff(xp) > 0)
+
+    Examples
+    --------
+    >>> xp = [1, 2, 3]
+    >>> fp = [3, 2, 0]
+    >>> np.interp(2.5, xp, fp)
+    1.0
+    >>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp)
+    array([3.  , 3.  , 2.5 , 0.56, 0.  ])
+    >>> UNDEF = -99.0
+    >>> np.interp(3.14, xp, fp, right=UNDEF)
+    -99.0
+
+    Plot an interpolant to the sine function:
+
+    >>> x = np.linspace(0, 2*np.pi, 10)
+    >>> y = np.sin(x)
+    >>> xvals = np.linspace(0, 2*np.pi, 50)
+    >>> yinterp = np.interp(xvals, x, y)
+    >>> import matplotlib.pyplot as plt
+    >>> plt.plot(x, y, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.plot(xvals, yinterp, '-x')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.show()
+
+    Interpolation with periodic x-coordinates:
+
+    >>> x = [-180, -170, -185, 185, -10, -5, 0, 365]
+    >>> xp = [190, -190, 350, -350]
+    >>> fp = [5, 10, 3, 4]
+    >>> np.interp(x, xp, fp, period=360)
+    array([7.5 , 5.  , 8.75, 6.25, 3.  , 3.25, 3.5 , 3.75])
+
+    Complex interpolation:
+
+    >>> x = [1.5, 4.0]
+    >>> xp = [2,3,5]
+    >>> fp = [1.0j, 0, 2+3j]
+    >>> np.interp(x, xp, fp)
+    array([0.+1.j , 1.+1.5j])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def genfromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "genfromtxt"))))
+(alter-meta! #'genfromtxt assoc :doc "
+    Load data from a text file, with missing values handled as specified.
+
+    Each line past the first `skip_header` lines is split at the `delimiter`
+    character, and characters following the `comments` character are discarded.
+
+    Parameters
+    ----------
+    fname : file, str, pathlib.Path, list of str, generator
+        File, filename, list, or generator to read.  If the filename
+        extension is `.gz` or `.bz2`, the file is first decompressed. Note
+        that generators must return byte strings. The strings
+        in a list or produced by a generator are treated as lines.
+    dtype : dtype, optional
+        Data type of the resulting array.
+        If None, the dtypes will be determined by the contents of each
+        column, individually.
+    comments : str, optional
+        The character used to indicate the start of a comment.
+        All the characters occurring on a line after a comment are discarded
+    delimiter : str, int, or sequence, optional
+        The string used to separate values.  By default, any consecutive
+        whitespaces act as delimiter.  An integer or sequence of integers
+        can also be provided as width(s) of each field.
+    skiprows : int, optional
+        `skiprows` was removed in numpy 1.10. Please use `skip_header` instead.
+    skip_header : int, optional
+        The number of lines to skip at the beginning of the file.
+    skip_footer : int, optional
+        The number of lines to skip at the end of the file.
+    converters : variable, optional
+        The set of functions that convert the data of a column to a value.
+        The converters can also be used to provide a default value
+        for missing data: ``converters = {3: lambda s: float(s or 0)}``.
+    missing : variable, optional
+        `missing` was removed in numpy 1.10. Please use `missing_values`
+        instead.
+    missing_values : variable, optional
+        The set of strings corresponding to missing data.
+    filling_values : variable, optional
+        The set of values to be used as default when the data are missing.
+    usecols : sequence, optional
+        Which columns to read, with 0 being the first.  For example,
+        ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.
+    names : {None, True, str, sequence}, optional
+        If `names` is True, the field names are read from the first line after
+        the first `skip_header` lines.  This line can optionally be proceeded
+        by a comment delimiter. If `names` is a sequence or a single-string of
+        comma-separated names, the names will be used to define the field names
+        in a structured dtype. If `names` is None, the names of the dtype
+        fields will be used, if any.
+    excludelist : sequence, optional
+        A list of names to exclude. This list is appended to the default list
+        ['return','file','print']. Excluded names are appended an underscore:
+        for example, `file` would become `file_`.
+    deletechars : str, optional
+        A string combining invalid characters that must be deleted from the
+        names.
+    defaultfmt : str, optional
+        A format used to define default field names, such as \"f%i\" or \"f_%02i\".
+    autostrip : bool, optional
+        Whether to automatically strip white spaces from the variables.
+    replace_space : char, optional
+        Character(s) used in replacement of white spaces in the variables
+        names. By default, use a '_'.
+    case_sensitive : {True, False, 'upper', 'lower'}, optional
+        If True, field names are case sensitive.
+        If False or 'upper', field names are converted to upper case.
+        If 'lower', field names are converted to lower case.
+    unpack : bool, optional
+        If True, the returned array is transposed, so that arguments may be
+        unpacked using ``x, y, z = loadtxt(...)``
+    usemask : bool, optional
+        If True, return a masked array.
+        If False, return a regular array.
+    loose : bool, optional
+        If True, do not raise errors for invalid values.
+    invalid_raise : bool, optional
+        If True, an exception is raised if an inconsistency is detected in the
+        number of columns.
+        If False, a warning is emitted and the offending lines are skipped.
+    max_rows : int,  optional
+        The maximum number of rows to read. Must not be used with skip_footer
+        at the same time.  If given, the value must be at least 1. Default is
+        to read the entire file.
+
+        .. versionadded:: 1.10.0
+    encoding : str, optional
+        Encoding used to decode the inputfile. Does not apply when `fname` is
+        a file object.  The special value 'bytes' enables backward compatibility
+        workarounds that ensure that you receive byte arrays when possible
+        and passes latin1 encoded strings to converters. Override this value to
+        receive unicode arrays and pass strings as input to converters.  If set
+        to None the system default is used. The default value is 'bytes'.
+
+        .. versionadded:: 1.14.0
+
+    Returns
+    -------
+    out : ndarray
+        Data read from the text file. If `usemask` is True, this is a
+        masked array.
+
+    See Also
+    --------
+    numpy.loadtxt : equivalent function when no data is missing.
+
+    Notes
+    -----
+    * When spaces are used as delimiters, or when no delimiter has been given
+      as input, there should not be any missing data between two fields.
+    * When the variables are named (either by a flexible dtype or with `names`,
+      there must not be any header in the file (else a ValueError
+      exception is raised).
+    * Individual values are not stripped of spaces by default.
+      When using a custom converter, make sure the function does remove spaces.
+
+    References
+    ----------
+    .. [1] NumPy User Guide, section `I/O with NumPy
+           <https://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html>`_.
+
+    Examples
+    ---------
+    >>> from io import StringIO
+    >>> import numpy as np
+
+    Comma delimited file with mixed dtype
+
+    >>> s = StringIO(u\"1,1.3,abcde\")
+    >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),
+    ... ('mystring','S5')], delimiter=\",\")
+    >>> data
+    array((1, 1.3, b'abcde'),
+          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
+
+    Using dtype = None
+
+    >>> _ = s.seek(0) # needed for StringIO example only
+    >>> data = np.genfromtxt(s, dtype=None,
+    ... names = ['myint','myfloat','mystring'], delimiter=\",\")
+    >>> data
+    array((1, 1.3, b'abcde'),
+          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
+
+    Specifying dtype and names
+
+    >>> _ = s.seek(0)
+    >>> data = np.genfromtxt(s, dtype=\"i8,f8,S5\",
+    ... names=['myint','myfloat','mystring'], delimiter=\",\")
+    >>> data
+    array((1, 1.3, b'abcde'),
+          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
+
+    An example with fixed-width columns
+
+    >>> s = StringIO(u\"11.3abcde\")
+    >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],
+    ...     delimiter=[1,3,5])
+    >>> data
+    array((1, 1.3, b'abcde'),
+          dtype=[('intvar', '<i8'), ('fltvar', '<f8'), ('strvar', 'S5')])
+
+    An example to show comments
+
+    >>> f = StringIO('''
+    ... text,# of chars
+    ... hello world,11
+    ... numpy,5''')
+    >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',')
+    array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')],
+      dtype=[('f0', 'S12'), ('f1', 'S12')])
+
+    " :arglists '[[fname & [{names :names, max_rows :max_rows, encoding :encoding, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, max_rows :max_rows, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, excludelist :excludelist, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters, missing_values :missing_values, filling_values :filling_values}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters, missing_values :missing_values}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter}]] [fname & [{dtype :dtype, comments :comments}]] [fname & [{dtype :dtype}]] [fname]])
+
+(def errstate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "errstate"))))
+(alter-meta! #'errstate assoc :doc "
+    errstate(**kwargs)
+
+    Context manager for floating-point error handling.
+
+    Using an instance of `errstate` as a context manager allows statements in
+    that context to execute with a known error handling behavior. Upon entering
+    the context the error handling is set with `seterr` and `seterrcall`, and
+    upon exiting it is reset to what it was before.
+
+    ..  versionchanged:: 1.17.0
+        `errstate` is also usable as a function decorator, saving
+        a level of indentation if an entire function is wrapped.
+        See :py:class:`contextlib.ContextDecorator` for more information.
+
+    Parameters
+    ----------
+    kwargs : {divide, over, under, invalid}
+        Keyword arguments. The valid keywords are the possible floating-point
+        exceptions. Each keyword should have a string value that defines the
+        treatment for the particular error. Possible values are
+        {'ignore', 'warn', 'raise', 'call', 'print', 'log'}.
+
+    See Also
+    --------
+    seterr, geterr, seterrcall, geterrcall
+
+    Notes
+    -----
+    For complete documentation of the types of floating-point exceptions and
+    treatment options, see `seterr`.
+
+    Examples
+    --------
+    >>> from collections import OrderedDict
+    >>> olderr = np.seterr(all='ignore')  # Set error handling to known state.
+
+    >>> np.arange(3) / 0.
+    array([nan, inf, inf])
+    >>> with np.errstate(divide='warn'):
+    ...     np.arange(3) / 0.
+    array([nan, inf, inf])
+
+    >>> np.sqrt(-1)
+    nan
+    >>> with np.errstate(invalid='raise'):
+    ...     np.sqrt(-1)
+    Traceback (most recent call last):
+      File \"<stdin>\", line 2, in <module>
+    FloatingPointError: invalid value encountered in sqrt
+
+    Outside the context the error handling behavior has not changed:
+
+    >>> OrderedDict(sorted(np.geterr().items()))
+    OrderedDict([('divide', 'ignore'), ('invalid', 'ignore'), ('over', 'ignore'), ('under', 'ignore')])
+
+    " :arglists '[[self & [{:as kwargs}]]])
+
+(def set_numeric_ops (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "set_numeric_ops"))))
+(alter-meta! #'set_numeric_ops assoc :doc "set_numeric_ops(op1=func1, op2=func2, ...)
+
+    Set numerical operators for array objects.
+
+    .. deprecated:: 1.16
+
+        For the general case, use :c:func:`PyUFunc_ReplaceLoopBySignature`.
+        For ndarray subclasses, define the ``__array_ufunc__`` method and
+        override the relevant ufunc.
+
+    Parameters
+    ----------
+    op1, op2, ... : callable
+        Each ``op = func`` pair describes an operator to be replaced.
+        For example, ``add = lambda x, y: np.add(x, y) % 5`` would replace
+        addition by modulus 5 addition.
+
+    Returns
+    -------
+    saved_ops : list of callables
+        A list of all operators, stored before making replacements.
+
+    Notes
+    -----
+    .. WARNING::
+       Use with care!  Incorrect usage may lead to memory errors.
+
+    A function replacing an operator cannot make use of that operator.
+    For example, when replacing add, you may not use ``+``.  Instead,
+    directly call ufuncs.
+
+    Examples
+    --------
+    >>> def add_mod5(x, y):
+    ...     return np.add(x, y) % 5
+    ...
+    >>> old_funcs = np.set_numeric_ops(add=add_mod5)
+
+    >>> x = np.arange(12).reshape((3, 4))
+    >>> x + x
+    array([[0, 2, 4, 1],
+           [3, 0, 2, 4],
+           [1, 3, 0, 2]])
+
+    >>> ignore = np.set_numeric_ops(**old_funcs) # restore operators" :arglists '[[self & [args {:as kwargs}]]])
+
+(def degrees (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "degrees"))))
+(alter-meta! #'degrees assoc :doc "degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Convert angles from radians to degrees.
+
+Parameters
+----------
+x : array_like
+    Input array in radians.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray of floats
+    The corresponding degree values; if `out` was supplied this is a
+    reference to it.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+rad2deg : equivalent function
+
+Examples
+--------
+Convert a radian array to degrees
+
+>>> rad = np.arange(12.)*np.pi/6
+>>> np.degrees(rad)
+array([   0.,   30.,   60.,   90.,  120.,  150.,  180.,  210.,  240.,
+        270.,  300.,  330.])
+
+>>> out = np.zeros((rad.shape))
+>>> r = np.degrees(rad, out)
+>>> np.all(r == out)
+True" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} True_ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "True_"))))
+
+(def diff (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diff"))))
+(alter-meta! #'diff assoc :doc "
+    Calculate the n-th discrete difference along the given axis.
+
+    The first difference is given by ``out[i] = a[i+1] - a[i]`` along
+    the given axis, higher differences are calculated by using `diff`
+    recursively.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array
+    n : int, optional
+        The number of times values are differenced. If zero, the input
+        is returned as-is.
+    axis : int, optional
+        The axis along which the difference is taken, default is the
+        last axis.
+    prepend, append : array_like, optional
+        Values to prepend or append to `a` along axis prior to
+        performing the difference.  Scalar values are expanded to
+        arrays with length 1 in the direction of axis and the shape
+        of the input array in along all other axes.  Otherwise the
+        dimension and shape must match `a` except along axis.
+
+        .. versionadded:: 1.16.0
+
+    Returns
+    -------
+    diff : ndarray
+        The n-th differences. The shape of the output is the same as `a`
+        except along `axis` where the dimension is smaller by `n`. The
+        type of the output is the same as the type of the difference
+        between any two elements of `a`. This is the same as the type of
+        `a` in most cases. A notable exception is `datetime64`, which
+        results in a `timedelta64` output array.
+
+    See Also
+    --------
+    gradient, ediff1d, cumsum
+
+    Notes
+    -----
+    Type is preserved for boolean arrays, so the result will contain
+    `False` when consecutive elements are the same and `True` when they
+    differ.
+
+    For unsigned integer arrays, the results will also be unsigned. This
+    should not be surprising, as the result is consistent with
+    calculating the difference directly:
+
+    >>> u8_arr = np.array([1, 0], dtype=np.uint8)
+    >>> np.diff(u8_arr)
+    array([255], dtype=uint8)
+    >>> u8_arr[1,...] - u8_arr[0,...]
+    255
+
+    If this is not desirable, then the array should be cast to a larger
+    integer type first:
+
+    >>> i16_arr = u8_arr.astype(np.int16)
+    >>> np.diff(i16_arr)
+    array([-1], dtype=int16)
+
+    Examples
+    --------
+    >>> x = np.array([1, 2, 4, 7, 0])
+    >>> np.diff(x)
+    array([ 1,  2,  3, -7])
+    >>> np.diff(x, n=2)
+    array([  1,   1, -10])
+
+    >>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])
+    >>> np.diff(x)
+    array([[2, 3, 4],
+           [5, 1, 2]])
+    >>> np.diff(x, axis=0)
+    array([[-1,  2,  0, -2]])
+
+    >>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64)
+    >>> np.diff(x)
+    array([1, 1], dtype='timedelta64[D]')
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def isin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isin"))))
+(alter-meta! #'isin assoc :doc "
+    Calculates `element in test_elements`, broadcasting over `element` only.
+    Returns a boolean array of the same shape as `element` that is True
+    where an element of `element` is in `test_elements` and False otherwise.
+
+    Parameters
+    ----------
+    element : array_like
+        Input array.
+    test_elements : array_like
+        The values against which to test each value of `element`.
+        This argument is flattened if it is an array or array_like.
+        See notes for behavior with non-array-like parameters.
+    assume_unique : bool, optional
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+    invert : bool, optional
+        If True, the values in the returned array are inverted, as if
+        calculating `element not in test_elements`. Default is False.
+        ``np.isin(a, b, invert=True)`` is equivalent to (but faster
+        than) ``np.invert(np.isin(a, b))``.
+
+    Returns
+    -------
+    isin : ndarray, bool
+        Has the same shape as `element`. The values `element[isin]`
+        are in `test_elements`.
+
+    See Also
+    --------
+    in1d                  : Flattened version of this function.
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Notes
+    -----
+
+    `isin` is an element-wise function version of the python keyword `in`.
+    ``isin(a, b)`` is roughly equivalent to
+    ``np.array([item in b for item in a])`` if `a` and `b` are 1-D sequences.
+
+    `element` and `test_elements` are converted to arrays if they are not
+    already. If `test_elements` is a set (or other non-sequence collection)
+    it will be converted to an object array with one element, rather than an
+    array of the values contained in `test_elements`. This is a consequence
+    of the `array` constructor's way of handling non-sequence collections.
+    Converting the set to a list usually gives the desired behavior.
+
+    .. versionadded:: 1.13.0
+
+    Examples
+    --------
+    >>> element = 2*np.arange(4).reshape((2, 2))
+    >>> element
+    array([[0, 2],
+           [4, 6]])
+    >>> test_elements = [1, 2, 4, 8]
+    >>> mask = np.isin(element, test_elements)
+    >>> mask
+    array([[False,  True],
+           [ True, False]])
+    >>> element[mask]
+    array([2, 4])
+
+    The indices of the matched values can be obtained with `nonzero`:
+
+    >>> np.nonzero(mask)
+    (array([0, 1]), array([1, 0]))
+
+    The test can also be inverted:
+
+    >>> mask = np.isin(element, test_elements, invert=True)
+    >>> mask
+    array([[ True, False],
+           [False,  True]])
+    >>> element[mask]
+    array([0, 6])
+
+    Because of how `array` handles sets, the following does not
+    work as expected:
+
+    >>> test_set = {1, 2, 4, 8}
+    >>> np.isin(element, test_set)
+    array([[False, False],
+           [False, False]])
+
+    Casting the set to a list gives the expected result:
+
+    >>> np.isin(element, list(test_set))
+    array([[False,  True],
+           [ True, False]])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} sctypeNA (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "sctypeNA"))))
+
+(def argmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argmin"))))
+(alter-meta! #'argmin assoc :doc "
+    Returns the indices of the minimum values along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        By default, the index is into the flattened array, otherwise
+        along the specified axis.
+    out : array, optional
+        If provided, the result will be inserted into this array. It should
+        be of the appropriate shape and dtype.
+
+    Returns
+    -------
+    index_array : ndarray of ints
+        Array of indices into the array. It has the same shape as `a.shape`
+        with the dimension along `axis` removed.
+
+    See Also
+    --------
+    ndarray.argmin, argmax
+    amin : The minimum value along a given axis.
+    unravel_index : Convert a flat index into an index tuple.
+    take_along_axis : Apply ``np.expand_dims(index_array, axis)`` 
+                      from argmin to an array as if by calling min.
+
+    Notes
+    -----
+    In case of multiple occurrences of the minimum values, the indices
+    corresponding to the first occurrence are returned.
+
+    Examples
+    --------
+    >>> a = np.arange(6).reshape(2,3) + 10
+    >>> a
+    array([[10, 11, 12],
+           [13, 14, 15]])
+    >>> np.argmin(a)
+    0
+    >>> np.argmin(a, axis=0)
+    array([0, 0, 0])
+    >>> np.argmin(a, axis=1)
+    array([0, 0])
+
+    Indices of the minimum elements of a N-dimensional array:
+
+    >>> ind = np.unravel_index(np.argmin(a, axis=None), a.shape)
+    >>> ind
+    (0, 0)
+    >>> a[ind]
+    10
+
+    >>> b = np.arange(6) + 10
+    >>> b[4] = 10
+    >>> b
+    array([10, 11, 12, 13, 10, 15])
+    >>> np.argmin(b)  # Only the first occurrence is returned.
+    0
+
+    >>> x = np.array([[4,2,3], [1,0,3]])
+    >>> index_array = np.argmin(x, axis=-1)
+    >>> # Same as np.min(x, axis=-1, keepdims=True)
+    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
+    array([[2],
+           [0]])
+    >>> # Same as np.max(x, axis=-1)
+    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1)
+    array([2, 0])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def chararray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "chararray"))))
+(alter-meta! #'chararray assoc :doc "
+    chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,
+              strides=None, order=None)
+
+    Provides a convenient view on arrays of string and unicode values.
+
+    .. note::
+       The `chararray` class exists for backwards compatibility with
+       Numarray, it is not recommended for new development. Starting from numpy
+       1.4, if one needs arrays of strings, it is recommended to use arrays of
+       `dtype` `object_`, `string_` or `unicode_`, and use the free functions
+       in the `numpy.char` module for fast vectorized string operations.
+
+    Versus a regular NumPy array of type `str` or `unicode`, this
+    class adds the following functionality:
+
+      1) values automatically have whitespace removed from the end
+         when indexed
+
+      2) comparison operators automatically remove whitespace from the
+         end when comparing values
+
+      3) vectorized string operations are provided as methods
+         (e.g. `.endswith`) and infix operators (e.g. ``\"+\", \"*\", \"%\"``)
+
+    chararrays should be created using `numpy.char.array` or
+    `numpy.char.asarray`, rather than this constructor directly.
+
+    This constructor creates the array, using `buffer` (with `offset`
+    and `strides`) if it is not ``None``. If `buffer` is ``None``, then
+    constructs a new array with `strides` in \"C order\", unless both
+    ``len(shape) >= 2`` and ``order='F'``, in which case `strides`
+    is in \"Fortran order\".
+
+    Methods
+    -------
+    astype
+    argsort
+    copy
+    count
+    decode
+    dump
+    dumps
+    encode
+    endswith
+    expandtabs
+    fill
+    find
+    flatten
+    getfield
+    index
+    isalnum
+    isalpha
+    isdecimal
+    isdigit
+    islower
+    isnumeric
+    isspace
+    istitle
+    isupper
+    item
+    join
+    ljust
+    lower
+    lstrip
+    nonzero
+    put
+    ravel
+    repeat
+    replace
+    reshape
+    resize
+    rfind
+    rindex
+    rjust
+    rsplit
+    rstrip
+    searchsorted
+    setfield
+    setflags
+    sort
+    split
+    splitlines
+    squeeze
+    startswith
+    strip
+    swapaxes
+    swapcase
+    take
+    title
+    tofile
+    tolist
+    tostring
+    translate
+    transpose
+    upper
+    view
+    zfill
+
+    Parameters
+    ----------
+    shape : tuple
+        Shape of the array.
+    itemsize : int, optional
+        Length of each array element, in number of characters. Default is 1.
+    unicode : bool, optional
+        Are the array elements of type unicode (True) or string (False).
+        Default is False.
+    buffer : int, optional
+        Memory address of the start of the array data.  Default is None,
+        in which case a new array is created.
+    offset : int, optional
+        Fixed stride displacement from the beginning of an axis?
+        Default is 0. Needs to be >=0.
+    strides : array_like of ints, optional
+        Strides for the array (see `ndarray.strides` for full description).
+        Default is None.
+    order : {'C', 'F'}, optional
+        The order in which the array data is stored in memory: 'C' ->
+        \"row major\" order (the default), 'F' -> \"column major\"
+        (Fortran) order.
+
+    Examples
+    --------
+    >>> charar = np.chararray((3, 3))
+    >>> charar[:] = 'a'
+    >>> charar
+    chararray([[b'a', b'a', b'a'],
+               [b'a', b'a', b'a'],
+               [b'a', b'a', b'a']], dtype='|S1')
+
+    >>> charar = np.chararray(charar.shape, itemsize=5)
+    >>> charar[:] = 'abc'
+    >>> charar
+    chararray([[b'abc', b'abc', b'abc'],
+               [b'abc', b'abc', b'abc'],
+               [b'abc', b'abc', b'abc']], dtype='|S5')
+
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def shares_memory (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "shares_memory"))))
+(alter-meta! #'shares_memory assoc :doc "
+    shares_memory(a, b, max_work=None)
+
+    Determine if two arrays share memory
+
+    Parameters
+    ----------
+    a, b : ndarray
+        Input arrays
+    max_work : int, optional
+        Effort to spend on solving the overlap problem (maximum number
+        of candidate solutions to consider). The following special
+        values are recognized:
+
+        max_work=MAY_SHARE_EXACT  (default)
+            The problem is solved exactly. In this case, the function returns
+            True only if there is an element shared between the arrays.
+        max_work=MAY_SHARE_BOUNDS
+            Only the memory bounds of a and b are checked.
+
+    Raises
+    ------
+    numpy.TooHardError
+        Exceeded max_work.
+
+    Returns
+    -------
+    out : bool
+
+    See Also
+    --------
+    may_share_memory
+
+    Examples
+    --------
+    >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9]))
+    False
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def flip (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flip"))))
+(alter-meta! #'flip assoc :doc "
+    Reverse the order of elements in an array along the given axis.
+
+    The shape of the array is preserved, but the elements are reordered.
+
+    .. versionadded:: 1.12.0
+
+    Parameters
+    ----------
+    m : array_like
+        Input array.
+    axis : None or int or tuple of ints, optional
+         Axis or axes along which to flip over. The default,
+         axis=None, will flip over all of the axes of the input array.
+         If axis is negative it counts from the last to the first axis.
+
+         If axis is a tuple of ints, flipping is performed on all of the axes
+         specified in the tuple.
+
+         .. versionchanged:: 1.15.0
+            None and tuples of axes are supported
+
+    Returns
+    -------
+    out : array_like
+        A view of `m` with the entries of axis reversed.  Since a view is
+        returned, this operation is done in constant time.
+
+    See Also
+    --------
+    flipud : Flip an array vertically (axis=0).
+    fliplr : Flip an array horizontally (axis=1).
+
+    Notes
+    -----
+    flip(m, 0) is equivalent to flipud(m).
+
+    flip(m, 1) is equivalent to fliplr(m).
+
+    flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n.
+
+    flip(m) corresponds to ``m[::-1,::-1,...,::-1]`` with ``::-1`` at all
+    positions.
+
+    flip(m, (0, 1)) corresponds to ``m[::-1,::-1,...]`` with ``::-1`` at
+    position 0 and position 1.
+
+    Examples
+    --------
+    >>> A = np.arange(8).reshape((2,2,2))
+    >>> A
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+    >>> np.flip(A, 0)
+    array([[[4, 5],
+            [6, 7]],
+           [[0, 1],
+            [2, 3]]])
+    >>> np.flip(A, 1)
+    array([[[2, 3],
+            [0, 1]],
+           [[6, 7],
+            [4, 5]]])
+    >>> np.flip(A)
+    array([[[7, 6],
+            [5, 4]],
+           [[3, 2],
+            [1, 0]]])
+    >>> np.flip(A, (0, 2))
+    array([[[5, 4],
+            [7, 6]],
+           [[1, 0],
+            [3, 2]]])
+    >>> A = np.random.randn(3,4,5)
+    >>> np.all(np.flip(A,2) == A[:,:,::-1,...])
+    True
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def block (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "block"))))
+(alter-meta! #'block assoc :doc "
+    Assemble an nd-array from nested lists of blocks.
+
+    Blocks in the innermost lists are concatenated (see `concatenate`) along
+    the last dimension (-1), then these are concatenated along the
+    second-last dimension (-2), and so on until the outermost list is reached.
+
+    Blocks can be of any dimension, but will not be broadcasted using the normal
+    rules. Instead, leading axes of size 1 are inserted, to make ``block.ndim``
+    the same for all blocks. This is primarily useful for working with scalars,
+    and means that code like ``np.block([v, 1])`` is valid, where
+    ``v.ndim == 1``.
+
+    When the nested list is two levels deep, this allows block matrices to be
+    constructed from their components.
+
+    .. versionadded:: 1.13.0
+
+    Parameters
+    ----------
+    arrays : nested list of array_like or scalars (but not tuples)
+        If passed a single ndarray or scalar (a nested list of depth 0), this
+        is returned unmodified (and not copied).
+
+        Elements shapes must match along the appropriate axes (without
+        broadcasting), but leading 1s will be prepended to the shape as
+        necessary to make the dimensions match.
+
+    Returns
+    -------
+    block_array : ndarray
+        The array assembled from the given blocks.
+
+        The dimensionality of the output is equal to the greatest of:
+        * the dimensionality of all the inputs
+        * the depth to which the input list is nested
+
+    Raises
+    ------
+    ValueError
+        * If list depths are mismatched - for instance, ``[[a, b], c]`` is
+          illegal, and should be spelt ``[[a, b], [c]]``
+        * If lists are empty - for instance, ``[[a, b], []]``
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays together.
+    stack : Stack arrays in sequence along a new dimension.
+    hstack : Stack arrays in sequence horizontally (column wise).
+    vstack : Stack arrays in sequence vertically (row wise).
+    dstack : Stack arrays in sequence depth wise (along third dimension).
+    vsplit : Split array into a list of multiple sub-arrays vertically.
+
+    Notes
+    -----
+
+    When called with only scalars, ``np.block`` is equivalent to an ndarray
+    call. So ``np.block([[1, 2], [3, 4]])`` is equivalent to
+    ``np.array([[1, 2], [3, 4]])``.
+
+    This function does not enforce that the blocks lie on a fixed grid.
+    ``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form::
+
+        AAAbb
+        AAAbb
+        cccDD
+
+    But is also allowed to produce, for some ``a, b, c, d``::
+
+        AAAbb
+        AAAbb
+        cDDDD
+
+    Since concatenation happens along the last axis first, `block` is _not_
+    capable of producing the following directly::
+
+        AAAbb
+        cccbb
+        cccDD
+
+    Matlab's \"square bracket stacking\", ``[A, B, ...; p, q, ...]``, is
+    equivalent to ``np.block([[A, B, ...], [p, q, ...]])``.
+
+    Examples
+    --------
+    The most common use of this function is to build a block matrix
+
+    >>> A = np.eye(2) * 2
+    >>> B = np.eye(3) * 3
+    >>> np.block([
+    ...     [A,               np.zeros((2, 3))],
+    ...     [np.ones((3, 2)), B               ]
+    ... ])
+    array([[2., 0., 0., 0., 0.],
+           [0., 2., 0., 0., 0.],
+           [1., 1., 3., 0., 0.],
+           [1., 1., 0., 3., 0.],
+           [1., 1., 0., 0., 3.]])
+
+    With a list of depth 1, `block` can be used as `hstack`
+
+    >>> np.block([1, 2, 3])              # hstack([1, 2, 3])
+    array([1, 2, 3])
+
+    >>> a = np.array([1, 2, 3])
+    >>> b = np.array([2, 3, 4])
+    >>> np.block([a, b, 10])             # hstack([a, b, 10])
+    array([ 1,  2,  3,  2,  3,  4, 10])
+
+    >>> A = np.ones((2, 2), int)
+    >>> B = 2 * A
+    >>> np.block([A, B])                 # hstack([A, B])
+    array([[1, 1, 2, 2],
+           [1, 1, 2, 2]])
+
+    With a list of depth 2, `block` can be used in place of `vstack`:
+
+    >>> a = np.array([1, 2, 3])
+    >>> b = np.array([2, 3, 4])
+    >>> np.block([[a], [b]])             # vstack([a, b])
+    array([[1, 2, 3],
+           [2, 3, 4]])
+
+    >>> A = np.ones((2, 2), int)
+    >>> B = 2 * A
+    >>> np.block([[A], [B]])             # vstack([A, B])
+    array([[1, 1],
+           [1, 1],
+           [2, 2],
+           [2, 2]])
+
+    It can also be used in places of `atleast_1d` and `atleast_2d`
+
+    >>> a = np.array(0)
+    >>> b = np.array([1])
+    >>> np.block([a])                    # atleast_1d(a)
+    array([0])
+    >>> np.block([b])                    # atleast_1d(b)
+    array([1])
+
+    >>> np.block([[a]])                  # atleast_2d(a)
+    array([[0]])
+    >>> np.block([[b]])                  # atleast_2d(b)
+    array([[1]])
+
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def putmask (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "putmask"))))
+(alter-meta! #'putmask assoc :doc "
+    putmask(a, mask, values)
+
+    Changes elements of an array based on conditional and input values.
+
+    Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``.
+
+    If `values` is not the same size as `a` and `mask` then it will repeat.
+    This gives behavior different from ``a[mask] = values``.
+
+    Parameters
+    ----------
+    a : array_like
+        Target array.
+    mask : array_like
+        Boolean mask array. It has to be the same shape as `a`.
+    values : array_like
+        Values to put into `a` where `mask` is True. If `values` is smaller
+        than `a` it will be repeated.
+
+    See Also
+    --------
+    place, put, take, copyto
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2, 3)
+    >>> np.putmask(x, x>2, x**2)
+    >>> x
+    array([[ 0,  1,  2],
+           [ 9, 16, 25]])
+
+    If `values` is smaller than `a` it is repeated:
+
+    >>> x = np.arange(5)
+    >>> np.putmask(x, x>1, [-33, -44])
+    >>> x
+    array([  0,   1, -33, -44, -33])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def arctanh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arctanh"))))
+(alter-meta! #'arctanh assoc :doc "arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Inverse hyperbolic tangent element-wise.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Array of the same shape as `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+emath.arctanh
+
+Notes
+-----
+`arctanh` is a multivalued function: for each `x` there are infinitely
+many numbers `z` such that `tanh(z) = x`. The convention is to return
+the `z` whose imaginary part lies in `[-pi/2, pi/2]`.
+
+For real-valued input data types, `arctanh` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arctanh` is a complex analytical function
+that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from
+above on the former and from below on the latter.
+
+The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Inverse hyperbolic function\",
+       https://en.wikipedia.org/wiki/Arctanh
+
+Examples
+--------
+>>> np.arctanh([0, -0.5])
+array([ 0.        , -0.54930614])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def take (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "take"))))
+(alter-meta! #'take assoc :doc "
+    Take elements from an array along an axis.
+
+    When axis is not None, this function does the same thing as \"fancy\"
+    indexing (indexing arrays using arrays); however, it can be easier to use
+    if you need elements along a given axis. A call such as
+    ``np.take(arr, indices, axis=3)`` is equivalent to
+    ``arr[:,:,:,indices,...]``.
+
+    Explained without fancy indexing, this is equivalent to the following use
+    of `ndindex`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of
+    indices::
+
+        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+        Nj = indices.shape
+        for ii in ndindex(Ni):
+            for jj in ndindex(Nj):
+                for kk in ndindex(Nk):
+                    out[ii + jj + kk] = a[ii + (indices[jj],) + kk]
+
+    Parameters
+    ----------
+    a : array_like (Ni..., M, Nk...)
+        The source array.
+    indices : array_like (Nj...)
+        The indices of the values to extract.
+
+        .. versionadded:: 1.8.0
+
+        Also allow scalars for indices.
+    axis : int, optional
+        The axis over which to select values. By default, the flattened
+        input array is used.
+    out : ndarray, optional (Ni..., Nj..., Nk...)
+        If provided, the result will be placed in this array. It should
+        be of the appropriate shape and dtype. Note that `out` is always
+        buffered if `mode='raise'`; use other modes for better performance.
+    mode : {'raise', 'wrap', 'clip'}, optional
+        Specifies how out-of-bounds indices will behave.
+
+        * 'raise' -- raise an error (default)
+        * 'wrap' -- wrap around
+        * 'clip' -- clip to the range
+
+        'clip' mode means that all indices that are too large are replaced
+        by the index that addresses the last element along that axis. Note
+        that this disables indexing with negative numbers.
+
+    Returns
+    -------
+    out : ndarray (Ni..., Nj..., Nk...)
+        The returned array has the same type as `a`.
+
+    See Also
+    --------
+    compress : Take elements using a boolean mask
+    ndarray.take : equivalent method
+    take_along_axis : Take elements by matching the array and the index arrays
+
+    Notes
+    -----
+
+    By eliminating the inner loop in the description above, and using `s_` to
+    build simple slice objects, `take` can be expressed  in terms of applying
+    fancy indexing to each 1-d slice::
+
+        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nj):
+                out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices]
+
+    For this reason, it is equivalent to (but faster than) the following use
+    of `apply_along_axis`::
+
+        out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a)
+
+    Examples
+    --------
+    >>> a = [4, 3, 5, 7, 6, 8]
+    >>> indices = [0, 1, 4]
+    >>> np.take(a, indices)
+    array([4, 3, 6])
+
+    In this example if `a` is an ndarray, \"fancy\" indexing can be used.
+
+    >>> a = np.array(a)
+    >>> a[indices]
+    array([4, 3, 6])
+
+    If `indices` is not one dimensional, the output also has these dimensions.
+
+    >>> np.take(a, [[0, 1], [2, 3]])
+    array([[4, 3],
+           [5, 7]])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def conjugate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "conjugate"))))
+(alter-meta! #'conjugate assoc :doc "conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the complex conjugate, element-wise.
+
+The complex conjugate of a complex number is obtained by changing the
+sign of its imaginary part.
+
+Parameters
+----------
+x : array_like
+    Input value.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The complex conjugate of `x`, with same dtype as `y`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+`conj` is an alias for `conjugate`:
+
+>>> np.conj is np.conjugate
+True
+
+Examples
+--------
+>>> np.conjugate(1+2j)
+(1-2j)
+
+>>> x = np.eye(2) + 1j * np.eye(2)
+>>> np.conjugate(x)
+array([[ 1.-1.j,  0.-0.j],
+       [ 0.-0.j,  1.-1.j]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def __getattr__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__getattr__"))))
+(alter-meta! #'__getattr__ assoc :doc "" :arglists '[[attr]])
+
+(def seterrcall (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "seterrcall"))))
+(alter-meta! #'seterrcall assoc :doc "
+    Set the floating-point error callback function or log object.
+
+    There are two ways to capture floating-point error messages.  The first
+    is to set the error-handler to 'call', using `seterr`.  Then, set
+    the function to call using this function.
+
+    The second is to set the error-handler to 'log', using `seterr`.
+    Floating-point errors then trigger a call to the 'write' method of
+    the provided object.
+
+    Parameters
+    ----------
+    func : callable f(err, flag) or object with write method
+        Function to call upon floating-point errors ('call'-mode) or
+        object whose 'write' method is used to log such message ('log'-mode).
+
+        The call function takes two arguments. The first is a string describing
+        the type of error (such as \"divide by zero\", \"overflow\", \"underflow\",
+        or \"invalid value\"), and the second is the status flag.  The flag is a
+        byte, whose four least-significant bits indicate the type of error, one
+        of \"divide\", \"over\", \"under\", \"invalid\"::
+
+          [0 0 0 0 divide over under invalid]
+
+        In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.
+
+        If an object is provided, its write method should take one argument,
+        a string.
+
+    Returns
+    -------
+    h : callable, log instance or None
+        The old error handler.
+
+    See Also
+    --------
+    seterr, geterr, geterrcall
+
+    Examples
+    --------
+    Callback upon error:
+
+    >>> def err_handler(type, flag):
+    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
+    ...
+
+    >>> saved_handler = np.seterrcall(err_handler)
+    >>> save_err = np.seterr(all='call')
+    >>> from collections import OrderedDict
+
+    >>> np.array([1, 2, 3]) / 0.0
+    Floating point error (divide by zero), with flag 1
+    array([inf, inf, inf])
+
+    >>> np.seterrcall(saved_handler)
+    <function err_handler at 0x...>
+    >>> OrderedDict(sorted(np.seterr(**save_err).items()))
+    OrderedDict([('divide', 'call'), ('invalid', 'call'), ('over', 'call'), ('under', 'call')])
+
+    Log error message:
+
+    >>> class Log(object):
+    ...     def write(self, msg):
+    ...         print(\"LOG: %s\" % msg)
+    ...
+
+    >>> log = Log()
+    >>> saved_handler = np.seterrcall(log)
+    >>> save_err = np.seterr(all='log')
+
+    >>> np.array([1, 2, 3]) / 0.0
+    LOG: Warning: divide by zero encountered in true_divide
+    array([inf, inf, inf])
+
+    >>> np.seterrcall(saved_handler)
+    <numpy.core.numeric.Log object at 0x...>
+    >>> OrderedDict(sorted(np.seterr(**save_err).items()))
+    OrderedDict([('divide', 'log'), ('invalid', 'log'), ('over', 'log'), ('under', 'log')])
+
+    " :arglists '[[func]])
+
+(def unicode (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unicode"))))
+(alter-meta! #'unicode assoc :doc "str(object='') -> str
+str(bytes_or_buffer[, encoding[, errors]]) -> str
+
+Create a new string object from the given object. If encoding or
+errors is specified, then the object must expose a data buffer
+that will be decoded using the given encoding and error handler.
+Otherwise, returns the result of object.__str__() (if defined)
+or repr(object).
+encoding defaults to sys.getdefaultencoding().
+errors defaults to 'strict'." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} SHIFT_OVERFLOW (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "SHIFT_OVERFLOW"))))
+
+(def iscomplex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iscomplex"))))
+(alter-meta! #'iscomplex assoc :doc "
+    Returns a bool array, where True if input element is complex.
+
+    What is tested is whether the input has a non-zero imaginary part, not if
+    the input type is complex.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray of bools
+        Output array.
+
+    See Also
+    --------
+    isreal
+    iscomplexobj : Return True if x is a complex type or an array of complex
+                   numbers.
+
+    Examples
+    --------
+    >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])
+    array([ True, False, False, False, False,  True])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ushort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ushort"))))
+(alter-meta! #'ushort assoc :doc "Unsigned integer type, compatible with C ``unsigned short``.
+    Character code: ``'H'``.
+    Canonical name: ``np.ushort``.
+    Alias *on this platform*: ``np.uint16``: 16-bit unsigned integer (0 to 65535)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def fmod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fmod"))))
+(alter-meta! #'fmod assoc :doc "fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the element-wise remainder of division.
+
+This is the NumPy implementation of the C library function fmod, the
+remainder has the same sign as the dividend `x1`. It is equivalent to
+the Matlab(TM) ``rem`` function and should not be confused with the
+Python modulus operator ``x1 % x2``.
+
+Parameters
+----------
+x1 : array_like
+    Dividend.
+x2 : array_like
+    Divisor. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : array_like
+    The remainder of the division of `x1` by `x2`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+remainder : Equivalent to the Python ``%`` operator.
+divide
+
+Notes
+-----
+The result of the modulo operation for negative dividend and divisors
+is bound by conventions. For `fmod`, the sign of result is the sign of
+the dividend, while for `remainder` the sign of the result is the sign
+of the divisor. The `fmod` function is equivalent to the Matlab(TM)
+``rem`` function.
+
+Examples
+--------
+>>> np.fmod([-3, -2, -1, 1, 2, 3], 2)
+array([-1,  0, -1,  1,  0,  1])
+>>> np.remainder([-3, -2, -1, 1, 2, 3], 2)
+array([1, 0, 1, 1, 0, 1])
+
+>>> np.fmod([5, 3], [2, 2.])
+array([ 1.,  1.])
+>>> a = np.arange(-3, 3).reshape(3, 2)
+>>> a
+array([[-3, -2],
+       [-1,  0],
+       [ 1,  2]])
+>>> np.fmod(a, [2,2])
+array([[-1,  0],
+       [-1,  0],
+       [ 1,  0]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def can_cast (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "can_cast"))))
+(alter-meta! #'can_cast assoc :doc "
+    can_cast(from_, to, casting='safe')
+
+    Returns True if cast between data types can occur according to the
+    casting rule.  If from is a scalar or array scalar, also returns
+    True if the scalar value can be cast without overflow or truncation
+    to an integer.
+
+    Parameters
+    ----------
+    from_ : dtype, dtype specifier, scalar, or array
+        Data type, scalar, or array to cast from.
+    to : dtype or dtype specifier
+        Data type to cast to.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur.
+
+          * 'no' means the data types should not be cast at all.
+          * 'equiv' means only byte-order changes are allowed.
+          * 'safe' means only casts which can preserve values are allowed.
+          * 'same_kind' means only safe casts or casts within a kind,
+            like float64 to float32, are allowed.
+          * 'unsafe' means any data conversions may be done.
+
+    Returns
+    -------
+    out : bool
+        True if cast can occur according to the casting rule.
+
+    Notes
+    -----
+    .. versionchanged:: 1.17.0
+       Casting between a simple data type and a structured one is possible only
+       for \"unsafe\" casting.  Casting to multiple fields is allowed, but
+       casting from multiple fields is not.
+
+    .. versionchanged:: 1.9.0
+       Casting from numeric to string types in 'safe' casting mode requires
+       that the string dtype length is long enough to store the maximum
+       integer/float value converted.
+
+    See also
+    --------
+    dtype, result_type
+
+    Examples
+    --------
+    Basic examples
+
+    >>> np.can_cast(np.int32, np.int64)
+    True
+    >>> np.can_cast(np.float64, complex)
+    True
+    >>> np.can_cast(complex, float)
+    False
+
+    >>> np.can_cast('i8', 'f8')
+    True
+    >>> np.can_cast('i8', 'f4')
+    False
+    >>> np.can_cast('i4', 'S4')
+    False
+
+    Casting scalars
+
+    >>> np.can_cast(100, 'i1')
+    True
+    >>> np.can_cast(150, 'i1')
+    False
+    >>> np.can_cast(150, 'u1')
+    True
+
+    >>> np.can_cast(3.5e100, np.float32)
+    False
+    >>> np.can_cast(1000.0, np.float32)
+    True
+
+    Array scalar checks the value, array does not
+
+    >>> np.can_cast(np.array(1000.0), np.float32)
+    True
+    >>> np.can_cast(np.array([1000.0]), np.float32)
+    False
+
+    Using the casting rules
+
+    >>> np.can_cast('i8', 'i8', 'no')
+    True
+    >>> np.can_cast('<i8', '>i8', 'no')
+    False
+
+    >>> np.can_cast('<i8', '>i8', 'equiv')
+    True
+    >>> np.can_cast('<i4', '>i8', 'equiv')
+    False
+
+    >>> np.can_cast('<i4', '>i8', 'safe')
+    True
+    >>> np.can_cast('<i8', '>i4', 'safe')
+    False
+
+    >>> np.can_cast('<i8', '>i4', 'same_kind')
+    True
+    >>> np.can_cast('<i8', '>u4', 'same_kind')
+    False
+
+    >>> np.can_cast('<i8', '>u4', 'unsafe')
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def quantile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "quantile"))))
+(alter-meta! #'quantile assoc :doc "
+    Compute the q-th quantile of the data along the specified axis.
+    
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    q : array_like of float
+        Quantile or sequence of quantiles to compute, which must be between
+        0 and 1 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the quantiles are computed. The
+        default is to compute the quantile(s) along a flattened
+        version of the array.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by intermediate
+        calculations, to save memory. In this case, the contents of the input
+        `a` after this function completes is undefined.
+    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
+        This optional parameter specifies the interpolation method to
+        use when the desired quantile lies between two data points
+        ``i < j``:
+
+            * linear: ``i + (j - i) * fraction``, where ``fraction``
+              is the fractional part of the index surrounded by ``i``
+              and ``j``.
+            * lower: ``i``.
+            * higher: ``j``.
+            * nearest: ``i`` or ``j``, whichever is nearest.
+            * midpoint: ``(i + j) / 2``.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+    Returns
+    -------
+    quantile : scalar or ndarray
+        If `q` is a single quantile and `axis=None`, then the result
+        is a scalar. If multiple quantiles are given, first axis of
+        the result corresponds to the quantiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean
+    percentile : equivalent to quantile, but with q in the range [0, 100].
+    median : equivalent to ``quantile(..., 0.5)``
+    nanquantile
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the q-th quantile of
+    ``V`` is the value ``q`` of the way from the minimum to the
+    maximum in a sorted copy of ``V``. The values and distances of
+    the two nearest neighbors as well as the `interpolation` parameter
+    will determine the quantile if the normalized ranking does not
+    match the location of ``q`` exactly. This function is the same as
+    the median if ``q=0.5``, the same as the minimum if ``q=0.0`` and the
+    same as the maximum if ``q=1.0``.
+
+    Examples
+    --------
+    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
+    >>> a
+    array([[10,  7,  4],
+           [ 3,  2,  1]])
+    >>> np.quantile(a, 0.5)
+    3.5
+    >>> np.quantile(a, 0.5, axis=0)
+    array([6.5, 4.5, 2.5])
+    >>> np.quantile(a, 0.5, axis=1)
+    array([7.,  2.])
+    >>> np.quantile(a, 0.5, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+    >>> m = np.quantile(a, 0.5, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.quantile(a, 0.5, axis=0, out=out)
+    array([6.5, 4.5, 2.5])
+    >>> m
+    array([6.5, 4.5, 2.5])
+    >>> b = a.copy()
+    >>> np.quantile(b, 0.5, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a == b)
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def unwrap (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unwrap"))))
+(alter-meta! #'unwrap assoc :doc "
+    Unwrap by changing deltas between values to 2*pi complement.
+
+    Unwrap radian phase `p` by changing absolute jumps greater than
+    `discont` to their 2*pi complement along the given axis.
+
+    Parameters
+    ----------
+    p : array_like
+        Input array.
+    discont : float, optional
+        Maximum discontinuity between values, default is ``pi``.
+    axis : int, optional
+        Axis along which unwrap will operate, default is the last axis.
+
+    Returns
+    -------
+    out : ndarray
+        Output array.
+
+    See Also
+    --------
+    rad2deg, deg2rad
+
+    Notes
+    -----
+    If the discontinuity in `p` is smaller than ``pi``, but larger than
+    `discont`, no unwrapping is done because taking the 2*pi complement
+    would only make the discontinuity larger.
+
+    Examples
+    --------
+    >>> phase = np.linspace(0, np.pi, num=5)
+    >>> phase[3:] += np.pi
+    >>> phase
+    array([ 0.        ,  0.78539816,  1.57079633,  5.49778714,  6.28318531]) # may vary
+    >>> np.unwrap(phase)
+    array([ 0.        ,  0.78539816,  1.57079633, -0.78539816,  0.        ]) # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} __file__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__file__"))))
+
+(def short (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "short"))))
+(alter-meta! #'short assoc :doc "Signed integer type, compatible with C ``short``.
+    Character code: ``'h'``.
+    Canonical name: ``np.short``.
+    Alias *on this platform*: ``np.int16``: 16-bit signed integer (-32768 to 32767)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def datetime_as_string (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "datetime_as_string"))))
+(alter-meta! #'datetime_as_string assoc :doc "
+    datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind')
+
+    Convert an array of datetimes into an array of strings.
+
+    Parameters
+    ----------
+    arr : array_like of datetime64
+        The array of UTC timestamps to format.
+    unit : str
+        One of None, 'auto', or a :ref:`datetime unit <arrays.dtypes.dateunits>`.
+    timezone : {'naive', 'UTC', 'local'} or tzinfo
+        Timezone information to use when displaying the datetime. If 'UTC', end
+        with a Z to indicate UTC time. If 'local', convert to the local timezone
+        first, and suffix with a +-#### timezone offset. If a tzinfo object,
+        then do as with 'local', but use the specified timezone.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}
+        Casting to allow when changing between datetime units.
+
+    Returns
+    -------
+    str_arr : ndarray
+        An array of strings the same shape as `arr`.
+
+    Examples
+    --------
+    >>> import pytz
+    >>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]')
+    >>> d
+    array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30',
+           '2002-10-27T07:30'], dtype='datetime64[m]')
+
+    Setting the timezone to UTC shows the same information, but with a Z suffix
+
+    >>> np.datetime_as_string(d, timezone='UTC')
+    array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z',
+           '2002-10-27T07:30Z'], dtype='<U35')
+
+    Note that we picked datetimes that cross a DST boundary. Passing in a
+    ``pytz`` timezone object will print the appropriate offset
+
+    >>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern'))
+    array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400',
+           '2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='<U39')
+
+    Passing in a unit will change the precision
+
+    >>> np.datetime_as_string(d, unit='h')
+    array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'],
+          dtype='<U32')
+    >>> np.datetime_as_string(d, unit='s')
+    array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00',
+           '2002-10-27T07:30:00'], dtype='<U38')
+
+    'casting' can be used to specify whether precision can be changed
+
+    >>> np.datetime_as_string(d, unit='h', casting='safe')
+    Traceback (most recent call last):
+        ...
+    TypeError: Cannot create a datetime string as units 'h' from a NumPy
+    datetime with units 'm' according to the rule 'safe'
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def datetime_data (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "datetime_data"))))
+(alter-meta! #'datetime_data assoc :doc "datetime_data(dtype, /)
+
+    Get information about the step size of a date or time type.
+
+    The returned tuple can be passed as the second argument of `numpy.datetime64` and
+    `numpy.timedelta64`.
+
+    Parameters
+    ----------
+    dtype : dtype
+        The dtype object, which must be a `datetime64` or `timedelta64` type.
+
+    Returns
+    -------
+    unit : str
+        The :ref:`datetime unit <arrays.dtypes.dateunits>` on which this dtype
+        is based.
+    count : int
+        The number of base units in a step.
+
+    Examples
+    --------
+    >>> dt_25s = np.dtype('timedelta64[25s]')
+    >>> np.datetime_data(dt_25s)
+    ('s', 25)
+    >>> np.array(10, dt_25s).astype('timedelta64[s]')
+    array(250, dtype='timedelta64[s]')
+
+    The result can be used to construct a datetime that uses the same units
+    as a timedelta
+
+    >>> np.datetime64('2010', np.datetime_data(dt_25s))
+    numpy.datetime64('2010-01-01T00:00:00','25s')" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} nan (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "nan"))))
+
+(def imag (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "imag"))))
+(alter-meta! #'imag assoc :doc "
+    Return the imaginary part of the complex argument.
+
+    Parameters
+    ----------
+    val : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray or scalar
+        The imaginary component of the complex argument. If `val` is real,
+        the type of `val` is used for the output.  If `val` has complex
+        elements, the returned type is float.
+
+    See Also
+    --------
+    real, angle, real_if_close
+
+    Examples
+    --------
+    >>> a = np.array([1+2j, 3+4j, 5+6j])
+    >>> a.imag
+    array([2.,  4.,  6.])
+    >>> a.imag = np.array([8, 10, 12])
+    >>> a
+    array([1. +8.j,  3.+10.j,  5.+12.j])
+    >>> np.imag(1 + 1j)
+    1.0
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def count_nonzero (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "count_nonzero"))))
+(alter-meta! #'count_nonzero assoc :doc "
+    Counts the number of non-zero values in the array ``a``.
+
+    The word \"non-zero\" is in reference to the Python 2.x
+    built-in method ``__nonzero__()`` (renamed ``__bool__()``
+    in Python 3.x) of Python objects that tests an object's
+    \"truthfulness\". For example, any number is considered
+    truthful if it is nonzero, whereas any string is considered
+    truthful if it is not the empty string. Thus, this function
+    (recursively) counts how many elements in ``a`` (and in
+    sub-arrays thereof) have their ``__nonzero__()`` or ``__bool__()``
+    method evaluated to ``True``.
+
+    Parameters
+    ----------
+    a : array_like
+        The array for which to count non-zeros.
+    axis : int or tuple, optional
+        Axis or tuple of axes along which to count non-zeros.
+        Default is None, meaning that non-zeros will be counted
+        along a flattened version of ``a``.
+
+        .. versionadded:: 1.12.0
+
+    Returns
+    -------
+    count : int or array of int
+        Number of non-zero values in the array along a given axis.
+        Otherwise, the total number of non-zero values in the array
+        is returned.
+
+    See Also
+    --------
+    nonzero : Return the coordinates of all the non-zero values.
+
+    Examples
+    --------
+    >>> np.count_nonzero(np.eye(4))
+    4
+    >>> np.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]])
+    5
+    >>> np.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]], axis=0)
+    array([1, 1, 1, 1, 1])
+    >>> np.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]], axis=1)
+    array([2, 3])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def float128 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float128"))))
+(alter-meta! #'float128 assoc :doc "Extended-precision floating-point number type, compatible with C
+    ``long double`` but not necessarily with IEEE 754 quadruple-precision.
+    Character code: ``'g'``.
+    Canonical name: ``np.longdouble``.
+    Alias: ``np.longfloat``.
+    Alias *on this platform*: ``np.float128``: 128-bit extended-precision floating-point number type." :arglists '[[self & [args {:as kwargs}]]])
+
+(def greater (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "greater"))))
+(alter-meta! #'greater assoc :doc "greater(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the truth value of (x1 > x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+
+See Also
+--------
+greater_equal, less, less_equal, equal, not_equal
+
+Examples
+--------
+>>> np.greater([4,2],[2,2])
+array([ True, False])
+
+If the inputs are ndarrays, then np.greater is equivalent to '>'.
+
+>>> a = np.array([4,2])
+>>> b = np.array([2,2])
+>>> a > b
+array([ True, False])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def sort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sort"))))
+(alter-meta! #'sort assoc :doc "
+    Return a sorted copy of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Array to be sorted.
+    axis : int or None, optional
+        Axis along which to sort. If None, the array is flattened before
+        sorting. The default is -1, which sorts along the last axis.
+    kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
+        Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
+        and 'mergesort' use timsort or radix sort under the covers and, in general,
+        the actual implementation will vary with data type. The 'mergesort' option
+        is retained for backwards compatibility.
+
+        .. versionchanged:: 1.15.0.
+           The 'stable' option was added.
+
+    order : str or list of str, optional
+        When `a` is an array with fields defined, this argument specifies
+        which fields to compare first, second, etc.  A single field can
+        be specified as a string, and not all fields need be specified,
+        but unspecified fields will still be used, in the order in which
+        they come up in the dtype, to break ties.
+
+    Returns
+    -------
+    sorted_array : ndarray
+        Array of the same type and shape as `a`.
+
+    See Also
+    --------
+    ndarray.sort : Method to sort an array in-place.
+    argsort : Indirect sort.
+    lexsort : Indirect stable sort on multiple keys.
+    searchsorted : Find elements in a sorted array.
+    partition : Partial sort.
+
+    Notes
+    -----
+    The various sorting algorithms are characterized by their average speed,
+    worst case performance, work space size, and whether they are stable. A
+    stable sort keeps items with the same key in the same relative
+    order. The four algorithms implemented in NumPy have the following
+    properties:
+
+    =========== ======= ============= ============ ========
+       kind      speed   worst case    work space   stable
+    =========== ======= ============= ============ ========
+    'quicksort'    1     O(n^2)            0          no
+    'heapsort'     3     O(n*log(n))       0          no
+    'mergesort'    2     O(n*log(n))      ~n/2        yes
+    'timsort'      2     O(n*log(n))      ~n/2        yes
+    =========== ======= ============= ============ ========
+
+    .. note:: The datatype determines which of 'mergesort' or 'timsort'
+       is actually used, even if 'mergesort' is specified. User selection
+       at a finer scale is not currently available.
+
+    All the sort algorithms make temporary copies of the data when
+    sorting along any but the last axis.  Consequently, sorting along
+    the last axis is faster and uses less space than sorting along
+    any other axis.
+
+    The sort order for complex numbers is lexicographic. If both the real
+    and imaginary parts are non-nan then the order is determined by the
+    real parts except when they are equal, in which case the order is
+    determined by the imaginary parts.
+
+    Previous to numpy 1.4.0 sorting real and complex arrays containing nan
+    values led to undefined behaviour. In numpy versions >= 1.4.0 nan
+    values are sorted to the end. The extended sort order is:
+
+      * Real: [R, nan]
+      * Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]
+
+    where R is a non-nan real value. Complex values with the same nan
+    placements are sorted according to the non-nan part if it exists.
+    Non-nan values are sorted as before.
+
+    .. versionadded:: 1.12.0
+
+    quicksort has been changed to `introsort <https://en.wikipedia.org/wiki/Introsort>`_.
+    When sorting does not make enough progress it switches to
+    `heapsort <https://en.wikipedia.org/wiki/Heapsort>`_.
+    This implementation makes quicksort O(n*log(n)) in the worst case.
+
+    'stable' automatically chooses the best stable sorting algorithm
+    for the data type being sorted.
+    It, along with 'mergesort' is currently mapped to
+    `timsort <https://en.wikipedia.org/wiki/Timsort>`_
+    or `radix sort <https://en.wikipedia.org/wiki/Radix_sort>`_
+    depending on the data type.
+    API forward compatibility currently limits the
+    ability to select the implementation and it is hardwired for the different
+    data types.
+
+    .. versionadded:: 1.17.0
+
+    Timsort is added for better performance on already or nearly
+    sorted data. On random data timsort is almost identical to
+    mergesort. It is now used for stable sort while quicksort is still the
+    default sort if none is chosen. For timsort details, refer to
+    `CPython listsort.txt <https://github.com/python/cpython/blob/3.7/Objects/listsort.txt>`_.
+    'mergesort' and 'stable' are mapped to radix sort for integer data types. Radix sort is an
+    O(n) sort instead of O(n log n).
+
+    .. versionchanged:: 1.17.0
+
+    NaT now sorts to the end of arrays for consistency with NaN.
+
+    Examples
+    --------
+    >>> a = np.array([[1,4],[3,1]])
+    >>> np.sort(a)                # sort along the last axis
+    array([[1, 4],
+           [1, 3]])
+    >>> np.sort(a, axis=None)     # sort the flattened array
+    array([1, 1, 3, 4])
+    >>> np.sort(a, axis=0)        # sort along the first axis
+    array([[1, 1],
+           [3, 4]])
+
+    Use the `order` keyword to specify a field to use when sorting a
+    structured array:
+
+    >>> dtype = [('name', 'S10'), ('height', float), ('age', int)]
+    >>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),
+    ...           ('Galahad', 1.7, 38)]
+    >>> a = np.array(values, dtype=dtype)       # create a structured array
+    >>> np.sort(a, order='height')                        # doctest: +SKIP
+    array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),
+           ('Lancelot', 1.8999999999999999, 38)],
+          dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])
+
+    Sort by age, then height if ages are equal:
+
+    >>> np.sort(a, order=['age', 'height'])               # doctest: +SKIP
+    array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),
+           ('Arthur', 1.8, 41)],
+          dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def poly1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "poly1d"))))
+(alter-meta! #'poly1d assoc :doc "
+    A one-dimensional polynomial class.
+
+    A convenience class, used to encapsulate \"natural\" operations on
+    polynomials so that said operations may take on their customary
+    form in code (see Examples).
+
+    Parameters
+    ----------
+    c_or_r : array_like
+        The polynomial's coefficients, in decreasing powers, or if
+        the value of the second parameter is True, the polynomial's
+        roots (values where the polynomial evaluates to 0).  For example,
+        ``poly1d([1, 2, 3])`` returns an object that represents
+        :math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns
+        one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`.
+    r : bool, optional
+        If True, `c_or_r` specifies the polynomial's roots; the default
+        is False.
+    variable : str, optional
+        Changes the variable used when printing `p` from `x` to `variable`
+        (see Examples).
+
+    Examples
+    --------
+    Construct the polynomial :math:`x^2 + 2x + 3`:
+
+    >>> p = np.poly1d([1, 2, 3])
+    >>> print(np.poly1d(p))
+       2
+    1 x + 2 x + 3
+
+    Evaluate the polynomial at :math:`x = 0.5`:
+
+    >>> p(0.5)
+    4.25
+
+    Find the roots:
+
+    >>> p.r
+    array([-1.+1.41421356j, -1.-1.41421356j])
+    >>> p(p.r)
+    array([ -4.44089210e-16+0.j,  -4.44089210e-16+0.j]) # may vary
+
+    These numbers in the previous line represent (0, 0) to machine precision
+
+    Show the coefficients:
+
+    >>> p.c
+    array([1, 2, 3])
+
+    Display the order (the leading zero-coefficients are removed):
+
+    >>> p.order
+    2
+
+    Show the coefficient of the k-th power in the polynomial
+    (which is equivalent to ``p.c[-(i+1)]``):
+
+    >>> p[1]
+    2
+
+    Polynomials can be added, subtracted, multiplied, and divided
+    (returns quotient and remainder):
+
+    >>> p * p
+    poly1d([ 1,  4, 10, 12,  9])
+
+    >>> (p**3 + 4) / p
+    (poly1d([ 1.,  4., 10., 12.,  9.]), poly1d([4.]))
+
+    ``asarray(p)`` gives the coefficient array, so polynomials can be
+    used in all functions that accept arrays:
+
+    >>> p**2 # square of polynomial
+    poly1d([ 1,  4, 10, 12,  9])
+
+    >>> np.square(p) # square of individual coefficients
+    array([1, 4, 9])
+
+    The variable used in the string representation of `p` can be modified,
+    using the `variable` parameter:
+
+    >>> p = np.poly1d([1,2,3], variable='z')
+    >>> print(p)
+       2
+    1 z + 2 z + 3
+
+    Construct a polynomial from its roots:
+
+    >>> np.poly1d([1, 2], True)
+    poly1d([ 1., -3.,  2.])
+
+    This is the same polynomial as obtained by:
+
+    >>> np.poly1d([1, -1]) * np.poly1d([1, -2])
+    poly1d([ 1, -3,  2])
+
+    " :arglists '[[self c_or_r & [{r :r, variable :variable}]] [self c_or_r & [{r :r}]] [self c_or_r]])
+
+(def isfinite (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isfinite"))))
+(alter-meta! #'isfinite assoc :doc "isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Test element-wise for finiteness (not infinity or not Not a Number).
+
+The result is returned as a boolean array.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray, bool
+    True where ``x`` is not positive infinity, negative infinity,
+    or NaN; false otherwise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+isinf, isneginf, isposinf, isnan
+
+Notes
+-----
+Not a Number, positive infinity and negative infinity are considered
+to be non-finite.
+
+NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+(IEEE 754). This means that Not a Number is not equivalent to infinity.
+Also that positive infinity is not equivalent to negative infinity. But
+infinity is equivalent to positive infinity.  Errors result if the
+second argument is also supplied when `x` is a scalar input, or if
+first and second arguments have different shapes.
+
+Examples
+--------
+>>> np.isfinite(1)
+True
+>>> np.isfinite(0)
+True
+>>> np.isfinite(np.nan)
+False
+>>> np.isfinite(np.inf)
+False
+>>> np.isfinite(np.NINF)
+False
+>>> np.isfinite([np.log(-1.),1.,np.log(0)])
+array([False,  True, False])
+
+>>> x = np.array([-np.inf, 0., np.inf])
+>>> y = np.array([2, 2, 2])
+>>> np.isfinite(x, y)
+array([0, 1, 0])
+>>> y
+array([0, 1, 0])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def log (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log"))))
+(alter-meta! #'log assoc :doc "log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Natural logarithm, element-wise.
+
+The natural logarithm `log` is the inverse of the exponential function,
+so that `log(exp(x)) = x`. The natural logarithm is logarithm in base
+`e`.
+
+Parameters
+----------
+x : array_like
+    Input value.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The natural logarithm of `x`, element-wise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+log10, log2, log1p, emath.log
+
+Notes
+-----
+Logarithm is a multivalued function: for each `x` there is an infinite
+number of `z` such that `exp(z) = x`. The convention is to return the
+`z` whose imaginary part lies in `[-pi, pi]`.
+
+For real-valued input data types, `log` always returns real output. For
+each value that cannot be expressed as a real number or infinity, it
+yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `log` is a complex analytical function that
+has a branch cut `[-inf, 0]` and is continuous from above on it. `log`
+handles the floating-point negative zero as an infinitesimal negative
+number, conforming to the C99 standard.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm
+
+Examples
+--------
+>>> np.log([1, np.e, np.e**2, 0])
+array([  0.,   1.,   2., -Inf])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def complex128 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex128"))))
+(alter-meta! #'complex128 assoc :doc "Complex number type composed of two double-precision floating-point
+    numbers, compatible with Python `complex`.
+    Character code: ``'D'``.
+    Canonical name: ``np.cdouble``.
+    Alias: ``np.cfloat``.
+    Alias: ``np.complex_``.
+    Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def fromfunction (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromfunction"))))
+(alter-meta! #'fromfunction assoc :doc "
+    Construct an array by executing a function over each coordinate.
+
+    The resulting array therefore has a value ``fn(x, y, z)`` at
+    coordinate ``(x, y, z)``.
+
+    Parameters
+    ----------
+    function : callable
+        The function is called with N parameters, where N is the rank of
+        `shape`.  Each parameter represents the coordinates of the array
+        varying along a specific axis.  For example, if `shape`
+        were ``(2, 2)``, then the parameters would be
+        ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])``
+    shape : (N,) tuple of ints
+        Shape of the output array, which also determines the shape of
+        the coordinate arrays passed to `function`.
+    dtype : data-type, optional
+        Data-type of the coordinate arrays passed to `function`.
+        By default, `dtype` is float.
+
+    Returns
+    -------
+    fromfunction : any
+        The result of the call to `function` is passed back directly.
+        Therefore the shape of `fromfunction` is completely determined by
+        `function`.  If `function` returns a scalar value, the shape of
+        `fromfunction` would not match the `shape` parameter.
+
+    See Also
+    --------
+    indices, meshgrid
+
+    Notes
+    -----
+    Keywords other than `dtype` are passed to `function`.
+
+    Examples
+    --------
+    >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
+    array([[ True, False, False],
+           [False,  True, False],
+           [False, False,  True]])
+
+    >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
+    array([[0, 1, 2],
+           [1, 2, 3],
+           [2, 3, 4]])
+
+    " :arglists '[[function shape & [{:as kwargs}]]])
+
+(def nancumprod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nancumprod"))))
+(alter-meta! #'nancumprod assoc :doc "
+    Return the cumulative product of array elements over a given axis treating Not a
+    Numbers (NaNs) as one.  The cumulative product does not change when NaNs are
+    encountered and leading NaNs are replaced by ones.
+
+    Ones are returned for slices that are all-NaN or empty.
+
+    .. versionadded:: 1.12.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        Axis along which the cumulative product is computed.  By default
+        the input is flattened.
+    dtype : dtype, optional
+        Type of the returned array, as well as of the accumulator in which
+        the elements are multiplied.  If *dtype* is not specified, it
+        defaults to the dtype of `a`, unless `a` has an integer dtype with
+        a precision less than that of the default platform integer.  In
+        that case, the default platform integer is used instead.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type of the resulting values will be cast if necessary.
+
+    Returns
+    -------
+    nancumprod : ndarray
+        A new array holding the result is returned unless `out` is
+        specified, in which case it is returned.
+
+    See Also
+    --------
+    numpy.cumprod : Cumulative product across array propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> np.nancumprod(1)
+    array([1])
+    >>> np.nancumprod([1])
+    array([1])
+    >>> np.nancumprod([1, np.nan])
+    array([1.,  1.])
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nancumprod(a)
+    array([1.,  2.,  6.,  6.])
+    >>> np.nancumprod(a, axis=0)
+    array([[1.,  2.],
+           [3.,  2.]])
+    >>> np.nancumprod(a, axis=1)
+    array([[1.,  2.],
+           [3.,  3.]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def divmod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "divmod"))))
+(alter-meta! #'divmod assoc :doc "divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return element-wise quotient and remainder simultaneously.
+
+.. versionadded:: 1.13.0
+
+``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster
+because it avoids redundant work. It is used to implement the Python
+built-in function ``divmod`` on NumPy arrays.
+
+Parameters
+----------
+x1 : array_like
+    Dividend array.
+x2 : array_like
+    Divisor array. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out1 : ndarray
+    Element-wise quotient resulting from floor division.
+    This is a scalar if both `x1` and `x2` are scalars.
+out2 : ndarray
+    Element-wise remainder from floor division.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+floor_divide : Equivalent to Python's ``//`` operator.
+remainder : Equivalent to Python's ``%`` operator.
+modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return
+       values switched.
+
+Examples
+--------
+>>> np.divmod(np.arange(5), 3)
+(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} ERR_DEFAULT (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_DEFAULT"))))
+
+(def diag_indices_from (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diag_indices_from"))))
+(alter-meta! #'diag_indices_from assoc :doc "
+    Return the indices to access the main diagonal of an n-dimensional array.
+
+    See `diag_indices` for full details.
+
+    Parameters
+    ----------
+    arr : array, at least 2-D
+
+    See Also
+    --------
+    diag_indices
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def savetxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "savetxt"))))
+(alter-meta! #'savetxt assoc :doc "
+    Save an array to a text file.
+
+    Parameters
+    ----------
+    fname : filename or file handle
+        If the filename ends in ``.gz``, the file is automatically saved in
+        compressed gzip format.  `loadtxt` understands gzipped files
+        transparently.
+    X : 1D or 2D array_like
+        Data to be saved to a text file.
+    fmt : str or sequence of strs, optional
+        A single format (%10.5f), a sequence of formats, or a
+        multi-format string, e.g. 'Iteration %d -- %10.5f', in which
+        case `delimiter` is ignored. For complex `X`, the legal options
+        for `fmt` are:
+
+        * a single specifier, `fmt='%.4e'`, resulting in numbers formatted
+          like `' (%s+%sj)' % (fmt, fmt)`
+        * a full string specifying every real and imaginary part, e.g.
+          `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns
+        * a list of specifiers, one per column - in this case, the real
+          and imaginary part must have separate specifiers,
+          e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns
+    delimiter : str, optional
+        String or character separating columns.
+    newline : str, optional
+        String or character separating lines.
+
+        .. versionadded:: 1.5.0
+    header : str, optional
+        String that will be written at the beginning of the file.
+
+        .. versionadded:: 1.7.0
+    footer : str, optional
+        String that will be written at the end of the file.
+
+        .. versionadded:: 1.7.0
+    comments : str, optional
+        String that will be prepended to the ``header`` and ``footer`` strings,
+        to mark them as comments. Default: '# ',  as expected by e.g.
+        ``numpy.loadtxt``.
+
+        .. versionadded:: 1.7.0
+    encoding : {None, str}, optional
+        Encoding used to encode the outputfile. Does not apply to output
+        streams. If the encoding is something other than 'bytes' or 'latin1'
+        you will not be able to load the file in NumPy versions < 1.14. Default
+        is 'latin1'.
+
+        .. versionadded:: 1.14.0
+
+
+    See Also
+    --------
+    save : Save an array to a binary file in NumPy ``.npy`` format
+    savez : Save several arrays into an uncompressed ``.npz`` archive
+    savez_compressed : Save several arrays into a compressed ``.npz`` archive
+
+    Notes
+    -----
+    Further explanation of the `fmt` parameter
+    (``%[flag]width[.precision]specifier``):
+
+    flags:
+        ``-`` : left justify
+
+        ``+`` : Forces to precede result with + or -.
+
+        ``0`` : Left pad the number with zeros instead of space (see width).
+
+    width:
+        Minimum number of characters to be printed. The value is not truncated
+        if it has more characters.
+
+    precision:
+        - For integer specifiers (eg. ``d,i,o,x``), the minimum number of
+          digits.
+        - For ``e, E`` and ``f`` specifiers, the number of digits to print
+          after the decimal point.
+        - For ``g`` and ``G``, the maximum number of significant digits.
+        - For ``s``, the maximum number of characters.
+
+    specifiers:
+        ``c`` : character
+
+        ``d`` or ``i`` : signed decimal integer
+
+        ``e`` or ``E`` : scientific notation with ``e`` or ``E``.
+
+        ``f`` : decimal floating point
+
+        ``g,G`` : use the shorter of ``e,E`` or ``f``
+
+        ``o`` : signed octal
+
+        ``s`` : string of characters
+
+        ``u`` : unsigned decimal integer
+
+        ``x,X`` : unsigned hexadecimal integer
+
+    This explanation of ``fmt`` is not complete, for an exhaustive
+    specification see [1]_.
+
+    References
+    ----------
+    .. [1] `Format Specification Mini-Language
+           <https://docs.python.org/library/string.html#format-specification-mini-language>`_,
+           Python Documentation.
+
+    Examples
+    --------
+    >>> x = y = z = np.arange(0.0,5.0,1.0)
+    >>> np.savetxt('test.out', x, delimiter=',')   # X is an array
+    >>> np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays
+    >>> np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def timedelta64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "timedelta64"))))
+(alter-meta! #'timedelta64 assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def atleast_3d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "atleast_3d"))))
+(alter-meta! #'atleast_3d assoc :doc "
+    View inputs as arrays with at least three dimensions.
+
+    Parameters
+    ----------
+    arys1, arys2, ... : array_like
+        One or more array-like sequences.  Non-array inputs are converted to
+        arrays.  Arrays that already have three or more dimensions are
+        preserved.
+
+    Returns
+    -------
+    res1, res2, ... : ndarray
+        An array, or list of arrays, each with ``a.ndim >= 3``.  Copies are
+        avoided where possible, and views with three or more dimensions are
+        returned.  For example, a 1-D array of shape ``(N,)`` becomes a view
+        of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a
+        view of shape ``(M, N, 1)``.
+
+    See Also
+    --------
+    atleast_1d, atleast_2d
+
+    Examples
+    --------
+    >>> np.atleast_3d(3.0)
+    array([[[3.]]])
+
+    >>> x = np.arange(3.0)
+    >>> np.atleast_3d(x).shape
+    (1, 3, 1)
+
+    >>> x = np.arange(12.0).reshape(4,3)
+    >>> np.atleast_3d(x).shape
+    (4, 3, 1)
+    >>> np.atleast_3d(x).base is x.base  # x is a reshape, so not base itself
+    True
+
+    >>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):
+    ...     print(arr, arr.shape) # doctest: +SKIP
+    ...
+    [[[1]
+      [2]]] (1, 2, 1)
+    [[[1]
+      [2]]] (1, 2, 1)
+    [[[1 2]]] (1, 1, 2)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} division (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "division"))))
+
+(def ndarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndarray"))))
+(alter-meta! #'ndarray assoc :doc "ndarray(shape, dtype=float, buffer=None, offset=0,
+            strides=None, order=None)
+
+    An array object represents a multidimensional, homogeneous array
+    of fixed-size items.  An associated data-type object describes the
+    format of each element in the array (its byte-order, how many bytes it
+    occupies in memory, whether it is an integer, a floating point number,
+    or something else, etc.)
+
+    Arrays should be constructed using `array`, `zeros` or `empty` (refer
+    to the See Also section below).  The parameters given here refer to
+    a low-level method (`ndarray(...)`) for instantiating an array.
+
+    For more information, refer to the `numpy` module and examine the
+    methods and attributes of an array.
+
+    Parameters
+    ----------
+    (for the __new__ method; see Notes below)
+
+    shape : tuple of ints
+        Shape of created array.
+    dtype : data-type, optional
+        Any object that can be interpreted as a numpy data type.
+    buffer : object exposing buffer interface, optional
+        Used to fill the array with data.
+    offset : int, optional
+        Offset of array data in buffer.
+    strides : tuple of ints, optional
+        Strides of data in memory.
+    order : {'C', 'F'}, optional
+        Row-major (C-style) or column-major (Fortran-style) order.
+
+    Attributes
+    ----------
+    T : ndarray
+        Transpose of the array.
+    data : buffer
+        The array's elements, in memory.
+    dtype : dtype object
+        Describes the format of the elements in the array.
+    flags : dict
+        Dictionary containing information related to memory use, e.g.,
+        'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.
+    flat : numpy.flatiter object
+        Flattened version of the array as an iterator.  The iterator
+        allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for
+        assignment examples; TODO).
+    imag : ndarray
+        Imaginary part of the array.
+    real : ndarray
+        Real part of the array.
+    size : int
+        Number of elements in the array.
+    itemsize : int
+        The memory use of each array element in bytes.
+    nbytes : int
+        The total number of bytes required to store the array data,
+        i.e., ``itemsize * size``.
+    ndim : int
+        The array's number of dimensions.
+    shape : tuple of ints
+        Shape of the array.
+    strides : tuple of ints
+        The step-size required to move from one element to the next in
+        memory. For example, a contiguous ``(3, 4)`` array of type
+        ``int16`` in C-order has strides ``(8, 2)``.  This implies that
+        to move from element to element in memory requires jumps of 2 bytes.
+        To move from row-to-row, one needs to jump 8 bytes at a time
+        (``2 * 4``).
+    ctypes : ctypes object
+        Class containing properties of the array needed for interaction
+        with ctypes.
+    base : ndarray
+        If the array is a view into another array, that array is its `base`
+        (unless that array is also a view).  The `base` array is where the
+        array data is actually stored.
+
+    See Also
+    --------
+    array : Construct an array.
+    zeros : Create an array, each element of which is zero.
+    empty : Create an array, but leave its allocated memory unchanged (i.e.,
+            it contains \"garbage\").
+    dtype : Create a data-type.
+
+    Notes
+    -----
+    There are two modes of creating an array using ``__new__``:
+
+    1. If `buffer` is None, then only `shape`, `dtype`, and `order`
+       are used.
+    2. If `buffer` is an object exposing the buffer interface, then
+       all keywords are interpreted.
+
+    No ``__init__`` method is needed because the array is fully initialized
+    after the ``__new__`` method.
+
+    Examples
+    --------
+    These examples illustrate the low-level `ndarray` constructor.  Refer
+    to the `See Also` section above for easier ways of constructing an
+    ndarray.
+
+    First mode, `buffer` is None:
+
+    >>> np.ndarray(shape=(2,2), dtype=float, order='F')
+    array([[0.0e+000, 0.0e+000], # random
+           [     nan, 2.5e-323]])
+
+    Second mode:
+
+    >>> np.ndarray((2,), buffer=np.array([1,2,3]),
+    ...            offset=np.int_().itemsize,
+    ...            dtype=int) # offset = 1*itemsize, i.e. skip first element
+    array([2, 3])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def product (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "product"))))
+(alter-meta! #'product assoc :doc "
+    Return the product of array elements over a given axis.
+
+    See Also
+    --------
+    prod : equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "Built-in mutable sequence.
+
+If no argument is given, the constructor creates a new empty list.
+The argument must be an iterable if specified."} __path__ (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* "__path__")))) 
+
+(def ptp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ptp"))))
+(alter-meta! #'ptp assoc :doc "
+    Range of values (maximum - minimum) along an axis.
+
+    The name of the function comes from the acronym for 'peak to peak'.
+
+    Parameters
+    ----------
+    a : array_like
+        Input values.
+    axis : None or int or tuple of ints, optional
+        Axis along which to find the peaks.  By default, flatten the
+        array.  `axis` may be negative, in
+        which case it counts from the last to the first axis.
+
+        .. versionadded:: 1.15.0
+
+        If this is a tuple of ints, a reduction is performed on multiple
+        axes, instead of a single axis or all the axes as before.
+    out : array_like
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type of the output values will be cast if necessary.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `ptp` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    ptp : ndarray
+        A new array holding the result, unless `out` was
+        specified, in which case a reference to `out` is returned.
+
+    Examples
+    --------
+    >>> x = np.arange(4).reshape((2,2))
+    >>> x
+    array([[0, 1],
+           [2, 3]])
+
+    >>> np.ptp(x, axis=0)
+    array([2, 2])
+
+    >>> np.ptp(x, axis=1)
+    array([1, 1])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def floating (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "floating"))))
+(alter-meta! #'floating assoc :doc "Abstract base class of all floating-point scalar types." :arglists '[[self & [args {:as kwargs}]]])
+
+(def arctan (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arctan"))))
+(alter-meta! #'arctan assoc :doc "arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Trigonometric inverse tangent, element-wise.
+
+The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``.
+
+Parameters
+----------
+x : array_like
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Out has the same shape as `x`.  Its real part is in
+    ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``).
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+arctan2 : The \"four quadrant\" arctan of the angle formed by (`x`, `y`)
+    and the positive `x`-axis.
+angle : Argument of complex values.
+
+Notes
+-----
+`arctan` is a multi-valued function: for each `x` there are infinitely
+many numbers `z` such that tan(`z`) = `x`.  The convention is to return
+the angle `z` whose real part lies in [-pi/2, pi/2].
+
+For real-valued input data types, `arctan` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arctan` is a complex analytic function that
+has [`1j, infj`] and [`-1j, -infj`] as branch cuts, and is continuous
+from the left on the former and from the right on the latter.
+
+The inverse tangent is also known as `atan` or tan^{-1}.
+
+References
+----------
+Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
+10th printing, New York: Dover, 1964, pp. 79.
+http://www.math.sfu.ca/~cbm/aands/
+
+Examples
+--------
+We expect the arctan of 0 to be 0, and of 1 to be pi/4:
+
+>>> np.arctan([0, 1])
+array([ 0.        ,  0.78539816])
+
+>>> np.pi/4
+0.78539816339744828
+
+Plot arctan:
+
+>>> import matplotlib.pyplot as plt
+>>> x = np.linspace(-10, 10)
+>>> plt.plot(x, np.arctan(x))
+>>> plt.axis('tight')
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
+
+(def fromstring (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromstring"))))
+(alter-meta! #'fromstring assoc :doc "fromstring(string, dtype=float, count=-1, sep='')
+
+    A new 1-D array initialized from text data in a string.
+
+    Parameters
+    ----------
+    string : str
+        A string containing the data.
+    dtype : data-type, optional
+        The data type of the array; default: float.  For binary input data,
+        the data must be in exactly this format. Most builtin numeric types are 
+        supported and extension types may be supported.
+
+        .. versionadded:: 1.18.0
+            Complex dtypes.
+
+    count : int, optional
+        Read this number of `dtype` elements from the data.  If this is
+        negative (the default), the count will be determined from the
+        length of the data.
+    sep : str, optional
+        The string separating numbers in the data; extra whitespace between
+        elements is also ignored.
+
+        .. deprecated:: 1.14
+            Passing ``sep=''``, the default, is deprecated since it will
+            trigger the deprecated binary mode of this function. This mode
+            interprets `string` as binary bytes, rather than ASCII text with
+            decimal numbers, an operation which is better spelt
+            ``frombuffer(string, dtype, count)``. If `string` contains unicode
+            text, the binary mode of `fromstring` will first encode it into
+            bytes using either utf-8 (python 3) or the default encoding
+            (python 2), neither of which produce sane results.
+
+    Returns
+    -------
+    arr : ndarray
+        The constructed array.
+
+    Raises
+    ------
+    ValueError
+        If the string is not the correct size to satisfy the requested
+        `dtype` and `count`.
+
+    See Also
+    --------
+    frombuffer, fromfile, fromiter
+
+    Examples
+    --------
+    >>> np.fromstring('1 2', dtype=int, sep=' ')
+    array([1, 2])
+    >>> np.fromstring('1, 2', dtype=int, sep=',')
+    array([1, 2])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc "Special keyword value.
+
+    The instance of this class may be used as the default value assigned to a
+    deprecated keyword in order to check if it has been given a user defined
+    value.
+    "} _NoValue (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_NoValue"))))
+
+(def signedinteger (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "signedinteger"))))
+(alter-meta! #'signedinteger assoc :doc "Abstract base class of all signed integer scalar types." :arglists '[[self & [args {:as kwargs}]]])
+
+(def any (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "any"))))
+(alter-meta! #'any assoc :doc "
+    Test whether any array element along a given axis evaluates to True.
+
+    Returns single boolean unless `axis` is not ``None``
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a logical OR reduction is performed.
+        The default (``axis=None``) is to perform a logical OR over all
+        the dimensions of the input array. `axis` may be negative, in
+        which case it counts from the last to the first axis.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a reduction is performed on multiple
+        axes, instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  It must have
+        the same shape as the expected output and its type is preserved
+        (e.g., if it is of type float, then it will remain so, returning
+        1.0 for True and 0.0 for False, regardless of the type of `a`).
+        See `ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `any` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    any : bool or ndarray
+        A new boolean or `ndarray` is returned unless `out` is specified,
+        in which case a reference to `out` is returned.
+
+    See Also
+    --------
+    ndarray.any : equivalent method
+
+    all : Test whether all elements along a given axis evaluate to True.
+
+    Notes
+    -----
+    Not a Number (NaN), positive infinity and negative infinity evaluate
+    to `True` because these are not equal to zero.
+
+    Examples
+    --------
+    >>> np.any([[True, False], [True, True]])
+    True
+
+    >>> np.any([[True, False], [False, False]], axis=0)
+    array([ True, False])
+
+    >>> np.any([-1, 0, 5])
+    True
+
+    >>> np.any(np.nan)
+    True
+
+    >>> o=np.array(False)
+    >>> z=np.any([-1, 4, 5], out=o)
+    >>> z, o
+    (array(True), array(True))
+    >>> # Check now that z is a reference to o
+    >>> z is o
+    True
+    >>> id(z), id(o) # identity of z and o              # doctest: +SKIP
+    (191614240, 191614240)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def angle (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "angle"))))
+(alter-meta! #'angle assoc :doc "
+    Return the angle of the complex argument.
+
+    Parameters
+    ----------
+    z : array_like
+        A complex number or sequence of complex numbers.
+    deg : bool, optional
+        Return angle in degrees if True, radians if False (default).
+
+    Returns
+    -------
+    angle : ndarray or scalar
+        The counterclockwise angle from the positive real axis on the complex
+        plane in the range ``(-pi, pi]``, with dtype as numpy.float64.
+
+        ..versionchanged:: 1.16.0
+            This function works on subclasses of ndarray like `ma.array`.
+
+    See Also
+    --------
+    arctan2
+    absolute
+
+    Examples
+    --------
+    >>> np.angle([1.0, 1.0j, 1+1j])               # in radians
+    array([ 0.        ,  1.57079633,  0.78539816]) # may vary
+    >>> np.angle(1+1j, deg=True)                  # in degrees
+    45.0
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def reshape (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "reshape"))))
+(alter-meta! #'reshape assoc :doc "
+    Gives a new shape to an array without changing its data.
+
+    Parameters
+    ----------
+    a : array_like
+        Array to be reshaped.
+    newshape : int or tuple of ints
+        The new shape should be compatible with the original shape. If
+        an integer, then the result will be a 1-D array of that length.
+        One shape dimension can be -1. In this case, the value is
+        inferred from the length of the array and remaining dimensions.
+    order : {'C', 'F', 'A'}, optional
+        Read the elements of `a` using this index order, and place the
+        elements into the reshaped array using this index order.  'C'
+        means to read / write the elements using C-like index order,
+        with the last axis index changing fastest, back to the first
+        axis index changing slowest. 'F' means to read / write the
+        elements using Fortran-like index order, with the first index
+        changing fastest, and the last index changing slowest. Note that
+        the 'C' and 'F' options take no account of the memory layout of
+        the underlying array, and only refer to the order of indexing.
+        'A' means to read / write the elements in Fortran-like index
+        order if `a` is Fortran *contiguous* in memory, C-like order
+        otherwise.
+
+    Returns
+    -------
+    reshaped_array : ndarray
+        This will be a new view object if possible; otherwise, it will
+        be a copy.  Note there is no guarantee of the *memory layout* (C- or
+        Fortran- contiguous) of the returned array.
+
+    See Also
+    --------
+    ndarray.reshape : Equivalent method.
+
+    Notes
+    -----
+    It is not always possible to change the shape of an array without
+    copying the data. If you want an error to be raised when the data is copied,
+    you should assign the new shape to the shape attribute of the array::
+
+     >>> a = np.zeros((10, 2))
+
+     # A transpose makes the array non-contiguous
+     >>> b = a.T
+
+     # Taking a view makes it possible to modify the shape without modifying
+     # the initial object.
+     >>> c = b.view()
+     >>> c.shape = (20)
+     Traceback (most recent call last):
+        ...
+     AttributeError: incompatible shape for a non-contiguous array
+
+    The `order` keyword gives the index ordering both for *fetching* the values
+    from `a`, and then *placing* the values into the output array.
+    For example, let's say you have an array:
+
+    >>> a = np.arange(6).reshape((3, 2))
+    >>> a
+    array([[0, 1],
+           [2, 3],
+           [4, 5]])
+
+    You can think of reshaping as first raveling the array (using the given
+    index order), then inserting the elements from the raveled array into the
+    new array using the same kind of index ordering as was used for the
+    raveling.
+
+    >>> np.reshape(a, (2, 3)) # C-like index ordering
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering
+    array([[0, 4, 3],
+           [2, 1, 5]])
+    >>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F')
+    array([[0, 4, 3],
+           [2, 1, 5]])
+
+    Examples
+    --------
+    >>> a = np.array([[1,2,3], [4,5,6]])
+    >>> np.reshape(a, 6)
+    array([1, 2, 3, 4, 5, 6])
+    >>> np.reshape(a, 6, order='F')
+    array([1, 4, 2, 5, 3, 6])
+
+    >>> np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2
+    array([[1, 2],
+           [3, 4],
+           [5, 6]])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def i0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "i0"))))
+(alter-meta! #'i0 assoc :doc "
+    Modified Bessel function of the first kind, order 0.
+
+    Usually denoted :math:`I_0`.  This function does broadcast, but will *not*
+    \"up-cast\" int dtype arguments unless accompanied by at least one float or
+    complex dtype argument (see Raises below).
+
+    Parameters
+    ----------
+    x : array_like, dtype float or complex
+        Argument of the Bessel function.
+
+    Returns
+    -------
+    out : ndarray, shape = x.shape, dtype = x.dtype
+        The modified Bessel function evaluated at each of the elements of `x`.
+
+    Raises
+    ------
+    TypeError: array cannot be safely cast to required type
+        If argument consists exclusively of int dtypes.
+
+    See Also
+    --------
+    scipy.special.i0, scipy.special.iv, scipy.special.ive
+
+    Notes
+    -----
+    The scipy implementation is recommended over this function: it is a
+    proper ufunc written in C, and more than an order of magnitude faster.
+
+    We use the algorithm published by Clenshaw [1]_ and referenced by
+    Abramowitz and Stegun [2]_, for which the function domain is
+    partitioned into the two intervals [0,8] and (8,inf), and Chebyshev
+    polynomial expansions are employed in each interval. Relative error on
+    the domain [0,30] using IEEE arithmetic is documented [3]_ as having a
+    peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).
+
+    References
+    ----------
+    .. [1] C. W. Clenshaw, \"Chebyshev series for mathematical functions\", in
+           *National Physical Laboratory Mathematical Tables*, vol. 5, London:
+           Her Majesty's Stationery Office, 1962.
+    .. [2] M. Abramowitz and I. A. Stegun, *Handbook of Mathematical
+           Functions*, 10th printing, New York: Dover, 1964, pp. 379.
+           http://www.math.sfu.ca/~cbm/aands/page_379.htm
+    .. [3] http://kobesearch.cpan.org/htdocs/Math-Cephes/Math/Cephes.html
+
+    Examples
+    --------
+    >>> np.i0(0.)
+    array(1.0)  # may vary
+    >>> np.i0([0., 1. + 2j])
+    array([ 1.00000000+0.j        ,  0.18785373+0.64616944j])  # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ndenumerate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndenumerate"))))
+(alter-meta! #'ndenumerate assoc :doc "
+    Multidimensional index iterator.
+
+    Return an iterator yielding pairs of array coordinates and values.
+
+    Parameters
+    ----------
+    arr : ndarray
+      Input array.
+
+    See Also
+    --------
+    ndindex, flatiter
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> for index, x in np.ndenumerate(a):
+    ...     print(index, x)
+    (0, 0) 1
+    (0, 1) 2
+    (1, 0) 3
+    (1, 1) 4
+
+    " :arglists '[[self arr]])
+
+(def hamming (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hamming"))))
+(alter-meta! #'hamming assoc :doc "
+    Return the Hamming window.
+
+    The Hamming window is a taper formed by using a weighted cosine.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+
+    Returns
+    -------
+    out : ndarray
+        The window, with the maximum value normalized to one (the value
+        one appears only if the number of samples is odd).
+
+    See Also
+    --------
+    bartlett, blackman, hanning, kaiser
+
+    Notes
+    -----
+    The Hamming window is defined as
+
+    .. math::  w(n) = 0.54 - 0.46cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
+               \\qquad 0 \\leq n \\leq M-1
+
+    The Hamming was named for R. W. Hamming, an associate of J. W. Tukey
+    and is described in Blackman and Tukey. It was recommended for
+    smoothing the truncated autocovariance function in the time domain.
+    Most references to the Hamming window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    \"removing the foot\", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function.
+
+    References
+    ----------
+    .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
+           spectra, Dover Publications, New York.
+    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\", The
+           University of Alberta Press, 1975, pp. 109-110.
+    .. [3] Wikipedia, \"Window function\",
+           https://en.wikipedia.org/wiki/Window_function
+    .. [4] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
+           \"Numerical Recipes\", Cambridge University Press, 1986, page 425.
+
+    Examples
+    --------
+    >>> np.hamming(12)
+    array([ 0.08      ,  0.15302337,  0.34890909,  0.60546483,  0.84123594, # may vary
+            0.98136677,  0.98136677,  0.84123594,  0.60546483,  0.34890909,
+            0.15302337,  0.08      ])
+
+    Plot the window and the frequency response:
+
+    >>> import matplotlib.pyplot as plt
+    >>> from numpy.fft import fft, fftshift
+    >>> window = np.hamming(51)
+    >>> plt.plot(window)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Hamming window\")
+    Text(0.5, 1.0, 'Hamming window')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"Sample\")
+    Text(0.5, 0, 'Sample')
+    >>> plt.show()
+
+    >>> plt.figure()
+    <Figure size 640x480 with 0 Axes>
+    >>> A = fft(window, 2048) / 25.5
+    >>> mag = np.abs(fftshift(A))
+    >>> freq = np.linspace(-0.5, 0.5, len(A))
+    >>> response = 20 * np.log10(mag)
+    >>> response = np.clip(response, -100, 100)
+    >>> plt.plot(freq, response)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Frequency response of Hamming window\")
+    Text(0.5, 1.0, 'Frequency response of Hamming window')
+    >>> plt.ylabel(\"Magnitude [dB]\")
+    Text(0, 0.5, 'Magnitude [dB]')
+    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
+    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
+    >>> plt.axis('tight')
+    ...
+    >>> plt.show()
+
+    " :arglists '[[M]])
+
+(def ^{:doc ""} NAN (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "NAN"))))
+
+(def ^{:doc ""} Infinity (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "Infinity"))))
+
+(def ^{:doc ""} MAY_SHARE_EXACT (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "MAY_SHARE_EXACT"))))
+
+(def array2string (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array2string"))))
+(alter-meta! #'array2string assoc :doc "
+    Return a string representation of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    max_line_width : int, optional
+        Inserts newlines if text is longer than `max_line_width`.
+        Defaults to ``numpy.get_printoptions()['linewidth']``.
+    precision : int or None, optional
+        Floating point precision.
+        Defaults to ``numpy.get_printoptions()['precision']``.
+    suppress_small : bool, optional
+        Represent numbers \"very close\" to zero as zero; default is False.
+        Very close is defined by precision: if the precision is 8, e.g.,
+        numbers smaller (in absolute value) than 5e-9 are represented as
+        zero.
+        Defaults to ``numpy.get_printoptions()['suppress']``.
+    separator : str, optional
+        Inserted between elements.
+    prefix : str, optional
+    suffix: str, optional
+        The length of the prefix and suffix strings are used to respectively
+        align and wrap the output. An array is typically printed as::
+
+          prefix + array2string(a) + suffix
+
+        The output is left-padded by the length of the prefix string, and
+        wrapping is forced at the column ``max_line_width - len(suffix)``.
+        It should be noted that the content of prefix and suffix strings are
+        not included in the output.
+    style : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.14.0
+    formatter : dict of callables, optional
+        If not None, the keys should indicate the type(s) that the respective
+        formatting function applies to.  Callables should return a string.
+        Types that are not specified (by their corresponding keys) are handled
+        by the default formatters.  Individual types for which a formatter
+        can be set are:
+
+        - 'bool'
+        - 'int'
+        - 'timedelta' : a `numpy.timedelta64`
+        - 'datetime' : a `numpy.datetime64`
+        - 'float'
+        - 'longfloat' : 128-bit floats
+        - 'complexfloat'
+        - 'longcomplexfloat' : composed of two 128-bit floats
+        - 'void' : type `numpy.void`
+        - 'numpystr' : types `numpy.string_` and `numpy.unicode_`
+        - 'str' : all other strings
+
+        Other keys that can be used to set a group of types at once are:
+
+        - 'all' : sets all types
+        - 'int_kind' : sets 'int'
+        - 'float_kind' : sets 'float' and 'longfloat'
+        - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
+        - 'str_kind' : sets 'str' and 'numpystr'
+    threshold : int, optional
+        Total number of array elements which trigger summarization
+        rather than full repr.
+        Defaults to ``numpy.get_printoptions()['threshold']``.
+    edgeitems : int, optional
+        Number of array items in summary at beginning and end of
+        each dimension.
+        Defaults to ``numpy.get_printoptions()['edgeitems']``.
+    sign : string, either '-', '+', or ' ', optional
+        Controls printing of the sign of floating-point types. If '+', always
+        print the sign of positive values. If ' ', always prints a space
+        (whitespace character) in the sign position of positive values.  If
+        '-', omit the sign character of positive values.
+        Defaults to ``numpy.get_printoptions()['sign']``.
+    floatmode : str, optional
+        Controls the interpretation of the `precision` option for
+        floating-point types.
+        Defaults to ``numpy.get_printoptions()['floatmode']``.
+        Can take the following values:
+
+        - 'fixed': Always print exactly `precision` fractional digits,
+          even if this would print more or fewer digits than
+          necessary to specify the value uniquely.
+        - 'unique': Print the minimum number of fractional digits necessary
+          to represent each value uniquely. Different elements may
+          have a different number of digits.  The value of the
+          `precision` option is ignored.
+        - 'maxprec': Print at most `precision` fractional digits, but if
+          an element can be uniquely represented with fewer digits
+          only print it with that many.
+        - 'maxprec_equal': Print at most `precision` fractional digits,
+          but if every element in the array can be uniquely
+          represented with an equal number of fewer digits, use that
+          many digits for all elements.
+    legacy : string or `False`, optional
+        If set to the string `'1.13'` enables 1.13 legacy printing mode. This
+        approximates numpy 1.13 print output by including a space in the sign
+        position of floats and different behavior for 0d arrays. If set to
+        `False`, disables legacy mode. Unrecognized strings will be ignored
+        with a warning for forward compatibility.
+
+        .. versionadded:: 1.14.0
+
+    Returns
+    -------
+    array_str : str
+        String representation of the array.
+
+    Raises
+    ------
+    TypeError
+        if a callable in `formatter` does not return a string.
+
+    See Also
+    --------
+    array_str, array_repr, set_printoptions, get_printoptions
+
+    Notes
+    -----
+    If a formatter is specified for a certain type, the `precision` keyword is
+    ignored for that type.
+
+    This is a very flexible function; `array_repr` and `array_str` are using
+    `array2string` internally so keywords with the same name should work
+    identically in all three functions.
+
+    Examples
+    --------
+    >>> x = np.array([1e-16,1,2,3])
+    >>> np.array2string(x, precision=2, separator=',',
+    ...                       suppress_small=True)
+    '[0.,1.,2.,3.]'
+
+    >>> x  = np.arange(3.)
+    >>> np.array2string(x, formatter={'float_kind':lambda x: \"%.2f\" % x})
+    '[0.00 1.00 2.00]'
+
+    >>> x  = np.arange(3)
+    >>> np.array2string(x, formatter={'int':lambda x: hex(x)})
+    '[0x0 0x1 0x2]'
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def disp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "disp"))))
+(alter-meta! #'disp assoc :doc "
+    Display a message on a device.
+
+    Parameters
+    ----------
+    mesg : str
+        Message to display.
+    device : object
+        Device to write message. If None, defaults to ``sys.stdout`` which is
+        very similar to ``print``. `device` needs to have ``write()`` and
+        ``flush()`` methods.
+    linefeed : bool, optional
+        Option whether to print a line feed or not. Defaults to True.
+
+    Raises
+    ------
+    AttributeError
+        If `device` does not have a ``write()`` or ``flush()`` method.
+
+    Examples
+    --------
+    Besides ``sys.stdout``, a file-like object can also be used as it has
+    both required methods:
+
+    >>> from io import StringIO
+    >>> buf = StringIO()
+    >>> np.disp(u'\"Display\" in a file', device=buf)
+    >>> buf.getvalue()
+    '\"Display\" in a file\\n'
+
+    " :arglists '[[mesg & [{device :device, linefeed :linefeed}]] [mesg & [{device :device}]] [mesg]])
+
+(def packbits (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "packbits"))))
+(alter-meta! #'packbits assoc :doc "
+    packbits(a, axis=None, bitorder='big')
+
+    Packs the elements of a binary-valued array into bits in a uint8 array.
+
+    The result is padded to full bytes by inserting zero bits at the end.
+
+    Parameters
+    ----------
+    a : array_like
+        An array of integers or booleans whose elements should be packed to
+        bits.
+    axis : int, optional
+        The dimension over which bit-packing is done.
+        ``None`` implies packing the flattened array.
+    bitorder : {'big', 'little'}, optional
+        The order of the input bits. 'big' will mimic bin(val),
+        ``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011 => ``, 'little' will
+        reverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``.
+        Defaults to 'big'.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    packed : ndarray
+        Array of type uint8 whose elements represent bits corresponding to the
+        logical (0 or nonzero) value of the input elements. The shape of
+        `packed` has the same number of dimensions as the input (unless `axis`
+        is None, in which case the output is 1-D).
+
+    See Also
+    --------
+    unpackbits: Unpacks elements of a uint8 array into a binary-valued output
+                array.
+
+    Examples
+    --------
+    >>> a = np.array([[[1,0,1],
+    ...                [0,1,0]],
+    ...               [[1,1,0],
+    ...                [0,0,1]]])
+    >>> b = np.packbits(a, axis=-1)
+    >>> b
+    array([[[160],
+            [ 64]],
+           [[192],
+            [ 32]]], dtype=uint8)
+
+    Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000,
+    and 32 = 0010 0000.
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} ERR_WARN (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_WARN"))))
+
+(def percentile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "percentile"))))
+(alter-meta! #'percentile assoc :doc "
+    Compute the q-th percentile of the data along the specified axis.
+
+    Returns the q-th percentile(s) of the array elements.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    q : array_like of float
+        Percentile or sequence of percentiles to compute, which must be between
+        0 and 100 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the percentiles are computed. The
+        default is to compute the percentile(s) along a flattened
+        version of the array.
+
+        .. versionchanged:: 1.9.0
+            A tuple of axes is supported
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by intermediate
+        calculations, to save memory. In this case, the contents of the input
+        `a` after this function completes is undefined.
+
+    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
+        This optional parameter specifies the interpolation method to
+        use when the desired percentile lies between two data points
+        ``i < j``:
+
+        * 'linear': ``i + (j - i) * fraction``, where ``fraction``
+          is the fractional part of the index surrounded by ``i``
+          and ``j``.
+        * 'lower': ``i``.
+        * 'higher': ``j``.
+        * 'nearest': ``i`` or ``j``, whichever is nearest.
+        * 'midpoint': ``(i + j) / 2``.
+
+        .. versionadded:: 1.9.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+        .. versionadded:: 1.9.0
+
+    Returns
+    -------
+    percentile : scalar or ndarray
+        If `q` is a single percentile and `axis=None`, then the result
+        is a scalar. If multiple percentiles are given, first axis of
+        the result corresponds to the percentiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean
+    median : equivalent to ``percentile(..., 50)``
+    nanpercentile
+    quantile : equivalent to percentile, except with q in the range [0, 1].
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the q-th percentile of
+    ``V`` is the value ``q/100`` of the way from the minimum to the
+    maximum in a sorted copy of ``V``. The values and distances of
+    the two nearest neighbors as well as the `interpolation` parameter
+    will determine the percentile if the normalized ranking does not
+    match the location of ``q`` exactly. This function is the same as
+    the median if ``q=50``, the same as the minimum if ``q=0`` and the
+    same as the maximum if ``q=100``.
+
+    Examples
+    --------
+    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
+    >>> a
+    array([[10,  7,  4],
+           [ 3,  2,  1]])
+    >>> np.percentile(a, 50)
+    3.5
+    >>> np.percentile(a, 50, axis=0)
+    array([6.5, 4.5, 2.5])
+    >>> np.percentile(a, 50, axis=1)
+    array([7.,  2.])
+    >>> np.percentile(a, 50, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+
+    >>> m = np.percentile(a, 50, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.percentile(a, 50, axis=0, out=out)
+    array([6.5, 4.5, 2.5])
+    >>> m
+    array([6.5, 4.5, 2.5])
+
+    >>> b = a.copy()
+    >>> np.percentile(b, 50, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a == b)
+
+    The different types of interpolation can be visualized graphically:
+
+    .. plot::
+
+        import matplotlib.pyplot as plt
+
+        a = np.arange(4)
+        p = np.linspace(0, 100, 6001)
+        ax = plt.gca()
+        lines = [
+            ('linear', None),
+            ('higher', '--'),
+            ('lower', '--'),
+            ('nearest', '-.'),
+            ('midpoint', '-.'),
+        ]
+        for interpolation, style in lines:
+            ax.plot(
+                p, np.percentile(a, p, interpolation=interpolation),
+                label=interpolation, linestyle=style)
+        ax.set(
+            title='Interpolation methods for list: ' + str(a),
+            xlabel='Percentile',
+            ylabel='List item returned',
+            yticks=a)
+        ax.legend()
+        plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def nanquantile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanquantile"))))
+(alter-meta! #'nanquantile assoc :doc "
+    Compute the qth quantile of the data along the specified axis,
+    while ignoring nan values.
+    Returns the qth quantile(s) of the array elements.
+    
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array, containing
+        nan values to be ignored
+    q : array_like of float
+        Quantile or sequence of quantiles to compute, which must be between
+        0 and 1 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the quantiles are computed. The
+        default is to compute the quantile(s) along a flattened
+        version of the array.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by intermediate
+        calculations, to save memory. In this case, the contents of the input
+        `a` after this function completes is undefined.
+    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
+        This optional parameter specifies the interpolation method to
+        use when the desired quantile lies between two data points
+        ``i < j``:
+
+        * linear: ``i + (j - i) * fraction``, where ``fraction``
+          is the fractional part of the index surrounded by ``i``
+          and ``j``.
+        * lower: ``i``.
+        * higher: ``j``.
+        * nearest: ``i`` or ``j``, whichever is nearest.
+        * midpoint: ``(i + j) / 2``.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+        If this is anything but the default value it will be passed
+        through (in the special case of an empty array) to the
+        `mean` function of the underlying array.  If the array is
+        a sub-class and `mean` does not have the kwarg `keepdims` this
+        will raise a RuntimeError.
+
+    Returns
+    -------
+    quantile : scalar or ndarray
+        If `q` is a single percentile and `axis=None`, then the result
+        is a scalar. If multiple quantiles are given, first axis of
+        the result corresponds to the quantiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    quantile
+    nanmean, nanmedian
+    nanmedian : equivalent to ``nanquantile(..., 0.5)``
+    nanpercentile : same as nanquantile, but with q in the range [0, 100].
+
+    Examples
+    --------
+    >>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
+    >>> a[0][1] = np.nan
+    >>> a
+    array([[10.,  nan,   4.],
+          [ 3.,   2.,   1.]])
+    >>> np.quantile(a, 0.5)
+    nan
+    >>> np.nanquantile(a, 0.5)
+    3.0
+    >>> np.nanquantile(a, 0.5, axis=0)
+    array([6.5, 2. , 2.5])
+    >>> np.nanquantile(a, 0.5, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+    >>> m = np.nanquantile(a, 0.5, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.nanquantile(a, 0.5, axis=0, out=out)
+    array([6.5, 2. , 2.5])
+    >>> m
+    array([6.5,  2. ,  2.5])
+    >>> b = a.copy()
+    >>> np.nanquantile(b, 0.5, axis=1, overwrite_input=True)
+    array([7., 2.])
+    >>> assert not np.all(a==b)
+    " :arglists '[[& [args {:as kwargs}]]])
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} typecodes (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "typecodes")))) 
+
+(def tril (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tril"))))
+(alter-meta! #'tril assoc :doc "
+    Lower triangle of an array.
+
+    Return a copy of an array with elements above the `k`-th diagonal zeroed.
+
+    Parameters
+    ----------
+    m : array_like, shape (M, N)
+        Input array.
+    k : int, optional
+        Diagonal above which to zero elements.  `k = 0` (the default) is the
+        main diagonal, `k < 0` is below it and `k > 0` is above.
+
+    Returns
+    -------
+    tril : ndarray, shape (M, N)
+        Lower triangle of `m`, of same shape and data-type as `m`.
+
+    See Also
+    --------
+    triu : same thing, only for the upper triangle
+
+    Examples
+    --------
+    >>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
+    array([[ 0,  0,  0],
+           [ 4,  0,  0],
+           [ 7,  8,  0],
+           [10, 11, 12]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def sin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sin"))))
+(alter-meta! #'sin assoc :doc "sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Trigonometric sine, element-wise.
+
+Parameters
+----------
+x : array_like
+    Angle, in radians (:math:`2 \\pi` rad equals 360 degrees).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : array_like
+    The sine of each element of x.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+arcsin, sinh, cos
+
+Notes
+-----
+The sine is one of the fundamental functions of trigonometry (the
+mathematical study of triangles).  Consider a circle of radius 1
+centered on the origin.  A ray comes in from the :math:`+x` axis, makes
+an angle at the origin (measured counter-clockwise from that axis), and
+departs from the origin.  The :math:`y` coordinate of the outgoing
+ray's intersection with the unit circle is the sine of that angle.  It
+ranges from -1 for :math:`x=3\\pi / 2` to +1 for :math:`\\pi / 2.`  The
+function has zeroes where the angle is a multiple of :math:`\\pi`.
+Sines of angles between :math:`\\pi` and :math:`2\\pi` are negative.
+The numerous properties of the sine and related functions are included
+in any standard trigonometry text.
+
+Examples
+--------
+Print sine of one angle:
+
+>>> np.sin(np.pi/2.)
+1.0
+
+Print sines of an array of angles given in degrees:
+
+>>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. )
+array([ 0.        ,  0.5       ,  0.70710678,  0.8660254 ,  1.        ])
+
+Plot the sine function:
+
+>>> import matplotlib.pylab as plt
+>>> x = np.linspace(-np.pi, np.pi, 201)
+>>> plt.plot(x, np.sin(x))
+>>> plt.xlabel('Angle [rad]')
+>>> plt.ylabel('sin(x)')
+>>> plt.axis('tight')
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
+
+(def flipud (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flipud"))))
+(alter-meta! #'flipud assoc :doc "
+    Flip array in the up/down direction.
+
+    Flip the entries in each column in the up/down direction.
+    Rows are preserved, but appear in a different order than before.
+
+    Parameters
+    ----------
+    m : array_like
+        Input array.
+
+    Returns
+    -------
+    out : array_like
+        A view of `m` with the rows reversed.  Since a view is
+        returned, this operation is :math:`\\mathcal O(1)`.
+
+    See Also
+    --------
+    fliplr : Flip array in the left/right direction.
+    rot90 : Rotate array counterclockwise.
+
+    Notes
+    -----
+    Equivalent to ``m[::-1,...]``.
+    Does not require the array to be two-dimensional.
+
+    Examples
+    --------
+    >>> A = np.diag([1.0, 2, 3])
+    >>> A
+    array([[1.,  0.,  0.],
+           [0.,  2.,  0.],
+           [0.,  0.,  3.]])
+    >>> np.flipud(A)
+    array([[0.,  0.,  3.],
+           [0.,  2.,  0.],
+           [1.,  0.,  0.]])
+
+    >>> A = np.random.randn(2,3,5)
+    >>> np.all(np.flipud(A) == A[::-1,...])
+    True
+
+    >>> np.flipud([1,2])
+    array([2, 1])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def power (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "power"))))
+(alter-meta! #'power assoc :doc "power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+First array elements raised to powers from second array, element-wise.
+
+Raise each base in `x1` to the positionally-corresponding power in
+`x2`.  `x1` and `x2` must be broadcastable to the same shape. Note that an
+integer type raised to a negative integer power will raise a ValueError.
+
+Parameters
+----------
+x1 : array_like
+    The bases.
+x2 : array_like
+    The exponents. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The bases in `x1` raised to the exponents in `x2`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+float_power : power function that promotes integers to float
+
+Examples
+--------
+Cube each element in a list.
+
+>>> x1 = range(6)
+>>> x1
+[0, 1, 2, 3, 4, 5]
+>>> np.power(x1, 3)
+array([  0,   1,   8,  27,  64, 125])
+
+Raise the bases to different exponents.
+
+>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
+>>> np.power(x1, x2)
+array([  0.,   1.,   8.,  27.,  16.,   5.])
+
+The effect of broadcasting.
+
+>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
+>>> x2
+array([[1, 2, 3, 3, 2, 1],
+       [1, 2, 3, 3, 2, 1]])
+>>> np.power(x1, x2)
+array([[ 0,  1,  8, 27, 16,  5],
+       [ 0,  1,  8, 27, 16,  5]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} pi (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "pi"))))
+
+(def ^{:doc "
+Pytest test running.
+
+This module implements the ``test()`` function for NumPy modules. The usual
+boiler plate for doing that is to put the following in the module
+``__init__.py`` file::
+
+    from numpy._pytesttester import PytestTester
+    test = PytestTester(__name__).test
+    del PytestTester
+
+
+Warnings filtering and other runtime settings should be dealt with in the
+``pytest.ini`` file in the numpy repo root. The behavior of the test depends on
+whether or not that file is found as follows:
+
+* ``pytest.ini`` is present (develop mode)
+    All warnings except those explicily filtered out are raised as error.
+* ``pytest.ini`` is absent (release mode)
+    DeprecationWarnings and PendingDeprecationWarnings are ignored, other
+    warnings are passed through.
+
+In practice, tests run from the numpy repo are run in develop mode. That
+includes the standard ``python runtests.py`` invocation.
+
+This module is imported by every numpy subpackage, so lies at the top level to
+simplify circular import issues. For the same reason, it contains no numpy
+imports at module scope, instead importing numpy within function calls.
+"} _pytesttester (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_pytesttester"))))
+
+(def fabs (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fabs"))))
+(alter-meta! #'fabs assoc :doc "fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the absolute values element-wise.
+
+This function returns the absolute values (positive magnitude) of the
+data in `x`. Complex values are not handled, use `absolute` to find the
+absolute values of complex data.
+
+Parameters
+----------
+x : array_like
+    The array of numbers for which the absolute values are required. If
+    `x` is a scalar, the result `y` will also be a scalar.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The absolute values of `x`, the returned values are always floats.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+absolute : Absolute values including `complex` types.
+
+Examples
+--------
+>>> np.fabs(-1)
+1.0
+>>> np.fabs([-1.2, 1.2])
+array([ 1.2,  1.2])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def gcd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "gcd"))))
+(alter-meta! #'gcd assoc :doc "gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns the greatest common divisor of ``|x1|`` and ``|x2|``
+
+Parameters
+----------
+x1, x2 : array_like, int
+    Arrays of values. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+
+Returns
+-------
+y : ndarray or scalar
+    The greatest common divisor of the absolute value of the inputs
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+lcm : The lowest common multiple
+
+Examples
+--------
+>>> np.gcd(12, 20)
+4
+>>> np.gcd.reduce([15, 25, 35])
+5
+>>> np.gcd(np.arange(6), 20)
+array([20,  1,  2,  1,  4,  5])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def hypot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hypot"))))
+(alter-meta! #'hypot assoc :doc "hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Given the \"legs\" of a right triangle, return its hypotenuse.
+
+Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise.  If `x1` or
+`x2` is scalar_like (i.e., unambiguously cast-able to a scalar type),
+it is broadcast for use with each element of the other argument.
+(See Examples)
+
+Parameters
+----------
+x1, x2 : array_like
+    Leg of the triangle(s). If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+z : ndarray
+    The hypotenuse of the triangle(s).
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Examples
+--------
+>>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3)))
+array([[ 5.,  5.,  5.],
+       [ 5.,  5.,  5.],
+       [ 5.,  5.,  5.]])
+
+Example showing broadcast of scalar_like argument:
+
+>>> np.hypot(3*np.ones((3, 3)), [4])
+array([[ 5.,  5.,  5.],
+       [ 5.,  5.,  5.],
+       [ 5.,  5.,  5.]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def unicode_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unicode_"))))
+(alter-meta! #'unicode_ assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def nested_iters (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nested_iters"))))
+(alter-meta! #'nested_iters assoc :doc "Create nditers for use in nested loops
+
+    Create a tuple of `nditer` objects which iterate in nested loops over
+    different axes of the op argument. The first iterator is used in the
+    outermost loop, the last in the innermost loop. Advancing one will change
+    the subsequent iterators to point at its new element.
+
+    Parameters
+    ----------
+    op : ndarray or sequence of array_like
+        The array(s) to iterate over.
+
+    axes : list of list of int
+        Each item is used as an \"op_axes\" argument to an nditer
+
+    flags, op_flags, op_dtypes, order, casting, buffersize (optional)
+        See `nditer` parameters of the same name
+
+    Returns
+    -------
+    iters : tuple of nditer
+        An nditer for each item in `axes`, outermost first
+
+    See Also
+    --------
+    nditer
+
+    Examples
+    --------
+
+    Basic usage. Note how y is the \"flattened\" version of
+    [a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified
+    the first iter's axes as [1]
+
+    >>> a = np.arange(12).reshape(2, 3, 2)
+    >>> i, j = np.nested_iters(a, [[1], [0, 2]], flags=[\"multi_index\"])
+    >>> for x in i:
+    ...      print(i.multi_index)
+    ...      for y in j:
+    ...          print('', j.multi_index, y)
+    (0,)
+     (0, 0) 0
+     (0, 1) 1
+     (1, 0) 6
+     (1, 1) 7
+    (1,)
+     (0, 0) 2
+     (0, 1) 3
+     (1, 0) 8
+     (1, 1) 9
+    (2,)
+     (0, 0) 4
+     (0, 1) 5
+     (1, 0) 10
+     (1, 1) 11" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc "This module provides access to the mathematical functions
+defined by the C standard."} math (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "math"))))
+
+(def ^{:doc "
+=============
+Masked Arrays
+=============
+
+Arrays sometimes contain invalid or missing data.  When doing operations
+on such arrays, we wish to suppress invalid values, which is the purpose masked
+arrays fulfill (an example of typical use is given below).
+
+For example, examine the following array:
+
+>>> x = np.array([2, 1, 3, np.nan, 5, 2, 3, np.nan])
+
+When we try to calculate the mean of the data, the result is undetermined:
+
+>>> np.mean(x)
+nan
+
+The mean is calculated using roughly ``np.sum(x)/len(x)``, but since
+any number added to ``NaN`` [1]_ produces ``NaN``, this doesn't work.  Enter
+masked arrays:
+
+>>> m = np.ma.masked_array(x, np.isnan(x))
+>>> m
+masked_array(data = [2.0 1.0 3.0 -- 5.0 2.0 3.0 --],
+      mask = [False False False  True False False False  True],
+      fill_value=1e+20)
+
+Here, we construct a masked array that suppress all ``NaN`` values.  We
+may now proceed to calculate the mean of the other values:
+
+>>> np.mean(m)
+2.6666666666666665
+
+.. [1] Not-a-Number, a floating point value that is the result of an
+       invalid operation.
+
+.. moduleauthor:: Pierre Gerard-Marchant
+.. moduleauthor:: Jarrod Millman
+
+"} ma (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ma"))))
+
+(def rate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rate"))))
+(alter-meta! #'rate assoc :doc "
+    Compute the rate of interest per period.
+
+    .. deprecated:: 1.18
+
+       `rate` is deprecated; for details, see NEP 32 [1]_.
+       Use the corresponding function in the numpy-financial library,
+       https://pypi.org/project/numpy-financial.
+
+    Parameters
+    ----------
+    nper : array_like
+        Number of compounding periods
+    pmt : array_like
+        Payment
+    pv : array_like
+        Present value
+    fv : array_like
+        Future value
+    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
+        When payments are due ('begin' (1) or 'end' (0))
+    guess : Number, optional
+        Starting guess for solving the rate of interest, default 0.1
+    tol : Number, optional
+        Required tolerance for the solution, default 1e-6
+    maxiter : int, optional
+        Maximum iterations in finding the solution
+
+    Notes
+    -----
+    The rate of interest is computed by iteratively solving the
+    (non-linear) equation::
+
+     fv + pv*(1+rate)**nper + pmt*(1+rate*when)/rate * ((1+rate)**nper - 1) = 0
+
+    for ``rate``.
+
+    References
+    ----------
+    .. [1] NumPy Enhancement Proposal (NEP) 32,
+       https://numpy.org/neps/nep-0032-remove-financial-functions.html
+    .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).
+       Open Document Format for Office Applications (OpenDocument)v1.2,
+       Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,
+       Pre-Draft 12. Organization for the Advancement of Structured Information
+       Standards (OASIS). Billerica, MA, USA. [ODT Document].
+       Available:
+       http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula
+       OpenDocument-formula-20090508.odt
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ndfromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndfromtxt"))))
+(alter-meta! #'ndfromtxt assoc :doc "
+    Load ASCII data stored in a file and return it as a single array.
+
+    .. deprecated:: 1.17
+        ndfromtxt` is a deprecated alias of `genfromtxt` which
+        overwrites the ``usemask`` argument with `False` even when
+        explicitly called as ``ndfromtxt(..., usemask=True)``.
+        Use `genfromtxt` instead.
+
+    Parameters
+    ----------
+    fname, kwargs : For a description of input parameters, see `genfromtxt`.
+
+    See Also
+    --------
+    numpy.genfromtxt : generic function.
+
+    " :arglists '[[fname & [{:as kwargs}]]])
+
+(def bitwise_and (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_and"))))
+(alter-meta! #'bitwise_and assoc :doc "bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the bit-wise AND of two arrays element-wise.
+
+Computes the bit-wise AND of the underlying binary representation of
+the integers in the input arrays. This ufunc implements the C/Python
+operator ``&``.
+
+Parameters
+----------
+x1, x2 : array_like
+    Only integer and boolean types are handled. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Result.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_and
+bitwise_or
+bitwise_xor
+binary_repr :
+    Return the binary representation of the input number as a string.
+
+Examples
+--------
+The number 13 is represented by ``00001101``.  Likewise, 17 is
+represented by ``00010001``.  The bit-wise AND of 13 and 17 is
+therefore ``000000001``, or 1:
+
+>>> np.bitwise_and(13, 17)
+1
+
+>>> np.bitwise_and(14, 13)
+12
+>>> np.binary_repr(12)
+'1100'
+>>> np.bitwise_and([14,3], 13)
+array([12,  1])
+
+>>> np.bitwise_and([11,7], [4,25])
+array([0, 1])
+>>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16]))
+array([ 2,  4, 16])
+>>> np.bitwise_and([True, True], [False, True])
+array([False,  True])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def cdouble (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cdouble"))))
+(alter-meta! #'cdouble assoc :doc "Complex number type composed of two double-precision floating-point
+    numbers, compatible with Python `complex`.
+    Character code: ``'D'``.
+    Canonical name: ``np.cdouble``.
+    Alias: ``np.cfloat``.
+    Alias: ``np.complex_``.
+    Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def real (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "real"))))
+(alter-meta! #'real assoc :doc "
+    Return the real part of the complex argument.
+
+    Parameters
+    ----------
+    val : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray or scalar
+        The real component of the complex argument. If `val` is real, the type
+        of `val` is used for the output.  If `val` has complex elements, the
+        returned type is float.
+
+    See Also
+    --------
+    real_if_close, imag, angle
+
+    Examples
+    --------
+    >>> a = np.array([1+2j, 3+4j, 5+6j])
+    >>> a.real
+    array([1.,  3.,  5.])
+    >>> a.real = 9
+    >>> a
+    array([9.+2.j,  9.+4.j,  9.+6.j])
+    >>> a.real = np.array([9, 8, 7])
+    >>> a
+    array([9.+2.j,  8.+4.j,  7.+6.j])
+    >>> np.real(1 + 1j)
+    1.0
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def fmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fmin"))))
+(alter-meta! #'fmin assoc :doc "fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Element-wise minimum of array elements.
+
+Compare two arrays and returns a new array containing the element-wise
+minima. If one of the elements being compared is a NaN, then the
+non-nan element is returned. If both elements are NaNs then the first
+is returned.  The latter distinction is important for complex NaNs,
+which are defined as at least one of the real or imaginary parts being
+a NaN. The net effect is that NaNs are ignored when possible.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays holding the elements to be compared. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The minimum of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+fmax :
+    Element-wise maximum of two arrays, ignores NaNs.
+minimum :
+    Element-wise minimum of two arrays, propagates NaNs.
+amin :
+    The minimum value of an array along a given axis, propagates NaNs.
+nanmin :
+    The minimum value of an array along a given axis, ignores NaNs.
+
+maximum, amax, nanmax
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither
+x1 nor x2 are NaNs, but it is faster and does proper broadcasting.
+
+Examples
+--------
+>>> np.fmin([2, 3, 4], [1, 5, 2])
+array([1, 3, 2])
+
+>>> np.fmin(np.eye(2), [0.5, 2])
+array([[ 0.5,  0. ],
+       [ 0. ,  1. ]])
+
+>>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan])
+array([ 0.,  0., nan])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def format_float_positional (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "format_float_positional"))))
+(alter-meta! #'format_float_positional assoc :doc "
+    Format a floating-point scalar as a decimal string in positional notation.
+
+    Provides control over rounding, trimming and padding. Uses and assumes
+    IEEE unbiased rounding. Uses the \"Dragon4\" algorithm.
+
+    Parameters
+    ----------
+    x : python float or numpy floating scalar
+        Value to format.
+    precision : non-negative integer or None, optional
+        Maximum number of digits to print. May be None if `unique` is
+        `True`, but must be an integer if unique is `False`.
+    unique : boolean, optional
+        If `True`, use a digit-generation strategy which gives the shortest
+        representation which uniquely identifies the floating-point number from
+        other values of the same type, by judicious rounding. If `precision`
+        was omitted, print out all necessary digits, otherwise digit generation
+        is cut off after `precision` digits and the remaining value is rounded.
+        If `False`, digits are generated as if printing an infinite-precision
+        value and stopping after `precision` digits, rounding the remaining
+        value.
+    fractional : boolean, optional
+        If `True`, the cutoff of `precision` digits refers to the total number
+        of digits after the decimal point, including leading zeros.
+        If `False`, `precision` refers to the total number of significant
+        digits, before or after the decimal point, ignoring leading zeros.
+    trim : one of 'k', '.', '0', '-', optional
+        Controls post-processing trimming of trailing digits, as follows:
+
+        * 'k' : keep trailing zeros, keep decimal point (no trimming)
+        * '.' : trim all trailing zeros, leave decimal point
+        * '0' : trim all but the zero before the decimal point. Insert the
+          zero if it is missing.
+        * '-' : trim trailing zeros and any trailing decimal point
+    sign : boolean, optional
+        Whether to show the sign for positive values.
+    pad_left : non-negative integer, optional
+        Pad the left side of the string with whitespace until at least that
+        many characters are to the left of the decimal point.
+    pad_right : non-negative integer, optional
+        Pad the right side of the string with whitespace until at least that
+        many characters are to the right of the decimal point.
+
+    Returns
+    -------
+    rep : string
+        The string representation of the floating point value
+
+    See Also
+    --------
+    format_float_scientific
+
+    Examples
+    --------
+    >>> np.format_float_positional(np.float32(np.pi))
+    '3.1415927'
+    >>> np.format_float_positional(np.float16(np.pi))
+    '3.14'
+    >>> np.format_float_positional(np.float16(0.3))
+    '0.3'
+    >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10)
+    '0.3000488281'
+    " :arglists '[[x & [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign, pad_left :pad_left, pad_right :pad_right}]] [x & [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign, pad_left :pad_left}]] [x & [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign}]] [x & [{precision :precision, unique :unique, fractional :fractional, trim :trim}]] [x & [{precision :precision, unique :unique, fractional :fractional}]] [x & [{precision :precision, unique :unique}]] [x & [{precision :precision}]] [x]])
+
+(def __dir__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__dir__"))))
+(alter-meta! #'__dir__ assoc :doc "" :arglists '[[]])
+
+(def vectorize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vectorize"))))
+(alter-meta! #'vectorize assoc :doc "
+    vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False,
+              signature=None)
+
+    Generalized function class.
+
+    Define a vectorized function which takes a nested sequence of objects or
+    numpy arrays as inputs and returns a single numpy array or a tuple of numpy
+    arrays. The vectorized function evaluates `pyfunc` over successive tuples
+    of the input arrays like the python map function, except it uses the
+    broadcasting rules of numpy.
+
+    The data type of the output of `vectorized` is determined by calling
+    the function with the first element of the input.  This can be avoided
+    by specifying the `otypes` argument.
+
+    Parameters
+    ----------
+    pyfunc : callable
+        A python function or method.
+    otypes : str or list of dtypes, optional
+        The output data type. It must be specified as either a string of
+        typecode characters or a list of data type specifiers. There should
+        be one data type specifier for each output.
+    doc : str, optional
+        The docstring for the function. If None, the docstring will be the
+        ``pyfunc.__doc__``.
+    excluded : set, optional
+        Set of strings or integers representing the positional or keyword
+        arguments for which the function will not be vectorized.  These will be
+        passed directly to `pyfunc` unmodified.
+
+        .. versionadded:: 1.7.0
+
+    cache : bool, optional
+       If `True`, then cache the first function call that determines the number
+       of outputs if `otypes` is not provided.
+
+        .. versionadded:: 1.7.0
+
+    signature : string, optional
+        Generalized universal function signature, e.g., ``(m,n),(n)->(m)`` for
+        vectorized matrix-vector multiplication. If provided, ``pyfunc`` will
+        be called with (and expected to return) arrays with shapes given by the
+        size of corresponding core dimensions. By default, ``pyfunc`` is
+        assumed to take scalars as input and output.
+
+        .. versionadded:: 1.12.0
+
+    Returns
+    -------
+    vectorized : callable
+        Vectorized function.
+
+    See Also
+    --------
+    frompyfunc : Takes an arbitrary Python function and returns a ufunc
+
+    Notes
+    -----
+    The `vectorize` function is provided primarily for convenience, not for
+    performance. The implementation is essentially a for loop.
+
+    If `otypes` is not specified, then a call to the function with the
+    first argument will be used to determine the number of outputs.  The
+    results of this call will be cached if `cache` is `True` to prevent
+    calling the function twice.  However, to implement the cache, the
+    original function must be wrapped which will slow down subsequent
+    calls, so only do this if your function is expensive.
+
+    The new keyword argument interface and `excluded` argument support
+    further degrades performance.
+
+    References
+    ----------
+    .. [1] NumPy Reference, section `Generalized Universal Function API
+           <https://docs.scipy.org/doc/numpy/reference/c-api.generalized-ufuncs.html>`_.
+
+    Examples
+    --------
+    >>> def myfunc(a, b):
+    ...     \"Return a-b if a>b, otherwise return a+b\"
+    ...     if a > b:
+    ...         return a - b
+    ...     else:
+    ...         return a + b
+
+    >>> vfunc = np.vectorize(myfunc)
+    >>> vfunc([1, 2, 3, 4], 2)
+    array([3, 4, 1, 2])
+
+    The docstring is taken from the input function to `vectorize` unless it
+    is specified:
+
+    >>> vfunc.__doc__
+    'Return a-b if a>b, otherwise return a+b'
+    >>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`')
+    >>> vfunc.__doc__
+    'Vectorized `myfunc`'
+
+    The output type is determined by evaluating the first element of the input,
+    unless it is specified:
+
+    >>> out = vfunc([1, 2, 3, 4], 2)
+    >>> type(out[0])
+    <class 'numpy.int64'>
+    >>> vfunc = np.vectorize(myfunc, otypes=[float])
+    >>> out = vfunc([1, 2, 3, 4], 2)
+    >>> type(out[0])
+    <class 'numpy.float64'>
+
+    The `excluded` argument can be used to prevent vectorizing over certain
+    arguments.  This can be useful for array-like arguments of a fixed length
+    such as the coefficients for a polynomial as in `polyval`:
+
+    >>> def mypolyval(p, x):
+    ...     _p = list(p)
+    ...     res = _p.pop(0)
+    ...     while _p:
+    ...         res = res*x + _p.pop(0)
+    ...     return res
+    >>> vpolyval = np.vectorize(mypolyval, excluded=['p'])
+    >>> vpolyval(p=[1, 2, 3], x=[0, 1])
+    array([3, 6])
+
+    Positional arguments may also be excluded by specifying their position:
+
+    >>> vpolyval.excluded.add(0)
+    >>> vpolyval([1, 2, 3], x=[0, 1])
+    array([3, 6])
+
+    The `signature` argument allows for vectorizing functions that act on
+    non-scalar arrays of fixed length. For example, you can use it for a
+    vectorized calculation of Pearson correlation coefficient and its p-value:
+
+    >>> import scipy.stats
+    >>> pearsonr = np.vectorize(scipy.stats.pearsonr,
+    ...                 signature='(n),(n)->(),()')
+    >>> pearsonr([[0, 1, 2, 3]], [[1, 2, 3, 4], [4, 3, 2, 1]])
+    (array([ 1., -1.]), array([ 0.,  0.]))
+
+    Or for a vectorized convolution:
+
+    >>> convolve = np.vectorize(np.convolve, signature='(n),(m)->(k)')
+    >>> convolve(np.eye(4), [1, 2, 1])
+    array([[1., 2., 1., 0., 0., 0.],
+           [0., 1., 2., 1., 0., 0.],
+           [0., 0., 1., 2., 1., 0.],
+           [0., 0., 0., 1., 2., 1.]])
+
+    " :arglists '[[self pyfunc & [{otypes :otypes, doc :doc, excluded :excluded, cache :cache, signature :signature}]] [self pyfunc & [{otypes :otypes, doc :doc, excluded :excluded, cache :cache}]] [self pyfunc & [{otypes :otypes, doc :doc, excluded :excluded}]] [self pyfunc & [{otypes :otypes, doc :doc}]] [self pyfunc & [{otypes :otypes}]] [self pyfunc]])
+
+(def radians (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "radians"))))
+(alter-meta! #'radians assoc :doc "radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Convert angles from degrees to radians.
+
+Parameters
+----------
+x : array_like
+    Input array in degrees.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding radian values.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+deg2rad : equivalent function
+
+Examples
+--------
+Convert a degree array to radians
+
+>>> deg = np.arange(12.) * 30.
+>>> np.radians(deg)
+array([ 0.        ,  0.52359878,  1.04719755,  1.57079633,  2.0943951 ,
+        2.61799388,  3.14159265,  3.66519143,  4.1887902 ,  4.71238898,
+        5.23598776,  5.75958653])
+
+>>> out = np.zeros((deg.shape))
+>>> ret = np.radians(deg, out)
+>>> ret is out
+True" :arglists '[[self & [args {:as kwargs}]]])
+
+(def histogram (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogram"))))
+(alter-meta! #'histogram assoc :doc "
+    Compute the histogram of a set of data.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data. The histogram is computed over the flattened array.
+    bins : int or sequence of scalars or str, optional
+        If `bins` is an int, it defines the number of equal-width
+        bins in the given range (10, by default). If `bins` is a
+        sequence, it defines a monotonically increasing array of bin edges,
+        including the rightmost edge, allowing for non-uniform bin widths.
+
+        .. versionadded:: 1.11.0
+
+        If `bins` is a string, it defines the method used to calculate the
+        optimal bin width, as defined by `histogram_bin_edges`.
+
+    range : (float, float), optional
+        The lower and upper range of the bins.  If not provided, range
+        is simply ``(a.min(), a.max())``.  Values outside the range are
+        ignored. The first element of the range must be less than or
+        equal to the second. `range` affects the automatic bin
+        computation as well. While bin width is computed to be optimal
+        based on the actual data within `range`, the bin count will fill
+        the entire range including portions containing no data.
+    normed : bool, optional
+
+        .. deprecated:: 1.6.0
+
+        This is equivalent to the `density` argument, but produces incorrect
+        results for unequal bin widths. It should not be used.
+
+        .. versionchanged:: 1.15.0
+            DeprecationWarnings are actually emitted.
+
+    weights : array_like, optional
+        An array of weights, of the same shape as `a`.  Each value in
+        `a` only contributes its associated weight towards the bin count
+        (instead of 1). If `density` is True, the weights are
+        normalized, so that the integral of the density over the range
+        remains 1.
+    density : bool, optional
+        If ``False``, the result will contain the number of samples in
+        each bin. If ``True``, the result is the value of the
+        probability *density* function at the bin, normalized such that
+        the *integral* over the range is 1. Note that the sum of the
+        histogram values will not be equal to 1 unless bins of unity
+        width are chosen; it is not a probability *mass* function.
+
+        Overrides the ``normed`` keyword if given.
+
+    Returns
+    -------
+    hist : array
+        The values of the histogram. See `density` and `weights` for a
+        description of the possible semantics.
+    bin_edges : array of dtype float
+        Return the bin edges ``(length(hist)+1)``.
+
+
+    See Also
+    --------
+    histogramdd, bincount, searchsorted, digitize, histogram_bin_edges
+
+    Notes
+    -----
+    All but the last (righthand-most) bin is half-open.  In other words,
+    if `bins` is::
+
+      [1, 2, 3, 4]
+
+    then the first bin is ``[1, 2)`` (including 1, but excluding 2) and
+    the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which
+    *includes* 4.
+
+
+    Examples
+    --------
+    >>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3])
+    (array([0, 2, 1]), array([0, 1, 2, 3]))
+    >>> np.histogram(np.arange(4), bins=np.arange(5), density=True)
+    (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4]))
+    >>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3])
+    (array([1, 4, 1]), array([0, 1, 2, 3]))
+
+    >>> a = np.arange(5)
+    >>> hist, bin_edges = np.histogram(a, density=True)
+    >>> hist
+    array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5])
+    >>> hist.sum()
+    2.4999999999999996
+    >>> np.sum(hist * np.diff(bin_edges))
+    1.0
+
+    .. versionadded:: 1.11.0
+
+    Automated Bin Selection Methods example, using 2 peak random data
+    with 2000 points:
+
+    >>> import matplotlib.pyplot as plt
+    >>> rng = np.random.RandomState(10)  # deterministic random data
+    >>> a = np.hstack((rng.normal(size=1000),
+    ...                rng.normal(loc=5, scale=2, size=1000)))
+    >>> _ = plt.hist(a, bins='auto')  # arguments are passed to np.histogram
+    >>> plt.title(\"Histogram with 'auto' bins\")
+    Text(0.5, 1.0, \"Histogram with 'auto' bins\")
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} UFUNC_PYVALS_NAME (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "UFUNC_PYVALS_NAME"))))
+
+(def isfortran (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isfortran"))))
+(alter-meta! #'isfortran assoc :doc "
+    Check if the array is Fortran contiguous but *not* C contiguous.
+
+    This function is obsolete and, because of changes due to relaxed stride
+    checking, its return value for the same array may differ for versions
+    of NumPy >= 1.10.0 and previous versions. If you only want to check if an
+    array is Fortran contiguous use ``a.flags.f_contiguous`` instead.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input array.
+
+    Returns
+    -------
+    isfortran : bool
+        Returns True if the array is Fortran contiguous but *not* C contiguous.
+
+
+    Examples
+    --------
+
+    np.array allows to specify whether the array is written in C-contiguous
+    order (last index varies the fastest), or FORTRAN-contiguous order in
+    memory (first index varies the fastest).
+
+    >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
+    >>> a
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> np.isfortran(a)
+    False
+
+    >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F')
+    >>> b
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> np.isfortran(b)
+    True
+
+
+    The transpose of a C-ordered array is a FORTRAN-ordered array.
+
+    >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
+    >>> a
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> np.isfortran(a)
+    False
+    >>> b = a.T
+    >>> b
+    array([[1, 4],
+           [2, 5],
+           [3, 6]])
+    >>> np.isfortran(b)
+    True
+
+    C-ordered arrays evaluate as False even if they are also FORTRAN-ordered.
+
+    >>> np.isfortran(np.array([1, 2], order='F'))
+    False
+
+    " :arglists '[[a]])
+
+(def float16 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float16"))))
+(alter-meta! #'float16 assoc :doc "Half-precision floating-point number type.
+    Character code: ``'e'``.
+    Canonical name: ``np.half``.
+    Alias *on this platform*: ``np.float16``: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
+
+(def searchsorted (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "searchsorted"))))
+(alter-meta! #'searchsorted assoc :doc "
+    Find indices where elements should be inserted to maintain order.
+
+    Find the indices into a sorted array `a` such that, if the
+    corresponding elements in `v` were inserted before the indices, the
+    order of `a` would be preserved.
+
+    Assuming that `a` is sorted:
+
+    ======  ============================
+    `side`  returned index `i` satisfies
+    ======  ============================
+    left    ``a[i-1] < v <= a[i]``
+    right   ``a[i-1] <= v < a[i]``
+    ======  ============================
+
+    Parameters
+    ----------
+    a : 1-D array_like
+        Input array. If `sorter` is None, then it must be sorted in
+        ascending order, otherwise `sorter` must be an array of indices
+        that sort it.
+    v : array_like
+        Values to insert into `a`.
+    side : {'left', 'right'}, optional
+        If 'left', the index of the first suitable location found is given.
+        If 'right', return the last such index.  If there is no suitable
+        index, return either 0 or N (where N is the length of `a`).
+    sorter : 1-D array_like, optional
+        Optional array of integer indices that sort array a into ascending
+        order. They are typically the result of argsort.
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    indices : array of ints
+        Array of insertion points with the same shape as `v`.
+
+    See Also
+    --------
+    sort : Return a sorted copy of an array.
+    histogram : Produce histogram from 1-D data.
+
+    Notes
+    -----
+    Binary search is used to find the required insertion points.
+
+    As of NumPy 1.4.0 `searchsorted` works with real/complex arrays containing
+    `nan` values. The enhanced sort order is documented in `sort`.
+
+    This function uses the same algorithm as the builtin python `bisect.bisect_left`
+    (``side='left'``) and `bisect.bisect_right` (``side='right'``) functions,
+    which is also vectorized in the `v` argument.
+
+    Examples
+    --------
+    >>> np.searchsorted([1,2,3,4,5], 3)
+    2
+    >>> np.searchsorted([1,2,3,4,5], 3, side='right')
+    3
+    >>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
+    array([0, 5, 1, 2])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def fromiter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromiter"))))
+(alter-meta! #'fromiter assoc :doc "fromiter(iterable, dtype, count=-1)
+
+    Create a new 1-dimensional array from an iterable object.
+
+    Parameters
+    ----------
+    iterable : iterable object
+        An iterable object providing data for the array.
+    dtype : data-type
+        The data-type of the returned array.
+    count : int, optional
+        The number of items to read from *iterable*.  The default is -1,
+        which means all data is read.
+
+    Returns
+    -------
+    out : ndarray
+        The output array.
+
+    Notes
+    -----
+    Specify `count` to improve performance.  It allows ``fromiter`` to
+    pre-allocate the output array, instead of resizing it on demand.
+
+    Examples
+    --------
+    >>> iterable = (x*x for x in range(5))
+    >>> np.fromiter(iterable, float)
+    array([  0.,   1.,   4.,   9.,  16.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def character (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "character"))))
+(alter-meta! #'character assoc :doc "Abstract base class of all character string scalar types." :arglists '[[self & [args {:as kwargs}]]])
+
+(def uint64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint64"))))
+(alter-meta! #'uint64 assoc :doc "Unsigned integer type, compatible with C ``unsigned long``.
+    Character code: ``'L'``.
+    Canonical name: ``np.uint``.
+    Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615).
+    Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def full (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "full"))))
+(alter-meta! #'full assoc :doc "
+    Return a new array of given shape and type, filled with `fill_value`.
+
+    Parameters
+    ----------
+    shape : int or sequence of ints
+        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
+    fill_value : scalar
+        Fill value.
+    dtype : data-type, optional
+        The desired data-type for the array  The default, None, means
+         `np.array(fill_value).dtype`.
+    order : {'C', 'F'}, optional
+        Whether to store multidimensional data in C- or Fortran-contiguous
+        (row- or column-wise) order in memory.
+
+    Returns
+    -------
+    out : ndarray
+        Array of `fill_value` with the given shape, dtype, and order.
+
+    See Also
+    --------
+    full_like : Return a new array with shape of input filled with value.
+    empty : Return a new uninitialized array.
+    ones : Return a new array setting values to one.
+    zeros : Return a new array setting values to zero.
+
+    Examples
+    --------
+    >>> np.full((2, 2), np.inf)
+    array([[inf, inf],
+           [inf, inf]])
+    >>> np.full((2, 2), 10)
+    array([[10, 10],
+           [10, 10]])
+
+    " :arglists '[[shape fill_value & [{dtype :dtype, order :order}]] [shape fill_value & [{dtype :dtype}]] [shape fill_value]])
+
+(def extract (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "extract"))))
+(alter-meta! #'extract assoc :doc "
+    Return the elements of an array that satisfy some condition.
+
+    This is equivalent to ``np.compress(ravel(condition), ravel(arr))``.  If
+    `condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``.
+
+    Note that `place` does the exact opposite of `extract`.
+
+    Parameters
+    ----------
+    condition : array_like
+        An array whose nonzero or True entries indicate the elements of `arr`
+        to extract.
+    arr : array_like
+        Input array of the same size as `condition`.
+
+    Returns
+    -------
+    extract : ndarray
+        Rank 1 array of values from `arr` where `condition` is True.
+
+    See Also
+    --------
+    take, put, copyto, compress, place
+
+    Examples
+    --------
+    >>> arr = np.arange(12).reshape((3, 4))
+    >>> arr
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11]])
+    >>> condition = np.mod(arr, 3)==0
+    >>> condition
+    array([[ True, False, False,  True],
+           [False, False,  True, False],
+           [False,  True, False, False]])
+    >>> np.extract(condition, arr)
+    array([0, 3, 6, 9])
+
+
+    If `condition` is boolean:
+
+    >>> arr[condition]
+    array([0, 3, 6, 9])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def unravel_index (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unravel_index"))))
+(alter-meta! #'unravel_index assoc :doc "
+    unravel_index(indices, shape, order='C')
+
+    Converts a flat index or array of flat indices into a tuple
+    of coordinate arrays.
+
+    Parameters
+    ----------
+    indices : array_like
+        An integer array whose elements are indices into the flattened
+        version of an array of dimensions ``shape``. Before version 1.6.0,
+        this function accepted just one index value.
+    shape : tuple of ints
+        The shape of the array to use for unraveling ``indices``.
+
+        .. versionchanged:: 1.16.0
+            Renamed from ``dims`` to ``shape``.
+
+    order : {'C', 'F'}, optional
+        Determines whether the indices should be viewed as indexing in
+        row-major (C-style) or column-major (Fortran-style) order.
+
+        .. versionadded:: 1.6.0
+
+    Returns
+    -------
+    unraveled_coords : tuple of ndarray
+        Each array in the tuple has the same shape as the ``indices``
+        array.
+
+    See Also
+    --------
+    ravel_multi_index
+
+    Examples
+    --------
+    >>> np.unravel_index([22, 41, 37], (7,6))
+    (array([3, 6, 6]), array([4, 5, 1]))
+    >>> np.unravel_index([31, 41, 13], (7,6), order='F')
+    (array([3, 6, 6]), array([4, 5, 1]))
+
+    >>> np.unravel_index(1621, (6,7,8,9))
+    (3, 1, 4, 1)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def bool (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bool"))))
+(alter-meta! #'bool assoc :doc "bool(x) -> bool
+
+Returns True when the argument x is true, False otherwise.
+The builtins True and False are the only two instances of the class bool.
+The class bool is a subclass of the class int, and cannot be subclassed." :arglists '[[self & [args {:as kwargs}]]])
+
+(def blackman (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "blackman"))))
+(alter-meta! #'blackman assoc :doc "
+    Return the Blackman window.
+
+    The Blackman window is a taper formed by using the first three
+    terms of a summation of cosines. It was designed to have close to the
+    minimal leakage possible.  It is close to optimal, only slightly worse
+    than a Kaiser window.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an empty
+        array is returned.
+
+    Returns
+    -------
+    out : ndarray
+        The window, with the maximum value normalized to one (the value one
+        appears only if the number of samples is odd).
+
+    See Also
+    --------
+    bartlett, hamming, hanning, kaiser
+
+    Notes
+    -----
+    The Blackman window is defined as
+
+    .. math::  w(n) = 0.42 - 0.5 \\cos(2\\pi n/M) + 0.08 \\cos(4\\pi n/M)
+
+    Most references to the Blackman window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    \"removing the foot\", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function. It is known as a
+    \"near optimal\" tapering function, almost as good (by some measures)
+    as the kaiser window.
+
+    References
+    ----------
+    Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra,
+    Dover Publications, New York.
+
+    Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing.
+    Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471.
+
+    Examples
+    --------
+    >>> import matplotlib.pyplot as plt
+    >>> np.blackman(12)
+    array([-1.38777878e-17,   3.26064346e-02,   1.59903635e-01, # may vary
+            4.14397981e-01,   7.36045180e-01,   9.67046769e-01,
+            9.67046769e-01,   7.36045180e-01,   4.14397981e-01,
+            1.59903635e-01,   3.26064346e-02,  -1.38777878e-17])
+
+    Plot the window and the frequency response:
+
+    >>> from numpy.fft import fft, fftshift
+    >>> window = np.blackman(51)
+    >>> plt.plot(window)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Blackman window\")
+    Text(0.5, 1.0, 'Blackman window')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"Sample\")
+    Text(0.5, 0, 'Sample')
+    >>> plt.show()
+
+    >>> plt.figure()
+    <Figure size 640x480 with 0 Axes>
+    >>> A = fft(window, 2048) / 25.5
+    >>> mag = np.abs(fftshift(A))
+    >>> freq = np.linspace(-0.5, 0.5, len(A))
+    >>> with np.errstate(divide='ignore', invalid='ignore'):
+    ...     response = 20 * np.log10(mag)
+    ...
+    >>> response = np.clip(response, -100, 100)
+    >>> plt.plot(freq, response)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Frequency response of Blackman window\")
+    Text(0.5, 1.0, 'Frequency response of Blackman window')
+    >>> plt.ylabel(\"Magnitude [dB]\")
+    Text(0, 0.5, 'Magnitude [dB]')
+    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
+    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
+    >>> _ = plt.axis('tight')
+    >>> plt.show()
+
+    " :arglists '[[M]])
+
+(def ^{:doc "
+This module contains a set of functions for vectorized string
+operations and methods.
+
+.. note::
+   The `chararray` class exists for backwards compatibility with
+   Numarray, it is not recommended for new development. Starting from numpy
+   1.4, if one needs arrays of strings, it is recommended to use arrays of
+   `dtype` `object_`, `string_` or `unicode_`, and use the free functions
+   in the `numpy.char` module for fast vectorized string operations.
+
+Some methods will only be available if the corresponding string method is
+available in your version of Python.
+
+The preferred alias for `defchararray` is `numpy.char`.
+
+"} char (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "char"))))
+
+(def tile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tile"))))
+(alter-meta! #'tile assoc :doc "
+    Construct an array by repeating A the number of times given by reps.
+
+    If `reps` has length ``d``, the result will have dimension of
+    ``max(d, A.ndim)``.
+
+    If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new
+    axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication,
+    or shape (1, 1, 3) for 3-D replication. If this is not the desired
+    behavior, promote `A` to d-dimensions manually before calling this
+    function.
+
+    If ``A.ndim > d``, `reps` is promoted to `A`.ndim by pre-pending 1's to it.
+    Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as
+    (1, 1, 2, 2).
+
+    Note : Although tile may be used for broadcasting, it is strongly
+    recommended to use numpy's broadcasting operations and functions.
+
+    Parameters
+    ----------
+    A : array_like
+        The input array.
+    reps : array_like
+        The number of repetitions of `A` along each axis.
+
+    Returns
+    -------
+    c : ndarray
+        The tiled output array.
+
+    See Also
+    --------
+    repeat : Repeat elements of an array.
+    broadcast_to : Broadcast an array to a new shape
+
+    Examples
+    --------
+    >>> a = np.array([0, 1, 2])
+    >>> np.tile(a, 2)
+    array([0, 1, 2, 0, 1, 2])
+    >>> np.tile(a, (2, 2))
+    array([[0, 1, 2, 0, 1, 2],
+           [0, 1, 2, 0, 1, 2]])
+    >>> np.tile(a, (2, 1, 2))
+    array([[[0, 1, 2, 0, 1, 2]],
+           [[0, 1, 2, 0, 1, 2]]])
+
+    >>> b = np.array([[1, 2], [3, 4]])
+    >>> np.tile(b, 2)
+    array([[1, 2, 1, 2],
+           [3, 4, 3, 4]])
+    >>> np.tile(b, (2, 1))
+    array([[1, 2],
+           [3, 4],
+           [1, 2],
+           [3, 4]])
+
+    >>> c = np.array([1,2,3,4])
+    >>> np.tile(c,(4,1))
+    array([[1, 2, 3, 4],
+           [1, 2, 3, 4],
+           [1, 2, 3, 4],
+           [1, 2, 3, 4]])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def broadcast (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "broadcast"))))
+(alter-meta! #'broadcast assoc :doc "Produce an object that mimics broadcasting.
+
+    Parameters
+    ----------
+    in1, in2, ... : array_like
+        Input parameters.
+
+    Returns
+    -------
+    b : broadcast object
+        Broadcast the input parameters against one another, and
+        return an object that encapsulates the result.
+        Amongst others, it has ``shape`` and ``nd`` properties, and
+        may be used as an iterator.
+
+    See Also
+    --------
+    broadcast_arrays
+    broadcast_to
+
+    Examples
+    --------
+
+    Manually adding two vectors, using broadcasting:
+
+    >>> x = np.array([[1], [2], [3]])
+    >>> y = np.array([4, 5, 6])
+    >>> b = np.broadcast(x, y)
+
+    >>> out = np.empty(b.shape)
+    >>> out.flat = [u+v for (u,v) in b]
+    >>> out
+    array([[5.,  6.,  7.],
+           [6.,  7.,  8.],
+           [7.,  8.,  9.]])
+
+    Compare against built-in broadcasting:
+
+    >>> x + y
+    array([[5, 6, 7],
+           [6, 7, 8],
+           [7, 8, 9]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def half (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "half"))))
+(alter-meta! #'half assoc :doc "Half-precision floating-point number type.
+    Character code: ``'e'``.
+    Canonical name: ``np.half``.
+    Alias *on this platform*: ``np.float16``: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
+
+(def setdiff1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "setdiff1d"))))
+(alter-meta! #'setdiff1d assoc :doc "
+    Find the set difference of two arrays.
+
+    Return the unique values in `ar1` that are not in `ar2`.
+
+    Parameters
+    ----------
+    ar1 : array_like
+        Input array.
+    ar2 : array_like
+        Input comparison array.
+    assume_unique : bool
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+
+    Returns
+    -------
+    setdiff1d : ndarray
+        1D array of values in `ar1` that are not in `ar2`. The result
+        is sorted when `assume_unique=False`, but otherwise only sorted
+        if the input is sorted.
+
+    See Also
+    --------
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Examples
+    --------
+    >>> a = np.array([1, 2, 3, 2, 4, 1])
+    >>> b = np.array([3, 4, 5, 6])
+    >>> np.setdiff1d(a, b)
+    array([1, 2])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def npv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "npv"))))
+(alter-meta! #'npv assoc :doc "
+    Returns the NPV (Net Present Value) of a cash flow series.
+
+    .. deprecated:: 1.18
+
+       `npv` is deprecated; for details, see NEP 32 [1]_.
+       Use the corresponding function in the numpy-financial library,
+       https://pypi.org/project/numpy-financial.
+
+    Parameters
+    ----------
+    rate : scalar
+        The discount rate.
+    values : array_like, shape(M, )
+        The values of the time series of cash flows.  The (fixed) time
+        interval between cash flow \"events\" must be the same as that for
+        which `rate` is given (i.e., if `rate` is per year, then precisely
+        a year is understood to elapse between each cash flow event).  By
+        convention, investments or \"deposits\" are negative, income or
+        \"withdrawals\" are positive; `values` must begin with the initial
+        investment, thus `values[0]` will typically be negative.
+
+    Returns
+    -------
+    out : float
+        The NPV of the input cash flow series `values` at the discount
+        `rate`.
+
+    Warnings
+    --------
+    ``npv`` considers a series of cashflows starting in the present (t = 0).
+    NPV can also be defined with a series of future cashflows, paid at the
+    end, rather than the start, of each period. If future cashflows are used,
+    the first cashflow `values[0]` must be zeroed and added to the net
+    present value of the future cashflows. This is demonstrated in the
+    examples.
+
+    Notes
+    -----
+    Returns the result of: [2]_
+
+    .. math :: \\sum_{t=0}^{M-1}{\\frac{values_t}{(1+rate)^{t}}}
+
+    References
+    ----------
+    .. [1] NumPy Enhancement Proposal (NEP) 32,
+       https://numpy.org/neps/nep-0032-remove-financial-functions.html
+    .. [2] L. J. Gitman, \"Principles of Managerial Finance, Brief,\" 3rd ed.,
+       Addison-Wesley, 2003, pg. 346.
+
+    Examples
+    --------
+    Consider a potential project with an initial investment of $40 000 and
+    projected cashflows of $5 000, $8 000, $12 000 and $30 000 at the end of
+    each period discounted at a rate of 8% per period. To find the project's
+    net present value:
+
+    >>> rate, cashflows = 0.08, [-40_000, 5_000, 8_000, 12_000, 30_000]
+    >>> np.npv(rate, cashflows).round(5)
+    3065.22267
+
+    It may be preferable to split the projected cashflow into an initial
+    investment and expected future cashflows. In this case, the value of
+    the initial cashflow is zero and the initial investment is later added
+    to the future cashflows net present value:
+
+    >>> initial_cashflow = cashflows[0]
+    >>> cashflows[0] = 0
+    >>> np.round(np.npv(rate, cashflows) + initial_cashflow, 5)
+    3065.22267
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def remainder (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "remainder"))))
+(alter-meta! #'remainder assoc :doc "remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return element-wise remainder of division.
+
+Computes the remainder complementary to the `floor_divide` function.  It is
+equivalent to the Python modulus operator``x1 % x2`` and has the same sign
+as the divisor `x2`. The MATLAB function equivalent to ``np.remainder``
+is ``mod``.
+
+.. warning::
+
+    This should not be confused with:
+
+    * Python 3.7's `math.remainder` and C's ``remainder``, which
+      computes the IEEE remainder, which are the complement to
+      ``round(x1 / x2)``.
+    * The MATLAB ``rem`` function and or the C ``%`` operator which is the
+      complement to ``int(x1 / x2)``.
+
+Parameters
+----------
+x1 : array_like
+    Dividend array.
+x2 : array_like
+    Divisor array. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+floor_divide : Equivalent of Python ``//`` operator.
+divmod : Simultaneous floor division and remainder.
+fmod : Equivalent of the MATLAB ``rem`` function.
+divide, floor
+
+Notes
+-----
+Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
+integers.
+``mod`` is an alias of ``remainder``.
+
+Examples
+--------
+>>> np.remainder([4, 7], [2, 3])
+array([0, 1])
+>>> np.remainder(np.arange(7), 5)
+array([0, 1, 2, 3, 4, 0, 1])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} ALLOW_THREADS (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ALLOW_THREADS"))))
+
+(def exp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "exp"))))
+(alter-meta! #'exp assoc :doc "exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Calculate the exponential of all elements in the input array.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise exponential of `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+expm1 : Calculate ``exp(x) - 1`` for all elements in the array.
+exp2  : Calculate ``2**x`` for all elements in the array.
+
+Notes
+-----
+The irrational number ``e`` is also known as Euler's number.  It is
+approximately 2.718281, and is the base of the natural logarithm,
+``ln`` (this means that, if :math:`x = \\ln y = \\log_e y`,
+then :math:`e^x = y`. For real input, ``exp(x)`` is always positive.
+
+For complex arguments, ``x = a + ib``, we can write
+:math:`e^x = e^a e^{ib}`.  The first term, :math:`e^a`, is already
+known (it is the real argument, described above).  The second term,
+:math:`e^{ib}`, is :math:`\\cos b + i \\sin b`, a function with
+magnitude 1 and a periodic phase.
+
+References
+----------
+.. [1] Wikipedia, \"Exponential function\",
+       https://en.wikipedia.org/wiki/Exponential_function
+.. [2] M. Abramovitz and I. A. Stegun, \"Handbook of Mathematical Functions
+       with Formulas, Graphs, and Mathematical Tables,\" Dover, 1964, p. 69,
+       http://www.math.sfu.ca/~cbm/aands/page_69.htm
+
+Examples
+--------
+Plot the magnitude and phase of ``exp(x)`` in the complex plane:
+
+>>> import matplotlib.pyplot as plt
+
+>>> x = np.linspace(-2*np.pi, 2*np.pi, 100)
+>>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane
+>>> out = np.exp(xx)
+
+>>> plt.subplot(121)
+>>> plt.imshow(np.abs(out),
+...            extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray')
+>>> plt.title('Magnitude of exp(x)')
+
+>>> plt.subplot(122)
+>>> plt.imshow(np.angle(out),
+...            extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv')
+>>> plt.title('Phase (angle) of exp(x)')
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
+
+(def outer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "outer"))))
+(alter-meta! #'outer assoc :doc "
+    Compute the outer product of two vectors.
+
+    Given two vectors, ``a = [a0, a1, ..., aM]`` and
+    ``b = [b0, b1, ..., bN]``,
+    the outer product [1]_ is::
+
+      [[a0*b0  a0*b1 ... a0*bN ]
+       [a1*b0    .
+       [ ...          .
+       [aM*b0            aM*bN ]]
+
+    Parameters
+    ----------
+    a : (M,) array_like
+        First input vector.  Input is flattened if
+        not already 1-dimensional.
+    b : (N,) array_like
+        Second input vector.  Input is flattened if
+        not already 1-dimensional.
+    out : (M, N) ndarray, optional
+        A location where the result is stored
+
+        .. versionadded:: 1.9.0
+
+    Returns
+    -------
+    out : (M, N) ndarray
+        ``out[i, j] = a[i] * b[j]``
+
+    See also
+    --------
+    inner
+    einsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent.
+    ufunc.outer : A generalization to N dimensions and other operations.
+                  ``np.multiply.outer(a.ravel(), b.ravel())`` is the equivalent.
+
+    References
+    ----------
+    .. [1] : G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd
+             ed., Baltimore, MD, Johns Hopkins University Press, 1996,
+             pg. 8.
+
+    Examples
+    --------
+    Make a (*very* coarse) grid for computing a Mandelbrot set:
+
+    >>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))
+    >>> rl
+    array([[-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.]])
+    >>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
+    >>> im
+    array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
+           [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
+           [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
+           [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
+           [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
+    >>> grid = rl + im
+    >>> grid
+    array([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
+           [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
+           [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
+           [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
+           [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]])
+
+    An example using a \"vector\" of letters:
+
+    >>> x = np.array(['a', 'b', 'c'], dtype=object)
+    >>> np.outer(x, [1, 2, 3])
+    array([['a', 'aa', 'aaa'],
+           ['b', 'bb', 'bbb'],
+           ['c', 'cc', 'ccc']], dtype=object)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def uint8 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint8"))))
+(alter-meta! #'uint8 assoc :doc "Unsigned integer type, compatible with C ``unsigned char``.
+    Character code: ``'B'``.
+    Canonical name: ``np.ubyte``.
+    Alias *on this platform*: ``np.uint8``: 8-bit unsigned integer (0 to 255)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def atleast_2d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "atleast_2d"))))
+(alter-meta! #'atleast_2d assoc :doc "
+    View inputs as arrays with at least two dimensions.
+
+    Parameters
+    ----------
+    arys1, arys2, ... : array_like
+        One or more array-like sequences.  Non-array inputs are converted
+        to arrays.  Arrays that already have two or more dimensions are
+        preserved.
+
+    Returns
+    -------
+    res, res2, ... : ndarray
+        An array, or list of arrays, each with ``a.ndim >= 2``.
+        Copies are avoided where possible, and views with two or more
+        dimensions are returned.
+
+    See Also
+    --------
+    atleast_1d, atleast_3d
+
+    Examples
+    --------
+    >>> np.atleast_2d(3.0)
+    array([[3.]])
+
+    >>> x = np.arange(3.0)
+    >>> np.atleast_2d(x)
+    array([[0., 1., 2.]])
+    >>> np.atleast_2d(x).base is x
+    True
+
+    >>> np.atleast_2d(1, [1, 2], [[1, 2]])
+    [array([[1]]), array([[1, 2]]), array([[1, 2]])]
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} SHIFT_DIVIDEBYZERO (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "SHIFT_DIVIDEBYZERO"))))
+
+(def lexsort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "lexsort"))))
+(alter-meta! #'lexsort assoc :doc "
+    lexsort(keys, axis=-1)
+
+    Perform an indirect stable sort using a sequence of keys.
+
+    Given multiple sorting keys, which can be interpreted as columns in a
+    spreadsheet, lexsort returns an array of integer indices that describes
+    the sort order by multiple columns. The last key in the sequence is used
+    for the primary sort order, the second-to-last key for the secondary sort
+    order, and so on. The keys argument must be a sequence of objects that
+    can be converted to arrays of the same shape. If a 2D array is provided
+    for the keys argument, it's rows are interpreted as the sorting keys and
+    sorting is according to the last row, second last row etc.
+
+    Parameters
+    ----------
+    keys : (k, N) array or tuple containing k (N,)-shaped sequences
+        The `k` different \"columns\" to be sorted.  The last column (or row if
+        `keys` is a 2D array) is the primary sort key.
+    axis : int, optional
+        Axis to be indirectly sorted.  By default, sort over the last axis.
+
+    Returns
+    -------
+    indices : (N,) ndarray of ints
+        Array of indices that sort the keys along the specified axis.
+
+    See Also
+    --------
+    argsort : Indirect sort.
+    ndarray.sort : In-place sort.
+    sort : Return a sorted copy of an array.
+
+    Examples
+    --------
+    Sort names: first by surname, then by name.
+
+    >>> surnames =    ('Hertz',    'Galilei', 'Hertz')
+    >>> first_names = ('Heinrich', 'Galileo', 'Gustav')
+    >>> ind = np.lexsort((first_names, surnames))
+    >>> ind
+    array([1, 2, 0])
+
+    >>> [surnames[i] + \", \" + first_names[i] for i in ind]
+    ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich']
+
+    Sort two columns of numbers:
+
+    >>> a = [1,5,1,4,3,4,4] # First column
+    >>> b = [9,4,0,4,0,2,1] # Second column
+    >>> ind = np.lexsort((b,a)) # Sort by a, then by b
+    >>> ind
+    array([2, 0, 4, 6, 5, 3, 1])
+
+    >>> [(a[i],b[i]) for i in ind]
+    [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]
+
+    Note that sorting is first according to the elements of ``a``.
+    Secondary sorting is according to the elements of ``b``.
+
+    A normal ``argsort`` would have yielded:
+
+    >>> [(a[i],b[i]) for i in np.argsort(a)]
+    [(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)]
+
+    Structured arrays are sorted lexically by ``argsort``:
+
+    >>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)],
+    ...              dtype=np.dtype([('x', int), ('y', int)]))
+
+    >>> np.argsort(x) # or np.argsort(x, order=('x', 'y'))
+    array([2, 0, 4, 6, 5, 3, 1])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def subtract (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "subtract"))))
+(alter-meta! #'subtract assoc :doc "subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Subtract arguments, element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays to be subtracted from each other. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The difference of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+Equivalent to ``x1 - x2`` in terms of array broadcasting.
+
+Examples
+--------
+>>> np.subtract(1.0, 4.0)
+-3.0
+
+>>> x1 = np.arange(9.0).reshape((3, 3))
+>>> x2 = np.arange(3.0)
+>>> np.subtract(x1, x2)
+array([[ 0.,  0.,  0.],
+       [ 3.,  3.,  3.],
+       [ 6.,  6.,  6.]])" :arglists '[[self & [args {:as kwargs}]]])
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} sctypeDict (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "sctypeDict")))) 
+
+(def ^{:doc ""} FPE_OVERFLOW (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "FPE_OVERFLOW"))))
+
+(def isreal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isreal"))))
+(alter-meta! #'isreal assoc :doc "
+    Returns a bool array, where True if input element is real.
+
+    If element has complex type with zero complex part, the return value
+    for that element is True.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray, bool
+        Boolean array of same shape as `x`.
+
+    See Also
+    --------
+    iscomplex
+    isrealobj : Return True if x is not a complex type.
+
+    Examples
+    --------
+    >>> np.isreal([1+1j, 1+0j, 4.5, 3, 2, 2j])
+    array([False,  True,  True,  True,  True, False])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def asscalar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asscalar"))))
+(alter-meta! #'asscalar assoc :doc "
+    Convert an array of size 1 to its scalar equivalent.
+
+    .. deprecated:: 1.16
+
+        Deprecated, use `numpy.ndarray.item()` instead.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input array of size 1.
+
+    Returns
+    -------
+    out : scalar
+        Scalar representation of `a`. The output data type is the same type
+        returned by the input's `item` method.
+
+    Examples
+    --------
+    >>> np.asscalar(np.array([24]))
+    24
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def select (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "select"))))
+(alter-meta! #'select assoc :doc "
+    Return an array drawn from elements in choicelist, depending on conditions.
+
+    Parameters
+    ----------
+    condlist : list of bool ndarrays
+        The list of conditions which determine from which array in `choicelist`
+        the output elements are taken. When multiple conditions are satisfied,
+        the first one encountered in `condlist` is used.
+    choicelist : list of ndarrays
+        The list of arrays from which the output elements are taken. It has
+        to be of the same length as `condlist`.
+    default : scalar, optional
+        The element inserted in `output` when all conditions evaluate to False.
+
+    Returns
+    -------
+    output : ndarray
+        The output at position m is the m-th element of the array in
+        `choicelist` where the m-th element of the corresponding array in
+        `condlist` is True.
+
+    See Also
+    --------
+    where : Return elements from one of two arrays depending on condition.
+    take, choose, compress, diag, diagonal
+
+    Examples
+    --------
+    >>> x = np.arange(10)
+    >>> condlist = [x<3, x>5]
+    >>> choicelist = [x, x**2]
+    >>> np.select(condlist, choicelist)
+    array([ 0,  1,  2, ..., 49, 64, 81])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def identity (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "identity"))))
+(alter-meta! #'identity assoc :doc "
+    Return the identity array.
+
+    The identity array is a square array with ones on
+    the main diagonal.
+
+    Parameters
+    ----------
+    n : int
+        Number of rows (and columns) in `n` x `n` output.
+    dtype : data-type, optional
+        Data-type of the output.  Defaults to ``float``.
+
+    Returns
+    -------
+    out : ndarray
+        `n` x `n` array with its main diagonal set to one,
+        and all other elements 0.
+
+    Examples
+    --------
+    >>> np.identity(3)
+    array([[1.,  0.,  0.],
+           [0.,  1.,  0.],
+           [0.,  0.,  1.]])
+
+    " :arglists '[[n & [{dtype :dtype}]] [n]])
+
+(def geterr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geterr"))))
+(alter-meta! #'geterr assoc :doc "
+    Get the current way of handling floating-point errors.
+
+    Returns
+    -------
+    res : dict
+        A dictionary with keys \"divide\", \"over\", \"under\", and \"invalid\",
+        whose values are from the strings \"ignore\", \"print\", \"log\", \"warn\",
+        \"raise\", and \"call\". The keys represent possible floating-point
+        exceptions, and the values define how these exceptions are handled.
+
+    See Also
+    --------
+    geterrcall, seterr, seterrcall
+
+    Notes
+    -----
+    For complete documentation of the types of floating-point exceptions and
+    treatment options, see `seterr`.
+
+    Examples
+    --------
+    >>> from collections import OrderedDict
+    >>> sorted(np.geterr().items())
+    [('divide', 'warn'), ('invalid', 'warn'), ('over', 'warn'), ('under', 'ignore')]
+    >>> np.arange(3.) / np.arange(3.)
+    array([nan,  1.,  1.])
+
+    >>> oldsettings = np.seterr(all='warn', over='raise')
+    >>> OrderedDict(sorted(np.geterr().items()))
+    OrderedDict([('divide', 'warn'), ('invalid', 'warn'), ('over', 'raise'), ('under', 'warn')])
+    >>> np.arange(3.) / np.arange(3.)
+    array([nan,  1.,  1.])
+
+    " :arglists '[[]])
+
+(def eye (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "eye"))))
+(alter-meta! #'eye assoc :doc "
+    Return a 2-D array with ones on the diagonal and zeros elsewhere.
+
+    Parameters
+    ----------
+    N : int
+      Number of rows in the output.
+    M : int, optional
+      Number of columns in the output. If None, defaults to `N`.
+    k : int, optional
+      Index of the diagonal: 0 (the default) refers to the main diagonal,
+      a positive value refers to an upper diagonal, and a negative value
+      to a lower diagonal.
+    dtype : data-type, optional
+      Data-type of the returned array.
+    order : {'C', 'F'}, optional
+        Whether the output should be stored in row-major (C-style) or
+        column-major (Fortran-style) order in memory.
+
+        .. versionadded:: 1.14.0
+
+    Returns
+    -------
+    I : ndarray of shape (N,M)
+      An array where all elements are equal to zero, except for the `k`-th
+      diagonal, whose values are equal to one.
+
+    See Also
+    --------
+    identity : (almost) equivalent function
+    diag : diagonal 2-D array from a 1-D array specified by the user.
+
+    Examples
+    --------
+    >>> np.eye(2, dtype=int)
+    array([[1, 0],
+           [0, 1]])
+    >>> np.eye(3, k=1)
+    array([[0.,  1.,  0.],
+           [0.,  0.,  1.],
+           [0.,  0.,  0.]])
+
+    " :arglists '[[N & [{M :M, k :k, dtype :dtype, order :order}]] [N & [{M :M, k :k, dtype :dtype}]] [N & [{M :M, k :k}]] [N & [{M :M}]] [N]])
+
+(def heaviside (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "heaviside"))))
+(alter-meta! #'heaviside assoc :doc "heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the Heaviside step function.
+
+The Heaviside step function is defined as::
+
+                          0   if x1 < 0
+    heaviside(x1, x2) =  x2   if x1 == 0
+                          1   if x1 > 0
+
+where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used.
+
+Parameters
+----------
+x1 : array_like
+    Input values.
+x2 : array_like
+    The value of the function when x1 is 0. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    The output array, element-wise Heaviside step function of `x1`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+.. versionadded:: 1.13.0
+
+References
+----------
+.. Wikipedia, \"Heaviside step function\",
+   https://en.wikipedia.org/wiki/Heaviside_step_function
+
+Examples
+--------
+>>> np.heaviside([-1.5, 0, 2.0], 0.5)
+array([ 0. ,  0.5,  1. ])
+>>> np.heaviside([-1.5, 0, 2.0], 1)
+array([ 0.,  1.,  1.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def busday_offset (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "busday_offset"))))
+(alter-meta! #'busday_offset assoc :doc "
+    busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)
+
+    First adjusts the date to fall on a valid day according to
+    the ``roll`` rule, then applies offsets to the given dates
+    counted in valid days.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    dates : array_like of datetime64[D]
+        The array of dates to process.
+    offsets : array_like of int
+        The array of offsets, which is broadcast with ``dates``.
+    roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'}, optional
+        How to treat dates that do not fall on a valid day. The default
+        is 'raise'.
+
+          * 'raise' means to raise an exception for an invalid day.
+          * 'nat' means to return a NaT (not-a-time) for an invalid day.
+          * 'forward' and 'following' mean to take the first valid day
+            later in time.
+          * 'backward' and 'preceding' mean to take the first valid day
+            earlier in time.
+          * 'modifiedfollowing' means to take the first valid day
+            later in time unless it is across a Month boundary, in which
+            case to take the first valid day earlier in time.
+          * 'modifiedpreceding' means to take the first valid day
+            earlier in time unless it is across a Month boundary, in which
+            case to take the first valid day later in time.
+    weekmask : str or array_like of bool, optional
+        A seven-element array indicating which of Monday through Sunday are
+        valid days. May be specified as a length-seven list or array, like
+        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
+        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
+        weekdays, optionally separated by white space. Valid abbreviations
+        are: Mon Tue Wed Thu Fri Sat Sun
+    holidays : array_like of datetime64[D], optional
+        An array of dates to consider as invalid dates.  They may be
+        specified in any order, and NaT (not-a-time) dates are ignored.
+        This list is saved in a normalized form that is suited for
+        fast calculations of valid days.
+    busdaycal : busdaycalendar, optional
+        A `busdaycalendar` object which specifies the valid days. If this
+        parameter is provided, neither weekmask nor holidays may be
+        provided.
+    out : array of datetime64[D], optional
+        If provided, this array is filled with the result.
+
+    Returns
+    -------
+    out : array of datetime64[D]
+        An array with a shape from broadcasting ``dates`` and ``offsets``
+        together, containing the dates with offsets applied.
+
+    See Also
+    --------
+    busdaycalendar: An object that specifies a custom set of valid days.
+    is_busday : Returns a boolean array indicating valid days.
+    busday_count : Counts how many valid days are in a half-open date range.
+
+    Examples
+    --------
+    >>> # First business day in October 2011 (not accounting for holidays)
+    ... np.busday_offset('2011-10', 0, roll='forward')
+    numpy.datetime64('2011-10-03')
+    >>> # Last business day in February 2012 (not accounting for holidays)
+    ... np.busday_offset('2012-03', -1, roll='forward')
+    numpy.datetime64('2012-02-29')
+    >>> # Third Wednesday in January 2011
+    ... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed')
+    numpy.datetime64('2011-01-19')
+    >>> # 2012 Mother's Day in Canada and the U.S.
+    ... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun')
+    numpy.datetime64('2012-05-13')
+
+    >>> # First business day on or after a date
+    ... np.busday_offset('2011-03-20', 0, roll='forward')
+    numpy.datetime64('2011-03-21')
+    >>> np.busday_offset('2011-03-22', 0, roll='forward')
+    numpy.datetime64('2011-03-22')
+    >>> # First business day after a date
+    ... np.busday_offset('2011-03-20', 1, roll='backward')
+    numpy.datetime64('2011-03-21')
+    >>> np.busday_offset('2011-03-22', 1, roll='backward')
+    numpy.datetime64('2011-03-23')
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def greater_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "greater_equal"))))
+(alter-meta! #'greater_equal assoc :doc "greater_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the truth value of (x1 >= x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : bool or ndarray of bool
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+greater, less, less_equal, equal, not_equal
+
+Examples
+--------
+>>> np.greater_equal([4, 2, 1], [2, 2, 2])
+array([ True, True, False])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} ERR_IGNORE (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_IGNORE"))))
+
+(def ulonglong (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ulonglong"))))
+(alter-meta! #'ulonglong assoc :doc "Signed integer type, compatible with C ``unsigned long long``.
+    Character code: ``'Q'``." :arglists '[[self & [args {:as kwargs}]]])
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} typeDict (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "typeDict")))) 
+
+(def split (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "split"))))
+(alter-meta! #'split assoc :doc "
+    Split an array into multiple sub-arrays as views into `ary`.
+
+    Parameters
+    ----------
+    ary : ndarray
+        Array to be divided into sub-arrays.
+    indices_or_sections : int or 1-D array
+        If `indices_or_sections` is an integer, N, the array will be divided
+        into N equal arrays along `axis`.  If such a split is not possible,
+        an error is raised.
+
+        If `indices_or_sections` is a 1-D array of sorted integers, the entries
+        indicate where along `axis` the array is split.  For example,
+        ``[2, 3]`` would, for ``axis=0``, result in
+
+          - ary[:2]
+          - ary[2:3]
+          - ary[3:]
+
+        If an index exceeds the dimension of the array along `axis`,
+        an empty sub-array is returned correspondingly.
+    axis : int, optional
+        The axis along which to split, default is 0.
+
+    Returns
+    -------
+    sub-arrays : list of ndarrays
+        A list of sub-arrays as views into `ary`.
+
+    Raises
+    ------
+    ValueError
+        If `indices_or_sections` is given as an integer, but
+        a split does not result in equal division.
+
+    See Also
+    --------
+    array_split : Split an array into multiple sub-arrays of equal or
+                  near-equal size.  Does not raise an exception if
+                  an equal division cannot be made.
+    hsplit : Split array into multiple sub-arrays horizontally (column-wise).
+    vsplit : Split array into multiple sub-arrays vertically (row wise).
+    dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
+    concatenate : Join a sequence of arrays along an existing axis.
+    stack : Join a sequence of arrays along a new axis.
+    hstack : Stack arrays in sequence horizontally (column wise).
+    vstack : Stack arrays in sequence vertically (row wise).
+    dstack : Stack arrays in sequence depth wise (along third dimension).
+
+    Examples
+    --------
+    >>> x = np.arange(9.0)
+    >>> np.split(x, 3)
+    [array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.,  8.])]
+
+    >>> x = np.arange(8.0)
+    >>> np.split(x, [3, 5, 6, 10])
+    [array([0.,  1.,  2.]),
+     array([3.,  4.]),
+     array([5.]),
+     array([6.,  7.]),
+     array([], dtype=float64)]
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def asfarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asfarray"))))
+(alter-meta! #'asfarray assoc :doc "
+    Return an array converted to a float type.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+    dtype : str or dtype object, optional
+        Float type code to coerce input array `a`.  If `dtype` is one of the
+        'int' dtypes, it is replaced with float64.
+
+    Returns
+    -------
+    out : ndarray
+        The input `a` as a float ndarray.
+
+    Examples
+    --------
+    >>> np.asfarray([2, 3])
+    array([2.,  3.])
+    >>> np.asfarray([2, 3], dtype='float')
+    array([2.,  3.])
+    >>> np.asfarray([2, 3], dtype='int8')
+    array([2.,  3.])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def recfromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "recfromtxt"))))
+(alter-meta! #'recfromtxt assoc :doc "
+    Load ASCII data from a file and return it in a record array.
+
+    If ``usemask=False`` a standard `recarray` is returned,
+    if ``usemask=True`` a MaskedRecords array is returned.
+
+    Parameters
+    ----------
+    fname, kwargs : For a description of input parameters, see `genfromtxt`.
+
+    See Also
+    --------
+    numpy.genfromtxt : generic function
+
+    Notes
+    -----
+    By default, `dtype` is None, which means that the data-type of the output
+    array will be determined from the data.
+
+    " :arglists '[[fname & [{:as kwargs}]]])
+
+(def empty_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "empty_like"))))
+(alter-meta! #'empty_like assoc :doc "
+    empty_like(prototype, dtype=None, order='K', subok=True, shape=None)
+
+    Return a new array with the same shape and type as a given array.
+
+    Parameters
+    ----------
+    prototype : array_like
+        The shape and data-type of `prototype` define these same attributes
+        of the returned array.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+
+        .. versionadded:: 1.6.0
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if ``prototype`` is Fortran
+        contiguous, 'C' otherwise. 'K' means match the layout of ``prototype``
+        as closely as possible.
+
+        .. versionadded:: 1.6.0
+    subok : bool, optional.
+        If True, then the newly created array will use the sub-class
+        type of 'a', otherwise it will be a base-class array. Defaults
+        to True.
+    shape : int or sequence of ints, optional.
+        Overrides the shape of the result. If order='K' and the number of
+        dimensions is unchanged, will try to keep order, otherwise,
+        order='C' is implied.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of uninitialized (arbitrary) data with the same
+        shape and type as `prototype`.
+
+    See Also
+    --------
+    ones_like : Return an array of ones with shape and type of input.
+    zeros_like : Return an array of zeros with shape and type of input.
+    full_like : Return a new array with shape of input filled with value.
+    empty : Return a new uninitialized array.
+
+    Notes
+    -----
+    This function does *not* initialize the returned array; to do that use
+    `zeros_like` or `ones_like` instead.  It may be marginally faster than
+    the functions that do set the array values.
+
+    Examples
+    --------
+    >>> a = ([1,2,3], [4,5,6])                         # a is array-like
+    >>> np.empty_like(a)
+    array([[-1073741821, -1073741821,           3],    # uninitialized
+           [          0,           0, -1073741821]])
+    >>> a = np.array([[1., 2., 3.],[4.,5.,6.]])
+    >>> np.empty_like(a)
+    array([[ -2.00000715e+000,   1.48219694e-323,  -2.00000572e+000], # uninitialized
+           [  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def log10 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log10"))))
+(alter-meta! #'log10 assoc :doc "log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the base 10 logarithm of the input array, element-wise.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The logarithm to the base 10 of `x`, element-wise. NaNs are
+    returned where x is negative.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+emath.log10
+
+Notes
+-----
+Logarithm is a multivalued function: for each `x` there is an infinite
+number of `z` such that `10**z = x`. The convention is to return the
+`z` whose imaginary part lies in `[-pi, pi]`.
+
+For real-valued input data types, `log10` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `log10` is a complex analytical function that
+has a branch cut `[-inf, 0]` and is continuous from above on it.
+`log10` handles the floating-point negative zero as an infinitesimal
+negative number, conforming to the C99 standard.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm
+
+Examples
+--------
+>>> np.log10([1e-15, -3.])
+array([-15.,  nan])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def mask_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mask_indices"))))
+(alter-meta! #'mask_indices assoc :doc "
+    Return the indices to access (n, n) arrays, given a masking function.
+
+    Assume `mask_func` is a function that, for a square array a of size
+    ``(n, n)`` with a possible offset argument `k`, when called as
+    ``mask_func(a, k)`` returns a new array with zeros in certain locations
+    (functions like `triu` or `tril` do precisely this). Then this function
+    returns the indices where the non-zero values would be located.
+
+    Parameters
+    ----------
+    n : int
+        The returned indices will be valid to access arrays of shape (n, n).
+    mask_func : callable
+        A function whose call signature is similar to that of `triu`, `tril`.
+        That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`.
+        `k` is an optional argument to the function.
+    k : scalar
+        An optional argument which is passed through to `mask_func`. Functions
+        like `triu`, `tril` take a second argument that is interpreted as an
+        offset.
+
+    Returns
+    -------
+    indices : tuple of arrays.
+        The `n` arrays of indices corresponding to the locations where
+        ``mask_func(np.ones((n, n)), k)`` is True.
+
+    See Also
+    --------
+    triu, tril, triu_indices, tril_indices
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    These are the indices that would allow you to access the upper triangular
+    part of any 3x3 array:
+
+    >>> iu = np.mask_indices(3, np.triu)
+
+    For example, if `a` is a 3x3 array:
+
+    >>> a = np.arange(9).reshape(3, 3)
+    >>> a
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+    >>> a[iu]
+    array([0, 1, 2, 4, 5, 8])
+
+    An offset can be passed also to the masking function.  This gets us the
+    indices starting on the first diagonal right of the main one:
+
+    >>> iu1 = np.mask_indices(3, np.triu, 1)
+
+    with which we now extract only three elements:
+
+    >>> a[iu1]
+    array([1, 2, 5])
+
+    " :arglists '[[n mask_func & [{k :k}]] [n mask_func]])
+
+(def str0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "str0"))))
+(alter-meta! #'str0 assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def number (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "number"))))
+(alter-meta! #'number assoc :doc "Abstract base class of all numeric scalar types." :arglists '[[self & [args {:as kwargs}]]])
+
+(def nanargmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanargmax"))))
+(alter-meta! #'nanargmax assoc :doc "
+    Return the indices of the maximum values in the specified axis ignoring
+    NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the
+    results cannot be trusted if a slice contains only NaNs and -Infs.
+
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : int, optional
+        Axis along which to operate.  By default flattened input is used.
+
+    Returns
+    -------
+    index_array : ndarray
+        An array of indices or a single index value.
+
+    See Also
+    --------
+    argmax, nanargmin
+
+    Examples
+    --------
+    >>> a = np.array([[np.nan, 4], [2, 3]])
+    >>> np.argmax(a)
+    0
+    >>> np.nanargmax(a)
+    1
+    >>> np.nanargmax(a, axis=0)
+    array([1, 0])
+    >>> np.nanargmax(a, axis=1)
+    array([1, 1])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def sinc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sinc"))))
+(alter-meta! #'sinc assoc :doc "
+    Return the sinc function.
+
+    The sinc function is :math:`\\sin(\\pi x)/(\\pi x)`.
+
+    Parameters
+    ----------
+    x : ndarray
+        Array (possibly multi-dimensional) of values for which to to
+        calculate ``sinc(x)``.
+
+    Returns
+    -------
+    out : ndarray
+        ``sinc(x)``, which has the same shape as the input.
+
+    Notes
+    -----
+    ``sinc(0)`` is the limit value 1.
+
+    The name sinc is short for \"sine cardinal\" or \"sinus cardinalis\".
+
+    The sinc function is used in various signal processing applications,
+    including in anti-aliasing, in the construction of a Lanczos resampling
+    filter, and in interpolation.
+
+    For bandlimited interpolation of discrete-time signals, the ideal
+    interpolation kernel is proportional to the sinc function.
+
+    References
+    ----------
+    .. [1] Weisstein, Eric W. \"Sinc Function.\" From MathWorld--A Wolfram Web
+           Resource. http://mathworld.wolfram.com/SincFunction.html
+    .. [2] Wikipedia, \"Sinc function\",
+           https://en.wikipedia.org/wiki/Sinc_function
+
+    Examples
+    --------
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.linspace(-4, 4, 41)
+    >>> np.sinc(x)
+     array([-3.89804309e-17,  -4.92362781e-02,  -8.40918587e-02, # may vary
+            -8.90384387e-02,  -5.84680802e-02,   3.89804309e-17,
+            6.68206631e-02,   1.16434881e-01,   1.26137788e-01,
+            8.50444803e-02,  -3.89804309e-17,  -1.03943254e-01,
+            -1.89206682e-01,  -2.16236208e-01,  -1.55914881e-01,
+            3.89804309e-17,   2.33872321e-01,   5.04551152e-01,
+            7.56826729e-01,   9.35489284e-01,   1.00000000e+00,
+            9.35489284e-01,   7.56826729e-01,   5.04551152e-01,
+            2.33872321e-01,   3.89804309e-17,  -1.55914881e-01,
+           -2.16236208e-01,  -1.89206682e-01,  -1.03943254e-01,
+           -3.89804309e-17,   8.50444803e-02,   1.26137788e-01,
+            1.16434881e-01,   6.68206631e-02,   3.89804309e-17,
+            -5.84680802e-02,  -8.90384387e-02,  -8.40918587e-02,
+            -4.92362781e-02,  -3.89804309e-17])
+
+    >>> plt.plot(x, np.sinc(x))
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Sinc Function\")
+    Text(0.5, 1.0, 'Sinc Function')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"X\")
+    Text(0.5, 0, 'X')
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def fmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fmax"))))
+(alter-meta! #'fmax assoc :doc "fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Element-wise maximum of array elements.
+
+Compare two arrays and returns a new array containing the element-wise
+maxima. If one of the elements being compared is a NaN, then the
+non-nan element is returned. If both elements are NaNs then the first
+is returned.  The latter distinction is important for complex NaNs,
+which are defined as at least one of the real or imaginary parts being
+a NaN. The net effect is that NaNs are ignored when possible.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays holding the elements to be compared. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The maximum of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+fmin :
+    Element-wise minimum of two arrays, ignores NaNs.
+maximum :
+    Element-wise maximum of two arrays, propagates NaNs.
+amax :
+    The maximum value of an array along a given axis, propagates NaNs.
+nanmax :
+    The maximum value of an array along a given axis, ignores NaNs.
+
+minimum, amin, nanmin
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither
+x1 nor x2 are NaNs, but it is faster and does proper broadcasting.
+
+Examples
+--------
+>>> np.fmax([2, 3, 4], [1, 5, 2])
+array([ 2.,  5.,  4.])
+
+>>> np.fmax(np.eye(2), [0.5, 2])
+array([[ 1. ,  2. ],
+       [ 0.5,  2. ]])
+
+>>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan])
+array([ 0.,  0., nan])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ravel (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ravel"))))
+(alter-meta! #'ravel assoc :doc "Return a contiguous flattened array.
+
+    A 1-D array, containing the elements of the input, is returned.  A copy is
+    made only if needed.
+
+    As of NumPy 1.10, the returned array will have the same type as the input
+    array. (for example, a masked array will be returned for a masked array
+    input)
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.  The elements in `a` are read in the order specified by
+        `order`, and packed as a 1-D array.
+    order : {'C','F', 'A', 'K'}, optional
+
+        The elements of `a` are read using this index order. 'C' means
+        to index the elements in row-major, C-style order,
+        with the last axis index changing fastest, back to the first
+        axis index changing slowest.  'F' means to index the elements
+        in column-major, Fortran-style order, with the
+        first index changing fastest, and the last index changing
+        slowest. Note that the 'C' and 'F' options take no account of
+        the memory layout of the underlying array, and only refer to
+        the order of axis indexing.  'A' means to read the elements in
+        Fortran-like index order if `a` is Fortran *contiguous* in
+        memory, C-like order otherwise.  'K' means to read the
+        elements in the order they occur in memory, except for
+        reversing the data when strides are negative.  By default, 'C'
+        index order is used.
+
+    Returns
+    -------
+    y : array_like
+        y is an array of the same subtype as `a`, with shape ``(a.size,)``.
+        Note that matrices are special cased for backward compatibility, if `a`
+        is a matrix, then y is a 1-D ndarray.
+
+    See Also
+    --------
+    ndarray.flat : 1-D iterator over an array.
+    ndarray.flatten : 1-D array copy of the elements of an array
+                      in row-major order.
+    ndarray.reshape : Change the shape of an array without changing its data.
+
+    Notes
+    -----
+    In row-major, C-style order, in two dimensions, the row index
+    varies the slowest, and the column index the quickest.  This can
+    be generalized to multiple dimensions, where row-major order
+    implies that the index along the first axis varies slowest, and
+    the index along the last quickest.  The opposite holds for
+    column-major, Fortran-style index ordering.
+
+    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
+    may be preferable.
+
+    Examples
+    --------
+    It is equivalent to ``reshape(-1, order=order)``.
+
+    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
+    >>> np.ravel(x)
+    array([1, 2, 3, 4, 5, 6])
+
+    >>> x.reshape(-1)
+    array([1, 2, 3, 4, 5, 6])
+
+    >>> np.ravel(x, order='F')
+    array([1, 4, 2, 5, 3, 6])
+
+    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
+
+    >>> np.ravel(x.T)
+    array([1, 4, 2, 5, 3, 6])
+    >>> np.ravel(x.T, order='A')
+    array([1, 2, 3, 4, 5, 6])
+
+    When ``order`` is 'K', it will preserve orderings that are neither 'C'
+    nor 'F', but won't reverse axes:
+
+    >>> a = np.arange(3)[::-1]; a
+    array([2, 1, 0])
+    >>> a.ravel(order='C')
+    array([2, 1, 0])
+    >>> a.ravel(order='K')
+    array([2, 1, 0])
+
+    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
+    array([[[ 0,  2,  4],
+            [ 1,  3,  5]],
+           [[ 6,  8, 10],
+            [ 7,  9, 11]]])
+    >>> a.ravel(order='C')
+    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
+    >>> a.ravel(order='K')
+    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def correlate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "correlate"))))
+(alter-meta! #'correlate assoc :doc "
+    Cross-correlation of two 1-dimensional sequences.
+
+    This function computes the correlation as generally defined in signal
+    processing texts::
+
+        c_{av}[k] = sum_n a[n+k] * conj(v[n])
+
+    with a and v sequences being zero-padded where necessary and conj being
+    the conjugate.
+
+    Parameters
+    ----------
+    a, v : array_like
+        Input sequences.
+    mode : {'valid', 'same', 'full'}, optional
+        Refer to the `convolve` docstring.  Note that the default
+        is 'valid', unlike `convolve`, which uses 'full'.
+    old_behavior : bool
+        `old_behavior` was removed in NumPy 1.10. If you need the old
+        behavior, use `multiarray.correlate`.
+
+    Returns
+    -------
+    out : ndarray
+        Discrete cross-correlation of `a` and `v`.
+
+    See Also
+    --------
+    convolve : Discrete, linear convolution of two one-dimensional sequences.
+    multiarray.correlate : Old, no conjugate, version of correlate.
+
+    Notes
+    -----
+    The definition of correlation above is not unique and sometimes correlation
+    may be defined differently. Another common definition is::
+
+        c'_{av}[k] = sum_n a[n] conj(v[n+k])
+
+    which is related to ``c_{av}[k]`` by ``c'_{av}[k] = c_{av}[-k]``.
+
+    Examples
+    --------
+    >>> np.correlate([1, 2, 3], [0, 1, 0.5])
+    array([3.5])
+    >>> np.correlate([1, 2, 3], [0, 1, 0.5], \"same\")
+    array([2. ,  3.5,  3. ])
+    >>> np.correlate([1, 2, 3], [0, 1, 0.5], \"full\")
+    array([0.5,  2. ,  3.5,  3. ,  0. ])
+
+    Using complex sequences:
+
+    >>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full')
+    array([ 0.5-0.5j,  1.0+0.j ,  1.5-1.5j,  3.0-1.j ,  0.0+0.j ])
+
+    Note that you get the time reversed, complex conjugated result
+    when the two input sequences change places, i.e.,
+    ``c_{va}[k] = c^{*}_{av}[-k]``:
+
+    >>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')
+    array([ 0.0+0.j ,  3.0+1.j ,  1.5+1.5j,  1.0+0.j ,  0.5+0.5j])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def nanmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmin"))))
+(alter-meta! #'nanmin assoc :doc "
+    Return minimum of an array or minimum along an axis, ignoring any NaNs.
+    When all-NaN slices are encountered a ``RuntimeWarning`` is raised and
+    Nan is returned for that slice.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose minimum is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the minimum is computed. The default is to compute
+        the minimum of the flattened array.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary. See
+        `ufuncs-output-type` for more details.
+
+        .. versionadded:: 1.8.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `min` method
+        of sub-classes of `ndarray`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+        .. versionadded:: 1.8.0
+
+    Returns
+    -------
+    nanmin : ndarray
+        An array with the same shape as `a`, with the specified axis
+        removed.  If `a` is a 0-d array, or if axis is None, an ndarray
+        scalar is returned.  The same dtype as `a` is returned.
+
+    See Also
+    --------
+    nanmax :
+        The maximum value of an array along a given axis, ignoring any NaNs.
+    amin :
+        The minimum value of an array along a given axis, propagating any NaNs.
+    fmin :
+        Element-wise minimum of two arrays, ignoring any NaNs.
+    minimum :
+        Element-wise minimum of two arrays, propagating any NaNs.
+    isnan :
+        Shows which elements are Not a Number (NaN).
+    isfinite:
+        Shows which elements are neither NaN nor infinity.
+
+    amax, fmax, maximum
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+    Positive infinity is treated as a very large number and negative
+    infinity is treated as a very small (i.e. negative) number.
+
+    If the input has a integer type the function is equivalent to np.min.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nanmin(a)
+    1.0
+    >>> np.nanmin(a, axis=0)
+    array([1.,  2.])
+    >>> np.nanmin(a, axis=1)
+    array([1.,  3.])
+
+    When positive infinity and negative infinity are present:
+
+    >>> np.nanmin([1, 2, np.nan, np.inf])
+    1.0
+    >>> np.nanmin([1, 2, np.nan, np.NINF])
+    -inf
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def polyadd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyadd"))))
+(alter-meta! #'polyadd assoc :doc "
+    Find the sum of two polynomials.
+
+    Returns the polynomial resulting from the sum of two input polynomials.
+    Each input must be either a poly1d object or a 1D sequence of polynomial
+    coefficients, from highest to lowest degree.
+
+    Parameters
+    ----------
+    a1, a2 : array_like or poly1d object
+        Input polynomials.
+
+    Returns
+    -------
+    out : ndarray or poly1d object
+        The sum of the inputs. If either input is a poly1d object, then the
+        output is also a poly1d object. Otherwise, it is a 1D array of
+        polynomial coefficients from highest to lowest degree.
+
+    See Also
+    --------
+    poly1d : A one-dimensional polynomial class.
+    poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
+
+    Examples
+    --------
+    >>> np.polyadd([1, 2], [9, 5, 4])
+    array([9, 6, 6])
+
+    Using poly1d objects:
+
+    >>> p1 = np.poly1d([1, 2])
+    >>> p2 = np.poly1d([9, 5, 4])
+    >>> print(p1)
+    1 x + 2
+    >>> print(p2)
+       2
+    9 x + 5 x + 4
+    >>> print(np.polyadd(p1, p2))
+       2
+    9 x + 6 x + 6
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "The specification for a module, used for loading.
+
+    A module's spec is the source for information about the module.  For
+    data associated with the module, including source, use the spec's
+    loader.
+
+    `name` is the absolute name of the module.  `loader` is the loader
+    to use when loading the module.  `parent` is the name of the
+    package the module is in.  The parent is derived from the name.
+
+    `is_package` determines if the module is considered a package or
+    not.  On modules this is reflected by the `__path__` attribute.
+
+    `origin` is the specific location used by the loader from which to
+    load the module, if that information is available.  When filename is
+    set, origin will match.
+
+    `has_location` indicates that a spec's \"origin\" reflects a location.
+    When this is True, `__file__` attribute of the module is set.
+
+    `cached` is the location of the cached bytecode file, if any.  It
+    corresponds to the `__cached__` attribute.
+
+    `submodule_search_locations` is the sequence of path entries to
+    search when importing submodules.  If set, is_package should be
+    True--and False otherwise.
+
+    Packages are simply modules that (may) have submodules.  If a spec
+    has a non-None value in `submodule_search_locations`, the import
+    system will consider modules loaded from the spec as packages.
+
+    Only finders (see importlib.abc.MetaPathFinder and
+    importlib.abc.PathEntryFinder) should modify ModuleSpec instances.
+
+    "} __spec__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__spec__"))))
+
+(def ^{:doc ""} print_function (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "print_function"))))
+
+(def arcsinh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arcsinh"))))
+(alter-meta! #'arcsinh assoc :doc "arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Inverse hyperbolic sine element-wise.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Array of the same shape as `x`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+`arcsinh` is a multivalued function: for each `x` there are infinitely
+many numbers `z` such that `sinh(z) = x`. The convention is to return the
+`z` whose imaginary part lies in `[-pi/2, pi/2]`.
+
+For real-valued input data types, `arcsinh` always returns real output.
+For each value that cannot be expressed as a real number or infinity, it
+returns ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arccos` is a complex analytical function that
+has branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from
+the right on the former and from the left on the latter.
+
+The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Inverse hyperbolic function\",
+       https://en.wikipedia.org/wiki/Arcsinh
+
+Examples
+--------
+>>> np.arcsinh(np.array([np.e, 10.0]))
+array([ 1.72538256,  2.99822295])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc "
+    A nicer way to build up index tuples for arrays.
+
+    .. note::
+       Use one of the two predefined instances `index_exp` or `s_`
+       rather than directly using `IndexExpression`.
+
+    For any index combination, including slicing and axis insertion,
+    ``a[indices]`` is the same as ``a[np.index_exp[indices]]`` for any
+    array `a`. However, ``np.index_exp[indices]`` can be used anywhere
+    in Python code and returns a tuple of slice objects that can be
+    used in the construction of complex index expressions.
+
+    Parameters
+    ----------
+    maketuple : bool
+        If True, always returns a tuple.
+
+    See Also
+    --------
+    index_exp : Predefined instance that always returns a tuple:
+       `index_exp = IndexExpression(maketuple=True)`.
+    s_ : Predefined instance without tuple conversion:
+       `s_ = IndexExpression(maketuple=False)`.
+
+    Notes
+    -----
+    You can do all this with `slice()` plus a few special objects,
+    but there's a lot to remember and this version is simpler because
+    it uses the standard array indexing syntax.
+
+    Examples
+    --------
+    >>> np.s_[2::2]
+    slice(2, None, 2)
+    >>> np.index_exp[2::2]
+    (slice(2, None, 2),)
+
+    >>> np.array([0, 1, 2, 3, 4])[np.s_[2::2]]
+    array([2, 4])
+
+    "} index_exp (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "index_exp"))))
+
+(def ComplexWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ComplexWarning"))))
+(alter-meta! #'ComplexWarning assoc :doc "
+    The warning raised when casting a complex dtype to a real dtype.
+
+    As implemented, casting a complex number to a real discards its imaginary
+    part, but this behavior may not be what the user actually wants.
+
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def issctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issctype"))))
+(alter-meta! #'issctype assoc :doc "
+    Determines whether the given object represents a scalar data-type.
+
+    Parameters
+    ----------
+    rep : any
+        If `rep` is an instance of a scalar dtype, True is returned. If not,
+        False is returned.
+
+    Returns
+    -------
+    out : bool
+        Boolean result of check whether `rep` is a scalar dtype.
+
+    See Also
+    --------
+    issubsctype, issubdtype, obj2sctype, sctype2char
+
+    Examples
+    --------
+    >>> np.issctype(np.int32)
+    True
+    >>> np.issctype(list)
+    False
+    >>> np.issctype(1.1)
+    False
+
+    Strings are also a scalar type:
+
+    >>> np.issctype(np.dtype('str'))
+    True
+
+    " :arglists '[[rep]])
+
+(def sqrt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sqrt"))))
+(alter-meta! #'sqrt assoc :doc "sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the non-negative square-root of an array, element-wise.
+
+Parameters
+----------
+x : array_like
+    The values whose square-roots are required.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    An array of the same shape as `x`, containing the positive
+    square-root of each element in `x`.  If any element in `x` is
+    complex, a complex array is returned (and the square-roots of
+    negative reals are calculated).  If all of the elements in `x`
+    are real, so is `y`, with negative elements returning ``nan``.
+    If `out` was provided, `y` is a reference to it.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+lib.scimath.sqrt
+    A version which returns complex numbers when given negative reals.
+
+Notes
+-----
+*sqrt* has--consistent with common convention--as its branch cut the
+real \"interval\" [`-inf`, 0), and is continuous from above on it.
+A branch cut is a curve in the complex plane across which a given
+complex function fails to be continuous.
+
+Examples
+--------
+>>> np.sqrt([1,4,9])
+array([ 1.,  2.,  3.])
+
+>>> np.sqrt([4, -1, -3+4J])
+array([ 2.+0.j,  0.+1.j,  1.+2.j])
+
+>>> np.sqrt([4, -1, np.inf])
+array([ 2., nan, inf])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def polymul (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polymul"))))
+(alter-meta! #'polymul assoc :doc "
+    Find the product of two polynomials.
+
+    Finds the polynomial resulting from the multiplication of the two input
+    polynomials. Each input must be either a poly1d object or a 1D sequence
+    of polynomial coefficients, from highest to lowest degree.
+
+    Parameters
+    ----------
+    a1, a2 : array_like or poly1d object
+        Input polynomials.
+
+    Returns
+    -------
+    out : ndarray or poly1d object
+        The polynomial resulting from the multiplication of the inputs. If
+        either inputs is a poly1d object, then the output is also a poly1d
+        object. Otherwise, it is a 1D array of polynomial coefficients from
+        highest to lowest degree.
+
+    See Also
+    --------
+    poly1d : A one-dimensional polynomial class.
+    poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
+    convolve : Array convolution. Same output as polymul, but has parameter
+               for overlap mode.
+
+    Examples
+    --------
+    >>> np.polymul([1, 2, 3], [9, 5, 1])
+    array([ 9, 23, 38, 17,  3])
+
+    Using poly1d objects:
+
+    >>> p1 = np.poly1d([1, 2, 3])
+    >>> p2 = np.poly1d([9, 5, 1])
+    >>> print(p1)
+       2
+    1 x + 2 x + 3
+    >>> print(p2)
+       2
+    9 x + 5 x + 1
+    >>> print(np.polymul(p1, p2))
+       4      3      2
+    9 x + 23 x + 38 x + 17 x + 3
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def empty (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "empty"))))
+(alter-meta! #'empty assoc :doc "empty(shape, dtype=float, order='C')
+
+    Return a new array of given shape and type, without initializing entries.
+
+    Parameters
+    ----------
+    shape : int or tuple of int
+        Shape of the empty array, e.g., ``(2, 3)`` or ``2``.
+    dtype : data-type, optional
+        Desired output data-type for the array, e.g, `numpy.int8`. Default is
+        `numpy.float64`.
+    order : {'C', 'F'}, optional, default: 'C'
+        Whether to store multi-dimensional data in row-major
+        (C-style) or column-major (Fortran-style) order in
+        memory.
+
+    Returns
+    -------
+    out : ndarray
+        Array of uninitialized (arbitrary) data of the given shape, dtype, and
+        order.  Object arrays will be initialized to None.
+
+    See Also
+    --------
+    empty_like : Return an empty array with shape and type of input.
+    ones : Return a new array setting values to one.
+    zeros : Return a new array setting values to zero.
+    full : Return a new array of given shape filled with value.
+
+
+    Notes
+    -----
+    `empty`, unlike `zeros`, does not set the array values to zero,
+    and may therefore be marginally faster.  On the other hand, it requires
+    the user to manually set all the values in the array, and should be
+    used with caution.
+
+    Examples
+    --------
+    >>> np.empty([2, 2])
+    array([[ -9.74499359e+001,   6.69583040e-309],
+           [  2.13182611e-314,   3.06959433e-309]])         #uninitialized
+
+    >>> np.empty([2, 2], dtype=int)
+    array([[-1073741821, -1067949133],
+           [  496041986,    19249760]])                     #uninitialized" :arglists '[[self & [args {:as kwargs}]]])
+
+(def object0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "object0"))))
+(alter-meta! #'object0 assoc :doc "Any Python object.
+    Character code: ``'O'``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ndim (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndim"))))
+(alter-meta! #'ndim assoc :doc "
+    Return the number of dimensions of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.  If it is not already an ndarray, a conversion is
+        attempted.
+
+    Returns
+    -------
+    number_of_dimensions : int
+        The number of dimensions in `a`.  Scalars are zero-dimensional.
+
+    See Also
+    --------
+    ndarray.ndim : equivalent method
+    shape : dimensions of array
+    ndarray.shape : dimensions of array
+
+    Examples
+    --------
+    >>> np.ndim([[1,2,3],[4,5,6]])
+    2
+    >>> np.ndim(np.array([[1,2,3],[4,5,6]]))
+    2
+    >>> np.ndim(1)
+    0
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def polyfit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyfit"))))
+(alter-meta! #'polyfit assoc :doc "
+    Least squares polynomial fit.
+
+    Fit a polynomial ``p(x) = p[0] * x**deg + ... + p[deg]`` of degree `deg`
+    to points `(x, y)`. Returns a vector of coefficients `p` that minimises
+    the squared error in the order `deg`, `deg-1`, ... `0`.
+
+    The `Polynomial.fit <numpy.polynomial.polynomial.Polynomial.fit>` class
+    method is recommended for new code as it is more stable numerically. See
+    the documentation of the method for more information.
+
+    Parameters
+    ----------
+    x : array_like, shape (M,)
+        x-coordinates of the M sample points ``(x[i], y[i])``.
+    y : array_like, shape (M,) or (M, K)
+        y-coordinates of the sample points. Several data sets of sample
+        points sharing the same x-coordinates can be fitted at once by
+        passing in a 2D-array that contains one dataset per column.
+    deg : int
+        Degree of the fitting polynomial
+    rcond : float, optional
+        Relative condition number of the fit. Singular values smaller than
+        this relative to the largest singular value will be ignored. The
+        default value is len(x)*eps, where eps is the relative precision of
+        the float type, about 2e-16 in most cases.
+    full : bool, optional
+        Switch determining nature of return value. When it is False (the
+        default) just the coefficients are returned, when True diagnostic
+        information from the singular value decomposition is also returned.
+    w : array_like, shape (M,), optional
+        Weights to apply to the y-coordinates of the sample points. For
+        gaussian uncertainties, use 1/sigma (not 1/sigma**2).
+    cov : bool or str, optional
+        If given and not `False`, return not just the estimate but also its
+        covariance matrix. By default, the covariance are scaled by
+        chi2/sqrt(N-dof), i.e., the weights are presumed to be unreliable
+        except in a relative sense and everything is scaled such that the
+        reduced chi2 is unity. This scaling is omitted if ``cov='unscaled'``,
+        as is relevant for the case that the weights are 1/sigma**2, with
+        sigma known to be a reliable estimate of the uncertainty.
+
+    Returns
+    -------
+    p : ndarray, shape (deg + 1,) or (deg + 1, K)
+        Polynomial coefficients, highest power first.  If `y` was 2-D, the
+        coefficients for `k`-th data set are in ``p[:,k]``.
+
+    residuals, rank, singular_values, rcond
+        Present only if `full` = True.  Residuals is sum of squared residuals
+        of the least-squares fit, the effective rank of the scaled Vandermonde
+        coefficient matrix, its singular values, and the specified value of
+        `rcond`. For more details, see `linalg.lstsq`.
+
+    V : ndarray, shape (M,M) or (M,M,K)
+        Present only if `full` = False and `cov`=True.  The covariance
+        matrix of the polynomial coefficient estimates.  The diagonal of
+        this matrix are the variance estimates for each coefficient.  If y
+        is a 2-D array, then the covariance matrix for the `k`-th data set
+        are in ``V[:,:,k]``
+
+
+    Warns
+    -----
+    RankWarning
+        The rank of the coefficient matrix in the least-squares fit is
+        deficient. The warning is only raised if `full` = False.
+
+        The warnings can be turned off by
+
+        >>> import warnings
+        >>> warnings.simplefilter('ignore', np.RankWarning)
+
+    See Also
+    --------
+    polyval : Compute polynomial values.
+    linalg.lstsq : Computes a least-squares fit.
+    scipy.interpolate.UnivariateSpline : Computes spline fits.
+
+    Notes
+    -----
+    The solution minimizes the squared error
+
+    .. math ::
+        E = \\sum_{j=0}^k |p(x_j) - y_j|^2
+
+    in the equations::
+
+        x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]
+        x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]
+        ...
+        x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]
+
+    The coefficient matrix of the coefficients `p` is a Vandermonde matrix.
+
+    `polyfit` issues a `RankWarning` when the least-squares fit is badly
+    conditioned. This implies that the best fit is not well-defined due
+    to numerical error. The results may be improved by lowering the polynomial
+    degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter
+    can also be set to a value smaller than its default, but the resulting
+    fit may be spurious: including contributions from the small singular
+    values can add numerical noise to the result.
+
+    Note that fitting polynomial coefficients is inherently badly conditioned
+    when the degree of the polynomial is large or the interval of sample points
+    is badly centered. The quality of the fit should always be checked in these
+    cases. When polynomial fits are not satisfactory, splines may be a good
+    alternative.
+
+    References
+    ----------
+    .. [1] Wikipedia, \"Curve fitting\",
+           https://en.wikipedia.org/wiki/Curve_fitting
+    .. [2] Wikipedia, \"Polynomial interpolation\",
+           https://en.wikipedia.org/wiki/Polynomial_interpolation
+
+    Examples
+    --------
+    >>> import warnings
+    >>> x = np.array([0.0, 1.0, 2.0, 3.0,  4.0,  5.0])
+    >>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])
+    >>> z = np.polyfit(x, y, 3)
+    >>> z
+    array([ 0.08703704, -0.81349206,  1.69312169, -0.03968254]) # may vary
+
+    It is convenient to use `poly1d` objects for dealing with polynomials:
+
+    >>> p = np.poly1d(z)
+    >>> p(0.5)
+    0.6143849206349179 # may vary
+    >>> p(3.5)
+    -0.34732142857143039 # may vary
+    >>> p(10)
+    22.579365079365115 # may vary
+
+    High-order polynomials may oscillate wildly:
+
+    >>> with warnings.catch_warnings():
+    ...     warnings.simplefilter('ignore', np.RankWarning)
+    ...     p30 = np.poly1d(np.polyfit(x, y, 30))
+    ...
+    >>> p30(4)
+    -0.80000000000000204 # may vary
+    >>> p30(5)
+    -0.99999999999999445 # may vary
+    >>> p30(4.5)
+    -0.10547061179440398 # may vary
+
+    Illustration:
+
+    >>> import matplotlib.pyplot as plt
+    >>> xp = np.linspace(-2, 6, 100)
+    >>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')
+    >>> plt.ylim(-2,2)
+    (-2, 2)
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def string_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "string_"))))
+(alter-meta! #'string_ assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def choose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "choose"))))
+(alter-meta! #'choose assoc :doc "
+    Construct an array from an index array and a set of arrays to choose from.
+
+    First of all, if confused or uncertain, definitely look at the Examples -
+    in its full generality, this function is less simple than it might
+    seem from the following code description (below ndi =
+    `numpy.lib.index_tricks`):
+
+    ``np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])``.
+
+    But this omits some subtleties.  Here is a fully general summary:
+
+    Given an \"index\" array (`a`) of integers and a sequence of `n` arrays
+    (`choices`), `a` and each choice array are first broadcast, as necessary,
+    to arrays of a common shape; calling these *Ba* and *Bchoices[i], i =
+    0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape``
+    for each `i`.  Then, a new array with shape ``Ba.shape`` is created as
+    follows:
+
+    * if ``mode=raise`` (the default), then, first of all, each element of
+      `a` (and thus `Ba`) must be in the range `[0, n-1]`; now, suppose that
+      `i` (in that range) is the value at the `(j0, j1, ..., jm)` position
+      in `Ba` - then the value at the same position in the new array is the
+      value in `Bchoices[i]` at that same position;
+
+    * if ``mode=wrap``, values in `a` (and thus `Ba`) may be any (signed)
+      integer; modular arithmetic is used to map integers outside the range
+      `[0, n-1]` back into that range; and then the new array is constructed
+      as above;
+
+    * if ``mode=clip``, values in `a` (and thus `Ba`) may be any (signed)
+      integer; negative integers are mapped to 0; values greater than `n-1`
+      are mapped to `n-1`; and then the new array is constructed as above.
+
+    Parameters
+    ----------
+    a : int array
+        This array must contain integers in `[0, n-1]`, where `n` is the number
+        of choices, unless ``mode=wrap`` or ``mode=clip``, in which cases any
+        integers are permissible.
+    choices : sequence of arrays
+        Choice arrays. `a` and all of the choices must be broadcastable to the
+        same shape.  If `choices` is itself an array (not recommended), then
+        its outermost dimension (i.e., the one corresponding to
+        ``choices.shape[0]``) is taken as defining the \"sequence\".
+    out : array, optional
+        If provided, the result will be inserted into this array. It should
+        be of the appropriate shape and dtype. Note that `out` is always
+        buffered if `mode='raise'`; use other modes for better performance.
+    mode : {'raise' (default), 'wrap', 'clip'}, optional
+        Specifies how indices outside `[0, n-1]` will be treated:
+
+          * 'raise' : an exception is raised
+          * 'wrap' : value becomes value mod `n`
+          * 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1
+
+    Returns
+    -------
+    merged_array : array
+        The merged result.
+
+    Raises
+    ------
+    ValueError: shape mismatch
+        If `a` and each choice array are not all broadcastable to the same
+        shape.
+
+    See Also
+    --------
+    ndarray.choose : equivalent method
+    numpy.take_along_axis : Preferable if `choices` is an array
+
+    Notes
+    -----
+    To reduce the chance of misinterpretation, even though the following
+    \"abuse\" is nominally supported, `choices` should neither be, nor be
+    thought of as, a single array, i.e., the outermost sequence-like container
+    should be either a list or a tuple.
+
+    Examples
+    --------
+
+    >>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],
+    ...   [20, 21, 22, 23], [30, 31, 32, 33]]
+    >>> np.choose([2, 3, 1, 0], choices
+    ... # the first element of the result will be the first element of the
+    ... # third (2+1) \"array\" in choices, namely, 20; the second element
+    ... # will be the second element of the fourth (3+1) choice array, i.e.,
+    ... # 31, etc.
+    ... )
+    array([20, 31, 12,  3])
+    >>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)
+    array([20, 31, 12,  3])
+    >>> # because there are 4 choice arrays
+    >>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)
+    array([20,  1, 12,  3])
+    >>> # i.e., 0
+
+    A couple examples illustrating how choose broadcasts:
+
+    >>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
+    >>> choices = [-10, 10]
+    >>> np.choose(a, choices)
+    array([[ 10, -10,  10],
+           [-10,  10, -10],
+           [ 10, -10,  10]])
+
+    >>> # With thanks to Anne Archibald
+    >>> a = np.array([0, 1]).reshape((2,1,1))
+    >>> c1 = np.array([1, 2, 3]).reshape((1,3,1))
+    >>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5))
+    >>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2
+    array([[[ 1,  1,  1,  1,  1],
+            [ 2,  2,  2,  2,  2],
+            [ 3,  3,  3,  3,  3]],
+           [[-1, -2, -3, -4, -5],
+            [-1, -2, -3, -4, -5],
+            [-1, -2, -3, -4, -5]]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def irr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "irr"))))
+(alter-meta! #'irr assoc :doc "
+    Return the Internal Rate of Return (IRR).
+
+    .. deprecated:: 1.18
+
+       `irr` is deprecated; for details, see NEP 32 [1]_.
+       Use the corresponding function in the numpy-financial library,
+       https://pypi.org/project/numpy-financial.
+
+    This is the \"average\" periodically compounded rate of return
+    that gives a net present value of 0.0; for a more complete explanation,
+    see Notes below.
+
+    :class:`decimal.Decimal` type is not supported.
+
+    Parameters
+    ----------
+    values : array_like, shape(N,)
+        Input cash flows per time period.  By convention, net \"deposits\"
+        are negative and net \"withdrawals\" are positive.  Thus, for
+        example, at least the first element of `values`, which represents
+        the initial investment, will typically be negative.
+
+    Returns
+    -------
+    out : float
+        Internal Rate of Return for periodic input values.
+
+    Notes
+    -----
+    The IRR is perhaps best understood through an example (illustrated
+    using np.irr in the Examples section below).  Suppose one invests 100
+    units and then makes the following withdrawals at regular (fixed)
+    intervals: 39, 59, 55, 20.  Assuming the ending value is 0, one's 100
+    unit investment yields 173 units; however, due to the combination of
+    compounding and the periodic withdrawals, the \"average\" rate of return
+    is neither simply 0.73/4 nor (1.73)^0.25-1.  Rather, it is the solution
+    (for :math:`r`) of the equation:
+
+    .. math:: -100 + \\frac{39}{1+r} + \\frac{59}{(1+r)^2}
+     + \\frac{55}{(1+r)^3} + \\frac{20}{(1+r)^4} = 0
+
+    In general, for `values` :math:`= [v_0, v_1, ... v_M]`,
+    irr is the solution of the equation: [2]_
+
+    .. math:: \\sum_{t=0}^M{\\frac{v_t}{(1+irr)^{t}}} = 0
+
+    References
+    ----------
+    .. [1] NumPy Enhancement Proposal (NEP) 32,
+       https://numpy.org/neps/nep-0032-remove-financial-functions.html
+    .. [2] L. J. Gitman, \"Principles of Managerial Finance, Brief,\" 3rd ed.,
+       Addison-Wesley, 2003, pg. 348.
+
+    Examples
+    --------
+    >>> round(np.irr([-100, 39, 59, 55, 20]), 5)
+    0.28095
+    >>> round(np.irr([-100, 0, 0, 74]), 5)
+    -0.0955
+    >>> round(np.irr([-100, 100, 0, -7]), 5)
+    -0.0833
+    >>> round(np.irr([-100, 100, 0, 7]), 5)
+    0.06206
+    >>> round(np.irr([-5, 10.5, 1, -8, 1]), 5)
+    0.0886
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def logspace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logspace"))))
+(alter-meta! #'logspace assoc :doc "
+    Return numbers spaced evenly on a log scale.
+
+    In linear space, the sequence starts at ``base ** start``
+    (`base` to the power of `start`) and ends with ``base ** stop``
+    (see `endpoint` below).
+
+    .. versionchanged:: 1.16.0
+        Non-scalar `start` and `stop` are now supported.
+
+    Parameters
+    ----------
+    start : array_like
+        ``base ** start`` is the starting value of the sequence.
+    stop : array_like
+        ``base ** stop`` is the final value of the sequence, unless `endpoint`
+        is False.  In that case, ``num + 1`` values are spaced over the
+        interval in log-space, of which all but the last (a sequence of
+        length `num`) are returned.
+    num : integer, optional
+        Number of samples to generate.  Default is 50.
+    endpoint : boolean, optional
+        If true, `stop` is the last sample. Otherwise, it is not included.
+        Default is True.
+    base : float, optional
+        The base of the log space. The step size between the elements in
+        ``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform.
+        Default is 10.0.
+    dtype : dtype
+        The type of the output array.  If `dtype` is not given, infer the data
+        type from the other input arguments.
+    axis : int, optional
+        The axis in the result to store the samples.  Relevant only if start
+        or stop are array-like.  By default (0), the samples will be along a
+        new axis inserted at the beginning. Use -1 to get an axis at the end.
+
+        .. versionadded:: 1.16.0
+
+
+    Returns
+    -------
+    samples : ndarray
+        `num` samples, equally spaced on a log scale.
+
+    See Also
+    --------
+    arange : Similar to linspace, with the step size specified instead of the
+             number of samples. Note that, when used with a float endpoint, the
+             endpoint may or may not be included.
+    linspace : Similar to logspace, but with the samples uniformly distributed
+               in linear space, instead of log space.
+    geomspace : Similar to logspace, but with endpoints specified directly.
+
+    Notes
+    -----
+    Logspace is equivalent to the code
+
+    >>> y = np.linspace(start, stop, num=num, endpoint=endpoint)
+    ... # doctest: +SKIP
+    >>> power(base, y).astype(dtype)
+    ... # doctest: +SKIP
+
+    Examples
+    --------
+    >>> np.logspace(2.0, 3.0, num=4)
+    array([ 100.        ,  215.443469  ,  464.15888336, 1000.        ])
+    >>> np.logspace(2.0, 3.0, num=4, endpoint=False)
+    array([100.        ,  177.827941  ,  316.22776602,  562.34132519])
+    >>> np.logspace(2.0, 3.0, num=4, base=2.0)
+    array([4.        ,  5.0396842 ,  6.34960421,  8.        ])
+
+    Graphical illustration:
+
+    >>> import matplotlib.pyplot as plt
+    >>> N = 10
+    >>> x1 = np.logspace(0.1, 1, N, endpoint=True)
+    >>> x2 = np.logspace(0.1, 1, N, endpoint=False)
+    >>> y = np.zeros(N)
+    >>> plt.plot(x1, y, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.plot(x2, y + 0.5, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.ylim([-0.5, 1])
+    (-0.5, 1)
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def logical_not (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_not"))))
+(alter-meta! #'logical_not assoc :doc "logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the truth value of NOT x element-wise.
+
+Parameters
+----------
+x : array_like
+    Logical NOT is applied to the elements of `x`.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : bool or ndarray of bool
+    Boolean result with the same shape as `x` of the NOT operation
+    on elements of `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+logical_and, logical_or, logical_xor
+
+Examples
+--------
+>>> np.logical_not(3)
+False
+>>> np.logical_not([True, False, 0, 1])
+array([False,  True,  True, False])
+
+>>> x = np.arange(5)
+>>> np.logical_not(x<3)
+array([False, False, False,  True,  True])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def loads (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "loads"))))
+(alter-meta! #'loads assoc :doc "" :arglists '[[& [args {:as kwargs}]]])
+
+(def bincount (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bincount"))))
+(alter-meta! #'bincount assoc :doc "
+    bincount(x, weights=None, minlength=0)
+
+    Count number of occurrences of each value in array of non-negative ints.
+
+    The number of bins (of size 1) is one larger than the largest value in
+    `x`. If `minlength` is specified, there will be at least this number
+    of bins in the output array (though it will be longer if necessary,
+    depending on the contents of `x`).
+    Each bin gives the number of occurrences of its index value in `x`.
+    If `weights` is specified the input array is weighted by it, i.e. if a
+    value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead
+    of ``out[n] += 1``.
+
+    Parameters
+    ----------
+    x : array_like, 1 dimension, nonnegative ints
+        Input array.
+    weights : array_like, optional
+        Weights, array of the same shape as `x`.
+    minlength : int, optional
+        A minimum number of bins for the output array.
+
+        .. versionadded:: 1.6.0
+
+    Returns
+    -------
+    out : ndarray of ints
+        The result of binning the input array.
+        The length of `out` is equal to ``np.amax(x)+1``.
+
+    Raises
+    ------
+    ValueError
+        If the input is not 1-dimensional, or contains elements with negative
+        values, or if `minlength` is negative.
+    TypeError
+        If the type of the input is float or complex.
+
+    See Also
+    --------
+    histogram, digitize, unique
+
+    Examples
+    --------
+    >>> np.bincount(np.arange(5))
+    array([1, 1, 1, 1, 1])
+    >>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7]))
+    array([1, 3, 1, 1, 0, 0, 0, 1])
+
+    >>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23])
+    >>> np.bincount(x).size == np.amax(x)+1
+    True
+
+    The input array needs to be of integer dtype, otherwise a
+    TypeError is raised:
+
+    >>> np.bincount(np.arange(5, dtype=float))
+    Traceback (most recent call last):
+      File \"<stdin>\", line 1, in <module>
+    TypeError: array cannot be safely cast to required type
+
+    A possible use of ``bincount`` is to perform sums over
+    variable-size chunks of an array, using the ``weights`` keyword.
+
+    >>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights
+    >>> x = np.array([0, 1, 1, 2, 2, 2])
+    >>> np.bincount(x,  weights=w)
+    array([ 0.3,  0.7,  1.1])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def format_float_scientific (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "format_float_scientific"))))
+(alter-meta! #'format_float_scientific assoc :doc "
+    Format a floating-point scalar as a decimal string in scientific notation.
+
+    Provides control over rounding, trimming and padding. Uses and assumes
+    IEEE unbiased rounding. Uses the \"Dragon4\" algorithm.
+
+    Parameters
+    ----------
+    x : python float or numpy floating scalar
+        Value to format.
+    precision : non-negative integer or None, optional
+        Maximum number of digits to print. May be None if `unique` is
+        `True`, but must be an integer if unique is `False`.
+    unique : boolean, optional
+        If `True`, use a digit-generation strategy which gives the shortest
+        representation which uniquely identifies the floating-point number from
+        other values of the same type, by judicious rounding. If `precision`
+        was omitted, print all necessary digits, otherwise digit generation is
+        cut off after `precision` digits and the remaining value is rounded.
+        If `False`, digits are generated as if printing an infinite-precision
+        value and stopping after `precision` digits, rounding the remaining
+        value.
+    trim : one of 'k', '.', '0', '-', optional
+        Controls post-processing trimming of trailing digits, as follows:
+
+        * 'k' : keep trailing zeros, keep decimal point (no trimming)
+        * '.' : trim all trailing zeros, leave decimal point
+        * '0' : trim all but the zero before the decimal point. Insert the
+          zero if it is missing.
+        * '-' : trim trailing zeros and any trailing decimal point
+    sign : boolean, optional
+        Whether to show the sign for positive values.
+    pad_left : non-negative integer, optional
+        Pad the left side of the string with whitespace until at least that
+        many characters are to the left of the decimal point.
+    exp_digits : non-negative integer, optional
+        Pad the exponent with zeros until it contains at least this many digits.
+        If omitted, the exponent will be at least 2 digits.
+
+    Returns
+    -------
+    rep : string
+        The string representation of the floating point value
+
+    See Also
+    --------
+    format_float_positional
+
+    Examples
+    --------
+    >>> np.format_float_scientific(np.float32(np.pi))
+    '3.1415927e+00'
+    >>> s = np.float32(1.23e24)
+    >>> np.format_float_scientific(s, unique=False, precision=15)
+    '1.230000071797338e+24'
+    >>> np.format_float_scientific(s, exp_digits=4)
+    '1.23e+0024'
+    " :arglists '[[x & [{precision :precision, unique :unique, trim :trim, sign :sign, pad_left :pad_left, exp_digits :exp_digits}]] [x & [{precision :precision, unique :unique, trim :trim, sign :sign, pad_left :pad_left}]] [x & [{precision :precision, unique :unique, trim :trim, sign :sign}]] [x & [{precision :precision, unique :unique, trim :trim}]] [x & [{precision :precision, unique :unique}]] [x & [{precision :precision}]] [x]])
+
+(def tan (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tan"))))
+(alter-meta! #'tan assoc :doc "tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute tangent element-wise.
+
+Equivalent to ``np.sin(x)/np.cos(x)`` element-wise.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding tangent values.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+If `out` is provided, the function writes the result into it,
+and returns a reference to `out`.  (See Examples)
+
+References
+----------
+M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
+New York, NY: Dover, 1972.
+
+Examples
+--------
+>>> from math import pi
+>>> np.tan(np.array([-pi,pi/2,pi]))
+array([  1.22460635e-16,   1.63317787e+16,  -1.22460635e-16])
+>>>
+>>> # Example of providing the optional output parameter illustrating
+>>> # that what is returned is a reference to said parameter
+>>> out1 = np.array([0], dtype='d')
+>>> out2 = np.cos([0.1], out1)
+>>> out2 is out1
+True
+>>>
+>>> # Example of ValueError due to provision of shape mis-matched `out`
+>>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
+Traceback (most recent call last):
+  File \"<stdin>\", line 1, in <module>
+ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]])
+
+(def int_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int_"))))
+(alter-meta! #'int_ assoc :doc "Signed integer type, compatible with Python `int` anc C ``long``.
+    Character code: ``'l'``.
+    Canonical name: ``np.int_``.
+    Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807).
+    Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def recarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "recarray"))))
+(alter-meta! #'recarray assoc :doc "Construct an ndarray that allows field access using attributes.
+
+    Arrays may have a data-types containing fields, analogous
+    to columns in a spread sheet.  An example is ``[(x, int), (y, float)]``,
+    where each entry in the array is a pair of ``(int, float)``.  Normally,
+    these attributes are accessed using dictionary lookups such as ``arr['x']``
+    and ``arr['y']``.  Record arrays allow the fields to be accessed as members
+    of the array, using ``arr.x`` and ``arr.y``.
+
+    Parameters
+    ----------
+    shape : tuple
+        Shape of output array.
+    dtype : data-type, optional
+        The desired data-type.  By default, the data-type is determined
+        from `formats`, `names`, `titles`, `aligned` and `byteorder`.
+    formats : list of data-types, optional
+        A list containing the data-types for the different columns, e.g.
+        ``['i4', 'f8', 'i4']``.  `formats` does *not* support the new
+        convention of using types directly, i.e. ``(int, float, int)``.
+        Note that `formats` must be a list, not a tuple.
+        Given that `formats` is somewhat limited, we recommend specifying
+        `dtype` instead.
+    names : tuple of str, optional
+        The name of each column, e.g. ``('x', 'y', 'z')``.
+    buf : buffer, optional
+        By default, a new array is created of the given shape and data-type.
+        If `buf` is specified and is an object exposing the buffer interface,
+        the array will use the memory from the existing buffer.  In this case,
+        the `offset` and `strides` keywords are available.
+
+    Other Parameters
+    ----------------
+    titles : tuple of str, optional
+        Aliases for column names.  For example, if `names` were
+        ``('x', 'y', 'z')`` and `titles` is
+        ``('x_coordinate', 'y_coordinate', 'z_coordinate')``, then
+        ``arr['x']`` is equivalent to both ``arr.x`` and ``arr.x_coordinate``.
+    byteorder : {'<', '>', '='}, optional
+        Byte-order for all fields.
+    aligned : bool, optional
+        Align the fields in memory as the C-compiler would.
+    strides : tuple of ints, optional
+        Buffer (`buf`) is interpreted according to these strides (strides
+        define how many bytes each array element, row, column, etc.
+        occupy in memory).
+    offset : int, optional
+        Start reading buffer (`buf`) from this offset onwards.
+    order : {'C', 'F'}, optional
+        Row-major (C-style) or column-major (Fortran-style) order.
+
+    Returns
+    -------
+    rec : recarray
+        Empty array of the given shape and type.
+
+    See Also
+    --------
+    rec.fromrecords : Construct a record array from data.
+    record : fundamental data-type for `recarray`.
+    format_parser : determine a data-type from formats, names, titles.
+
+    Notes
+    -----
+    This constructor can be compared to ``empty``: it creates a new record
+    array but does not fill it with data.  To create a record array from data,
+    use one of the following methods:
+
+    1. Create a standard ndarray and convert it to a record array,
+       using ``arr.view(np.recarray)``
+    2. Use the `buf` keyword.
+    3. Use `np.rec.fromrecords`.
+
+    Examples
+    --------
+    Create an array with two fields, ``x`` and ``y``:
+
+    >>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', '<f8'), ('y', '<i8')])
+    >>> x
+    array([(1., 2), (3., 4)], dtype=[('x', '<f8'), ('y', '<i8')])
+
+    >>> x['x']
+    array([1., 3.])
+
+    View the array as a record array:
+
+    >>> x = x.view(np.recarray)
+
+    >>> x.x
+    array([1., 3.])
+
+    >>> x.y
+    array([2, 4])
+
+    Create a new, empty record array:
+
+    >>> np.recarray((2,),
+    ... dtype=[('x', int), ('y', float), ('z', int)]) #doctest: +SKIP
+    rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),
+           (3471280, 1.2134086255804012e-316, 0)],
+          dtype=[('x', '<i4'), ('y', '<f8'), ('z', '<i4')])
+
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def cos (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cos"))))
+(alter-meta! #'cos assoc :doc "cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Cosine element-wise.
+
+Parameters
+----------
+x : array_like
+    Input array in radians.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding cosine values.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+If `out` is provided, the function writes the result into it,
+and returns a reference to `out`.  (See Examples)
+
+References
+----------
+M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
+New York, NY: Dover, 1972.
+
+Examples
+--------
+>>> np.cos(np.array([0, np.pi/2, np.pi]))
+array([  1.00000000e+00,   6.12303177e-17,  -1.00000000e+00])
+>>>
+>>> # Example of providing the optional output parameter
+>>> out1 = np.array([0], dtype='d')
+>>> out2 = np.cos([0.1], out1)
+>>> out2 is out1
+True
+>>>
+>>> # Example of ValueError due to provision of shape mis-matched `out`
+>>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
+Traceback (most recent call last):
+  File \"<stdin>\", line 1, in <module>
+ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]])
+
+(def tensordot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tensordot"))))
+(alter-meta! #'tensordot assoc :doc "
+    Compute tensor dot product along specified axes.
+
+    Given two tensors, `a` and `b`, and an array_like object containing
+    two array_like objects, ``(a_axes, b_axes)``, sum the products of
+    `a`'s and `b`'s elements (components) over the axes specified by
+    ``a_axes`` and ``b_axes``. The third argument can be a single non-negative
+    integer_like scalar, ``N``; if it is such, then the last ``N`` dimensions
+    of `a` and the first ``N`` dimensions of `b` are summed over.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Tensors to \"dot\".
+
+    axes : int or (2,) array_like
+        * integer_like
+          If an int N, sum over the last N axes of `a` and the first N axes
+          of `b` in order. The sizes of the corresponding axes must match.
+        * (2,) array_like
+          Or, a list of axes to be summed over, first sequence applying to `a`,
+          second to `b`. Both elements array_like must be of the same length.
+
+    Returns
+    -------
+    output : ndarray
+        The tensor dot product of the input.
+
+    See Also
+    --------
+    dot, einsum
+
+    Notes
+    -----
+    Three common use cases are:
+        * ``axes = 0`` : tensor product :math:`a\\otimes b`
+        * ``axes = 1`` : tensor dot product :math:`a\\cdot b`
+        * ``axes = 2`` : (default) tensor double contraction :math:`a:b`
+
+    When `axes` is integer_like, the sequence for evaluation will be: first
+    the -Nth axis in `a` and 0th axis in `b`, and the -1th axis in `a` and
+    Nth axis in `b` last.
+
+    When there is more than one axis to sum over - and they are not the last
+    (first) axes of `a` (`b`) - the argument `axes` should consist of
+    two sequences of the same length, with the first axis to sum over given
+    first in both sequences, the second axis second, and so forth.
+
+    The shape of the result consists of the non-contracted axes of the
+    first tensor, followed by the non-contracted axes of the second.
+
+    Examples
+    --------
+    A \"traditional\" example:
+
+    >>> a = np.arange(60.).reshape(3,4,5)
+    >>> b = np.arange(24.).reshape(4,3,2)
+    >>> c = np.tensordot(a,b, axes=([1,0],[0,1]))
+    >>> c.shape
+    (5, 2)
+    >>> c
+    array([[4400., 4730.],
+           [4532., 4874.],
+           [4664., 5018.],
+           [4796., 5162.],
+           [4928., 5306.]])
+    >>> # A slower but equivalent way of computing the same...
+    >>> d = np.zeros((5,2))
+    >>> for i in range(5):
+    ...   for j in range(2):
+    ...     for k in range(3):
+    ...       for n in range(4):
+    ...         d[i,j] += a[k,n,i] * b[n,k,j]
+    >>> c == d
+    array([[ True,  True],
+           [ True,  True],
+           [ True,  True],
+           [ True,  True],
+           [ True,  True]])
+
+    An extended example taking advantage of the overloading of + and \\*:
+
+    >>> a = np.array(range(1, 9))
+    >>> a.shape = (2, 2, 2)
+    >>> A = np.array(('a', 'b', 'c', 'd'), dtype=object)
+    >>> A.shape = (2, 2)
+    >>> a; A
+    array([[[1, 2],
+            [3, 4]],
+           [[5, 6],
+            [7, 8]]])
+    array([['a', 'b'],
+           ['c', 'd']], dtype=object)
+
+    >>> np.tensordot(a, A) # third argument default is 2 for double-contraction
+    array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object)
+
+    >>> np.tensordot(a, A, 1)
+    array([[['acc', 'bdd'],
+            ['aaacccc', 'bbbdddd']],
+           [['aaaaacccccc', 'bbbbbdddddd'],
+            ['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object)
+
+    >>> np.tensordot(a, A, 0) # tensor product (result too long to incl.)
+    array([[[[['a', 'b'],
+              ['c', 'd']],
+              ...
+
+    >>> np.tensordot(a, A, (0, 1))
+    array([[['abbbbb', 'cddddd'],
+            ['aabbbbbb', 'ccdddddd']],
+           [['aaabbbbbbb', 'cccddddddd'],
+            ['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object)
+
+    >>> np.tensordot(a, A, (2, 1))
+    array([[['abb', 'cdd'],
+            ['aaabbbb', 'cccdddd']],
+           [['aaaaabbbbbb', 'cccccdddddd'],
+            ['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object)
+
+    >>> np.tensordot(a, A, ((0, 1), (0, 1)))
+    array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object)
+
+    >>> np.tensordot(a, A, ((2, 1), (1, 0)))
+    array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def DataSource (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "DataSource"))))
+(alter-meta! #'DataSource assoc :doc "
+    DataSource(destpath='.')
+
+    A generic data source file (file, http, ftp, ...).
+
+    DataSources can be local files or remote files/URLs.  The files may
+    also be compressed or uncompressed. DataSource hides some of the
+    low-level details of downloading the file, allowing you to simply pass
+    in a valid file path (or URL) and obtain a file object.
+
+    Parameters
+    ----------
+    destpath : str or None, optional
+        Path to the directory where the source file gets downloaded to for
+        use.  If `destpath` is None, a temporary directory will be created.
+        The default path is the current directory.
+
+    Notes
+    -----
+    URLs require a scheme string (``http://``) to be used, without it they
+    will fail::
+
+        >>> repos = np.DataSource()
+        >>> repos.exists('www.google.com/index.html')
+        False
+        >>> repos.exists('http://www.google.com/index.html')
+        True
+
+    Temporary directories are deleted when the DataSource is deleted.
+
+    Examples
+    --------
+    ::
+
+        >>> ds = np.DataSource('/home/guido')
+        >>> urlname = 'http://www.google.com/'
+        >>> gfile = ds.open('http://www.google.com/')
+        >>> ds.abspath(urlname)
+        '/home/guido/www.google.com/index.html'
+
+        >>> ds = np.DataSource(None)  # use with temporary file
+        >>> ds.open('/home/guido/foobar.txt')
+        <open file '/home/guido.foobar.txt', mode 'r' at 0x91d4430>
+        >>> ds.abspath('/home/guido/foobar.txt')
+        '/tmp/.../home/guido/foobar.txt'
+
+    " :arglists '[[self & [{destpath :destpath}]] [self]])
+
+(def argsort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argsort"))))
+(alter-meta! #'argsort assoc :doc "
+    Returns the indices that would sort an array.
+
+    Perform an indirect sort along the given axis using the algorithm specified
+    by the `kind` keyword. It returns an array of indices of the same shape as
+    `a` that index data along the given axis in sorted order.
+
+    Parameters
+    ----------
+    a : array_like
+        Array to sort.
+    axis : int or None, optional
+        Axis along which to sort.  The default is -1 (the last axis). If None,
+        the flattened array is used.
+    kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
+        Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
+        and 'mergesort' use timsort under the covers and, in general, the
+        actual implementation will vary with data type. The 'mergesort' option
+        is retained for backwards compatibility.
+
+        .. versionchanged:: 1.15.0.
+           The 'stable' option was added.
+    order : str or list of str, optional
+        When `a` is an array with fields defined, this argument specifies
+        which fields to compare first, second, etc.  A single field can
+        be specified as a string, and not all fields need be specified,
+        but unspecified fields will still be used, in the order in which
+        they come up in the dtype, to break ties.
+
+    Returns
+    -------
+    index_array : ndarray, int
+        Array of indices that sort `a` along the specified `axis`.
+        If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.
+        More generally, ``np.take_along_axis(a, index_array, axis=axis)``
+        always yields the sorted `a`, irrespective of dimensionality.
+
+    See Also
+    --------
+    sort : Describes sorting algorithms used.
+    lexsort : Indirect stable sort with multiple keys.
+    ndarray.sort : Inplace sort.
+    argpartition : Indirect partial sort.
+    take_along_axis : Apply ``index_array`` from argsort 
+                      to an array as if by calling sort.
+
+    Notes
+    -----
+    See `sort` for notes on the different sorting algorithms.
+
+    As of NumPy 1.4.0 `argsort` works with real/complex arrays containing
+    nan values. The enhanced sort order is documented in `sort`.
+
+    Examples
+    --------
+    One dimensional array:
+
+    >>> x = np.array([3, 1, 2])
+    >>> np.argsort(x)
+    array([1, 2, 0])
+
+    Two-dimensional array:
+
+    >>> x = np.array([[0, 3], [2, 2]])
+    >>> x
+    array([[0, 3],
+           [2, 2]])
+
+    >>> ind = np.argsort(x, axis=0)  # sorts along first axis (down)
+    >>> ind
+    array([[0, 1],
+           [1, 0]])
+    >>> np.take_along_axis(x, ind, axis=0)  # same as np.sort(x, axis=0)
+    array([[0, 2],
+           [2, 3]])
+
+    >>> ind = np.argsort(x, axis=1)  # sorts along last axis (across)
+    >>> ind
+    array([[0, 1],
+           [0, 1]])
+    >>> np.take_along_axis(x, ind, axis=1)  # same as np.sort(x, axis=1)
+    array([[0, 3],
+           [2, 2]])
+
+    Indices of the sorted elements of a N-dimensional array:
+
+    >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape)
+    >>> ind
+    (array([0, 1, 1, 0]), array([0, 0, 1, 1]))
+    >>> x[ind]  # same as np.sort(x, axis=None)
+    array([0, 2, 2, 3])
+
+    Sorting with keys:
+
+    >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
+    >>> x
+    array([(1, 0), (0, 1)],
+          dtype=[('x', '<i4'), ('y', '<i4')])
+
+    >>> np.argsort(x, order=('x','y'))
+    array([1, 0])
+
+    >>> np.argsort(x, order=('y','x'))
+    array([0, 1])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def trunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trunc"))))
+(alter-meta! #'trunc assoc :doc "trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the truncated value of the input, element-wise.
+
+The truncated value of the scalar `x` is the nearest integer `i` which
+is closer to zero than `x` is. In short, the fractional part of the
+signed number `x` is discarded.
+
+Parameters
+----------
+x : array_like
+    Input data.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The truncated value of each element in `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+ceil, floor, rint
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+Examples
+--------
+>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
+>>> np.trunc(a)
+array([-1., -1., -0.,  0.,  1.,  1.,  2.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def intersect1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "intersect1d"))))
+(alter-meta! #'intersect1d assoc :doc "
+    Find the intersection of two arrays.
+
+    Return the sorted, unique values that are in both of the input arrays.
+
+    Parameters
+    ----------
+    ar1, ar2 : array_like
+        Input arrays. Will be flattened if not already 1D.
+    assume_unique : bool
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+    return_indices : bool
+        If True, the indices which correspond to the intersection of the two
+        arrays are returned. The first instance of a value is used if there are
+        multiple. Default is False.
+
+        .. versionadded:: 1.15.0
+
+    Returns
+    -------
+    intersect1d : ndarray
+        Sorted 1D array of common and unique elements.
+    comm1 : ndarray
+        The indices of the first occurrences of the common values in `ar1`.
+        Only provided if `return_indices` is True.
+    comm2 : ndarray
+        The indices of the first occurrences of the common values in `ar2`.
+        Only provided if `return_indices` is True.
+
+
+    See Also
+    --------
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Examples
+    --------
+    >>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
+    array([1, 3])
+
+    To intersect more than two arrays, use functools.reduce:
+
+    >>> from functools import reduce
+    >>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
+    array([3])
+
+    To return the indices of the values common to the input arrays
+    along with the intersected values:
+
+    >>> x = np.array([1, 1, 2, 3, 4])
+    >>> y = np.array([2, 1, 4, 6])
+    >>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)
+    >>> x_ind, y_ind
+    (array([0, 2, 4]), array([1, 0, 2]))
+    >>> xy, x[x_ind], y[y_ind]
+    (array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def fill_diagonal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fill_diagonal"))))
+(alter-meta! #'fill_diagonal assoc :doc "Fill the main diagonal of the given array of any dimensionality.
+
+    For an array `a` with ``a.ndim >= 2``, the diagonal is the list of
+    locations with indices ``a[i, ..., i]`` all identical. This function
+    modifies the input array in-place, it does not return a value.
+
+    Parameters
+    ----------
+    a : array, at least 2-D.
+      Array whose diagonal is to be filled, it gets modified in-place.
+
+    val : scalar
+      Value to be written on the diagonal, its type must be compatible with
+      that of the array a.
+
+    wrap : bool
+      For tall matrices in NumPy version up to 1.6.2, the
+      diagonal \"wrapped\" after N columns. You can have this behavior
+      with this option. This affects only tall matrices.
+
+    See also
+    --------
+    diag_indices, diag_indices_from
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    This functionality can be obtained via `diag_indices`, but internally
+    this version uses a much faster implementation that never constructs the
+    indices and uses simple slicing.
+
+    Examples
+    --------
+    >>> a = np.zeros((3, 3), int)
+    >>> np.fill_diagonal(a, 5)
+    >>> a
+    array([[5, 0, 0],
+           [0, 5, 0],
+           [0, 0, 5]])
+
+    The same function can operate on a 4-D array:
+
+    >>> a = np.zeros((3, 3, 3, 3), int)
+    >>> np.fill_diagonal(a, 4)
+
+    We only show a few blocks for clarity:
+
+    >>> a[0, 0]
+    array([[4, 0, 0],
+           [0, 0, 0],
+           [0, 0, 0]])
+    >>> a[1, 1]
+    array([[0, 0, 0],
+           [0, 4, 0],
+           [0, 0, 0]])
+    >>> a[2, 2]
+    array([[0, 0, 0],
+           [0, 0, 0],
+           [0, 0, 4]])
+
+    The wrap option affects only tall matrices:
+
+    >>> # tall matrices no wrap
+    >>> a = np.zeros((5, 3), int)
+    >>> np.fill_diagonal(a, 4)
+    >>> a
+    array([[4, 0, 0],
+           [0, 4, 0],
+           [0, 0, 4],
+           [0, 0, 0],
+           [0, 0, 0]])
+
+    >>> # tall matrices wrap
+    >>> a = np.zeros((5, 3), int)
+    >>> np.fill_diagonal(a, 4, wrap=True)
+    >>> a
+    array([[4, 0, 0],
+           [0, 4, 0],
+           [0, 0, 4],
+           [0, 0, 0],
+           [4, 0, 0]])
+
+    >>> # wide matrices
+    >>> a = np.zeros((3, 5), int)
+    >>> np.fill_diagonal(a, 4, wrap=True)
+    >>> a
+    array([[4, 0, 0, 0, 0],
+           [0, 4, 0, 0, 0],
+           [0, 0, 4, 0, 0]])
+
+    The anti-diagonal can be filled by reversing the order of elements
+    using either `numpy.flipud` or `numpy.fliplr`.
+
+    >>> a = np.zeros((3, 3), int);
+    >>> np.fill_diagonal(np.fliplr(a), [1,2,3])  # Horizontal flip
+    >>> a
+    array([[0, 0, 1],
+           [0, 2, 0],
+           [3, 0, 0]])
+    >>> np.fill_diagonal(np.flipud(a), [1,2,3])  # Vertical flip
+    >>> a
+    array([[0, 0, 3],
+           [0, 2, 0],
+           [1, 0, 0]])
+
+    Note that the order in which the diagonal is filled varies depending
+    on the flip function.
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "
+``numpy.linalg``
+================
+
+The NumPy linear algebra functions rely on BLAS and LAPACK to provide efficient
+low level implementations of standard linear algebra algorithms. Those
+libraries may be provided by NumPy itself using C versions of a subset of their
+reference implementations but, when possible, highly optimized libraries that
+take advantage of specialized processor functionality are preferred. Examples
+of such libraries are OpenBLAS, MKL (TM), and ATLAS. Because those libraries
+are multithreaded and processor dependent, environmental variables and external
+packages such as threadpoolctl may be needed to control the number of threads
+or specify the processor architecture.
+
+- OpenBLAS: https://www.openblas.net/
+- threadpoolctl: https://github.com/joblib/threadpoolctl
+
+Please note that the most-used linear algebra functions in NumPy are present in
+the main ``numpy`` namespace rather than in ``numpy.linalg``.  There are:
+``dot``, ``vdot``, ``inner``, ``outer``, ``matmul``, ``tensordot``, ``einsum``,
+``einsum_path`` and ``kron``.
+
+Functions present in numpy.linalg are listed below.
+
+
+Matrix and vector products
+--------------------------
+
+   multi_dot
+   matrix_power
+
+Decompositions
+--------------
+
+   cholesky
+   qr
+   svd
+
+Matrix eigenvalues
+------------------
+
+   eig
+   eigh
+   eigvals
+   eigvalsh
+
+Norms and other numbers
+-----------------------
+
+   norm
+   cond
+   det
+   matrix_rank
+   slogdet
+
+Solving equations and inverting matrices
+----------------------------------------
+
+   solve
+   tensorsolve
+   lstsq
+   inv
+   pinv
+   tensorinv
+
+Exceptions
+----------
+
+   LinAlgError
+
+"} linalg (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "linalg"))))
+
+(def triu_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "triu_indices"))))
+(alter-meta! #'triu_indices assoc :doc "
+    Return the indices for the upper-triangle of an (n, m) array.
+
+    Parameters
+    ----------
+    n : int
+        The size of the arrays for which the returned indices will
+        be valid.
+    k : int, optional
+        Diagonal offset (see `triu` for details).
+    m : int, optional
+        .. versionadded:: 1.9.0
+
+        The column dimension of the arrays for which the returned
+        arrays will be valid.
+        By default `m` is taken equal to `n`.
+
+
+    Returns
+    -------
+    inds : tuple, shape(2) of ndarrays, shape(`n`)
+        The indices for the triangle. The returned tuple contains two arrays,
+        each with the indices along one dimension of the array.  Can be used
+        to slice a ndarray of shape(`n`, `n`).
+
+    See also
+    --------
+    tril_indices : similar function, for lower-triangular.
+    mask_indices : generic function accepting an arbitrary mask function.
+    triu, tril
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    Compute two different sets of indices to access 4x4 arrays, one for the
+    upper triangular part starting at the main diagonal, and one starting two
+    diagonals further right:
+
+    >>> iu1 = np.triu_indices(4)
+    >>> iu2 = np.triu_indices(4, 2)
+
+    Here is how they can be used with a sample array:
+
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+
+    Both for indexing:
+
+    >>> a[iu1]
+    array([ 0,  1,  2, ..., 10, 11, 15])
+
+    And for assigning values:
+
+    >>> a[iu1] = -1
+    >>> a
+    array([[-1, -1, -1, -1],
+           [ 4, -1, -1, -1],
+           [ 8,  9, -1, -1],
+           [12, 13, 14, -1]])
+
+    These cover only a small part of the whole array (two diagonals right
+    of the main one):
+
+    >>> a[iu2] = -10
+    >>> a
+    array([[ -1,  -1, -10, -10],
+           [  4,  -1,  -1, -10],
+           [  8,   9,  -1,  -1],
+           [ 12,  13,  14,  -1]])
+
+    " :arglists '[[n & [{k :k, m :m}]] [n & [{k :k}]] [n]])
+
+(def mod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mod"))))
+(alter-meta! #'mod assoc :doc "remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return element-wise remainder of division.
+
+Computes the remainder complementary to the `floor_divide` function.  It is
+equivalent to the Python modulus operator``x1 % x2`` and has the same sign
+as the divisor `x2`. The MATLAB function equivalent to ``np.remainder``
+is ``mod``.
+
+.. warning::
+
+    This should not be confused with:
+
+    * Python 3.7's `math.remainder` and C's ``remainder``, which
+      computes the IEEE remainder, which are the complement to
+      ``round(x1 / x2)``.
+    * The MATLAB ``rem`` function and or the C ``%`` operator which is the
+      complement to ``int(x1 / x2)``.
+
+Parameters
+----------
+x1 : array_like
+    Dividend array.
+x2 : array_like
+    Divisor array. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+floor_divide : Equivalent of Python ``//`` operator.
+divmod : Simultaneous floor division and remainder.
+fmod : Equivalent of the MATLAB ``rem`` function.
+divide, floor
+
+Notes
+-----
+Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
+integers.
+``mod`` is an alias of ``remainder``.
+
+Examples
+--------
+>>> np.remainder([4, 7], [2, 3])
+array([0, 1])
+>>> np.remainder(np.arange(7), 5)
+array([0, 1, 2, 3, 4, 0, 1])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def mirr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mirr"))))
+(alter-meta! #'mirr assoc :doc "
+    Modified internal rate of return.
+
+    .. deprecated:: 1.18
+
+       `mirr` is deprecated; for details, see NEP 32 [1]_.
+       Use the corresponding function in the numpy-financial library,
+       https://pypi.org/project/numpy-financial.
+
+    Parameters
+    ----------
+    values : array_like
+        Cash flows (must contain at least one positive and one negative
+        value) or nan is returned.  The first value is considered a sunk
+        cost at time zero.
+    finance_rate : scalar
+        Interest rate paid on the cash flows
+    reinvest_rate : scalar
+        Interest rate received on the cash flows upon reinvestment
+
+    Returns
+    -------
+    out : float
+        Modified internal rate of return
+
+    References
+    ----------
+    .. [1] NumPy Enhancement Proposal (NEP) 32,
+       https://numpy.org/neps/nep-0032-remove-financial-functions.html
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def broadcast_arrays (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "broadcast_arrays"))))
+(alter-meta! #'broadcast_arrays assoc :doc "
+    Broadcast any number of arrays against each other.
+
+    Parameters
+    ----------
+    `*args` : array_likes
+        The arrays to broadcast.
+
+    subok : bool, optional
+        If True, then sub-classes will be passed-through, otherwise
+        the returned arrays will be forced to be a base-class array (default).
+
+    Returns
+    -------
+    broadcasted : list of arrays
+        These arrays are views on the original arrays.  They are typically
+        not contiguous.  Furthermore, more than one element of a
+        broadcasted array may refer to a single memory location. If you need
+        to write to the arrays, make copies first. While you can set the
+        ``writable`` flag True, writing to a single output value may end up
+        changing more than one location in the output array.
+
+        .. deprecated:: 1.17
+            The output is currently marked so that if written to, a deprecation
+            warning will be emitted. A future version will set the
+            ``writable`` flag False so writing to it will raise an error.
+
+    Examples
+    --------
+    >>> x = np.array([[1,2,3]])
+    >>> y = np.array([[4],[5]])
+    >>> np.broadcast_arrays(x, y)
+    [array([[1, 2, 3],
+           [1, 2, 3]]), array([[4, 4, 4],
+           [5, 5, 5]])]
+
+    Here is a useful idiom for getting contiguous copies instead of
+    non-contiguous views.
+
+    >>> [np.array(a) for a in np.broadcast_arrays(x, y)]
+    [array([[1, 2, 3],
+           [1, 2, 3]]), array([[4, 4, 4],
+           [5, 5, 5]])]
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def integer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "integer"))))
+(alter-meta! #'integer assoc :doc "Abstract base class of all integer scalar types." :arglists '[[self & [args {:as kwargs}]]])
+
+(def geterrobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geterrobj"))))
+(alter-meta! #'geterrobj assoc :doc "geterrobj()
+
+    Return the current object that defines floating-point error handling.
+
+    The error object contains all information that defines the error handling
+    behavior in NumPy. `geterrobj` is used internally by the other
+    functions that get and set error handling behavior (`geterr`, `seterr`,
+    `geterrcall`, `seterrcall`).
+
+    Returns
+    -------
+    errobj : list
+        The error object, a list containing three elements:
+        [internal numpy buffer size, error mask, error callback function].
+
+        The error mask is a single integer that holds the treatment information
+        on all four floating point errors. The information for each error type
+        is contained in three bits of the integer. If we print it in base 8, we
+        can see what treatment is set for \"invalid\", \"under\", \"over\", and
+        \"divide\" (in that order). The printed string can be interpreted with
+
+        * 0 : 'ignore'
+        * 1 : 'warn'
+        * 2 : 'raise'
+        * 3 : 'call'
+        * 4 : 'print'
+        * 5 : 'log'
+
+    See Also
+    --------
+    seterrobj, seterr, geterr, seterrcall, geterrcall
+    getbufsize, setbufsize
+
+    Notes
+    -----
+    For complete documentation of the types of floating-point exceptions and
+    treatment options, see `seterr`.
+
+    Examples
+    --------
+    >>> np.geterrobj()  # first get the defaults
+    [8192, 521, None]
+
+    >>> def err_handler(type, flag):
+    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
+    ...
+    >>> old_bufsize = np.setbufsize(20000)
+    >>> old_err = np.seterr(divide='raise')
+    >>> old_handler = np.seterrcall(err_handler)
+    >>> np.geterrobj()
+    [8192, 521, <function err_handler at 0x91dcaac>]
+
+    >>> old_err = np.seterr(all='ignore')
+    >>> np.base_repr(np.geterrobj()[1], 8)
+    '0'
+    >>> old_err = np.seterr(divide='warn', over='log', under='call',
+    ...                     invalid='print')
+    >>> np.base_repr(np.geterrobj()[1], 8)
+    '4351'" :arglists '[[self & [args {:as kwargs}]]])
+
+(def printoptions (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "printoptions"))))
+(alter-meta! #'printoptions assoc :doc "Context manager for setting print options.
+
+    Set print options for the scope of the `with` block, and restore the old
+    options at the end. See `set_printoptions` for the full description of
+    available options.
+
+    Examples
+    --------
+
+    >>> from numpy.testing import assert_equal
+    >>> with np.printoptions(precision=2):
+    ...     np.array([2.0]) / 3
+    array([0.67])
+
+    The `as`-clause of the `with`-statement gives the current print options:
+
+    >>> with np.printoptions(precision=2) as opts:
+    ...      assert_equal(opts, np.get_printoptions())
+
+    See Also
+    --------
+    set_printoptions, get_printoptions
+
+    " :arglists '[[& [args {:as kwds}]]])
+
+(def int8 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int8"))))
+(alter-meta! #'int8 assoc :doc "Signed integer type, compatible with C ``char``.
+    Character code: ``'b'``.
+    Canonical name: ``np.byte``.
+    Alias *on this platform*: ``np.int8``: 8-bit signed integer (-128 to 127)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def safe_eval (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "safe_eval"))))
+(alter-meta! #'safe_eval assoc :doc "
+    Protected string evaluation.
+
+    Evaluate a string containing a Python literal expression without
+    allowing the execution of arbitrary non-literal code.
+
+    Parameters
+    ----------
+    source : str
+        The string to evaluate.
+
+    Returns
+    -------
+    obj : object
+       The result of evaluating `source`.
+
+    Raises
+    ------
+    SyntaxError
+        If the code has invalid Python syntax, or if it contains
+        non-literal code.
+
+    Examples
+    --------
+    >>> np.safe_eval('1')
+    1
+    >>> np.safe_eval('[1, 2, 3]')
+    [1, 2, 3]
+    >>> np.safe_eval('{\"foo\": (\"bar\", 10.0)}')
+    {'foo': ('bar', 10.0)}
+
+    >>> np.safe_eval('import os')
+    Traceback (most recent call last):
+      ...
+    SyntaxError: invalid syntax
+
+    >>> np.safe_eval('open(\"/home/user/.ssh/id_dsa\").read()')
+    Traceback (most recent call last):
+      ...
+    ValueError: malformed node or string: <_ast.Call object at 0x...>
+
+    " :arglists '[[source]])
+
+(def ^{:doc "
+**Note:** almost all functions in the ``numpy.lib`` namespace
+are also present in the main ``numpy`` namespace.  Please use the
+functions as ``np.<funcname>`` where possible.
+
+``numpy.lib`` is mostly a space for implementing functions that don't
+belong in core or in another NumPy submodule with a clear purpose
+(e.g. ``random``, ``fft``, ``linalg``, ``ma``).
+
+Most contains basic functions that are used by several submodules and are
+useful to have in the main name-space.
+
+"} lib (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "lib"))))
+
+(def promote_types (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "promote_types"))))
+(alter-meta! #'promote_types assoc :doc "promote_types(type1, type2)
+
+    Returns the data type with the smallest size and smallest scalar
+    kind to which both ``type1`` and ``type2`` may be safely cast.
+    The returned data type is always in native byte order.
+
+    This function is symmetric, but rarely associative.
+
+    Parameters
+    ----------
+    type1 : dtype or dtype specifier
+        First data type.
+    type2 : dtype or dtype specifier
+        Second data type.
+
+    Returns
+    -------
+    out : dtype
+        The promoted data type.
+
+    Notes
+    -----
+    .. versionadded:: 1.6.0
+
+    Starting in NumPy 1.9, promote_types function now returns a valid string
+    length when given an integer or float dtype as one argument and a string
+    dtype as another argument. Previously it always returned the input string
+    dtype, even if it wasn't long enough to store the max integer/float value
+    converted to a string.
+
+    See Also
+    --------
+    result_type, dtype, can_cast
+
+    Examples
+    --------
+    >>> np.promote_types('f4', 'f8')
+    dtype('float64')
+
+    >>> np.promote_types('i8', 'f4')
+    dtype('float64')
+
+    >>> np.promote_types('>i8', '<c8')
+    dtype('complex128')
+
+    >>> np.promote_types('i4', 'S8')
+    dtype('S11')
+
+    An example of a non-associative case:
+
+    >>> p = np.promote_types
+    >>> p('S', p('i1', 'u1'))
+    dtype('S6')
+    >>> p(p('S', 'i1'), 'u1')
+    dtype('S4')" :arglists '[[self & [args {:as kwargs}]]])
+
+(def square (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "square"))))
+(alter-meta! #'square assoc :doc "square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the element-wise square of the input.
+
+Parameters
+----------
+x : array_like
+    Input data.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Element-wise `x*x`, of the same shape and dtype as `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+numpy.linalg.matrix_power
+sqrt
+power
+
+Examples
+--------
+>>> np.square([-1j, 1])
+array([-1.-0.j,  1.+0.j])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ModuleDeprecationWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ModuleDeprecationWarning"))))
+(alter-meta! #'ModuleDeprecationWarning assoc :doc "Module deprecation warning.
+
+    The nose tester turns ordinary Deprecation warnings into test failures.
+    That makes it hard to deprecate whole modules, because they get
+    imported by default. So this is a special Deprecation warning that the
+    nose tester will let pass without making tests fail.
+
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def may_share_memory (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "may_share_memory"))))
+(alter-meta! #'may_share_memory assoc :doc "
+    may_share_memory(a, b, max_work=None)
+
+    Determine if two arrays might share memory
+
+    A return of True does not necessarily mean that the two arrays
+    share any element.  It just means that they *might*.
+
+    Only the memory bounds of a and b are checked by default.
+
+    Parameters
+    ----------
+    a, b : ndarray
+        Input arrays
+    max_work : int, optional
+        Effort to spend on solving the overlap problem.  See
+        `shares_memory` for details.  Default for ``may_share_memory``
+        is to do a bounds check.
+
+    Returns
+    -------
+    out : bool
+
+    See Also
+    --------
+    shares_memory
+
+    Examples
+    --------
+    >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9]))
+    False
+    >>> x = np.zeros([3, 4])
+    >>> np.may_share_memory(x[:,0], x[:,1])
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]])
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} __builtins__ (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "__builtins__")))) 
+
+(def source (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "source"))))
+(alter-meta! #'source assoc :doc "
+    Print or write to a file the source code for a NumPy object.
+
+    The source code is only returned for objects written in Python. Many
+    functions and classes are defined in C and will therefore not return
+    useful information.
+
+    Parameters
+    ----------
+    object : numpy object
+        Input object. This can be any object (function, class, module,
+        ...).
+    output : file object, optional
+        If `output` not supplied then source code is printed to screen
+        (sys.stdout).  File object must be created with either write 'w' or
+        append 'a' modes.
+
+    See Also
+    --------
+    lookfor, info
+
+    Examples
+    --------
+    >>> np.source(np.interp)                        #doctest: +SKIP
+    In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py
+    def interp(x, xp, fp, left=None, right=None):
+        \"\"\".... (full docstring printed)\"\"\"
+        if isinstance(x, (float, int, number)):
+            return compiled_interp([x], xp, fp, left, right).item()
+        else:
+            return compiled_interp(x, xp, fp, left, right)
+
+    The source code is only returned for objects written in Python.
+
+    >>> np.source(np.array)                         #doctest: +SKIP
+    Not available for this object.
+
+    " :arglists '[[object & [{output :output}]] [object]])
+
+(def swapaxes (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "swapaxes"))))
+(alter-meta! #'swapaxes assoc :doc "
+    Interchange two axes of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis1 : int
+        First axis.
+    axis2 : int
+        Second axis.
+
+    Returns
+    -------
+    a_swapped : ndarray
+        For NumPy >= 1.10.0, if `a` is an ndarray, then a view of `a` is
+        returned; otherwise a new array is created. For earlier NumPy
+        versions a view of `a` is returned only if the order of the
+        axes is changed, otherwise the input array is returned.
+
+    Examples
+    --------
+    >>> x = np.array([[1,2,3]])
+    >>> np.swapaxes(x,0,1)
+    array([[1],
+           [2],
+           [3]])
+
+    >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
+    >>> x
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+
+    >>> np.swapaxes(x,0,2)
+    array([[[0, 4],
+            [2, 6]],
+           [[1, 5],
+            [3, 7]]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} ERR_LOG (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_LOG"))))
+
+(def sort_complex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sort_complex"))))
+(alter-meta! #'sort_complex assoc :doc "
+    Sort a complex array using the real part first, then the imaginary part.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array
+
+    Returns
+    -------
+    out : complex ndarray
+        Always returns a sorted complex array.
+
+    Examples
+    --------
+    >>> np.sort_complex([5, 3, 6, 2, 1])
+    array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])
+
+    >>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])
+    array([1.+2.j,  2.-1.j,  3.-3.j,  3.-2.j,  3.+5.j])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def less (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "less"))))
+(alter-meta! #'less assoc :doc "less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the truth value of (x1 < x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+greater, less_equal, greater_equal, equal, not_equal
+
+Examples
+--------
+>>> np.less([1, 2], [2, 2])
+array([ True, False])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def complexfloating (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complexfloating"))))
+(alter-meta! #'complexfloating assoc :doc "Abstract base class of all complex number scalar types that are made up of
+    floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def unpackbits (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unpackbits"))))
+(alter-meta! #'unpackbits assoc :doc "
+    unpackbits(a, axis=None, count=None, bitorder='big')
+
+    Unpacks elements of a uint8 array into a binary-valued output array.
+
+    Each element of `a` represents a bit-field that should be unpacked
+    into a binary-valued output array. The shape of the output array is
+    either 1-D (if `axis` is ``None``) or the same shape as the input
+    array with unpacking done along the axis specified.
+
+    Parameters
+    ----------
+    a : ndarray, uint8 type
+       Input array.
+    axis : int, optional
+        The dimension over which bit-unpacking is done.
+        ``None`` implies unpacking the flattened array.
+    count : int or None, optional
+        The number of elements to unpack along `axis`, provided as a way
+        of undoing the effect of packing a size that is not a multiple
+        of eight. A non-negative number means to only unpack `count`
+        bits. A negative number means to trim off that many bits from
+        the end. ``None`` means to unpack the entire array (the
+        default). Counts larger than the available number of bits will
+        add zero padding to the output. Negative counts must not
+        exceed the available number of bits.
+
+        .. versionadded:: 1.17.0
+
+    bitorder : {'big', 'little'}, optional
+        The order of the returned bits. 'big' will mimic bin(val),
+        ``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse
+        the order to ``[1, 1, 0, 0, 0, 0, 0, 0]``.
+        Defaults to 'big'.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    unpacked : ndarray, uint8 type
+       The elements are binary-valued (0 or 1).
+
+    See Also
+    --------
+    packbits : Packs the elements of a binary-valued array into bits in
+               a uint8 array.
+
+    Examples
+    --------
+    >>> a = np.array([[2], [7], [23]], dtype=np.uint8)
+    >>> a
+    array([[ 2],
+           [ 7],
+           [23]], dtype=uint8)
+    >>> b = np.unpackbits(a, axis=1)
+    >>> b
+    array([[0, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)
+    >>> c = np.unpackbits(a, axis=1, count=-3)
+    >>> c
+    array([[0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0],
+           [0, 0, 0, 1, 0]], dtype=uint8)
+
+    >>> p = np.packbits(b, axis=0)
+    >>> np.unpackbits(p, axis=0)
+    array([[0, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 1, 0, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+    >>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0]))
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def union1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "union1d"))))
+(alter-meta! #'union1d assoc :doc "
+    Find the union of two arrays.
+
+    Return the unique, sorted array of values that are in either of the two
+    input arrays.
+
+    Parameters
+    ----------
+    ar1, ar2 : array_like
+        Input arrays. They are flattened if they are not already 1D.
+
+    Returns
+    -------
+    union1d : ndarray
+        Unique, sorted union of the input arrays.
+
+    See Also
+    --------
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Examples
+    --------
+    >>> np.union1d([-1, 0, 1], [-2, 0, 2])
+    array([-2, -1,  0,  1,  2])
+
+    To find the union of more than two arrays, use functools.reduce:
+
+    >>> from functools import reduce
+    >>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
+    array([1, 2, 3, 4, 6])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def piecewise (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "piecewise"))))
+(alter-meta! #'piecewise assoc :doc "
+    Evaluate a piecewise-defined function.
+
+    Given a set of conditions and corresponding functions, evaluate each
+    function on the input data wherever its condition is true.
+
+    Parameters
+    ----------
+    x : ndarray or scalar
+        The input domain.
+    condlist : list of bool arrays or bool scalars
+        Each boolean array corresponds to a function in `funclist`.  Wherever
+        `condlist[i]` is True, `funclist[i](x)` is used as the output value.
+
+        Each boolean array in `condlist` selects a piece of `x`,
+        and should therefore be of the same shape as `x`.
+
+        The length of `condlist` must correspond to that of `funclist`.
+        If one extra function is given, i.e. if
+        ``len(funclist) == len(condlist) + 1``, then that extra function
+        is the default value, used wherever all conditions are false.
+    funclist : list of callables, f(x,*args,**kw), or scalars
+        Each function is evaluated over `x` wherever its corresponding
+        condition is True.  It should take a 1d array as input and give an 1d
+        array or a scalar value as output.  If, instead of a callable,
+        a scalar is provided then a constant function (``lambda x: scalar``) is
+        assumed.
+    args : tuple, optional
+        Any further arguments given to `piecewise` are passed to the functions
+        upon execution, i.e., if called ``piecewise(..., ..., 1, 'a')``, then
+        each function is called as ``f(x, 1, 'a')``.
+    kw : dict, optional
+        Keyword arguments used in calling `piecewise` are passed to the
+        functions upon execution, i.e., if called
+        ``piecewise(..., ..., alpha=1)``, then each function is called as
+        ``f(x, alpha=1)``.
+
+    Returns
+    -------
+    out : ndarray
+        The output is the same shape and type as x and is found by
+        calling the functions in `funclist` on the appropriate portions of `x`,
+        as defined by the boolean arrays in `condlist`.  Portions not covered
+        by any condition have a default value of 0.
+
+
+    See Also
+    --------
+    choose, select, where
+
+    Notes
+    -----
+    This is similar to choose or select, except that functions are
+    evaluated on elements of `x` that satisfy the corresponding condition from
+    `condlist`.
+
+    The result is::
+
+            |--
+            |funclist[0](x[condlist[0]])
+      out = |funclist[1](x[condlist[1]])
+            |...
+            |funclist[n2](x[condlist[n2]])
+            |--
+
+    Examples
+    --------
+    Define the sigma function, which is -1 for ``x < 0`` and +1 for ``x >= 0``.
+
+    >>> x = np.linspace(-2.5, 2.5, 6)
+    >>> np.piecewise(x, [x < 0, x >= 0], [-1, 1])
+    array([-1., -1., -1.,  1.,  1.,  1.])
+
+    Define the absolute value, which is ``-x`` for ``x <0`` and ``x`` for
+    ``x >= 0``.
+
+    >>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x])
+    array([2.5,  1.5,  0.5,  0.5,  1.5,  2.5])
+
+    Apply the same function to a scalar value.
+
+    >>> y = -2
+    >>> np.piecewise(y, [y < 0, y >= 0], [lambda x: -x, lambda x: x])
+    array(2)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def abs (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "abs"))))
+(alter-meta! #'abs assoc :doc "absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Calculate the absolute value element-wise.
+
+``np.abs`` is a shorthand for this function.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+absolute : ndarray
+    An ndarray containing the absolute value of
+    each element in `x`.  For complex input, ``a + ib``, the
+    absolute value is :math:`\\sqrt{ a^2 + b^2 }`.
+    This is a scalar if `x` is a scalar.
+
+Examples
+--------
+>>> x = np.array([-1.2, 1.2])
+>>> np.absolute(x)
+array([ 1.2,  1.2])
+>>> np.absolute(1.2 + 1j)
+1.5620499351813308
+
+Plot the function over ``[-10, 10]``:
+
+>>> import matplotlib.pyplot as plt
+
+>>> x = np.linspace(start=-10, stop=10, num=101)
+>>> plt.plot(x, np.absolute(x))
+>>> plt.show()
+
+Plot the function over the complex plane:
+
+>>> xx = x + 1j * x[:, np.newaxis]
+>>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
+
+(def getbufsize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "getbufsize"))))
+(alter-meta! #'getbufsize assoc :doc "
+    Return the size of the buffer used in ufuncs.
+
+    Returns
+    -------
+    getbufsize : int
+        Size of ufunc buffer in bytes.
+
+    " :arglists '[[]])
+
+(def tril_indices_from (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tril_indices_from"))))
+(alter-meta! #'tril_indices_from assoc :doc "
+    Return the indices for the lower-triangle of arr.
+
+    See `tril_indices` for full details.
+
+    Parameters
+    ----------
+    arr : array_like
+        The indices will be valid for square arrays whose dimensions are
+        the same as arr.
+    k : int, optional
+        Diagonal offset (see `tril` for details).
+
+    See Also
+    --------
+    tril_indices, tril
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "
+Module defining global singleton classes.
+
+This module raises a RuntimeError if an attempt to reload it is made. In that
+way the identities of the classes defined here are fixed and will remain so
+even if numpy itself is reloaded. In particular, a function like the following
+will still work correctly after numpy is reloaded::
+
+    def foo(arg=np._NoValue):
+        if arg is np._NoValue:
+            ...
+
+That was not the case when the singleton classes were defined in the numpy
+``__init__.py`` file. See gh-7844 for a discussion of the reload problem that
+motivated this module.
+
+"} _globals (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_globals"))))
+
+(def conj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "conj"))))
+(alter-meta! #'conj assoc :doc "conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the complex conjugate, element-wise.
+
+The complex conjugate of a complex number is obtained by changing the
+sign of its imaginary part.
+
+Parameters
+----------
+x : array_like
+    Input value.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The complex conjugate of `x`, with same dtype as `y`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+`conj` is an alias for `conjugate`:
+
+>>> np.conj is np.conjugate
+True
+
+Examples
+--------
+>>> np.conjugate(1+2j)
+(1-2j)
+
+>>> x = np.eye(2) + 1j * np.eye(2)
+>>> np.conjugate(x)
+array([[ 1.-1.j,  0.-0.j],
+       [ 0.-0.j,  1.-1.j]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def argpartition (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argpartition"))))
+(alter-meta! #'argpartition assoc :doc "
+    Perform an indirect partition along the given axis using the
+    algorithm specified by the `kind` keyword. It returns an array of
+    indices of the same shape as `a` that index data along the given
+    axis in partitioned order.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array to sort.
+    kth : int or sequence of ints
+        Element index to partition by. The k-th element will be in its
+        final sorted position and all smaller elements will be moved
+        before it and all larger elements behind it. The order all
+        elements in the partitions is undefined. If provided with a
+        sequence of k-th it will partition all of them into their sorted
+        position at once.
+    axis : int or None, optional
+        Axis along which to sort. The default is -1 (the last axis). If
+        None, the flattened array is used.
+    kind : {'introselect'}, optional
+        Selection algorithm. Default is 'introselect'
+    order : str or list of str, optional
+        When `a` is an array with fields defined, this argument
+        specifies which fields to compare first, second, etc. A single
+        field can be specified as a string, and not all fields need be
+        specified, but unspecified fields will still be used, in the
+        order in which they come up in the dtype, to break ties.
+
+    Returns
+    -------
+    index_array : ndarray, int
+        Array of indices that partition `a` along the specified axis.
+        If `a` is one-dimensional, ``a[index_array]`` yields a partitioned `a`.
+        More generally, ``np.take_along_axis(a, index_array, axis=a)`` always
+        yields the partitioned `a`, irrespective of dimensionality.
+
+    See Also
+    --------
+    partition : Describes partition algorithms used.
+    ndarray.partition : Inplace partition.
+    argsort : Full indirect sort.
+    take_along_axis : Apply ``index_array`` from argpartition 
+                      to an array as if by calling partition.
+
+    Notes
+    -----
+    See `partition` for notes on the different selection algorithms.
+
+    Examples
+    --------
+    One dimensional array:
+
+    >>> x = np.array([3, 4, 2, 1])
+    >>> x[np.argpartition(x, 3)]
+    array([2, 1, 3, 4])
+    >>> x[np.argpartition(x, (1, 3))]
+    array([1, 2, 3, 4])
+
+    >>> x = [3, 4, 2, 1]
+    >>> np.array(x)[np.argpartition(x, 3)]
+    array([2, 1, 3, 4])
+
+    Multi-dimensional array:
+
+    >>> x = np.array([[3, 4, 2], [1, 3, 1]])
+    >>> index_array = np.argpartition(x, kth=1, axis=-1)
+    >>> np.take_along_axis(x, index_array, axis=-1)  # same as np.partition(x, kth=1)
+    array([[2, 3, 4],
+           [1, 1, 3]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def show_config (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "show_config"))))
+(alter-meta! #'show_config assoc :doc "" :arglists '[[]])
+
+(def arange (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arange"))))
+(alter-meta! #'arange assoc :doc "arange([start,] stop[, step,], dtype=None)
+
+    Return evenly spaced values within a given interval.
+
+    Values are generated within the half-open interval ``[start, stop)``
+    (in other words, the interval including `start` but excluding `stop`).
+    For integer arguments the function is equivalent to the Python built-in
+    `range` function, but returns an ndarray rather than a list.
+
+    When using a non-integer step, such as 0.1, the results will often not
+    be consistent.  It is better to use `numpy.linspace` for these cases.
+
+    Parameters
+    ----------
+    start : number, optional
+        Start of interval.  The interval includes this value.  The default
+        start value is 0.
+    stop : number
+        End of interval.  The interval does not include this value, except
+        in some cases where `step` is not an integer and floating point
+        round-off affects the length of `out`.
+    step : number, optional
+        Spacing between values.  For any output `out`, this is the distance
+        between two adjacent values, ``out[i+1] - out[i]``.  The default
+        step size is 1.  If `step` is specified as a position argument,
+        `start` must also be given.
+    dtype : dtype
+        The type of the output array.  If `dtype` is not given, infer the data
+        type from the other input arguments.
+
+    Returns
+    -------
+    arange : ndarray
+        Array of evenly spaced values.
+
+        For floating point arguments, the length of the result is
+        ``ceil((stop - start)/step)``.  Because of floating point overflow,
+        this rule may result in the last element of `out` being greater
+        than `stop`.
+
+    See Also
+    --------
+    numpy.linspace : Evenly spaced numbers with careful handling of endpoints.
+    numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.
+    numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
+
+    Examples
+    --------
+    >>> np.arange(3)
+    array([0, 1, 2])
+    >>> np.arange(3.0)
+    array([ 0.,  1.,  2.])
+    >>> np.arange(3,7)
+    array([3, 4, 5, 6])
+    >>> np.arange(3,7,2)
+    array([3, 5])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def vander (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vander"))))
+(alter-meta! #'vander assoc :doc "
+    Generate a Vandermonde matrix.
+
+    The columns of the output matrix are powers of the input vector. The
+    order of the powers is determined by the `increasing` boolean argument.
+    Specifically, when `increasing` is False, the `i`-th output column is
+    the input vector raised element-wise to the power of ``N - i - 1``. Such
+    a matrix with a geometric progression in each row is named for Alexandre-
+    Theophile Vandermonde.
+
+    Parameters
+    ----------
+    x : array_like
+        1-D input array.
+    N : int, optional
+        Number of columns in the output.  If `N` is not specified, a square
+        array is returned (``N = len(x)``).
+    increasing : bool, optional
+        Order of the powers of the columns.  If True, the powers increase
+        from left to right, if False (the default) they are reversed.
+
+        .. versionadded:: 1.9.0
+
+    Returns
+    -------
+    out : ndarray
+        Vandermonde matrix.  If `increasing` is False, the first column is
+        ``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is
+        True, the columns are ``x^0, x^1, ..., x^(N-1)``.
+
+    See Also
+    --------
+    polynomial.polynomial.polyvander
+
+    Examples
+    --------
+    >>> x = np.array([1, 2, 3, 5])
+    >>> N = 3
+    >>> np.vander(x, N)
+    array([[ 1,  1,  1],
+           [ 4,  2,  1],
+           [ 9,  3,  1],
+           [25,  5,  1]])
+
+    >>> np.column_stack([x**(N-1-i) for i in range(N)])
+    array([[ 1,  1,  1],
+           [ 4,  2,  1],
+           [ 9,  3,  1],
+           [25,  5,  1]])
+
+    >>> x = np.array([1, 2, 3, 5])
+    >>> np.vander(x)
+    array([[  1,   1,   1,   1],
+           [  8,   4,   2,   1],
+           [ 27,   9,   3,   1],
+           [125,  25,   5,   1]])
+    >>> np.vander(x, increasing=True)
+    array([[  1,   1,   1,   1],
+           [  1,   2,   4,   8],
+           [  1,   3,   9,  27],
+           [  1,   5,  25, 125]])
+
+    The determinant of a square Vandermonde matrix is the product
+    of the differences between the values of the input vector:
+
+    >>> np.linalg.det(np.vander(x))
+    48.000000000000043 # may vary
+    >>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)
+    48
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def expm1 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "expm1"))))
+(alter-meta! #'expm1 assoc :doc "expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Calculate ``exp(x) - 1`` for all elements in the array.
+
+Parameters
+----------
+x : array_like
+   Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Element-wise exponential minus one: ``out = exp(x) - 1``.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+log1p : ``log(1 + x)``, the inverse of expm1.
+
+
+Notes
+-----
+This function provides greater precision than ``exp(x) - 1``
+for small values of ``x``.
+
+Examples
+--------
+The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to
+about 32 significant digits. This example shows the superiority of
+expm1 in this case.
+
+>>> np.expm1(1e-10)
+1.00000000005e-10
+>>> np.exp(1e-10) - 1
+1.000000082740371e-10" :arglists '[[self & [args {:as kwargs}]]])
+
+(def binary_repr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "binary_repr"))))
+(alter-meta! #'binary_repr assoc :doc "
+    Return the binary representation of the input number as a string.
+
+    For negative numbers, if width is not given, a minus sign is added to the
+    front. If width is given, the two's complement of the number is
+    returned, with respect to that width.
+
+    In a two's-complement system negative numbers are represented by the two's
+    complement of the absolute value. This is the most common method of
+    representing signed integers on computers [1]_. A N-bit two's-complement
+    system can represent every integer in the range
+    :math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
+
+    Parameters
+    ----------
+    num : int
+        Only an integer decimal number can be used.
+    width : int, optional
+        The length of the returned string if `num` is positive, or the length
+        of the two's complement if `num` is negative, provided that `width` is
+        at least a sufficient number of bits for `num` to be represented in the
+        designated form.
+
+        If the `width` value is insufficient, it will be ignored, and `num` will
+        be returned in binary (`num` > 0) or two's complement (`num` < 0) form
+        with its width equal to the minimum number of bits needed to represent
+        the number in the designated form. This behavior is deprecated and will
+        later raise an error.
+
+        .. deprecated:: 1.12.0
+
+    Returns
+    -------
+    bin : str
+        Binary representation of `num` or two's complement of `num`.
+
+    See Also
+    --------
+    base_repr: Return a string representation of a number in the given base
+               system.
+    bin: Python's built-in binary representation generator of an integer.
+
+    Notes
+    -----
+    `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x
+    faster.
+
+    References
+    ----------
+    .. [1] Wikipedia, \"Two's complement\",
+        https://en.wikipedia.org/wiki/Two's_complement
+
+    Examples
+    --------
+    >>> np.binary_repr(3)
+    '11'
+    >>> np.binary_repr(-3)
+    '-11'
+    >>> np.binary_repr(3, width=4)
+    '0011'
+
+    The two's complement is returned when the input number is negative and
+    width is specified:
+
+    >>> np.binary_repr(-3, width=3)
+    '101'
+    >>> np.binary_repr(-3, width=5)
+    '11101'
+
+    " :arglists '[[num & [{width :width}]] [num]])
+
+(def double (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "double"))))
+(alter-meta! #'double assoc :doc "Double-precision floating-point number type, compatible with Python `float`
+    and C ``double``.
+    Character code: ``'d'``.
+    Canonical name: ``np.double``.
+    Alias: ``np.float_``.
+    Alias *on this platform*: ``np.float64``: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
+
+(def vstack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vstack"))))
+(alter-meta! #'vstack assoc :doc "
+    Stack arrays in sequence vertically (row wise).
+
+    This is equivalent to concatenation along the first axis after 1-D arrays
+    of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
+    `vsplit`.
+
+    This function makes most sense for arrays with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of ndarrays
+        The arrays must have the same shape along all but the first axis.
+        1-D arrays must have the same length.
+
+    Returns
+    -------
+    stacked : ndarray
+        The array formed by stacking the given arrays, will be at least 2-D.
+
+    See Also
+    --------
+    stack : Join a sequence of arrays along a new axis.
+    hstack : Stack arrays in sequence horizontally (column wise).
+    dstack : Stack arrays in sequence depth wise (along third dimension).
+    concatenate : Join a sequence of arrays along an existing axis.
+    vsplit : Split array into a list of multiple sub-arrays vertically.
+    block : Assemble arrays from blocks.
+
+    Examples
+    --------
+    >>> a = np.array([1, 2, 3])
+    >>> b = np.array([2, 3, 4])
+    >>> np.vstack((a,b))
+    array([[1, 2, 3],
+           [2, 3, 4]])
+
+    >>> a = np.array([[1], [2], [3]])
+    >>> b = np.array([[2], [3], [4]])
+    >>> np.vstack((a,b))
+    array([[1],
+           [2],
+           [3],
+           [2],
+           [3],
+           [4]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} version (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "version"))))
+
+(def argwhere (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argwhere"))))
+(alter-meta! #'argwhere assoc :doc "
+    Find the indices of array elements that are non-zero, grouped by element.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+
+    Returns
+    -------
+    index_array : (N, a.ndim) ndarray
+        Indices of elements that are non-zero. Indices are grouped by element.
+        This array will have shape ``(N, a.ndim)`` where ``N`` is the number of
+        non-zero items.
+
+    See Also
+    --------
+    where, nonzero
+
+    Notes
+    -----
+    ``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``,
+    but produces a result of the correct shape for a 0D array.
+
+    The output of ``argwhere`` is not suitable for indexing arrays.
+    For this purpose use ``nonzero(a)`` instead.
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2,3)
+    >>> x
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.argwhere(x>1)
+    array([[0, 2],
+           [1, 0],
+           [1, 1],
+           [1, 2]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def iterable (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iterable"))))
+(alter-meta! #'iterable assoc :doc "
+    Check whether or not an object can be iterated over.
+
+    Parameters
+    ----------
+    y : object
+      Input object.
+
+    Returns
+    -------
+    b : bool
+      Return ``True`` if the object has an iterator method or is a
+      sequence and ``False`` otherwise.
+
+
+    Examples
+    --------
+    >>> np.iterable([1, 2, 3])
+    True
+    >>> np.iterable(2)
+    False
+
+    " :arglists '[[y]])
+
+(def _add_newdoc_ufunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "_add_newdoc_ufunc"))))
+(alter-meta! #'_add_newdoc_ufunc assoc :doc "add_ufunc_docstring(ufunc, new_docstring)
+
+    Replace the docstring for a ufunc with new_docstring.
+    This method will only work if the current docstring for
+    the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)
+
+    Parameters
+    ----------
+    ufunc : numpy.ufunc
+        A ufunc whose current doc is NULL.
+    new_docstring : string
+        The new docstring for the ufunc.
+
+    Notes
+    -----
+    This method allocates memory for new_docstring on
+    the heap. Technically this creates a mempory leak, since this
+    memory will not be reclaimed until the end of the program
+    even if the ufunc itself is removed. However this will only
+    be a problem if the user is repeatedly creating ufuncs with
+    no documentation, adding documentation via add_newdoc_ufunc,
+    and then throwing away the ufunc." :arglists '[[self & [args {:as kwargs}]]])
+
+(def append (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "append"))))
+(alter-meta! #'append assoc :doc "
+    Append values to the end of an array.
+
+    Parameters
+    ----------
+    arr : array_like
+        Values are appended to a copy of this array.
+    values : array_like
+        These values are appended to a copy of `arr`.  It must be of the
+        correct shape (the same shape as `arr`, excluding `axis`).  If
+        `axis` is not specified, `values` can be any shape and will be
+        flattened before use.
+    axis : int, optional
+        The axis along which `values` are appended.  If `axis` is not
+        given, both `arr` and `values` are flattened before use.
+
+    Returns
+    -------
+    append : ndarray
+        A copy of `arr` with `values` appended to `axis`.  Note that
+        `append` does not occur in-place: a new array is allocated and
+        filled.  If `axis` is None, `out` is a flattened array.
+
+    See Also
+    --------
+    insert : Insert elements into an array.
+    delete : Delete elements from an array.
+
+    Examples
+    --------
+    >>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]])
+    array([1, 2, 3, ..., 7, 8, 9])
+
+    When `axis` is specified, `values` must have the correct shape.
+
+    >>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)
+    array([[1, 2, 3],
+           [4, 5, 6],
+           [7, 8, 9]])
+    >>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)
+    Traceback (most recent call last):
+        ...
+    ValueError: all the input arrays must have same number of dimensions
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def iinfo (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iinfo"))))
+(alter-meta! #'iinfo assoc :doc "
+    iinfo(type)
+
+    Machine limits for integer types.
+
+    Attributes
+    ----------
+    bits : int
+        The number of bits occupied by the type.
+    min : int
+        The smallest integer expressible by the type.
+    max : int
+        The largest integer expressible by the type.
+
+    Parameters
+    ----------
+    int_type : integer type, dtype, or instance
+        The kind of integer data type to get information about.
+
+    See Also
+    --------
+    finfo : The equivalent for floating point data types.
+
+    Examples
+    --------
+    With types:
+
+    >>> ii16 = np.iinfo(np.int16)
+    >>> ii16.min
+    -32768
+    >>> ii16.max
+    32767
+    >>> ii32 = np.iinfo(np.int32)
+    >>> ii32.min
+    -2147483648
+    >>> ii32.max
+    2147483647
+
+    With instances:
+
+    >>> ii32 = np.iinfo(np.int32(10))
+    >>> ii32.min
+    -2147483648
+    >>> ii32.max
+    2147483647
+
+    " :arglists '[[self int_type]])
+
+(def ones_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ones_like"))))
+(alter-meta! #'ones_like assoc :doc "
+    Return an array of ones with the same shape and type as a given array.
+
+    Parameters
+    ----------
+    a : array_like
+        The shape and data-type of `a` define these same attributes of
+        the returned array.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+
+        .. versionadded:: 1.6.0
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible.
+
+        .. versionadded:: 1.6.0
+    subok : bool, optional.
+        If True, then the newly created array will use the sub-class
+        type of 'a', otherwise it will be a base-class array. Defaults
+        to True.
+    shape : int or sequence of ints, optional.
+        Overrides the shape of the result. If order='K' and the number of
+        dimensions is unchanged, will try to keep order, otherwise,
+        order='C' is implied.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of ones with the same shape and type as `a`.
+
+    See Also
+    --------
+    empty_like : Return an empty array with shape and type of input.
+    zeros_like : Return an array of zeros with shape and type of input.
+    full_like : Return a new array with shape of input filled with value.
+    ones : Return a new array setting values to one.
+
+    Examples
+    --------
+    >>> x = np.arange(6)
+    >>> x = x.reshape((2, 3))
+    >>> x
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.ones_like(x)
+    array([[1, 1, 1],
+           [1, 1, 1]])
+
+    >>> y = np.arange(3, dtype=float)
+    >>> y
+    array([0., 1., 2.])
+    >>> np.ones_like(y)
+    array([1.,  1.,  1.])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def full_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "full_like"))))
+(alter-meta! #'full_like assoc :doc "
+    Return a full array with the same shape and type as a given array.
+
+    Parameters
+    ----------
+    a : array_like
+        The shape and data-type of `a` define these same attributes of
+        the returned array.
+    fill_value : scalar
+        Fill value.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible.
+    subok : bool, optional.
+        If True, then the newly created array will use the sub-class
+        type of 'a', otherwise it will be a base-class array. Defaults
+        to True.
+    shape : int or sequence of ints, optional.
+        Overrides the shape of the result. If order='K' and the number of
+        dimensions is unchanged, will try to keep order, otherwise,
+        order='C' is implied.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of `fill_value` with the same shape and type as `a`.
+
+    See Also
+    --------
+    empty_like : Return an empty array with shape and type of input.
+    ones_like : Return an array of ones with shape and type of input.
+    zeros_like : Return an array of zeros with shape and type of input.
+    full : Return a new array of given shape filled with value.
+
+    Examples
+    --------
+    >>> x = np.arange(6, dtype=int)
+    >>> np.full_like(x, 1)
+    array([1, 1, 1, 1, 1, 1])
+    >>> np.full_like(x, 0.1)
+    array([0, 0, 0, 0, 0, 0])
+    >>> np.full_like(x, 0.1, dtype=np.double)
+    array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
+    >>> np.full_like(x, np.nan, dtype=np.double)
+    array([nan, nan, nan, nan, nan, nan])
+
+    >>> y = np.arange(6, dtype=np.double)
+    >>> np.full_like(y, 0.1)
+    array([0.1,  0.1,  0.1,  0.1,  0.1,  0.1])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def atleast_1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "atleast_1d"))))
+(alter-meta! #'atleast_1d assoc :doc "
+    Convert inputs to arrays with at least one dimension.
+
+    Scalar inputs are converted to 1-dimensional arrays, whilst
+    higher-dimensional inputs are preserved.
+
+    Parameters
+    ----------
+    arys1, arys2, ... : array_like
+        One or more input arrays.
+
+    Returns
+    -------
+    ret : ndarray
+        An array, or list of arrays, each with ``a.ndim >= 1``.
+        Copies are made only if necessary.
+
+    See Also
+    --------
+    atleast_2d, atleast_3d
+
+    Examples
+    --------
+    >>> np.atleast_1d(1.0)
+    array([1.])
+
+    >>> x = np.arange(9.0).reshape(3,3)
+    >>> np.atleast_1d(x)
+    array([[0., 1., 2.],
+           [3., 4., 5.],
+           [6., 7., 8.]])
+    >>> np.atleast_1d(x) is x
+    True
+
+    >>> np.atleast_1d(1, [3, 4])
+    [array([1]), array([3, 4])]
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} SHIFT_UNDERFLOW (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "SHIFT_UNDERFLOW"))))
+
+(def asanyarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asanyarray"))))
+(alter-meta! #'asanyarray assoc :doc "Convert the input to an ndarray, but pass ndarray subclasses through.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data, in any form that can be converted to an array.  This
+        includes scalars, lists, lists of tuples, tuples, tuples of tuples,
+        tuples of lists, and ndarrays.
+    dtype : data-type, optional
+        By default, the data-type is inferred from the input data.
+    order : {'C', 'F'}, optional
+        Whether to use row-major (C-style) or column-major
+        (Fortran-style) memory representation.  Defaults to 'C'.
+
+    Returns
+    -------
+    out : ndarray or an ndarray subclass
+        Array interpretation of `a`.  If `a` is an ndarray or a subclass
+        of ndarray, it is returned as-is and no copy is performed.
+
+    See Also
+    --------
+    asarray : Similar function which always returns ndarrays.
+    ascontiguousarray : Convert input to a contiguous array.
+    asfarray : Convert input to a floating point ndarray.
+    asfortranarray : Convert input to an ndarray with column-major
+                     memory order.
+    asarray_chkfinite : Similar function which checks input for NaNs and
+                        Infs.
+    fromiter : Create an array from an iterator.
+    fromfunction : Construct an array by executing a function on grid
+                   positions.
+
+    Examples
+    --------
+    Convert a list into an array:
+
+    >>> a = [1, 2]
+    >>> np.asanyarray(a)
+    array([1, 2])
+
+    Instances of `ndarray` subclasses are passed through as-is:
+
+    >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
+    >>> np.asanyarray(a) is a
+    True
+
+    " :arglists '[[a & [{dtype :dtype, order :order}]] [a & [{dtype :dtype}]] [a]])
+
+(def lookfor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "lookfor"))))
+(alter-meta! #'lookfor assoc :doc "
+    Do a keyword search on docstrings.
+
+    A list of objects that matched the search is displayed,
+    sorted by relevance. All given keywords need to be found in the
+    docstring for it to be returned as a result, but the order does
+    not matter.
+
+    Parameters
+    ----------
+    what : str
+        String containing words to look for.
+    module : str or list, optional
+        Name of module(s) whose docstrings to go through.
+    import_modules : bool, optional
+        Whether to import sub-modules in packages. Default is True.
+    regenerate : bool, optional
+        Whether to re-generate the docstring cache. Default is False.
+    output : file-like, optional
+        File-like object to write the output to. If omitted, use a pager.
+
+    See Also
+    --------
+    source, info
+
+    Notes
+    -----
+    Relevance is determined only roughly, by checking if the keywords occur
+    in the function name, at the start of a docstring, etc.
+
+    Examples
+    --------
+    >>> np.lookfor('binary representation') # doctest: +SKIP
+    Search results for 'binary representation'
+    ------------------------------------------
+    numpy.binary_repr
+        Return the binary representation of the input number as a string.
+    numpy.core.setup_common.long_double_representation
+        Given a binary dump as given by GNU od -b, look for long double
+    numpy.base_repr
+        Return a string representation of a number in the given base system.
+    ...
+
+    " :arglists '[[what & [{module :module, import_modules :import_modules, regenerate :regenerate, output :output}]] [what & [{module :module, import_modules :import_modules, regenerate :regenerate}]] [what & [{module :module, import_modules :import_modules}]] [what & [{module :module}]] [what]])
+
+(def divide (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "divide"))))
+(alter-meta! #'divide assoc :doc "true_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns a true division of the inputs, element-wise.
+
+Instead of the Python traditional 'floor division', this returns a true
+division.  True division adjusts the output type to present the best
+answer, regardless of input types.
+
+Parameters
+----------
+x1 : array_like
+    Dividend array.
+x2 : array_like
+    Divisor array. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+The floor division operator ``//`` was added in Python 2.2 making
+``//`` and ``/`` equivalent operators.  The default floor division
+operation of ``/`` can be replaced by true division with ``from
+__future__ import division``.
+
+In Python 3.0, ``//`` is the floor division operator and ``/`` the
+true division operator.  The ``true_divide(x1, x2)`` function is
+equivalent to true division in Python.
+
+Examples
+--------
+>>> x = np.arange(5)
+>>> np.true_divide(x, 4)
+array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
+
+>>> x//4
+array([0, 0, 0, 0, 1])
+
+>>> from __future__ import division
+>>> x/4
+array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
+>>> x//4
+array([0, 0, 0, 0, 1])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def trim_zeros (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trim_zeros"))))
+(alter-meta! #'trim_zeros assoc :doc "
+    Trim the leading and/or trailing zeros from a 1-D array or sequence.
+
+    Parameters
+    ----------
+    filt : 1-D array or sequence
+        Input array.
+    trim : str, optional
+        A string with 'f' representing trim from front and 'b' to trim from
+        back. Default is 'fb', trim zeros from both front and back of the
+        array.
+
+    Returns
+    -------
+    trimmed : 1-D array or sequence
+        The result of trimming the input. The input data type is preserved.
+
+    Examples
+    --------
+    >>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0))
+    >>> np.trim_zeros(a)
+    array([1, 2, 3, 0, 2, 1])
+
+    >>> np.trim_zeros(a, 'b')
+    array([0, 0, 0, ..., 0, 2, 1])
+
+    The input data type is preserved, list/tuple in means list/tuple out.
+
+    >>> np.trim_zeros([0, 1, 2, 0])
+    [1, 2]
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def insert (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "insert"))))
+(alter-meta! #'insert assoc :doc "
+    Insert values along the given axis before the given indices.
+
+    Parameters
+    ----------
+    arr : array_like
+        Input array.
+    obj : int, slice or sequence of ints
+        Object that defines the index or indices before which `values` is
+        inserted.
+
+        .. versionadded:: 1.8.0
+
+        Support for multiple insertions when `obj` is a single scalar or a
+        sequence with one element (similar to calling insert multiple
+        times).
+    values : array_like
+        Values to insert into `arr`. If the type of `values` is different
+        from that of `arr`, `values` is converted to the type of `arr`.
+        `values` should be shaped so that ``arr[...,obj,...] = values``
+        is legal.
+    axis : int, optional
+        Axis along which to insert `values`.  If `axis` is None then `arr`
+        is flattened first.
+
+    Returns
+    -------
+    out : ndarray
+        A copy of `arr` with `values` inserted.  Note that `insert`
+        does not occur in-place: a new array is returned. If
+        `axis` is None, `out` is a flattened array.
+
+    See Also
+    --------
+    append : Append elements at the end of an array.
+    concatenate : Join a sequence of arrays along an existing axis.
+    delete : Delete elements from an array.
+
+    Notes
+    -----
+    Note that for higher dimensional inserts `obj=0` behaves very different
+    from `obj=[0]` just like `arr[:,0,:] = values` is different from
+    `arr[:,[0],:] = values`.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 1], [2, 2], [3, 3]])
+    >>> a
+    array([[1, 1],
+           [2, 2],
+           [3, 3]])
+    >>> np.insert(a, 1, 5)
+    array([1, 5, 1, ..., 2, 3, 3])
+    >>> np.insert(a, 1, 5, axis=1)
+    array([[1, 5, 1],
+           [2, 5, 2],
+           [3, 5, 3]])
+
+    Difference between sequence and scalars:
+
+    >>> np.insert(a, [1], [[1],[2],[3]], axis=1)
+    array([[1, 1, 1],
+           [2, 2, 2],
+           [3, 3, 3]])
+    >>> np.array_equal(np.insert(a, 1, [1, 2, 3], axis=1),
+    ...                np.insert(a, [1], [[1],[2],[3]], axis=1))
+    True
+
+    >>> b = a.flatten()
+    >>> b
+    array([1, 1, 2, 2, 3, 3])
+    >>> np.insert(b, [2, 2], [5, 6])
+    array([1, 1, 5, ..., 2, 3, 3])
+
+    >>> np.insert(b, slice(2, 4), [5, 6])
+    array([1, 1, 5, ..., 2, 3, 3])
+
+    >>> np.insert(b, [2, 2], [7.13, False]) # type casting
+    array([1, 1, 7, ..., 2, 3, 3])
+
+    >>> x = np.arange(8).reshape(2, 4)
+    >>> idx = (1, 3)
+    >>> np.insert(x, idx, 999, axis=1)
+    array([[  0, 999,   1,   2, 999,   3],
+           [  4, 999,   5,   6, 999,   7]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} __version__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__version__"))))
+
+(def compare_chararrays (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "compare_chararrays"))))
+(alter-meta! #'compare_chararrays assoc :doc "compare_chararrays(a, b, cmp_op, rstrip)
+
+    Performs element-wise comparison of two string arrays using the
+    comparison operator specified by `cmp_op`.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Arrays to be compared.
+    cmp_op : {\"<\", \"<=\", \"==\", \">=\", \">\", \"!=\"}
+        Type of comparison.
+    rstrip : Boolean
+        If True, the spaces at the end of Strings are removed before the comparison.
+
+    Returns
+    -------
+    out : ndarray
+        The output array of type Boolean with the same shape as a and b.
+
+    Raises
+    ------
+    ValueError
+        If `cmp_op` is not valid.
+    TypeError
+        If at least one of `a` or `b` is a non-string array
+
+    Examples
+    --------
+    >>> a = np.array([\"a\", \"b\", \"cde\"])
+    >>> b = np.array([\"a\", \"a\", \"dec\"])
+    >>> np.compare_chararrays(a, b, \">\", True)
+    array([False,  True, False])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} __git_revision__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__git_revision__"))))
+
+(def array_repr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_repr"))))
+(alter-meta! #'array_repr assoc :doc "
+    Return the string representation of an array.
+
+    Parameters
+    ----------
+    arr : ndarray
+        Input array.
+    max_line_width : int, optional
+        Inserts newlines if text is longer than `max_line_width`.
+        Defaults to ``numpy.get_printoptions()['linewidth']``.
+    precision : int, optional
+        Floating point precision.
+        Defaults to ``numpy.get_printoptions()['precision']``.
+    suppress_small : bool, optional
+        Represent numbers \"very close\" to zero as zero; default is False.
+        Very close is defined by precision: if the precision is 8, e.g.,
+        numbers smaller (in absolute value) than 5e-9 are represented as
+        zero.
+        Defaults to ``numpy.get_printoptions()['suppress']``.
+
+    Returns
+    -------
+    string : str
+      The string representation of an array.
+
+    See Also
+    --------
+    array_str, array2string, set_printoptions
+
+    Examples
+    --------
+    >>> np.array_repr(np.array([1,2]))
+    'array([1, 2])'
+    >>> np.array_repr(np.ma.array([0.]))
+    'MaskedArray([0.])'
+    >>> np.array_repr(np.array([], np.int32))
+    'array([], dtype=int32)'
+
+    >>> x = np.array([1e-6, 4e-7, 2, 3])
+    >>> np.array_repr(x, precision=6, suppress_small=True)
+    'array([0.000001,  0.      ,  2.      ,  3.      ])'
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def issubsctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issubsctype"))))
+(alter-meta! #'issubsctype assoc :doc "
+    Determine if the first argument is a subclass of the second argument.
+
+    Parameters
+    ----------
+    arg1, arg2 : dtype or dtype specifier
+        Data-types.
+
+    Returns
+    -------
+    out : bool
+        The result.
+
+    See Also
+    --------
+    issctype, issubdtype, obj2sctype
+
+    Examples
+    --------
+    >>> np.issubsctype('S8', str)
+    False
+    >>> np.issubsctype(np.array([1]), int)
+    True
+    >>> np.issubsctype(np.array([1]), float)
+    False
+
+    " :arglists '[[arg1 arg2]])
+
+(def ^{:doc ""} PINF (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "PINF"))))
+(def ^{:doc "Built-in immutable sequence.
+
+If no argument is given, the constructor returns an empty tuple.
+If iterable is specified the tuple is initialized from iterable's items.
+
+If the argument is a tuple, the return value is the same object."} ScalarType (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* "ScalarType")))) 
+
+(def dstack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dstack"))))
+(alter-meta! #'dstack assoc :doc "
+    Stack arrays in sequence depth wise (along third axis).
+
+    This is equivalent to concatenation along the third axis after 2-D arrays
+    of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape
+    `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by
+    `dsplit`.
+
+    This function makes most sense for arrays with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of arrays
+        The arrays must have the same shape along all but the third axis.
+        1-D or 2-D arrays must have the same shape.
+
+    Returns
+    -------
+    stacked : ndarray
+        The array formed by stacking the given arrays, will be at least 3-D.
+
+    See Also
+    --------
+    stack : Join a sequence of arrays along a new axis.
+    vstack : Stack along first axis.
+    hstack : Stack along second axis.
+    concatenate : Join a sequence of arrays along an existing axis.
+    dsplit : Split array along third axis.
+
+    Examples
+    --------
+    >>> a = np.array((1,2,3))
+    >>> b = np.array((2,3,4))
+    >>> np.dstack((a,b))
+    array([[[1, 2],
+            [2, 3],
+            [3, 4]]])
+
+    >>> a = np.array([[1],[2],[3]])
+    >>> b = np.array([[2],[3],[4]])
+    >>> np.dstack((a,b))
+    array([[[1, 2]],
+           [[2, 3]],
+           [[3, 4]]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "
+    `nd_grid` instance which returns an open multi-dimensional \"meshgrid\".
+
+    An instance of `numpy.lib.index_tricks.nd_grid` which returns an open
+    (i.e. not fleshed out) mesh-grid when indexed, so that only one dimension
+    of each returned array is greater than 1.  The dimension and number of the
+    output arrays are equal to the number of indexing dimensions.  If the step
+    length is not a complex number, then the stop is not inclusive.
+
+    However, if the step length is a **complex number** (e.g. 5j), then
+    the integer part of its magnitude is interpreted as specifying the
+    number of points to create between the start and stop values, where
+    the stop value **is inclusive**.
+
+    Returns
+    -------
+    mesh-grid
+        `ndarrays` with only one dimension not equal to 1
+
+    See Also
+    --------
+    np.lib.index_tricks.nd_grid : class of `ogrid` and `mgrid` objects
+    mgrid : like `ogrid` but returns dense (or fleshed out) mesh grids
+    r_ : array concatenator
+
+    Examples
+    --------
+    >>> from numpy import ogrid
+    >>> ogrid[-1:1:5j]
+    array([-1. , -0.5,  0. ,  0.5,  1. ])
+    >>> ogrid[0:5,0:5]
+    [array([[0],
+            [1],
+            [2],
+            [3],
+            [4]]), array([[0, 1, 2, 3, 4]])]
+
+    "} ogrid (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ogrid"))))
+
+(def isposinf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isposinf"))))
+(alter-meta! #'isposinf assoc :doc "
+    Test element-wise for positive infinity, return result as bool array.
+
+    Parameters
+    ----------
+    x : array_like
+        The input array.
+    y : array_like, optional
+        A boolean array with the same shape as `x` to store the result.
+
+    Returns
+    -------
+    out : ndarray
+        A boolean array with the same dimensions as the input.
+        If second argument is not supplied then a boolean array is returned
+        with values True where the corresponding element of the input is
+        positive infinity and values False where the element of the input is
+        not positive infinity.
+
+        If a second argument is supplied the result is stored there. If the
+        type of that array is a numeric type the result is represented as zeros
+        and ones, if the type is boolean then as False and True.
+        The return value `out` is then a reference to that array.
+
+    See Also
+    --------
+    isinf, isneginf, isfinite, isnan
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754).
+
+    Errors result if the second argument is also supplied when x is a scalar
+    input, if first and second arguments have different shapes, or if the
+    first argument has complex values
+
+    Examples
+    --------
+    >>> np.isposinf(np.PINF)
+    True
+    >>> np.isposinf(np.inf)
+    True
+    >>> np.isposinf(np.NINF)
+    False
+    >>> np.isposinf([-np.inf, 0., np.inf])
+    array([False, False,  True])
+
+    >>> x = np.array([-np.inf, 0., np.inf])
+    >>> y = np.array([2, 2, 2])
+    >>> np.isposinf(x, y)
+    array([0, 0, 1])
+    >>> y
+    array([0, 0, 1])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def exp2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "exp2"))))
+(alter-meta! #'exp2 assoc :doc "exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Calculate `2**p` for all `p` in the input array.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Element-wise 2 to the power `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+power
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+
+
+Examples
+--------
+>>> np.exp2([2, 3])
+array([ 4.,  8.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def roll (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "roll"))))
+(alter-meta! #'roll assoc :doc "
+    Roll array elements along a given axis.
+
+    Elements that roll beyond the last position are re-introduced at
+    the first.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    shift : int or tuple of ints
+        The number of places by which elements are shifted.  If a tuple,
+        then `axis` must be a tuple of the same size, and each of the
+        given axes is shifted by the corresponding number.  If an int
+        while `axis` is a tuple of ints, then the same value is used for
+        all given axes.
+    axis : int or tuple of ints, optional
+        Axis or axes along which elements are shifted.  By default, the
+        array is flattened before shifting, after which the original
+        shape is restored.
+
+    Returns
+    -------
+    res : ndarray
+        Output array, with the same shape as `a`.
+
+    See Also
+    --------
+    rollaxis : Roll the specified axis backwards, until it lies in a
+               given position.
+
+    Notes
+    -----
+    .. versionadded:: 1.12.0
+
+    Supports rolling over multiple dimensions simultaneously.
+
+    Examples
+    --------
+    >>> x = np.arange(10)
+    >>> np.roll(x, 2)
+    array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
+    >>> np.roll(x, -2)
+    array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])
+
+    >>> x2 = np.reshape(x, (2,5))
+    >>> x2
+    array([[0, 1, 2, 3, 4],
+           [5, 6, 7, 8, 9]])
+    >>> np.roll(x2, 1)
+    array([[9, 0, 1, 2, 3],
+           [4, 5, 6, 7, 8]])
+    >>> np.roll(x2, -1)
+    array([[1, 2, 3, 4, 5],
+           [6, 7, 8, 9, 0]])
+    >>> np.roll(x2, 1, axis=0)
+    array([[5, 6, 7, 8, 9],
+           [0, 1, 2, 3, 4]])
+    >>> np.roll(x2, -1, axis=0)
+    array([[5, 6, 7, 8, 9],
+           [0, 1, 2, 3, 4]])
+    >>> np.roll(x2, 1, axis=1)
+    array([[4, 0, 1, 2, 3],
+           [9, 5, 6, 7, 8]])
+    >>> np.roll(x2, -1, axis=1)
+    array([[1, 2, 3, 4, 0],
+           [6, 7, 8, 9, 5]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} WRAP (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "WRAP"))))
+
+(def asarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asarray"))))
+(alter-meta! #'asarray assoc :doc "Convert the input to an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data, in any form that can be converted to an array.  This
+        includes lists, lists of tuples, tuples, tuples of tuples, tuples
+        of lists and ndarrays.
+    dtype : data-type, optional
+        By default, the data-type is inferred from the input data.
+    order : {'C', 'F'}, optional
+        Whether to use row-major (C-style) or
+        column-major (Fortran-style) memory representation.
+        Defaults to 'C'.
+
+    Returns
+    -------
+    out : ndarray
+        Array interpretation of `a`.  No copy is performed if the input
+        is already an ndarray with matching dtype and order.  If `a` is a
+        subclass of ndarray, a base class ndarray is returned.
+
+    See Also
+    --------
+    asanyarray : Similar function which passes through subclasses.
+    ascontiguousarray : Convert input to a contiguous array.
+    asfarray : Convert input to a floating point ndarray.
+    asfortranarray : Convert input to an ndarray with column-major
+                     memory order.
+    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
+    fromiter : Create an array from an iterator.
+    fromfunction : Construct an array by executing a function on grid
+                   positions.
+
+    Examples
+    --------
+    Convert a list into an array:
+
+    >>> a = [1, 2]
+    >>> np.asarray(a)
+    array([1, 2])
+
+    Existing arrays are not copied:
+
+    >>> a = np.array([1, 2])
+    >>> np.asarray(a) is a
+    True
+
+    If `dtype` is set, array is copied only if dtype does not match:
+
+    >>> a = np.array([1, 2], dtype=np.float32)
+    >>> np.asarray(a, dtype=np.float32) is a
+    True
+    >>> np.asarray(a, dtype=np.float64) is a
+    False
+
+    Contrary to `asanyarray`, ndarray subclasses are not passed through:
+
+    >>> issubclass(np.recarray, np.ndarray)
+    True
+    >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
+    >>> np.asarray(a) is a
+    False
+    >>> np.asanyarray(a) is a
+    True
+
+    " :arglists '[[a & [{dtype :dtype, order :order}]] [a & [{dtype :dtype}]] [a]])
+
+(def fastCopyAndTranspose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fastCopyAndTranspose"))))
+(alter-meta! #'fastCopyAndTranspose assoc :doc "_fastCopyAndTranspose(a)" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} oldnumeric (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "oldnumeric"))))
+
+(def isclose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isclose"))))
+(alter-meta! #'isclose assoc :doc "
+    Returns a boolean array where two arrays are element-wise equal within a
+    tolerance.
+
+    The tolerance values are positive, typically very small numbers.  The
+    relative difference (`rtol` * abs(`b`)) and the absolute difference
+    `atol` are added together to compare against the absolute difference
+    between `a` and `b`.
+
+    .. warning:: The default `atol` is not appropriate for comparing numbers
+                 that are much smaller than one (see Notes).
+
+    Parameters
+    ----------
+    a, b : array_like
+        Input arrays to compare.
+    rtol : float
+        The relative tolerance parameter (see Notes).
+    atol : float
+        The absolute tolerance parameter (see Notes).
+    equal_nan : bool
+        Whether to compare NaN's as equal.  If True, NaN's in `a` will be
+        considered equal to NaN's in `b` in the output array.
+
+    Returns
+    -------
+    y : array_like
+        Returns a boolean array of where `a` and `b` are equal within the
+        given tolerance. If both `a` and `b` are scalars, returns a single
+        boolean value.
+
+    See Also
+    --------
+    allclose
+
+    Notes
+    -----
+    .. versionadded:: 1.7.0
+
+    For finite values, isclose uses the following equation to test whether
+    two floating point values are equivalent.
+
+     absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
+
+    Unlike the built-in `math.isclose`, the above equation is not symmetric
+    in `a` and `b` -- it assumes `b` is the reference value -- so that
+    `isclose(a, b)` might be different from `isclose(b, a)`. Furthermore,
+    the default value of atol is not zero, and is used to determine what
+    small values should be considered close to zero. The default value is
+    appropriate for expected values of order unity: if the expected values
+    are significantly smaller than one, it can result in false positives.
+    `atol` should be carefully selected for the use case at hand. A zero value
+    for `atol` will result in `False` if either `a` or `b` is zero.
+
+    Examples
+    --------
+    >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
+    array([ True, False])
+    >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
+    array([ True, True])
+    >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
+    array([False,  True])
+    >>> np.isclose([1.0, np.nan], [1.0, np.nan])
+    array([ True, False])
+    >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
+    array([ True, True])
+    >>> np.isclose([1e-8, 1e-7], [0.0, 0.0])
+    array([ True, False])
+    >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)
+    array([False, False])
+    >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0])
+    array([ True,  True])
+    >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0)
+    array([False,  True])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def bitwise_not (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_not"))))
+(alter-meta! #'bitwise_not assoc :doc "invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute bit-wise inversion, or bit-wise NOT, element-wise.
+
+Computes the bit-wise NOT of the underlying binary representation of
+the integers in the input arrays. This ufunc implements the C/Python
+operator ``~``.
+
+For signed integer inputs, the two's complement is returned.  In a
+two's-complement system negative numbers are represented by the two's
+complement of the absolute value. This is the most common method of
+representing signed integers on computers [1]_. A N-bit
+two's-complement system can represent every integer in the range
+:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
+
+Parameters
+----------
+x : array_like
+    Only integer and boolean types are handled.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Result.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+bitwise_and, bitwise_or, bitwise_xor
+logical_not
+binary_repr :
+    Return the binary representation of the input number as a string.
+
+Notes
+-----
+`bitwise_not` is an alias for `invert`:
+
+>>> np.bitwise_not is np.invert
+True
+
+References
+----------
+.. [1] Wikipedia, \"Two's complement\",
+    https://en.wikipedia.org/wiki/Two's_complement
+
+Examples
+--------
+We've seen that 13 is represented by ``00001101``.
+The invert or bit-wise NOT of 13 is then:
+
+>>> x = np.invert(np.array(13, dtype=np.uint8))
+>>> x
+242
+>>> np.binary_repr(x, width=8)
+'11110010'
+
+The result depends on the bit-width:
+
+>>> x = np.invert(np.array(13, dtype=np.uint16))
+>>> x
+65522
+>>> np.binary_repr(x, width=16)
+'1111111111110010'
+
+When using signed integer types the result is the two's complement of
+the result for the unsigned type:
+
+>>> np.invert(np.array([13], dtype=np.int8))
+array([-14], dtype=int8)
+>>> np.binary_repr(-14, width=8)
+'11110010'
+
+Booleans are accepted as well:
+
+>>> np.invert(np.array([True, False]))
+array([False,  True])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def int0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int0"))))
+(alter-meta! #'int0 assoc :doc "Signed integer type, compatible with Python `int` anc C ``long``.
+    Character code: ``'l'``.
+    Canonical name: ``np.int_``.
+    Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807).
+    Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ldexp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ldexp"))))
+(alter-meta! #'ldexp assoc :doc "ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns x1 * 2**x2, element-wise.
+
+The mantissas `x1` and twos exponents `x2` are used to construct
+floating point numbers ``x1 * 2**x2``.
+
+Parameters
+----------
+x1 : array_like
+    Array of multipliers.
+x2 : array_like, int
+    Array of twos exponents. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The result of ``x1 * 2**x2``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`.
+
+Notes
+-----
+Complex dtypes are not supported, they will raise a TypeError.
+
+`ldexp` is useful as the inverse of `frexp`, if used by itself it is
+more clear to simply use the expression ``x1 * 2**x2``.
+
+Examples
+--------
+>>> np.ldexp(5, np.arange(4))
+array([ 5., 10., 20., 40.], dtype=float16)
+
+>>> x = np.arange(6)
+>>> np.ldexp(*np.frexp(x))
+array([ 0.,  1.,  2.,  3.,  4.,  5.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def around (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "around"))))
+(alter-meta! #'around assoc :doc "
+    Evenly round to the given number of decimals.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    decimals : int, optional
+        Number of decimal places to round to (default: 0).  If
+        decimals is negative, it specifies the number of positions to
+        the left of the decimal point.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output, but the type of the output
+        values will be cast if necessary. See `ufuncs-output-type` for more
+        details.
+
+    Returns
+    -------
+    rounded_array : ndarray
+        An array of the same type as `a`, containing the rounded values.
+        Unless `out` was specified, a new array is created.  A reference to
+        the result is returned.
+
+        The real and imaginary parts of complex numbers are rounded
+        separately.  The result of rounding a float is a float.
+
+    See Also
+    --------
+    ndarray.round : equivalent method
+
+    ceil, fix, floor, rint, trunc
+
+
+    Notes
+    -----
+    For values exactly halfway between rounded decimal values, NumPy
+    rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,
+    -0.5 and 0.5 round to 0.0, etc.
+
+    ``np.around`` uses a fast but sometimes inexact algorithm to round
+    floating-point datatypes. For positive `decimals` it is equivalent to
+    ``np.true_divide(np.rint(a * 10**decimals), 10**decimals)``, which has
+    error due to the inexact representation of decimal fractions in the IEEE
+    floating point standard [1]_ and errors introduced when scaling by powers
+    of ten. For instance, note the extra \"1\" in the following:
+
+        >>> np.round(56294995342131.5, 3)
+        56294995342131.51
+
+    If your goal is to print such values with a fixed number of decimals, it is
+    preferable to use numpy's float printing routines to limit the number of
+    printed decimals:
+
+        >>> np.format_float_positional(56294995342131.5, precision=3)
+        '56294995342131.5'
+
+    The float printing routines use an accurate but much more computationally
+    demanding algorithm to compute the number of digits after the decimal
+    point.
+
+    Alternatively, Python's builtin `round` function uses a more accurate
+    but slower algorithm for 64-bit floating point values:
+
+        >>> round(56294995342131.5, 3)
+        56294995342131.5
+        >>> np.round(16.055, 2), round(16.055, 2)  # equals 16.0549999999999997
+        (16.06, 16.05)
+
+
+    References
+    ----------
+    .. [1] \"Lecture Notes on the Status of IEEE 754\", William Kahan,
+           https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF
+    .. [2] \"How Futile are Mindless Assessments of
+           Roundoff in Floating-Point Computation?\", William Kahan,
+           https://people.eecs.berkeley.edu/~wkahan/Mindless.pdf
+
+    Examples
+    --------
+    >>> np.around([0.37, 1.64])
+    array([0.,  2.])
+    >>> np.around([0.37, 1.64], decimals=1)
+    array([0.4,  1.6])
+    >>> np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value
+    array([0.,  2.,  2.,  4.,  4.])
+    >>> np.around([1,2,3,11], decimals=1) # ndarray of ints is returned
+    array([ 1,  2,  3, 11])
+    >>> np.around([1,2,3,11], decimals=-1)
+    array([ 0,  0,  0, 10])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def convolve (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "convolve"))))
+(alter-meta! #'convolve assoc :doc "
+    Returns the discrete, linear convolution of two one-dimensional sequences.
+
+    The convolution operator is often seen in signal processing, where it
+    models the effect of a linear time-invariant system on a signal [1]_.  In
+    probability theory, the sum of two independent random variables is
+    distributed according to the convolution of their individual
+    distributions.
+
+    If `v` is longer than `a`, the arrays are swapped before computation.
+
+    Parameters
+    ----------
+    a : (N,) array_like
+        First one-dimensional input array.
+    v : (M,) array_like
+        Second one-dimensional input array.
+    mode : {'full', 'valid', 'same'}, optional
+        'full':
+          By default, mode is 'full'.  This returns the convolution
+          at each point of overlap, with an output shape of (N+M-1,). At
+          the end-points of the convolution, the signals do not overlap
+          completely, and boundary effects may be seen.
+
+        'same':
+          Mode 'same' returns output of length ``max(M, N)``.  Boundary
+          effects are still visible.
+
+        'valid':
+          Mode 'valid' returns output of length
+          ``max(M, N) - min(M, N) + 1``.  The convolution product is only given
+          for points where the signals overlap completely.  Values outside
+          the signal boundary have no effect.
+
+    Returns
+    -------
+    out : ndarray
+        Discrete, linear convolution of `a` and `v`.
+
+    See Also
+    --------
+    scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier
+                               Transform.
+    scipy.linalg.toeplitz : Used to construct the convolution operator.
+    polymul : Polynomial multiplication. Same output as convolve, but also
+              accepts poly1d objects as input.
+
+    Notes
+    -----
+    The discrete convolution operation is defined as
+
+    .. math:: (a * v)[n] = \\sum_{m = -\\infty}^{\\infty} a[m] v[n - m]
+
+    It can be shown that a convolution :math:`x(t) * y(t)` in time/space
+    is equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier
+    domain, after appropriate padding (padding is necessary to prevent
+    circular convolution).  Since multiplication is more efficient (faster)
+    than convolution, the function `scipy.signal.fftconvolve` exploits the
+    FFT to calculate the convolution of large data-sets.
+
+    References
+    ----------
+    .. [1] Wikipedia, \"Convolution\",
+        https://en.wikipedia.org/wiki/Convolution
+
+    Examples
+    --------
+    Note how the convolution operator flips the second array
+    before \"sliding\" the two across one another:
+
+    >>> np.convolve([1, 2, 3], [0, 1, 0.5])
+    array([0. , 1. , 2.5, 4. , 1.5])
+
+    Only return the middle values of the convolution.
+    Contains boundary effects, where zeros are taken
+    into account:
+
+    >>> np.convolve([1,2,3],[0,1,0.5], 'same')
+    array([1. ,  2.5,  4. ])
+
+    The two arrays are of the same length, so there
+    is only one position where they completely overlap:
+
+    >>> np.convolve([1,2,3],[0,1,0.5], 'valid')
+    array([2.5])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def round_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "round_"))))
+(alter-meta! #'round_ assoc :doc "
+    Round an array to the given number of decimals.
+
+    See Also
+    --------
+    around : equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def add (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add"))))
+(alter-meta! #'add assoc :doc "add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Add arguments element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays to be added. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+add : ndarray or scalar
+    The sum of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+Equivalent to `x1` + `x2` in terms of array broadcasting.
+
+Examples
+--------
+>>> np.add(1.0, 4.0)
+5.0
+>>> x1 = np.arange(9.0).reshape((3, 3))
+>>> x2 = np.arange(3.0)
+>>> np.add(x1, x2)
+array([[  0.,   2.,   4.],
+       [  3.,   5.,   7.],
+       [  6.,   8.,  10.]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def base_repr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "base_repr"))))
+(alter-meta! #'base_repr assoc :doc "
+    Return a string representation of a number in the given base system.
+
+    Parameters
+    ----------
+    number : int
+        The value to convert. Positive and negative values are handled.
+    base : int, optional
+        Convert `number` to the `base` number system. The valid range is 2-36,
+        the default value is 2.
+    padding : int, optional
+        Number of zeros padded on the left. Default is 0 (no padding).
+
+    Returns
+    -------
+    out : str
+        String representation of `number` in `base` system.
+
+    See Also
+    --------
+    binary_repr : Faster version of `base_repr` for base 2.
+
+    Examples
+    --------
+    >>> np.base_repr(5)
+    '101'
+    >>> np.base_repr(6, 5)
+    '11'
+    >>> np.base_repr(7, base=5, padding=3)
+    '00012'
+
+    >>> np.base_repr(10, base=16)
+    'A'
+    >>> np.base_repr(32, base=16)
+    '20'
+
+    " :arglists '[[number & [{base :base, padding :padding}]] [number & [{base :base}]] [number]])
+
+(def mafromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mafromtxt"))))
+(alter-meta! #'mafromtxt assoc :doc "
+    Load ASCII data stored in a text file and return a masked array.
+
+    .. deprecated:: 1.17
+        np.mafromtxt is a deprecated alias of `genfromtxt` which
+        overwrites the ``usemask`` argument with `True` even when
+        explicitly called as ``mafromtxt(..., usemask=False)``.
+        Use `genfromtxt` instead.
+
+    Parameters
+    ----------
+    fname, kwargs : For a description of input parameters, see `genfromtxt`.
+
+    See Also
+    --------
+    numpy.genfromtxt : generic function to load ASCII data.
+
+    " :arglists '[[fname & [{:as kwargs}]]])
+
+(def nanstd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanstd"))))
+(alter-meta! #'nanstd assoc :doc "
+    Compute the standard deviation along the specified axis, while
+    ignoring NaNs.
+
+    Returns the standard deviation, a measure of the spread of a
+    distribution, of the non-NaN array elements. The standard deviation is
+    computed for the flattened array by default, otherwise over the
+    specified axis.
+
+    For all-NaN slices or slices with zero degrees of freedom, NaN is
+    returned and a `RuntimeWarning` is raised.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Calculate the standard deviation of the non-NaN values.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the standard deviation is computed. The default is
+        to compute the standard deviation of the flattened array.
+    dtype : dtype, optional
+        Type to use in computing the standard deviation. For arrays of
+        integer type the default is float64, for arrays of float types it
+        is the same as the array type.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type (of the
+        calculated values) will be cast if necessary.
+    ddof : int, optional
+        Means Delta Degrees of Freedom.  The divisor used in calculations
+        is ``N - ddof``, where ``N`` represents the number of non-NaN
+        elements.  By default `ddof` is zero.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If this value is anything but the default it is passed through
+        as-is to the relevant functions of the sub-classes.  If these
+        functions do not have a `keepdims` kwarg, a RuntimeError will
+        be raised.
+
+    Returns
+    -------
+    standard_deviation : ndarray, see dtype parameter above.
+        If `out` is None, return a new array containing the standard
+        deviation, otherwise return a reference to the output array. If
+        ddof is >= the number of non-NaN elements in a slice or the slice
+        contains only NaNs, then the result for that slice is NaN.
+
+    See Also
+    --------
+    var, mean, std
+    nanvar, nanmean
+    ufuncs-output-type
+
+    Notes
+    -----
+    The standard deviation is the square root of the average of the squared
+    deviations from the mean: ``std = sqrt(mean(abs(x - x.mean())**2))``.
+
+    The average squared deviation is normally calculated as
+    ``x.sum() / N``, where ``N = len(x)``.  If, however, `ddof` is
+    specified, the divisor ``N - ddof`` is used instead. In standard
+    statistical practice, ``ddof=1`` provides an unbiased estimator of the
+    variance of the infinite population. ``ddof=0`` provides a maximum
+    likelihood estimate of the variance for normally distributed variables.
+    The standard deviation computed in this function is the square root of
+    the estimated variance, so even with ``ddof=1``, it will not be an
+    unbiased estimate of the standard deviation per se.
+
+    Note that, for complex numbers, `std` takes the absolute value before
+    squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the *std* is computed using the same
+    precision the input has. Depending on the input data, this can cause
+    the results to be inaccurate, especially for float32 (see example
+    below).  Specifying a higher-accuracy accumulator using the `dtype`
+    keyword can alleviate this issue.
+
+    Examples
+    --------
+    >>> a = np.array([[1, np.nan], [3, 4]])
+    >>> np.nanstd(a)
+    1.247219128924647
+    >>> np.nanstd(a, axis=0)
+    array([1., 0.])
+    >>> np.nanstd(a, axis=1)
+    array([0.,  0.5]) # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def single (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "single"))))
+(alter-meta! #'single assoc :doc "Single-precision floating-point number type, compatible with C ``float``.
+    Character code: ``'f'``.
+    Canonical name: ``np.single``.
+    Alias *on this platform*: ``np.float32``: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
+
+(def inner (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "inner"))))
+(alter-meta! #'inner assoc :doc "
+    inner(a, b)
+
+    Inner product of two arrays.
+
+    Ordinary inner product of vectors for 1-D arrays (without complex
+    conjugation), in higher dimensions a sum product over the last axes.
+
+    Parameters
+    ----------
+    a, b : array_like
+        If `a` and `b` are nonscalar, their last dimensions must match.
+
+    Returns
+    -------
+    out : ndarray
+        `out.shape = a.shape[:-1] + b.shape[:-1]`
+
+    Raises
+    ------
+    ValueError
+        If the last dimension of `a` and `b` has different size.
+
+    See Also
+    --------
+    tensordot : Sum products over arbitrary axes.
+    dot : Generalised matrix product, using second last dimension of `b`.
+    einsum : Einstein summation convention.
+
+    Notes
+    -----
+    For vectors (1-D arrays) it computes the ordinary inner-product::
+
+        np.inner(a, b) = sum(a[:]*b[:])
+
+    More generally, if `ndim(a) = r > 0` and `ndim(b) = s > 0`::
+
+        np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))
+
+    or explicitly::
+
+        np.inner(a, b)[i0,...,ir-1,j0,...,js-1]
+             = sum(a[i0,...,ir-1,:]*b[j0,...,js-1,:])
+
+    In addition `a` or `b` may be scalars, in which case::
+
+       np.inner(a,b) = a*b
+
+    Examples
+    --------
+    Ordinary inner product for vectors:
+
+    >>> a = np.array([1,2,3])
+    >>> b = np.array([0,1,0])
+    >>> np.inner(a, b)
+    2
+
+    A multidimensional example:
+
+    >>> a = np.arange(24).reshape((2,3,4))
+    >>> b = np.arange(4)
+    >>> np.inner(a, b)
+    array([[ 14,  38,  62],
+           [ 86, 110, 134]])
+
+    An example where `b` is a scalar:
+
+    >>> np.inner(np.eye(2), 7)
+    array([[7., 0.],
+           [0., 7.]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def column_stack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "column_stack"))))
+(alter-meta! #'column_stack assoc :doc "
+    Stack 1-D arrays as columns into a 2-D array.
+
+    Take a sequence of 1-D arrays and stack them as columns
+    to make a single 2-D array. 2-D arrays are stacked as-is,
+    just like with `hstack`.  1-D arrays are turned into 2-D columns
+    first.
+
+    Parameters
+    ----------
+    tup : sequence of 1-D or 2-D arrays.
+        Arrays to stack. All of them must have the same first dimension.
+
+    Returns
+    -------
+    stacked : 2-D array
+        The array formed by stacking the given arrays.
+
+    See Also
+    --------
+    stack, hstack, vstack, concatenate
+
+    Examples
+    --------
+    >>> a = np.array((1,2,3))
+    >>> b = np.array((2,3,4))
+    >>> np.column_stack((a,b))
+    array([[1, 2],
+           [2, 3],
+           [3, 4]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def cov (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cov"))))
+(alter-meta! #'cov assoc :doc "
+    Estimate a covariance matrix, given data and weights.
+
+    Covariance indicates the level to which two variables vary together.
+    If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`,
+    then the covariance matrix element :math:`C_{ij}` is the covariance of
+    :math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance
+    of :math:`x_i`.
+
+    See the notes for an outline of the algorithm.
+
+    Parameters
+    ----------
+    m : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `m` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same form
+        as that of `m`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+    bias : bool, optional
+        Default normalization (False) is by ``(N - 1)``, where ``N`` is the
+        number of observations given (unbiased estimate). If `bias` is True,
+        then normalization is by ``N``. These values can be overridden by using
+        the keyword ``ddof`` in numpy versions >= 1.5.
+    ddof : int, optional
+        If not ``None`` the default value implied by `bias` is overridden.
+        Note that ``ddof=1`` will return the unbiased estimate, even if both
+        `fweights` and `aweights` are specified, and ``ddof=0`` will return
+        the simple average. See the notes for the details. The default value
+        is ``None``.
+
+        .. versionadded:: 1.5
+    fweights : array_like, int, optional
+        1-D array of integer frequency weights; the number of times each
+        observation vector should be repeated.
+
+        .. versionadded:: 1.10
+    aweights : array_like, optional
+        1-D array of observation vector weights. These relative weights are
+        typically large for observations considered \"important\" and smaller for
+        observations considered less \"important\". If ``ddof=0`` the array of
+        weights can be used to assign probabilities to observation vectors.
+
+        .. versionadded:: 1.10
+
+    Returns
+    -------
+    out : ndarray
+        The covariance matrix of the variables.
+
+    See Also
+    --------
+    corrcoef : Normalized covariance matrix
+
+    Notes
+    -----
+    Assume that the observations are in the columns of the observation
+    array `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The
+    steps to compute the weighted covariance are as follows::
+
+        >>> m = np.arange(10, dtype=np.float64)
+        >>> f = np.arange(10) * 2
+        >>> a = np.arange(10) ** 2.
+        >>> ddof = 1
+        >>> w = f * a
+        >>> v1 = np.sum(w)
+        >>> v2 = np.sum(w * a)
+        >>> m -= np.sum(m * w, axis=None, keepdims=True) / v1
+        >>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)
+
+    Note that when ``a == 1``, the normalization factor
+    ``v1 / (v1**2 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)``
+    as it should.
+
+    Examples
+    --------
+    Consider two variables, :math:`x_0` and :math:`x_1`, which
+    correlate perfectly, but in opposite directions:
+
+    >>> x = np.array([[0, 2], [1, 1], [2, 0]]).T
+    >>> x
+    array([[0, 1, 2],
+           [2, 1, 0]])
+
+    Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance
+    matrix shows this clearly:
+
+    >>> np.cov(x)
+    array([[ 1., -1.],
+           [-1.,  1.]])
+
+    Note that element :math:`C_{0,1}`, which shows the correlation between
+    :math:`x_0` and :math:`x_1`, is negative.
+
+    Further, note how `x` and `y` are combined:
+
+    >>> x = [-2.1, -1,  4.3]
+    >>> y = [3,  1.1,  0.12]
+    >>> X = np.stack((x, y), axis=0)
+    >>> np.cov(X)
+    array([[11.71      , -4.286     ], # may vary
+           [-4.286     ,  2.144133]])
+    >>> np.cov(x, y)
+    array([[11.71      , -4.286     ], # may vary
+           [-4.286     ,  2.144133]])
+    >>> np.cov(x)
+    array(11.71)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def geterrcall (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geterrcall"))))
+(alter-meta! #'geterrcall assoc :doc "
+    Return the current callback function used on floating-point errors.
+
+    When the error handling for a floating-point error (one of \"divide\",
+    \"over\", \"under\", or \"invalid\") is set to 'call' or 'log', the function
+    that is called or the log instance that is written to is returned by
+    `geterrcall`. This function or log instance has been set with
+    `seterrcall`.
+
+    Returns
+    -------
+    errobj : callable, log instance or None
+        The current error handler. If no handler was set through `seterrcall`,
+        ``None`` is returned.
+
+    See Also
+    --------
+    seterrcall, seterr, geterr
+
+    Notes
+    -----
+    For complete documentation of the types of floating-point exceptions and
+    treatment options, see `seterr`.
+
+    Examples
+    --------
+    >>> np.geterrcall()  # we did not yet set a handler, returns None
+
+    >>> oldsettings = np.seterr(all='call')
+    >>> def err_handler(type, flag):
+    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
+    >>> oldhandler = np.seterrcall(err_handler)
+    >>> np.array([1, 2, 3]) / 0.0
+    Floating point error (divide by zero), with flag 1
+    array([inf, inf, inf])
+
+    >>> cur_handler = np.geterrcall()
+    >>> cur_handler is err_handler
+    True
+
+    " :arglists '[[]])
+
+(def signbit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "signbit"))))
+(alter-meta! #'signbit assoc :doc "signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns element-wise True where signbit is set (less than zero).
+
+Parameters
+----------
+x : array_like
+    The input value(s).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+result : ndarray of bool
+    Output array, or reference to `out` if that was supplied.
+    This is a scalar if `x` is a scalar.
+
+Examples
+--------
+>>> np.signbit(-1.2)
+True
+>>> np.signbit(np.array([1, -2.3, 2.1]))
+array([False,  True, False])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def amax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "amax"))))
+(alter-meta! #'amax assoc :doc "
+    Return the maximum of an array or maximum along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to operate.  By default, flattened input is
+        used.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, the maximum is selected over multiple axes,
+        instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternative output array in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+        See `ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `amax` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    initial : scalar, optional
+        The minimum value of an output element. Must be present to allow
+        computation on empty slice. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to compare for the maximum. See `~numpy.ufunc.reduce`
+        for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    amax : ndarray or scalar
+        Maximum of `a`. If `axis` is None, the result is a scalar value.
+        If `axis` is given, the result is an array of dimension
+        ``a.ndim - 1``.
+
+    See Also
+    --------
+    amin :
+        The minimum value of an array along a given axis, propagating any NaNs.
+    nanmax :
+        The maximum value of an array along a given axis, ignoring any NaNs.
+    maximum :
+        Element-wise maximum of two arrays, propagating any NaNs.
+    fmax :
+        Element-wise maximum of two arrays, ignoring any NaNs.
+    argmax :
+        Return the indices of the maximum values.
+
+    nanmin, minimum, fmin
+
+    Notes
+    -----
+    NaN values are propagated, that is if at least one item is NaN, the
+    corresponding max value will be NaN as well. To ignore NaN values
+    (MATLAB behavior), please use nanmax.
+
+    Don't use `amax` for element-wise comparison of 2 arrays; when
+    ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
+    ``amax(a, axis=0)``.
+
+    Examples
+    --------
+    >>> a = np.arange(4).reshape((2,2))
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> np.amax(a)           # Maximum of the flattened array
+    3
+    >>> np.amax(a, axis=0)   # Maxima along the first axis
+    array([2, 3])
+    >>> np.amax(a, axis=1)   # Maxima along the second axis
+    array([1, 3])
+    >>> np.amax(a, where=[False, True], initial=-1, axis=0)
+    array([-1,  3])
+    >>> b = np.arange(5, dtype=float)
+    >>> b[2] = np.NaN
+    >>> np.amax(b)
+    nan
+    >>> np.amax(b, where=~np.isnan(b), initial=-1)
+    4.0
+    >>> np.nanmax(b)
+    4.0
+
+    You can use an initial value to compute the maximum of an empty slice, or
+    to initialize it to a different value:
+
+    >>> np.max([[-50], [10]], axis=-1, initial=0)
+    array([ 0, 10])
+
+    Notice that the initial value is used as one of the elements for which the
+    maximum is determined, unlike for the default argument Python's max
+    function, which is only used for empty iterables.
+
+    >>> np.max([5], initial=6)
+    6
+    >>> max([5], default=6)
+    5
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def all (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "all"))))
+(alter-meta! #'all assoc :doc "
+    Test whether all array elements along a given axis evaluate to True.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a logical AND reduction is performed.
+        The default (``axis=None``) is to perform a logical AND over all
+        the dimensions of the input array. `axis` may be negative, in
+        which case it counts from the last to the first axis.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a reduction is performed on multiple
+        axes, instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternate output array in which to place the result.
+        It must have the same shape as the expected output and its
+        type is preserved (e.g., if ``dtype(out)`` is float, the result
+        will consist of 0.0's and 1.0's). See `ufuncs-output-type` for more
+        details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `all` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    all : ndarray, bool
+        A new boolean or array is returned unless `out` is specified,
+        in which case a reference to `out` is returned.
+
+    See Also
+    --------
+    ndarray.all : equivalent method
+
+    any : Test whether any element along a given axis evaluates to True.
+
+    Notes
+    -----
+    Not a Number (NaN), positive infinity and negative infinity
+    evaluate to `True` because these are not equal to zero.
+
+    Examples
+    --------
+    >>> np.all([[True,False],[True,True]])
+    False
+
+    >>> np.all([[True,False],[True,True]], axis=0)
+    array([ True, False])
+
+    >>> np.all([-1, 4, 5])
+    True
+
+    >>> np.all([1.0, np.nan])
+    True
+
+    >>> o=np.array(False)
+    >>> z=np.all([-1, 4, 5], out=o)
+    >>> id(z), id(o), z
+    (28293632, 28293632, array(True)) # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "This module provides access to some objects used or maintained by the
+interpreter and to functions that interact strongly with the interpreter.
+
+Dynamic objects:
+
+argv -- command line arguments; argv[0] is the script pathname if known
+path -- module search path; path[0] is the script directory, else ''
+modules -- dictionary of loaded modules
+
+displayhook -- called to show results in an interactive session
+excepthook -- called to handle any uncaught exception other than SystemExit
+  To customize printing in an interactive session or to install a custom
+  top-level exception handler, assign other functions to replace these.
+
+stdin -- standard input file object; used by input()
+stdout -- standard output file object; used by print()
+stderr -- standard error object; used for error messages
+  By assigning other file objects (or objects that behave like files)
+  to these, it is possible to redirect all of the interpreter's I/O.
+
+last_type -- type of last uncaught exception
+last_value -- value of last uncaught exception
+last_traceback -- traceback of last uncaught exception
+  These three are only available in an interactive session after a
+  traceback has been printed.
+
+Static objects:
+
+builtin_module_names -- tuple of module names built into this interpreter
+copyright -- copyright notice pertaining to this interpreter
+exec_prefix -- prefix used to find the machine-specific Python library
+executable -- absolute path of the executable binary of the Python interpreter
+float_info -- a named tuple with information about the float implementation.
+float_repr_style -- string indicating the style of repr() output for floats
+hash_info -- a named tuple with information about the hash algorithm.
+hexversion -- version information encoded as a single integer
+implementation -- Python implementation information.
+int_info -- a named tuple with information about the int implementation.
+maxsize -- the largest supported length of containers.
+maxunicode -- the value of the largest Unicode code point
+platform -- platform identifier
+prefix -- prefix used to find the Python library
+thread_info -- a named tuple with information about the thread implementation.
+version -- the version of this interpreter as a string
+version_info -- version information as a named tuple
+__stdin__ -- the original stdin; don't touch!
+__stdout__ -- the original stdout; don't touch!
+__stderr__ -- the original stderr; don't touch!
+__displayhook__ -- the original displayhook; don't touch!
+__excepthook__ -- the original excepthook; don't touch!
+
+Functions:
+
+displayhook() -- print an object to the screen, and save it in builtins._
+excepthook() -- print an exception and its traceback to sys.stderr
+exc_info() -- return thread-safe information about the current exception
+exit() -- exit the interpreter by raising SystemExit
+getdlopenflags() -- returns flags to be used for dlopen() calls
+getprofile() -- get the global profiling function
+getrefcount() -- return the reference count for an object (plus one :-)
+getrecursionlimit() -- return the max recursion depth for the interpreter
+getsizeof() -- return the size of an object in bytes
+gettrace() -- get the global debug tracing function
+setcheckinterval() -- control how often the interpreter checks for events
+setdlopenflags() -- set the flags to be used for dlopen() calls
+setprofile() -- set the global profiling function
+setrecursionlimit() -- set the max recursion depth for the interpreter
+settrace() -- set the global debug tracing function
+"} sys (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "sys"))))
+
+(def true_divide (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "true_divide"))))
+(alter-meta! #'true_divide assoc :doc "true_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns a true division of the inputs, element-wise.
+
+Instead of the Python traditional 'floor division', this returns a true
+division.  True division adjusts the output type to present the best
+answer, regardless of input types.
+
+Parameters
+----------
+x1 : array_like
+    Dividend array.
+x2 : array_like
+    Divisor array. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+The floor division operator ``//`` was added in Python 2.2 making
+``//`` and ``/`` equivalent operators.  The default floor division
+operation of ``/`` can be replaced by true division with ``from
+__future__ import division``.
+
+In Python 3.0, ``//`` is the floor division operator and ``/`` the
+true division operator.  The ``true_divide(x1, x2)`` function is
+equivalent to true division in Python.
+
+Examples
+--------
+>>> x = np.arange(5)
+>>> np.true_divide(x, 4)
+array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
+
+>>> x//4
+array([0, 0, 0, 0, 1])
+
+>>> from __future__ import division
+>>> x/4
+array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
+>>> x//4
+array([0, 0, 0, 0, 1])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} NZERO (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "NZERO"))))
+
+(def ^{:doc ""} FPE_INVALID (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "FPE_INVALID"))))
+
+(def hanning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hanning"))))
+(alter-meta! #'hanning assoc :doc "
+    Return the Hanning window.
+
+    The Hanning window is a taper formed by using a weighted cosine.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+
+    Returns
+    -------
+    out : ndarray, shape(M,)
+        The window, with the maximum value normalized to one (the value
+        one appears only if `M` is odd).
+
+    See Also
+    --------
+    bartlett, blackman, hamming, kaiser
+
+    Notes
+    -----
+    The Hanning window is defined as
+
+    .. math::  w(n) = 0.5 - 0.5cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
+               \\qquad 0 \\leq n \\leq M-1
+
+    The Hanning was named for Julius von Hann, an Austrian meteorologist.
+    It is also known as the Cosine Bell. Some authors prefer that it be
+    called a Hann window, to help avoid confusion with the very similar
+    Hamming window.
+
+    Most references to the Hanning window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    \"removing the foot\", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function.
+
+    References
+    ----------
+    .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
+           spectra, Dover Publications, New York.
+    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\",
+           The University of Alberta Press, 1975, pp. 106-108.
+    .. [3] Wikipedia, \"Window function\",
+           https://en.wikipedia.org/wiki/Window_function
+    .. [4] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
+           \"Numerical Recipes\", Cambridge University Press, 1986, page 425.
+
+    Examples
+    --------
+    >>> np.hanning(12)
+    array([0.        , 0.07937323, 0.29229249, 0.57115742, 0.82743037,
+           0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249,
+           0.07937323, 0.        ])
+
+    Plot the window and its frequency response:
+
+    >>> import matplotlib.pyplot as plt
+    >>> from numpy.fft import fft, fftshift
+    >>> window = np.hanning(51)
+    >>> plt.plot(window)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Hann window\")
+    Text(0.5, 1.0, 'Hann window')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"Sample\")
+    Text(0.5, 0, 'Sample')
+    >>> plt.show()
+
+    >>> plt.figure()
+    <Figure size 640x480 with 0 Axes>
+    >>> A = fft(window, 2048) / 25.5
+    >>> mag = np.abs(fftshift(A))
+    >>> freq = np.linspace(-0.5, 0.5, len(A))
+    >>> with np.errstate(divide='ignore', invalid='ignore'):
+    ...     response = 20 * np.log10(mag)
+    ...
+    >>> response = np.clip(response, -100, 100)
+    >>> plt.plot(freq, response)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Frequency response of the Hann window\")
+    Text(0.5, 1.0, 'Frequency response of the Hann window')
+    >>> plt.ylabel(\"Magnitude [dB]\")
+    Text(0, 0.5, 'Magnitude [dB]')
+    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
+    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
+    >>> plt.axis('tight')
+    ...
+    >>> plt.show()
+
+    " :arglists '[[M]])
+
+(def ^{:doc "Python part of the warnings subsystem."} warnings (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "warnings"))))
+
+(def uintc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uintc"))))
+(alter-meta! #'uintc assoc :doc "Unsigned integer type, compatible with C ``unsigned int``.
+    Character code: ``'I'``.
+    Canonical name: ``np.uintc``.
+    Alias *on this platform*: ``np.uint32``: 32-bit unsigned integer (0 to 4294967295)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def resize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "resize"))))
+(alter-meta! #'resize assoc :doc "
+    Return a new array with the specified shape.
+
+    If the new array is larger than the original array, then the new
+    array is filled with repeated copies of `a`.  Note that this behavior
+    is different from a.resize(new_shape) which fills with zeros instead
+    of repeated copies of `a`.
+
+    Parameters
+    ----------
+    a : array_like
+        Array to be resized.
+
+    new_shape : int or tuple of int
+        Shape of resized array.
+
+    Returns
+    -------
+    reshaped_array : ndarray
+        The new array is formed from the data in the old array, repeated
+        if necessary to fill out the required number of elements.  The
+        data are repeated in the order that they are stored in memory.
+
+    See Also
+    --------
+    ndarray.resize : resize an array in-place.
+
+    Notes
+    -----
+    Warning: This functionality does **not** consider axes separately,
+    i.e. it does not apply interpolation/extrapolation.
+    It fills the return array with the required number of elements, taken
+    from `a` as they are laid out in memory, disregarding strides and axes.
+    (This is in case the new shape is smaller. For larger, see above.)
+    This functionality is therefore not suitable to resize images,
+    or data where each axis represents a separate and distinct entity.
+
+    Examples
+    --------
+    >>> a=np.array([[0,1],[2,3]])
+    >>> np.resize(a,(2,3))
+    array([[0, 1, 2],
+           [3, 0, 1]])
+    >>> np.resize(a,(1,4))
+    array([[0, 1, 2, 3]])
+    >>> np.resize(a,(2,4))
+    array([[0, 1, 2, 3],
+           [0, 1, 2, 3]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def size (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "size"))))
+(alter-meta! #'size assoc :doc "
+    Return the number of elements along a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : int, optional
+        Axis along which the elements are counted.  By default, give
+        the total number of elements.
+
+    Returns
+    -------
+    element_count : int
+        Number of elements along the specified axis.
+
+    See Also
+    --------
+    shape : dimensions of array
+    ndarray.shape : dimensions of array
+    ndarray.size : number of elements in array
+
+    Examples
+    --------
+    >>> a = np.array([[1,2,3],[4,5,6]])
+    >>> np.size(a)
+    6
+    >>> np.size(a,1)
+    3
+    >>> np.size(a,0)
+    2
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def unsignedinteger (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unsignedinteger"))))
+(alter-meta! #'unsignedinteger assoc :doc "Abstract base class of all unsigned integer scalar types." :arglists '[[self & [args {:as kwargs}]]])
+
+(def float_power (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float_power"))))
+(alter-meta! #'float_power assoc :doc "float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+First array elements raised to powers from second array, element-wise.
+
+Raise each base in `x1` to the positionally-corresponding power in `x2`.
+`x1` and `x2` must be broadcastable to the same shape. This differs from
+the power function in that integers, float16, and float32  are promoted to
+floats with a minimum precision of float64 so that the result is always
+inexact.  The intent is that the function will return a usable result for
+negative powers and seldom overflow for positive powers.
+
+.. versionadded:: 1.12.0
+
+Parameters
+----------
+x1 : array_like
+    The bases.
+x2 : array_like
+    The exponents. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The bases in `x1` raised to the exponents in `x2`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+power : power function that preserves type
+
+Examples
+--------
+Cube each element in a list.
+
+>>> x1 = range(6)
+>>> x1
+[0, 1, 2, 3, 4, 5]
+>>> np.float_power(x1, 3)
+array([   0.,    1.,    8.,   27.,   64.,  125.])
+
+Raise the bases to different exponents.
+
+>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
+>>> np.float_power(x1, x2)
+array([  0.,   1.,   8.,  27.,  16.,   5.])
+
+The effect of broadcasting.
+
+>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
+>>> x2
+array([[1, 2, 3, 3, 2, 1],
+       [1, 2, 3, 3, 2, 1]])
+>>> np.float_power(x1, x2)
+array([[  0.,   1.,   8.,  27.,  16.,   5.],
+       [  0.,   1.,   8.,  27.,  16.,   5.]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def logical_xor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_xor"))))
+(alter-meta! #'logical_xor assoc :doc "logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the truth value of x1 XOR x2, element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Logical XOR is applied to the elements of `x1` and `x2`. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : bool or ndarray of bool
+    Boolean result of the logical XOR operation applied to the elements
+    of `x1` and `x2`; the shape is determined by broadcasting.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_and, logical_or, logical_not, bitwise_xor
+
+Examples
+--------
+>>> np.logical_xor(True, False)
+True
+>>> np.logical_xor([True, True, False, False], [True, False, True, False])
+array([False,  True,  True, False])
+
+>>> x = np.arange(5)
+>>> np.logical_xor(x < 1, x > 3)
+array([ True, False, False, False,  True])
+
+Simple example showing support of broadcasting
+
+>>> np.logical_xor(0, np.eye(2))
+array([[ True, False],
+       [False,  True]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def set_string_function (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "set_string_function"))))
+(alter-meta! #'set_string_function assoc :doc "
+    Set a Python function to be used when pretty printing arrays.
+
+    Parameters
+    ----------
+    f : function or None
+        Function to be used to pretty print arrays. The function should expect
+        a single array argument and return a string of the representation of
+        the array. If None, the function is reset to the default NumPy function
+        to print arrays.
+    repr : bool, optional
+        If True (default), the function for pretty printing (``__repr__``)
+        is set, if False the function that returns the default string
+        representation (``__str__``) is set.
+
+    See Also
+    --------
+    set_printoptions, get_printoptions
+
+    Examples
+    --------
+    >>> def pprint(arr):
+    ...     return 'HA! - What are you going to do now?'
+    ...
+    >>> np.set_string_function(pprint)
+    >>> a = np.arange(10)
+    >>> a
+    HA! - What are you going to do now?
+    >>> _ = a
+    >>> # [0 1 2 3 4 5 6 7 8 9]
+
+    We can reset the function to the default:
+
+    >>> np.set_string_function(None)
+    >>> a
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+    `repr` affects either pretty printing or normal string representation.
+    Note that ``__repr__`` is still affected by setting ``__str__``
+    because the width of each array element in the returned string becomes
+    equal to the length of the result of ``__str__()``.
+
+    >>> x = np.arange(4)
+    >>> np.set_string_function(lambda x:'random', repr=False)
+    >>> x.__str__()
+    'random'
+    >>> x.__repr__()
+    'array([0, 1, 2, 3])'
+
+    " :arglists '[[f & [{repr :repr}]] [f]])
+
+(def allclose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "allclose"))))
+(alter-meta! #'allclose assoc :doc "
+    Returns True if two arrays are element-wise equal within a tolerance.
+
+    The tolerance values are positive, typically very small numbers.  The
+    relative difference (`rtol` * abs(`b`)) and the absolute difference
+    `atol` are added together to compare against the absolute difference
+    between `a` and `b`.
+
+    NaNs are treated as equal if they are in the same place and if
+    ``equal_nan=True``.  Infs are treated as equal if they are in the same
+    place and of the same sign in both arrays.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Input arrays to compare.
+    rtol : float
+        The relative tolerance parameter (see Notes).
+    atol : float
+        The absolute tolerance parameter (see Notes).
+    equal_nan : bool
+        Whether to compare NaN's as equal.  If True, NaN's in `a` will be
+        considered equal to NaN's in `b` in the output array.
+
+        .. versionadded:: 1.10.0
+
+    Returns
+    -------
+    allclose : bool
+        Returns True if the two arrays are equal within the given
+        tolerance; False otherwise.
+
+    See Also
+    --------
+    isclose, all, any, equal
+
+    Notes
+    -----
+    If the following equation is element-wise True, then allclose returns
+    True.
+
+     absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
+
+    The above equation is not symmetric in `a` and `b`, so that
+    ``allclose(a, b)`` might be different from ``allclose(b, a)`` in
+    some rare cases.
+
+    The comparison of `a` and `b` uses standard broadcasting, which
+    means that `a` and `b` need not have the same shape in order for
+    ``allclose(a, b)`` to evaluate to True.  The same is true for
+    `equal` but not `array_equal`.
+
+    Examples
+    --------
+    >>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])
+    False
+    >>> np.allclose([1e10,1e-8], [1.00001e10,1e-9])
+    True
+    >>> np.allclose([1e10,1e-8], [1.0001e10,1e-9])
+    False
+    >>> np.allclose([1.0, np.nan], [1.0, np.nan])
+    False
+    >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} Inf (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "Inf"))))
+
+(def cumproduct (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cumproduct"))))
+(alter-meta! #'cumproduct assoc :doc "
+    Return the cumulative product over the given axis.
+
+    See Also
+    --------
+    cumprod : equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def amin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "amin"))))
+(alter-meta! #'amin assoc :doc "
+    Return the minimum of an array or minimum along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to operate.  By default, flattened input is
+        used.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, the minimum is selected over multiple axes,
+        instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternative output array in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+        See `ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `amin` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    initial : scalar, optional
+        The maximum value of an output element. Must be present to allow
+        computation on empty slice. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to compare for the minimum. See `~numpy.ufunc.reduce`
+        for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    amin : ndarray or scalar
+        Minimum of `a`. If `axis` is None, the result is a scalar value.
+        If `axis` is given, the result is an array of dimension
+        ``a.ndim - 1``.
+
+    See Also
+    --------
+    amax :
+        The maximum value of an array along a given axis, propagating any NaNs.
+    nanmin :
+        The minimum value of an array along a given axis, ignoring any NaNs.
+    minimum :
+        Element-wise minimum of two arrays, propagating any NaNs.
+    fmin :
+        Element-wise minimum of two arrays, ignoring any NaNs.
+    argmin :
+        Return the indices of the minimum values.
+
+    nanmax, maximum, fmax
+
+    Notes
+    -----
+    NaN values are propagated, that is if at least one item is NaN, the
+    corresponding min value will be NaN as well. To ignore NaN values
+    (MATLAB behavior), please use nanmin.
+
+    Don't use `amin` for element-wise comparison of 2 arrays; when
+    ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than
+    ``amin(a, axis=0)``.
+
+    Examples
+    --------
+    >>> a = np.arange(4).reshape((2,2))
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> np.amin(a)           # Minimum of the flattened array
+    0
+    >>> np.amin(a, axis=0)   # Minima along the first axis
+    array([0, 1])
+    >>> np.amin(a, axis=1)   # Minima along the second axis
+    array([0, 2])
+    >>> np.amin(a, where=[False, True], initial=10, axis=0)
+    array([10,  1])
+
+    >>> b = np.arange(5, dtype=float)
+    >>> b[2] = np.NaN
+    >>> np.amin(b)
+    nan
+    >>> np.amin(b, where=~np.isnan(b), initial=10)
+    0.0
+    >>> np.nanmin(b)
+    0.0
+
+    >>> np.min([[-50], [10]], axis=-1, initial=0)
+    array([-50,   0])
+
+    Notice that the initial value is used as one of the elements for which the
+    minimum is determined, unlike for the default argument Python's max
+    function, which is only used for empty iterables.
+
+    Notice that this isn't the same as Python's ``default`` argument.
+
+    >>> np.min([6], initial=5)
+    5
+    >>> min([6], default=5)
+    6
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def nan_to_num (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nan_to_num"))))
+(alter-meta! #'nan_to_num assoc :doc "
+    Replace NaN with zero and infinity with large finite numbers (default
+    behaviour) or with the numbers defined by the user using the `nan`, 
+    `posinf` and/or `neginf` keywords.
+
+    If `x` is inexact, NaN is replaced by zero or by the user defined value in
+    `nan` keyword, infinity is replaced by the largest finite floating point 
+    values representable by ``x.dtype`` or by the user defined value in 
+    `posinf` keyword and -infinity is replaced by the most negative finite 
+    floating point values representable by ``x.dtype`` or by the user defined 
+    value in `neginf` keyword.
+
+    For complex dtypes, the above is applied to each of the real and
+    imaginary components of `x` separately.
+
+    If `x` is not inexact, then no replacements are made.
+
+    Parameters
+    ----------
+    x : scalar or array_like
+        Input data.
+    copy : bool, optional
+        Whether to create a copy of `x` (True) or to replace values
+        in-place (False). The in-place operation only occurs if
+        casting to an array does not require a copy.
+        Default is True.
+        
+        .. versionadded:: 1.13
+    nan : int, float, optional
+        Value to be used to fill NaN values. If no value is passed 
+        then NaN values will be replaced with 0.0.
+        
+        .. versionadded:: 1.17
+    posinf : int, float, optional
+        Value to be used to fill positive infinity values. If no value is 
+        passed then positive infinity values will be replaced with a very
+        large number.
+        
+        .. versionadded:: 1.17
+    neginf : int, float, optional
+        Value to be used to fill negative infinity values. If no value is 
+        passed then negative infinity values will be replaced with a very
+        small (or negative) number.
+        
+        .. versionadded:: 1.17
+
+        
+
+    Returns
+    -------
+    out : ndarray
+        `x`, with the non-finite values replaced. If `copy` is False, this may
+        be `x` itself.
+
+    See Also
+    --------
+    isinf : Shows which elements are positive or negative infinity.
+    isneginf : Shows which elements are negative infinity.
+    isposinf : Shows which elements are positive infinity.
+    isnan : Shows which elements are Not a Number (NaN).
+    isfinite : Shows which elements are finite (not NaN, not infinity)
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+
+    Examples
+    --------
+    >>> np.nan_to_num(np.inf)
+    1.7976931348623157e+308
+    >>> np.nan_to_num(-np.inf)
+    -1.7976931348623157e+308
+    >>> np.nan_to_num(np.nan)
+    0.0
+    >>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])
+    >>> np.nan_to_num(x)
+    array([ 1.79769313e+308, -1.79769313e+308,  0.00000000e+000, # may vary
+           -1.28000000e+002,  1.28000000e+002])
+    >>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)
+    array([ 3.3333333e+07,  3.3333333e+07, -9.9990000e+03, 
+           -1.2800000e+02,  1.2800000e+02])
+    >>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])
+    array([  1.79769313e+308,  -1.79769313e+308,   0.00000000e+000, # may vary
+         -1.28000000e+002,   1.28000000e+002])
+    >>> np.nan_to_num(y)
+    array([  1.79769313e+308 +0.00000000e+000j, # may vary
+             0.00000000e+000 +0.00000000e+000j,
+             0.00000000e+000 +1.79769313e+308j])
+    >>> np.nan_to_num(y, nan=111111, posinf=222222)
+    array([222222.+111111.j, 111111.     +0.j, 111111.+222222.j])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def diag_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diag_indices"))))
+(alter-meta! #'diag_indices assoc :doc "
+    Return the indices to access the main diagonal of an array.
+
+    This returns a tuple of indices that can be used to access the main
+    diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape
+    (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for
+    ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]``
+    for ``i = [0..n-1]``.
+
+    Parameters
+    ----------
+    n : int
+      The size, along each dimension, of the arrays for which the returned
+      indices can be used.
+
+    ndim : int, optional
+      The number of dimensions.
+
+    See also
+    --------
+    diag_indices_from
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    Create a set of indices to access the diagonal of a (4, 4) array:
+
+    >>> di = np.diag_indices(4)
+    >>> di
+    (array([0, 1, 2, 3]), array([0, 1, 2, 3]))
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+    >>> a[di] = 100
+    >>> a
+    array([[100,   1,   2,   3],
+           [  4, 100,   6,   7],
+           [  8,   9, 100,  11],
+           [ 12,  13,  14, 100]])
+
+    Now, we create indices to manipulate a 3-D array:
+
+    >>> d3 = np.diag_indices(2, 3)
+    >>> d3
+    (array([0, 1]), array([0, 1]), array([0, 1]))
+
+    And use it to set the diagonal of an array of zeros to 1:
+
+    >>> a = np.zeros((2, 2, 2), dtype=int)
+    >>> a[d3] = 1
+    >>> a
+    array([[[1, 0],
+            [0, 0]],
+           [[0, 0],
+            [0, 1]]])
+
+    " :arglists '[[n & [{ndim :ndim}]] [n]])
+
+(def sometrue (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sometrue"))))
+(alter-meta! #'sometrue assoc :doc "
+    Check whether some values are true.
+
+    Refer to `any` for full documentation.
+
+    See Also
+    --------
+    any : equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def str_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "str_"))))
+(alter-meta! #'str_ assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def singlecomplex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "singlecomplex"))))
+(alter-meta! #'singlecomplex assoc :doc "Complex number type composed of two single-precision floating-point
+    numbers.
+    Character code: ``'F'``.
+    Canonical name: ``np.csingle``.
+    Alias: ``np.singlecomplex``.
+    Alias *on this platform*: ``np.complex64``: Complex number type composed of 2 32-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def get_printoptions (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "get_printoptions"))))
+(alter-meta! #'get_printoptions assoc :doc "
+    Return the current print options.
+
+    Returns
+    -------
+    print_opts : dict
+        Dictionary of current print options with keys
+
+          - precision : int
+          - threshold : int
+          - edgeitems : int
+          - linewidth : int
+          - suppress : bool
+          - nanstr : str
+          - infstr : str
+          - formatter : dict of callables
+          - sign : str
+
+        For a full description of these options, see `set_printoptions`.
+
+    See Also
+    --------
+    set_printoptions, printoptions, set_string_function
+
+    " :arglists '[[]])
+
+(def sinh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sinh"))))
+(alter-meta! #'sinh assoc :doc "sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Hyperbolic sine, element-wise.
+
+Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or
+``-1j * np.sin(1j*x)``.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding hyperbolic sine values.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+If `out` is provided, the function writes the result into it,
+and returns a reference to `out`.  (See Examples)
+
+References
+----------
+M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
+New York, NY: Dover, 1972, pg. 83.
+
+Examples
+--------
+>>> np.sinh(0)
+0.0
+>>> np.sinh(np.pi*1j/2)
+1j
+>>> np.sinh(np.pi*1j) # (exact value is 0)
+1.2246063538223773e-016j
+>>> # Discrepancy due to vagaries of floating point arithmetic.
+
+>>> # Example of providing the optional output parameter
+>>> out1 = np.array([0], dtype='d')
+>>> out2 = np.sinh([0.1], out1)
+>>> out2 is out1
+True
+
+>>> # Example of ValueError due to provision of shape mis-matched `out`
+>>> np.sinh(np.zeros((3,3)),np.zeros((2,2)))
+Traceback (most recent call last):
+  File \"<stdin>\", line 1, in <module>
+ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]])
+
+(def triu_indices_from (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "triu_indices_from"))))
+(alter-meta! #'triu_indices_from assoc :doc "
+    Return the indices for the upper-triangle of arr.
+
+    See `triu_indices` for full details.
+
+    Parameters
+    ----------
+    arr : ndarray, shape(N, N)
+        The indices will be valid for square arrays.
+    k : int, optional
+        Diagonal offset (see `triu` for details).
+
+    Returns
+    -------
+    triu_indices_from : tuple, shape(2) of ndarray, shape(N)
+        Indices for the upper-triangle of `arr`.
+
+    See Also
+    --------
+    triu_indices, triu
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} __doc__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__doc__"))))
+
+(def rot90 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rot90"))))
+(alter-meta! #'rot90 assoc :doc "
+    Rotate an array by 90 degrees in the plane specified by axes.
+
+    Rotation direction is from the first towards the second axis.
+
+    Parameters
+    ----------
+    m : array_like
+        Array of two or more dimensions.
+    k : integer
+        Number of times the array is rotated by 90 degrees.
+    axes: (2,) array_like
+        The array is rotated in the plane defined by the axes.
+        Axes must be different.
+
+        .. versionadded:: 1.12.0
+
+    Returns
+    -------
+    y : ndarray
+        A rotated view of `m`.
+
+    See Also
+    --------
+    flip : Reverse the order of elements in an array along the given axis.
+    fliplr : Flip an array horizontally.
+    flipud : Flip an array vertically.
+
+    Notes
+    -----
+    rot90(m, k=1, axes=(1,0)) is the reverse of rot90(m, k=1, axes=(0,1))
+    rot90(m, k=1, axes=(1,0)) is equivalent to rot90(m, k=-1, axes=(0,1))
+
+    Examples
+    --------
+    >>> m = np.array([[1,2],[3,4]], int)
+    >>> m
+    array([[1, 2],
+           [3, 4]])
+    >>> np.rot90(m)
+    array([[2, 4],
+           [1, 3]])
+    >>> np.rot90(m, 2)
+    array([[4, 3],
+           [2, 1]])
+    >>> m = np.arange(8).reshape((2,2,2))
+    >>> np.rot90(m, 1, (1,2))
+    array([[[1, 3],
+            [0, 2]],
+           [[5, 7],
+            [4, 6]]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def dsplit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dsplit"))))
+(alter-meta! #'dsplit assoc :doc "
+    Split array into multiple sub-arrays along the 3rd axis (depth).
+
+    Please refer to the `split` documentation.  `dsplit` is equivalent
+    to `split` with ``axis=2``, the array is always split along the third
+    axis provided the array dimension is greater than or equal to 3.
+
+    See Also
+    --------
+    split : Split an array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> x = np.arange(16.0).reshape(2, 2, 4)
+    >>> x
+    array([[[ 0.,   1.,   2.,   3.],
+            [ 4.,   5.,   6.,   7.]],
+           [[ 8.,   9.,  10.,  11.],
+            [12.,  13.,  14.,  15.]]])
+    >>> np.dsplit(x, 2)
+    [array([[[ 0.,  1.],
+            [ 4.,  5.]],
+           [[ 8.,  9.],
+            [12., 13.]]]), array([[[ 2.,  3.],
+            [ 6.,  7.]],
+           [[10., 11.],
+            [14., 15.]]])]
+    >>> np.dsplit(x, np.array([3, 6]))
+    [array([[[ 0.,   1.,   2.],
+            [ 4.,   5.,   6.]],
+           [[ 8.,   9.,  10.],
+            [12.,  13.,  14.]]]),
+     array([[[ 3.],
+            [ 7.]],
+           [[11.],
+            [15.]]]),
+    array([], shape=(2, 2, 0), dtype=float64)]
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "equal"))))
+(alter-meta! #'equal assoc :doc "equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return (x1 == x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+not_equal, greater_equal, less_equal, greater, less
+
+Examples
+--------
+>>> np.equal([0, 1, 3], np.arange(3))
+array([ True,  True, False])
+
+What is compared are values, not types. So an int (1) and an array of
+length one can evaluate as True:
+
+>>> np.equal(1, np.ones(1))
+array([ True])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} CLIP (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "CLIP"))))
+
+(def broadcast_to (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "broadcast_to"))))
+(alter-meta! #'broadcast_to assoc :doc "Broadcast an array to a new shape.
+
+    Parameters
+    ----------
+    array : array_like
+        The array to broadcast.
+    shape : tuple
+        The shape of the desired array.
+    subok : bool, optional
+        If True, then sub-classes will be passed-through, otherwise
+        the returned array will be forced to be a base-class array (default).
+
+    Returns
+    -------
+    broadcast : array
+        A readonly view on the original array with the given shape. It is
+        typically not contiguous. Furthermore, more than one element of a
+        broadcasted array may refer to a single memory location.
+
+    Raises
+    ------
+    ValueError
+        If the array is not compatible with the new shape according to NumPy's
+        broadcasting rules.
+
+    Notes
+    -----
+    .. versionadded:: 1.10.0
+
+    Examples
+    --------
+    >>> x = np.array([1, 2, 3])
+    >>> np.broadcast_to(x, (3, 3))
+    array([[1, 2, 3],
+           [1, 2, 3],
+           [1, 2, 3]])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def einsum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "einsum"))))
+(alter-meta! #'einsum assoc :doc "
+    einsum(subscripts, *operands, out=None, dtype=None, order='K',
+           casting='safe', optimize=False)
+
+    Evaluates the Einstein summation convention on the operands.
+
+    Using the Einstein summation convention, many common multi-dimensional,
+    linear algebraic array operations can be represented in a simple fashion.
+    In *implicit* mode `einsum` computes these values.
+
+    In *explicit* mode, `einsum` provides further flexibility to compute
+    other array operations that might not be considered classical Einstein
+    summation operations, by disabling, or forcing summation over specified
+    subscript labels.
+
+    See the notes and examples for clarification.
+
+    Parameters
+    ----------
+    subscripts : str
+        Specifies the subscripts for summation as comma separated list of
+        subscript labels. An implicit (classical Einstein summation)
+        calculation is performed unless the explicit indicator '->' is
+        included as well as subscript labels of the precise output form.
+    operands : list of array_like
+        These are the arrays for the operation.
+    out : ndarray, optional
+        If provided, the calculation is done into this array.
+    dtype : {data-type, None}, optional
+        If provided, forces the calculation to use the data type specified.
+        Note that you may have to also give a more liberal `casting`
+        parameter to allow the conversions. Default is None.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Controls the memory layout of the output. 'C' means it should
+        be C contiguous. 'F' means it should be Fortran contiguous,
+        'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise.
+        'K' means it should be as close to the layout as the inputs as
+        is possible, including arbitrarily permuted axes.
+        Default is 'K'.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur.  Setting this to
+        'unsafe' is not recommended, as it can adversely affect accumulations.
+
+          * 'no' means the data types should not be cast at all.
+          * 'equiv' means only byte-order changes are allowed.
+          * 'safe' means only casts which can preserve values are allowed.
+          * 'same_kind' means only safe casts or casts within a kind,
+            like float64 to float32, are allowed.
+          * 'unsafe' means any data conversions may be done.
+
+        Default is 'safe'.
+    optimize : {False, True, 'greedy', 'optimal'}, optional
+        Controls if intermediate optimization should occur. No optimization
+        will occur if False and True will default to the 'greedy' algorithm.
+        Also accepts an explicit contraction list from the ``np.einsum_path``
+        function. See ``np.einsum_path`` for more details. Defaults to False.
+
+    Returns
+    -------
+    output : ndarray
+        The calculation based on the Einstein summation convention.
+
+    See Also
+    --------
+    einsum_path, dot, inner, outer, tensordot, linalg.multi_dot
+
+    Notes
+    -----
+    .. versionadded:: 1.6.0
+
+    The Einstein summation convention can be used to compute
+    many multi-dimensional, linear algebraic array operations. `einsum`
+    provides a succinct way of representing these.
+
+    A non-exhaustive list of these operations,
+    which can be computed by `einsum`, is shown below along with examples:
+
+    * Trace of an array, :py:func:`numpy.trace`.
+    * Return a diagonal, :py:func:`numpy.diag`.
+    * Array axis summations, :py:func:`numpy.sum`.
+    * Transpositions and permutations, :py:func:`numpy.transpose`.
+    * Matrix multiplication and dot product, :py:func:`numpy.matmul` :py:func:`numpy.dot`.
+    * Vector inner and outer products, :py:func:`numpy.inner` :py:func:`numpy.outer`.
+    * Broadcasting, element-wise and scalar multiplication, :py:func:`numpy.multiply`.
+    * Tensor contractions, :py:func:`numpy.tensordot`.
+    * Chained array operations, in efficient calculation order, :py:func:`numpy.einsum_path`.
+
+    The subscripts string is a comma-separated list of subscript labels,
+    where each label refers to a dimension of the corresponding operand.
+    Whenever a label is repeated it is summed, so ``np.einsum('i,i', a, b)``
+    is equivalent to :py:func:`np.inner(a,b) <numpy.inner>`. If a label
+    appears only once, it is not summed, so ``np.einsum('i', a)`` produces a
+    view of ``a`` with no changes. A further example ``np.einsum('ij,jk', a, b)``
+    describes traditional matrix multiplication and is equivalent to
+    :py:func:`np.matmul(a,b) <numpy.matmul>`. Repeated subscript labels in one
+    operand take the diagonal. For example, ``np.einsum('ii', a)`` is equivalent
+    to :py:func:`np.trace(a) <numpy.trace>`.
+
+    In *implicit mode*, the chosen subscripts are important
+    since the axes of the output are reordered alphabetically.  This
+    means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while
+    ``np.einsum('ji', a)`` takes its transpose. Additionally,
+    ``np.einsum('ij,jk', a, b)`` returns a matrix multiplication, while,
+    ``np.einsum('ij,jh', a, b)`` returns the transpose of the
+    multiplication since subscript 'h' precedes subscript 'i'.
+
+    In *explicit mode* the output can be directly controlled by
+    specifying output subscript labels.  This requires the
+    identifier '->' as well as the list of output subscript labels.
+    This feature increases the flexibility of the function since
+    summing can be disabled or forced when required. The call
+    ``np.einsum('i->', a)`` is like :py:func:`np.sum(a, axis=-1) <numpy.sum>`,
+    and ``np.einsum('ii->i', a)`` is like :py:func:`np.diag(a) <numpy.diag>`.
+    The difference is that `einsum` does not allow broadcasting by default.
+    Additionally ``np.einsum('ij,jh->ih', a, b)`` directly specifies the
+    order of the output subscript labels and therefore returns matrix
+    multiplication, unlike the example above in implicit mode.
+
+    To enable and control broadcasting, use an ellipsis.  Default
+    NumPy-style broadcasting is done by adding an ellipsis
+    to the left of each term, like ``np.einsum('...ii->...i', a)``.
+    To take the trace along the first and last axes,
+    you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix
+    product with the left-most indices instead of rightmost, one can do
+    ``np.einsum('ij...,jk...->ik...', a, b)``.
+
+    When there is only one operand, no axes are summed, and no output
+    parameter is provided, a view into the operand is returned instead
+    of a new array.  Thus, taking the diagonal as ``np.einsum('ii->i', a)``
+    produces a view (changed in version 1.10.0).
+
+    `einsum` also provides an alternative way to provide the subscripts
+    and operands as ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``.
+    If the output shape is not provided in this format `einsum` will be
+    calculated in implicit mode, otherwise it will be performed explicitly.
+    The examples below have corresponding `einsum` calls with the two
+    parameter methods.
+
+    .. versionadded:: 1.10.0
+
+    Views returned from einsum are now writeable whenever the input array
+    is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now
+    have the same effect as :py:func:`np.swapaxes(a, 0, 2) <numpy.swapaxes>`
+    and ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal
+    of a 2D array.
+
+    .. versionadded:: 1.12.0
+
+    Added the ``optimize`` argument which will optimize the contraction order
+    of an einsum expression. For a contraction with three or more operands this
+    can greatly increase the computational efficiency at the cost of a larger
+    memory footprint during computation.
+
+    Typically a 'greedy' algorithm is applied which empirical tests have shown
+    returns the optimal path in the majority of cases. In some cases 'optimal'
+    will return the superlative path through a more expensive, exhaustive search.
+    For iterative calculations it may be advisable to calculate the optimal path
+    once and reuse that path by supplying it as an argument. An example is given
+    below.
+
+    See :py:func:`numpy.einsum_path` for more details.
+
+    Examples
+    --------
+    >>> a = np.arange(25).reshape(5,5)
+    >>> b = np.arange(5)
+    >>> c = np.arange(6).reshape(2,3)
+
+    Trace of a matrix:
+
+    >>> np.einsum('ii', a)
+    60
+    >>> np.einsum(a, [0,0])
+    60
+    >>> np.trace(a)
+    60
+
+    Extract the diagonal (requires explicit form):
+
+    >>> np.einsum('ii->i', a)
+    array([ 0,  6, 12, 18, 24])
+    >>> np.einsum(a, [0,0], [0])
+    array([ 0,  6, 12, 18, 24])
+    >>> np.diag(a)
+    array([ 0,  6, 12, 18, 24])
+
+    Sum over an axis (requires explicit form):
+
+    >>> np.einsum('ij->i', a)
+    array([ 10,  35,  60,  85, 110])
+    >>> np.einsum(a, [0,1], [0])
+    array([ 10,  35,  60,  85, 110])
+    >>> np.sum(a, axis=1)
+    array([ 10,  35,  60,  85, 110])
+
+    For higher dimensional arrays summing a single axis can be done with ellipsis:
+
+    >>> np.einsum('...j->...', a)
+    array([ 10,  35,  60,  85, 110])
+    >>> np.einsum(a, [Ellipsis,1], [Ellipsis])
+    array([ 10,  35,  60,  85, 110])
+
+    Compute a matrix transpose, or reorder any number of axes:
+
+    >>> np.einsum('ji', c)
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+    >>> np.einsum('ij->ji', c)
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+    >>> np.einsum(c, [1,0])
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+    >>> np.transpose(c)
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+
+    Vector inner products:
+
+    >>> np.einsum('i,i', b, b)
+    30
+    >>> np.einsum(b, [0], b, [0])
+    30
+    >>> np.inner(b,b)
+    30
+
+    Matrix vector multiplication:
+
+    >>> np.einsum('ij,j', a, b)
+    array([ 30,  80, 130, 180, 230])
+    >>> np.einsum(a, [0,1], b, [1])
+    array([ 30,  80, 130, 180, 230])
+    >>> np.dot(a, b)
+    array([ 30,  80, 130, 180, 230])
+    >>> np.einsum('...j,j', a, b)
+    array([ 30,  80, 130, 180, 230])
+
+    Broadcasting and scalar multiplication:
+
+    >>> np.einsum('..., ...', 3, c)
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+    >>> np.einsum(',ij', 3, c)
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+    >>> np.einsum(3, [Ellipsis], c, [Ellipsis])
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+    >>> np.multiply(3, c)
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+
+    Vector outer product:
+
+    >>> np.einsum('i,j', np.arange(2)+1, b)
+    array([[0, 1, 2, 3, 4],
+           [0, 2, 4, 6, 8]])
+    >>> np.einsum(np.arange(2)+1, [0], b, [1])
+    array([[0, 1, 2, 3, 4],
+           [0, 2, 4, 6, 8]])
+    >>> np.outer(np.arange(2)+1, b)
+    array([[0, 1, 2, 3, 4],
+           [0, 2, 4, 6, 8]])
+
+    Tensor contraction:
+
+    >>> a = np.arange(60.).reshape(3,4,5)
+    >>> b = np.arange(24.).reshape(4,3,2)
+    >>> np.einsum('ijk,jil->kl', a, b)
+    array([[4400., 4730.],
+           [4532., 4874.],
+           [4664., 5018.],
+           [4796., 5162.],
+           [4928., 5306.]])
+    >>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3])
+    array([[4400., 4730.],
+           [4532., 4874.],
+           [4664., 5018.],
+           [4796., 5162.],
+           [4928., 5306.]])
+    >>> np.tensordot(a,b, axes=([1,0],[0,1]))
+    array([[4400., 4730.],
+           [4532., 4874.],
+           [4664., 5018.],
+           [4796., 5162.],
+           [4928., 5306.]])
+
+    Writeable returned arrays (since version 1.10.0):
+
+    >>> a = np.zeros((3, 3))
+    >>> np.einsum('ii->i', a)[:] = 1
+    >>> a
+    array([[1., 0., 0.],
+           [0., 1., 0.],
+           [0., 0., 1.]])
+
+    Example of ellipsis use:
+
+    >>> a = np.arange(6).reshape((3,2))
+    >>> b = np.arange(12).reshape((4,3))
+    >>> np.einsum('ki,jk->ij', a, b)
+    array([[10, 28, 46, 64],
+           [13, 40, 67, 94]])
+    >>> np.einsum('ki,...k->i...', a, b)
+    array([[10, 28, 46, 64],
+           [13, 40, 67, 94]])
+    >>> np.einsum('k...,jk', a, b)
+    array([[10, 28, 46, 64],
+           [13, 40, 67, 94]])
+
+    Chained array operations. For more complicated contractions, speed ups
+    might be achieved by repeatedly computing a 'greedy' path or pre-computing the
+    'optimal' path and repeatedly applying it, using an
+    `einsum_path` insertion (since version 1.12.0). Performance improvements can be
+    particularly significant with larger arrays:
+
+    >>> a = np.ones(64).reshape(2,4,8)
+
+    Basic `einsum`: ~1520ms  (benchmarked on 3.1GHz Intel i5.)
+
+    >>> for iteration in range(500):
+    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a)
+
+    Sub-optimal `einsum` (due to repeated path calculation time): ~330ms
+
+    >>> for iteration in range(500):
+    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')
+
+    Greedy `einsum` (faster optimal path approximation): ~160ms
+
+    >>> for iteration in range(500):
+    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy')
+
+    Optimal `einsum` (best usage pattern in some use cases): ~110ms
+
+    >>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')[0]
+    >>> for iteration in range(500):
+    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} numarray (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "numarray"))))
+
+(def bytes0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bytes0"))))
+(alter-meta! #'bytes0 assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} little_endian (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "little_endian"))))
+
+(def VisibleDeprecationWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "VisibleDeprecationWarning"))))
+(alter-meta! #'VisibleDeprecationWarning assoc :doc "Visible deprecation warning.
+
+    By default, python will not show deprecation warnings, so this class
+    can be used when a very visible warning is helpful, for example because
+    the usage is most likely a user bug.
+
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def AxisError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "AxisError"))))
+(alter-meta! #'AxisError assoc :doc " Axis supplied was invalid. " :arglists '[[self axis & [{ndim :ndim, msg_prefix :msg_prefix}]] [self axis & [{ndim :ndim}]] [self axis]])
+
+(def apply_along_axis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "apply_along_axis"))))
+(alter-meta! #'apply_along_axis assoc :doc "
+    Apply a function to 1-D slices along the given axis.
+
+    Execute `func1d(a, *args)` where `func1d` operates on 1-D arrays and `a`
+    is a 1-D slice of `arr` along `axis`.
+
+    This is equivalent to (but faster than) the following use of `ndindex` and
+    `s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices::
+
+        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                f = func1d(arr[ii + s_[:,] + kk])
+                Nj = f.shape
+                for jj in ndindex(Nj):
+                    out[ii + jj + kk] = f[jj]
+
+    Equivalently, eliminating the inner loop, this can be expressed as::
+
+        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])
+
+    Parameters
+    ----------
+    func1d : function (M,) -> (Nj...)
+        This function should accept 1-D arrays. It is applied to 1-D
+        slices of `arr` along the specified axis.
+    axis : integer
+        Axis along which `arr` is sliced.
+    arr : ndarray (Ni..., M, Nk...)
+        Input array.
+    args : any
+        Additional arguments to `func1d`.
+    kwargs : any
+        Additional named arguments to `func1d`.
+
+        .. versionadded:: 1.9.0
+
+
+    Returns
+    -------
+    out : ndarray  (Ni..., Nj..., Nk...)
+        The output array. The shape of `out` is identical to the shape of
+        `arr`, except along the `axis` dimension. This axis is removed, and
+        replaced with new dimensions equal to the shape of the return value
+        of `func1d`. So if `func1d` returns a scalar `out` will have one
+        fewer dimensions than `arr`.
+
+    See Also
+    --------
+    apply_over_axes : Apply a function repeatedly over multiple axes.
+
+    Examples
+    --------
+    >>> def my_func(a):
+    ...     \"\"\"Average first and last element of a 1-D array\"\"\"
+    ...     return (a[0] + a[-1]) * 0.5
+    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
+    >>> np.apply_along_axis(my_func, 0, b)
+    array([4., 5., 6.])
+    >>> np.apply_along_axis(my_func, 1, b)
+    array([2.,  5.,  8.])
+
+    For a function that returns a 1D array, the number of dimensions in
+    `outarr` is the same as `arr`.
+
+    >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])
+    >>> np.apply_along_axis(sorted, 1, b)
+    array([[1, 7, 8],
+           [3, 4, 9],
+           [2, 5, 6]])
+
+    For a function that returns a higher dimensional array, those dimensions
+    are inserted in place of the `axis` dimension.
+
+    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
+    >>> np.apply_along_axis(np.diag, -1, b)
+    array([[[1, 0, 0],
+            [0, 2, 0],
+            [0, 0, 3]],
+           [[4, 0, 0],
+            [0, 5, 0],
+            [0, 0, 6]],
+           [[7, 0, 0],
+            [0, 8, 0],
+            [0, 0, 9]]])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def nextafter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nextafter"))))
+(alter-meta! #'nextafter assoc :doc "nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the next floating-point value after x1 towards x2, element-wise.
+
+Parameters
+----------
+x1 : array_like
+    Values to find the next representable value of.
+x2 : array_like
+    The direction where to look for the next representable value of `x1`.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    The next representable values of `x1` in the direction of `x2`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Examples
+--------
+>>> eps = np.finfo(np.float64).eps
+>>> np.nextafter(1, 2) == eps + 1
+True
+>>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps]
+array([ True,  True])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def cumsum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cumsum"))))
+(alter-meta! #'cumsum assoc :doc "
+    Return the cumulative sum of the elements along a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        Axis along which the cumulative sum is computed. The default
+        (None) is to compute the cumsum over the flattened array.
+    dtype : dtype, optional
+        Type of the returned array and of the accumulator in which the
+        elements are summed.  If `dtype` is not specified, it defaults
+        to the dtype of `a`, unless `a` has an integer dtype with a
+        precision less than that of the default platform integer.  In
+        that case, the default platform integer is used.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary. See `ufuncs-output-type` for
+        more details.
+
+    Returns
+    -------
+    cumsum_along_axis : ndarray.
+        A new array holding the result is returned unless `out` is
+        specified, in which case a reference to `out` is returned. The
+        result has the same size as `a`, and the same shape as `a` if
+        `axis` is not None or `a` is a 1-d array.
+
+
+    See Also
+    --------
+    sum : Sum array elements.
+
+    trapz : Integration of array values using the composite trapezoidal rule.
+
+    diff :  Calculate the n-th discrete difference along given axis.
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.
+
+    Examples
+    --------
+    >>> a = np.array([[1,2,3], [4,5,6]])
+    >>> a
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> np.cumsum(a)
+    array([ 1,  3,  6, 10, 15, 21])
+    >>> np.cumsum(a, dtype=float)     # specifies type of output value(s)
+    array([  1.,   3.,   6.,  10.,  15.,  21.])
+
+    >>> np.cumsum(a,axis=0)      # sum over rows for each of the 3 columns
+    array([[1, 2, 3],
+           [5, 7, 9]])
+    >>> np.cumsum(a,axis=1)      # sum over columns for each of the 2 rows
+    array([[ 1,  3,  6],
+           [ 4,  9, 15]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def bartlett (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bartlett"))))
+(alter-meta! #'bartlett assoc :doc "
+    Return the Bartlett window.
+
+    The Bartlett window is very similar to a triangular window, except
+    that the end points are at zero.  It is often used in signal
+    processing for tapering a signal, without generating too much
+    ripple in the frequency domain.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+
+    Returns
+    -------
+    out : array
+        The triangular window, with the maximum value normalized to one
+        (the value one appears only if the number of samples is odd), with
+        the first and last samples equal to zero.
+
+    See Also
+    --------
+    blackman, hamming, hanning, kaiser
+
+    Notes
+    -----
+    The Bartlett window is defined as
+
+    .. math:: w(n) = \\frac{2}{M-1} \\left(
+              \\frac{M-1}{2} - \\left|n - \\frac{M-1}{2}\\right|
+              \\right)
+
+    Most references to the Bartlett window come from the signal
+    processing literature, where it is used as one of many windowing
+    functions for smoothing values.  Note that convolution with this
+    window produces linear interpolation.  It is also known as an
+    apodization (which means\"removing the foot\", i.e. smoothing
+    discontinuities at the beginning and end of the sampled signal) or
+    tapering function. The fourier transform of the Bartlett is the product
+    of two sinc functions.
+    Note the excellent discussion in Kanasewich.
+
+    References
+    ----------
+    .. [1] M.S. Bartlett, \"Periodogram Analysis and Continuous Spectra\",
+           Biometrika 37, 1-16, 1950.
+    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\",
+           The University of Alberta Press, 1975, pp. 109-110.
+    .. [3] A.V. Oppenheim and R.W. Schafer, \"Discrete-Time Signal
+           Processing\", Prentice-Hall, 1999, pp. 468-471.
+    .. [4] Wikipedia, \"Window function\",
+           https://en.wikipedia.org/wiki/Window_function
+    .. [5] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
+           \"Numerical Recipes\", Cambridge University Press, 1986, page 429.
+
+    Examples
+    --------
+    >>> import matplotlib.pyplot as plt
+    >>> np.bartlett(12)
+    array([ 0.        ,  0.18181818,  0.36363636,  0.54545455,  0.72727273, # may vary
+            0.90909091,  0.90909091,  0.72727273,  0.54545455,  0.36363636,
+            0.18181818,  0.        ])
+
+    Plot the window and its frequency response (requires SciPy and matplotlib):
+
+    >>> from numpy.fft import fft, fftshift
+    >>> window = np.bartlett(51)
+    >>> plt.plot(window)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Bartlett window\")
+    Text(0.5, 1.0, 'Bartlett window')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"Sample\")
+    Text(0.5, 0, 'Sample')
+    >>> plt.show()
+
+    >>> plt.figure()
+    <Figure size 640x480 with 0 Axes>
+    >>> A = fft(window, 2048) / 25.5
+    >>> mag = np.abs(fftshift(A))
+    >>> freq = np.linspace(-0.5, 0.5, len(A))
+    >>> with np.errstate(divide='ignore', invalid='ignore'):
+    ...     response = 20 * np.log10(mag)
+    ...
+    >>> response = np.clip(response, -100, 100)
+    >>> plt.plot(freq, response)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Frequency response of Bartlett window\")
+    Text(0.5, 1.0, 'Frequency response of Bartlett window')
+    >>> plt.ylabel(\"Magnitude [dB]\")
+    Text(0, 0.5, 'Magnitude [dB]')
+    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
+    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
+    >>> _ = plt.axis('tight')
+    >>> plt.show()
+
+    " :arglists '[[M]])
+
+(def bool8 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bool8"))))
+(alter-meta! #'bool8 assoc :doc "Boolean type (True or False), stored as a byte.
+    Character code: ``'?'``.
+    Alias: ``np.bool8``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def nanmean (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmean"))))
+(alter-meta! #'nanmean assoc :doc "
+    Compute the arithmetic mean along the specified axis, ignoring NaNs.
+
+    Returns the average of the array elements.  The average is taken over
+    the flattened array by default, otherwise over the specified axis.
+    `float64` intermediate and return values are used for integer inputs.
+
+    For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose mean is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the means are computed. The default is to compute
+        the mean of the flattened array.
+    dtype : data-type, optional
+        Type to use in computing the mean.  For integer inputs, the default
+        is `float64`; for inexact inputs, it is the same as the input
+        dtype.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary. See
+        `ufuncs-output-type` for more details.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `mean` or `sum` methods
+        of sub-classes of `ndarray`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+    Returns
+    -------
+    m : ndarray, see dtype parameter above
+        If `out=None`, returns a new array containing the mean values,
+        otherwise a reference to the output array is returned. Nan is
+        returned for slices that contain only NaNs.
+
+    See Also
+    --------
+    average : Weighted average
+    mean : Arithmetic mean taken while not ignoring NaNs
+    var, nanvar
+
+    Notes
+    -----
+    The arithmetic mean is the sum of the non-NaN elements along the axis
+    divided by the number of non-NaN elements.
+
+    Note that for floating-point input, the mean is computed using the same
+    precision the input has.  Depending on the input data, this can cause
+    the results to be inaccurate, especially for `float32`.  Specifying a
+    higher-precision accumulator using the `dtype` keyword can alleviate
+    this issue.
+
+    Examples
+    --------
+    >>> a = np.array([[1, np.nan], [3, 4]])
+    >>> np.nanmean(a)
+    2.6666666666666665
+    >>> np.nanmean(a, axis=0)
+    array([2.,  4.])
+    >>> np.nanmean(a, axis=1)
+    array([1.,  3.5]) # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def dtype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dtype"))))
+(alter-meta! #'dtype assoc :doc "dtype(obj, align=False, copy=False)
+
+    Create a data type object.
+
+    A numpy array is homogeneous, and contains elements described by a
+    dtype object. A dtype object can be constructed from different
+    combinations of fundamental numeric types.
+
+    Parameters
+    ----------
+    obj
+        Object to be converted to a data type object.
+    align : bool, optional
+        Add padding to the fields to match what a C compiler would output
+        for a similar C-struct. Can be ``True`` only if `obj` is a dictionary
+        or a comma-separated string. If a struct dtype is being created,
+        this also sets a sticky alignment flag ``isalignedstruct``.
+    copy : bool, optional
+        Make a new copy of the data-type object. If ``False``, the result
+        may just be a reference to a built-in data-type object.
+
+    See also
+    --------
+    result_type
+
+    Examples
+    --------
+    Using array-scalar type:
+
+    >>> np.dtype(np.int16)
+    dtype('int16')
+
+    Structured type, one field name 'f1', containing int16:
+
+    >>> np.dtype([('f1', np.int16)])
+    dtype([('f1', '<i2')])
+
+    Structured type, one field named 'f1', in itself containing a structured
+    type with one field:
+
+    >>> np.dtype([('f1', [('f1', np.int16)])])
+    dtype([('f1', [('f1', '<i2')])])
+
+    Structured type, two fields: the first field contains an unsigned int, the
+    second an int32:
+
+    >>> np.dtype([('f1', np.uint64), ('f2', np.int32)])
+    dtype([('f1', '<u8'), ('f2', '<i4')])
+
+    Using array-protocol type strings:
+
+    >>> np.dtype([('a','f8'),('b','S10')])
+    dtype([('a', '<f8'), ('b', 'S10')])
+
+    Using comma-separated field formats.  The shape is (2,3):
+
+    >>> np.dtype(\"i4, (2,3)f8\")
+    dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])
+
+    Using tuples.  ``int`` is a fixed type, 3 the field's shape.  ``void``
+    is a flexible type, here of size 10:
+
+    >>> np.dtype([('hello',(np.int64,3)),('world',np.void,10)])
+    dtype([('hello', '<i8', (3,)), ('world', 'V10')])
+
+    Subdivide ``int16`` into 2 ``int8``'s, called x and y.  0 and 1 are
+    the offsets in bytes:
+
+    >>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))
+    dtype((numpy.int16, [('x', 'i1'), ('y', 'i1')]))
+
+    Using dictionaries.  Two fields named 'gender' and 'age':
+
+    >>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]})
+    dtype([('gender', 'S1'), ('age', 'u1')])
+
+    Offsets in bytes, here 0 and 25:
+
+    >>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
+    dtype([('surname', 'S25'), ('age', 'u1')])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def geomspace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geomspace"))))
+(alter-meta! #'geomspace assoc :doc "
+    Return numbers spaced evenly on a log scale (a geometric progression).
+
+    This is similar to `logspace`, but with endpoints specified directly.
+    Each output sample is a constant multiple of the previous.
+
+    .. versionchanged:: 1.16.0
+        Non-scalar `start` and `stop` are now supported.
+
+    Parameters
+    ----------
+    start : array_like
+        The starting value of the sequence.
+    stop : array_like
+        The final value of the sequence, unless `endpoint` is False.
+        In that case, ``num + 1`` values are spaced over the
+        interval in log-space, of which all but the last (a sequence of
+        length `num`) are returned.
+    num : integer, optional
+        Number of samples to generate.  Default is 50.
+    endpoint : boolean, optional
+        If true, `stop` is the last sample. Otherwise, it is not included.
+        Default is True.
+    dtype : dtype
+        The type of the output array.  If `dtype` is not given, infer the data
+        type from the other input arguments.
+    axis : int, optional
+        The axis in the result to store the samples.  Relevant only if start
+        or stop are array-like.  By default (0), the samples will be along a
+        new axis inserted at the beginning. Use -1 to get an axis at the end.
+
+        .. versionadded:: 1.16.0
+
+    Returns
+    -------
+    samples : ndarray
+        `num` samples, equally spaced on a log scale.
+
+    See Also
+    --------
+    logspace : Similar to geomspace, but with endpoints specified using log
+               and base.
+    linspace : Similar to geomspace, but with arithmetic instead of geometric
+               progression.
+    arange : Similar to linspace, with the step size specified instead of the
+             number of samples.
+
+    Notes
+    -----
+    If the inputs or dtype are complex, the output will follow a logarithmic
+    spiral in the complex plane.  (There are an infinite number of spirals
+    passing through two points; the output will follow the shortest such path.)
+
+    Examples
+    --------
+    >>> np.geomspace(1, 1000, num=4)
+    array([    1.,    10.,   100.,  1000.])
+    >>> np.geomspace(1, 1000, num=3, endpoint=False)
+    array([   1.,   10.,  100.])
+    >>> np.geomspace(1, 1000, num=4, endpoint=False)
+    array([   1.        ,    5.62341325,   31.6227766 ,  177.827941  ])
+    >>> np.geomspace(1, 256, num=9)
+    array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.])
+
+    Note that the above may not produce exact integers:
+
+    >>> np.geomspace(1, 256, num=9, dtype=int)
+    array([  1,   2,   4,   7,  16,  32,  63, 127, 256])
+    >>> np.around(np.geomspace(1, 256, num=9)).astype(int)
+    array([  1,   2,   4,   8,  16,  32,  64, 128, 256])
+
+    Negative, decreasing, and complex inputs are allowed:
+
+    >>> np.geomspace(1000, 1, num=4)
+    array([1000.,  100.,   10.,    1.])
+    >>> np.geomspace(-1000, -1, num=4)
+    array([-1000.,  -100.,   -10.,    -1.])
+    >>> np.geomspace(1j, 1000j, num=4)  # Straight line
+    array([0.   +1.j, 0.  +10.j, 0. +100.j, 0.+1000.j])
+    >>> np.geomspace(-1+0j, 1+0j, num=5)  # Circle
+    array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,
+            6.12323400e-17+1.00000000e+00j,  7.07106781e-01+7.07106781e-01j,
+            1.00000000e+00+0.00000000e+00j])
+
+    Graphical illustration of ``endpoint`` parameter:
+
+    >>> import matplotlib.pyplot as plt
+    >>> N = 10
+    >>> y = np.zeros(N)
+    >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.axis([0.5, 2000, 0, 3])
+    [0.5, 2000, 0, 3]
+    >>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both')
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def round (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "round"))))
+(alter-meta! #'round assoc :doc "
+    Round an array to the given number of decimals.
+
+    See Also
+    --------
+    around : equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def uintp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uintp"))))
+(alter-meta! #'uintp assoc :doc "Unsigned integer type, compatible with C ``unsigned long``.
+    Character code: ``'L'``.
+    Canonical name: ``np.uint``.
+    Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615).
+    Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ubyte (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ubyte"))))
+(alter-meta! #'ubyte assoc :doc "Unsigned integer type, compatible with C ``unsigned char``.
+    Character code: ``'B'``.
+    Canonical name: ``np.ubyte``.
+    Alias *on this platform*: ``np.uint8``: 8-bit unsigned integer (0 to 255)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def triu (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "triu"))))
+(alter-meta! #'triu assoc :doc "
+    Upper triangle of an array.
+
+    Return a copy of a matrix with the elements below the `k`-th diagonal
+    zeroed.
+
+    Please refer to the documentation for `tril` for further details.
+
+    See Also
+    --------
+    tril : lower triangle of an array
+
+    Examples
+    --------
+    >>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
+    array([[ 1,  2,  3],
+           [ 4,  5,  6],
+           [ 0,  8,  9],
+           [ 0,  0, 12]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def diagflat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diagflat"))))
+(alter-meta! #'diagflat assoc :doc "
+    Create a two-dimensional array with the flattened input as a diagonal.
+
+    Parameters
+    ----------
+    v : array_like
+        Input data, which is flattened and set as the `k`-th
+        diagonal of the output.
+    k : int, optional
+        Diagonal to set; 0, the default, corresponds to the \"main\" diagonal,
+        a positive (negative) `k` giving the number of the diagonal above
+        (below) the main.
+
+    Returns
+    -------
+    out : ndarray
+        The 2-D output array.
+
+    See Also
+    --------
+    diag : MATLAB work-alike for 1-D and 2-D arrays.
+    diagonal : Return specified diagonals.
+    trace : Sum along diagonals.
+
+    Examples
+    --------
+    >>> np.diagflat([[1,2], [3,4]])
+    array([[1, 0, 0, 0],
+           [0, 2, 0, 0],
+           [0, 0, 3, 0],
+           [0, 0, 0, 4]])
+
+    >>> np.diagflat([1,2], 1)
+    array([[0, 1, 0],
+           [0, 0, 2],
+           [0, 0, 0]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def complex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex"))))
+(alter-meta! #'complex assoc :doc "Create a complex number from a real part and an optional imaginary part.
+
+This is equivalent to (real + imag*1j) where imag defaults to 0." :arglists '[[self & [args {:as kwargs}]]])
+
+(def object_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "object_"))))
+(alter-meta! #'object_ assoc :doc "Any Python object.
+    Character code: ``'O'``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def isrealobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isrealobj"))))
+(alter-meta! #'isrealobj assoc :doc "
+    Return True if x is a not complex type or an array of complex numbers.
+
+    The type of the input is checked, not the value. So even if the input
+    has an imaginary part equal to zero, `isrealobj` evaluates to False
+    if the data type is complex.
+
+    Parameters
+    ----------
+    x : any
+        The input can be of any type and shape.
+
+    Returns
+    -------
+    y : bool
+        The return value, False if `x` is of a complex type.
+
+    See Also
+    --------
+    iscomplexobj, isreal
+
+    Examples
+    --------
+    >>> np.isrealobj(1)
+    True
+    >>> np.isrealobj(1+0j)
+    False
+    >>> np.isrealobj([3, 1+0j, True])
+    False
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} __name__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__name__"))))
+
+(def ^{:doc "
+Record Arrays
+=============
+Record arrays expose the fields of structured arrays as properties.
+
+Most commonly, ndarrays contain elements of a single type, e.g. floats,
+integers, bools etc.  However, it is possible for elements to be combinations
+of these using structured types, such as::
+
+  >>> a = np.array([(1, 2.0), (1, 2.0)], dtype=[('x', np.int64), ('y', np.float64)])
+  >>> a
+  array([(1, 2.), (1, 2.)], dtype=[('x', '<i8'), ('y', '<f8')])
+
+Here, each element consists of two fields: x (and int), and y (a float).
+This is known as a structured array.  The different fields are analogous
+to columns in a spread-sheet.  The different fields can be accessed as
+one would a dictionary::
+
+  >>> a['x']
+  array([1, 1])
+
+  >>> a['y']
+  array([2., 2.])
+
+Record arrays allow us to access fields as properties::
+
+  >>> ar = np.rec.array(a)
+
+  >>> ar.x
+  array([1, 1])
+
+  >>> ar.y
+  array([2., 2.])
+
+"} rec (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "rec"))))
+
+(def ^{:doc ""} euler_gamma (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "euler_gamma"))))
+
+(def cfloat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cfloat"))))
+(alter-meta! #'cfloat assoc :doc "Complex number type composed of two double-precision floating-point
+    numbers, compatible with Python `complex`.
+    Character code: ``'D'``.
+    Canonical name: ``np.cdouble``.
+    Alias: ``np.cfloat``.
+    Alias: ``np.complex_``.
+    Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def hstack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hstack"))))
+(alter-meta! #'hstack assoc :doc "
+    Stack arrays in sequence horizontally (column wise).
+
+    This is equivalent to concatenation along the second axis, except for 1-D
+    arrays where it concatenates along the first axis. Rebuilds arrays divided
+    by `hsplit`.
+
+    This function makes most sense for arrays with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of ndarrays
+        The arrays must have the same shape along all but the second axis,
+        except 1-D arrays which can be any length.
+
+    Returns
+    -------
+    stacked : ndarray
+        The array formed by stacking the given arrays.
+
+    See Also
+    --------
+    stack : Join a sequence of arrays along a new axis.
+    vstack : Stack arrays in sequence vertically (row wise).
+    dstack : Stack arrays in sequence depth wise (along third axis).
+    concatenate : Join a sequence of arrays along an existing axis.
+    hsplit : Split array along second axis.
+    block : Assemble arrays from blocks.
+
+    Examples
+    --------
+    >>> a = np.array((1,2,3))
+    >>> b = np.array((2,3,4))
+    >>> np.hstack((a,b))
+    array([1, 2, 3, 2, 3, 4])
+    >>> a = np.array([[1],[2],[3]])
+    >>> b = np.array([[2],[3],[4]])
+    >>> np.hstack((a,b))
+    array([[1, 2],
+           [2, 3],
+           [3, 4]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "
+    Base object for a dictionary for look-up with any alias for an array dtype.
+
+    Instances of `_typedict` can not be used as dictionaries directly,
+    first they have to be populated.
+
+    "} nbytes (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "nbytes"))))
+
+(def nanmedian (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmedian"))))
+(alter-meta! #'nanmedian assoc :doc "
+    Compute the median along the specified axis, while ignoring NaNs.
+
+    Returns the median of the array elements.
+
+    .. versionadded:: 1.9.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : {int, sequence of int, None}, optional
+        Axis or axes along which the medians are computed. The default
+        is to compute the median along a flattened version of the array.
+        A sequence of axes is supported since version 1.9.0.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+       If True, then allow use of memory of input array `a` for
+       calculations. The input array will be modified by the call to
+       `median`. This will save memory when you do not need to preserve
+       the contents of the input array. Treat the input as undefined,
+       but it will probably be fully or partially sorted. Default is
+       False. If `overwrite_input` is ``True`` and `a` is not already an
+       `ndarray`, an error will be raised.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If this is anything but the default value it will be passed
+        through (in the special case of an empty array) to the
+        `mean` function of the underlying array.  If the array is
+        a sub-class and `mean` does not have the kwarg `keepdims` this
+        will raise a RuntimeError.
+
+    Returns
+    -------
+    median : ndarray
+        A new array holding the result. If the input contains integers
+        or floats smaller than ``float64``, then the output data-type is
+        ``np.float64``.  Otherwise, the data-type of the output is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean, median, percentile
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the median of ``V`` is the
+    middle value of a sorted copy of ``V``, ``V_sorted`` - i.e.,
+    ``V_sorted[(N-1)/2]``, when ``N`` is odd and the average of the two
+    middle values of ``V_sorted`` when ``N`` is even.
+
+    Examples
+    --------
+    >>> a = np.array([[10.0, 7, 4], [3, 2, 1]])
+    >>> a[0, 1] = np.nan
+    >>> a
+    array([[10., nan,  4.],
+           [ 3.,  2.,  1.]])
+    >>> np.median(a)
+    nan
+    >>> np.nanmedian(a)
+    3.0
+    >>> np.nanmedian(a, axis=0)
+    array([6.5, 2. , 2.5])
+    >>> np.median(a, axis=1)
+    array([nan,  2.])
+    >>> b = a.copy()
+    >>> np.nanmedian(b, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a==b)
+    >>> b = a.copy()
+    >>> np.nanmedian(b, axis=None, overwrite_input=True)
+    3.0
+    >>> assert not np.all(a==b)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def sign (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sign"))))
+(alter-meta! #'sign assoc :doc "sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns an element-wise indication of the sign of a number.
+
+The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``.  nan
+is returned for nan inputs.
+
+For complex inputs, the `sign` function returns
+``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``.
+
+complex(nan, 0) is returned for complex nan inputs.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The sign of `x`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+There is more than one definition of sign in common use for complex
+numbers.  The definition used here is equivalent to :math:`x/\\sqrt{x*x}`
+which is different from a common alternative, :math:`x/|x|`.
+
+Examples
+--------
+>>> np.sign([-5., 4.5])
+array([-1.,  1.])
+>>> np.sign(0)
+0
+>>> np.sign(5-2j)
+(1+0j)" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc "
+Discrete Fourier Transform (:mod:`numpy.fft`)
+=============================================
+
+.. currentmodule:: numpy.fft
+
+Standard FFTs
+-------------
+
+.. autosummary::
+   :toctree: generated/
+
+   fft       Discrete Fourier transform.
+   ifft      Inverse discrete Fourier transform.
+   fft2      Discrete Fourier transform in two dimensions.
+   ifft2     Inverse discrete Fourier transform in two dimensions.
+   fftn      Discrete Fourier transform in N-dimensions.
+   ifftn     Inverse discrete Fourier transform in N dimensions.
+
+Real FFTs
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+   rfft      Real discrete Fourier transform.
+   irfft     Inverse real discrete Fourier transform.
+   rfft2     Real discrete Fourier transform in two dimensions.
+   irfft2    Inverse real discrete Fourier transform in two dimensions.
+   rfftn     Real discrete Fourier transform in N dimensions.
+   irfftn    Inverse real discrete Fourier transform in N dimensions.
+
+Hermitian FFTs
+--------------
+
+.. autosummary::
+   :toctree: generated/
+
+   hfft      Hermitian discrete Fourier transform.
+   ihfft     Inverse Hermitian discrete Fourier transform.
+
+Helper routines
+---------------
+
+.. autosummary::
+   :toctree: generated/
+
+   fftfreq   Discrete Fourier Transform sample frequencies.
+   rfftfreq  DFT sample frequencies (for usage with rfft, irfft).
+   fftshift  Shift zero-frequency component to center of spectrum.
+   ifftshift Inverse of fftshift.
+
+
+Background information
+----------------------
+
+Fourier analysis is fundamentally a method for expressing a function as a
+sum of periodic components, and for recovering the function from those
+components.  When both the function and its Fourier transform are
+replaced with discretized counterparts, it is called the discrete Fourier
+transform (DFT).  The DFT has become a mainstay of numerical computing in
+part because of a very fast algorithm for computing it, called the Fast
+Fourier Transform (FFT), which was known to Gauss (1805) and was brought
+to light in its current form by Cooley and Tukey [CT]_.  Press et al. [NR]_
+provide an accessible introduction to Fourier analysis and its
+applications.
+
+Because the discrete Fourier transform separates its input into
+components that contribute at discrete frequencies, it has a great number
+of applications in digital signal processing, e.g., for filtering, and in
+this context the discretized input to the transform is customarily
+referred to as a *signal*, which exists in the *time domain*.  The output
+is called a *spectrum* or *transform* and exists in the *frequency
+domain*.
+
+Implementation details
+----------------------
+
+There are many ways to define the DFT, varying in the sign of the
+exponent, normalization, etc.  In this implementation, the DFT is defined
+as
+
+.. math::
+   A_k =  \\sum_{m=0}^{n-1} a_m \\exp\\left\\{-2\\pi i{mk \\over n}\\right\\}
+   \\qquad k = 0,\\ldots,n-1.
+
+The DFT is in general defined for complex inputs and outputs, and a
+single-frequency component at linear frequency :math:`f` is
+represented by a complex exponential
+:math:`a_m = \\exp\\{2\\pi i\\,f m\\Delta t\\}`, where :math:`\\Delta t`
+is the sampling interval.
+
+The values in the result follow so-called \"standard\" order: If ``A =
+fft(a, n)``, then ``A[0]`` contains the zero-frequency term (the sum of
+the signal), which is always purely real for real inputs. Then ``A[1:n/2]``
+contains the positive-frequency terms, and ``A[n/2+1:]`` contains the
+negative-frequency terms, in order of decreasingly negative frequency.
+For an even number of input points, ``A[n/2]`` represents both positive and
+negative Nyquist frequency, and is also purely real for real input.  For
+an odd number of input points, ``A[(n-1)/2]`` contains the largest positive
+frequency, while ``A[(n+1)/2]`` contains the largest negative frequency.
+The routine ``np.fft.fftfreq(n)`` returns an array giving the frequencies
+of corresponding elements in the output.  The routine
+``np.fft.fftshift(A)`` shifts transforms and their frequencies to put the
+zero-frequency components in the middle, and ``np.fft.ifftshift(A)`` undoes
+that shift.
+
+When the input `a` is a time-domain signal and ``A = fft(a)``, ``np.abs(A)``
+is its amplitude spectrum and ``np.abs(A)**2`` is its power spectrum.
+The phase spectrum is obtained by ``np.angle(A)``.
+
+The inverse DFT is defined as
+
+.. math::
+   a_m = \\frac{1}{n}\\sum_{k=0}^{n-1}A_k\\exp\\left\\{2\\pi i{mk\\over n}\\right\\}
+   \\qquad m = 0,\\ldots,n-1.
+
+It differs from the forward transform by the sign of the exponential
+argument and the default normalization by :math:`1/n`.
+
+Type Promotion
+--------------
+
+`numpy.fft` promotes ``float32`` and ``complex64`` arrays to ``float64`` and
+``complex128`` arrays respectively. For an FFT implementation that does not
+promote input arrays, see `scipy.fftpack`.
+
+Normalization
+-------------
+
+The default normalization has the direct transforms unscaled and the inverse
+transforms are scaled by :math:`1/n`. It is possible to obtain unitary
+transforms by setting the keyword argument ``norm`` to ``\"ortho\"`` (default is
+`None`) so that both direct and inverse transforms will be scaled by
+:math:`1/\\sqrt{n}`.
+
+Real and Hermitian transforms
+-----------------------------
+
+When the input is purely real, its transform is Hermitian, i.e., the
+component at frequency :math:`f_k` is the complex conjugate of the
+component at frequency :math:`-f_k`, which means that for real
+inputs there is no information in the negative frequency components that
+is not already available from the positive frequency components.
+The family of `rfft` functions is
+designed to operate on real inputs, and exploits this symmetry by
+computing only the positive frequency components, up to and including the
+Nyquist frequency.  Thus, ``n`` input points produce ``n/2+1`` complex
+output points.  The inverses of this family assumes the same symmetry of
+its input, and for an output of ``n`` points uses ``n/2+1`` input points.
+
+Correspondingly, when the spectrum is purely real, the signal is
+Hermitian.  The `hfft` family of functions exploits this symmetry by
+using ``n/2+1`` complex points in the input (time) domain for ``n`` real
+points in the frequency domain.
+
+In higher dimensions, FFTs are used, e.g., for image analysis and
+filtering.  The computational efficiency of the FFT means that it can
+also be a faster way to compute large convolutions, using the property
+that a convolution in the time domain is equivalent to a point-by-point
+multiplication in the frequency domain.
+
+Higher dimensions
+-----------------
+
+In two dimensions, the DFT is defined as
+
+.. math::
+   A_{kl} =  \\sum_{m=0}^{M-1} \\sum_{n=0}^{N-1}
+   a_{mn}\\exp\\left\\{-2\\pi i \\left({mk\\over M}+{nl\\over N}\\right)\\right\\}
+   \\qquad k = 0, \\ldots, M-1;\\quad l = 0, \\ldots, N-1,
+
+which extends in the obvious way to higher dimensions, and the inverses
+in higher dimensions also extend in the same way.
+
+References
+----------
+
+.. [CT] Cooley, James W., and John W. Tukey, 1965, \"An algorithm for the
+        machine calculation of complex Fourier series,\" *Math. Comput.*
+        19: 297-301.
+
+.. [NR] Press, W., Teukolsky, S., Vetterline, W.T., and Flannery, B.P.,
+        2007, *Numerical Recipes: The Art of Scientific Computing*, ch.
+        12-13.  Cambridge Univ. Press, Cambridge, UK.
+
+Examples
+--------
+
+For examples, see the various functions.
+
+"} fft (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "fft"))))
+
+(def finfo (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "finfo"))))
+(alter-meta! #'finfo assoc :doc "
+    finfo(dtype)
+
+    Machine limits for floating point types.
+
+    Attributes
+    ----------
+    bits : int
+        The number of bits occupied by the type.
+    eps : float
+        The smallest representable positive number such that
+        ``1.0 + eps != 1.0``.  Type of `eps` is an appropriate floating
+        point type.
+    epsneg : floating point number of the appropriate type
+        The smallest representable positive number such that
+        ``1.0 - epsneg != 1.0``.
+    iexp : int
+        The number of bits in the exponent portion of the floating point
+        representation.
+    machar : MachAr
+        The object which calculated these parameters and holds more
+        detailed information.
+    machep : int
+        The exponent that yields `eps`.
+    max : floating point number of the appropriate type
+        The largest representable number.
+    maxexp : int
+        The smallest positive power of the base (2) that causes overflow.
+    min : floating point number of the appropriate type
+        The smallest representable number, typically ``-max``.
+    minexp : int
+        The most negative power of the base (2) consistent with there
+        being no leading 0's in the mantissa.
+    negep : int
+        The exponent that yields `epsneg`.
+    nexp : int
+        The number of bits in the exponent including its sign and bias.
+    nmant : int
+        The number of bits in the mantissa.
+    precision : int
+        The approximate number of decimal digits to which this kind of
+        float is precise.
+    resolution : floating point number of the appropriate type
+        The approximate decimal resolution of this type, i.e.,
+        ``10**-precision``.
+    tiny : float
+        The smallest positive usable number.  Type of `tiny` is an
+        appropriate floating point type.
+
+    Parameters
+    ----------
+    dtype : float, dtype, or instance
+        Kind of floating point data-type about which to get information.
+
+    See Also
+    --------
+    MachAr : The implementation of the tests that produce this information.
+    iinfo : The equivalent for integer data types.
+
+    Notes
+    -----
+    For developers of NumPy: do not instantiate this at the module level.
+    The initial calculation of these parameters is expensive and negatively
+    impacts import times.  These objects are cached, so calling ``finfo()``
+    repeatedly inside your functions is not a problem.
+
+    " :arglists '[[self & [args {:as kwargs}]]])
+
+(def issubdtype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issubdtype"))))
+(alter-meta! #'issubdtype assoc :doc "
+    Returns True if first argument is a typecode lower/equal in type hierarchy.
+
+    Parameters
+    ----------
+    arg1, arg2 : dtype_like
+        dtype or string representing a typecode.
+
+    Returns
+    -------
+    out : bool
+
+    See Also
+    --------
+    issubsctype, issubclass_
+    numpy.core.numerictypes : Overview of numpy type hierarchy.
+
+    Examples
+    --------
+    >>> np.issubdtype('S1', np.string_)
+    True
+    >>> np.issubdtype(np.float64, np.float32)
+    False
+
+    " :arglists '[[arg1 arg2]])
+
+(def array (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array"))))
+(alter-meta! #'array assoc :doc "array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)
+
+    Create an array.
+
+    Parameters
+    ----------
+    object : array_like
+        An array, any object exposing the array interface, an object whose
+        __array__ method returns an array, or any (nested) sequence.
+    dtype : data-type, optional
+        The desired data-type for the array.  If not given, then the type will
+        be determined as the minimum type required to hold the objects in the
+        sequence.
+    copy : bool, optional
+        If true (default), then the object is copied.  Otherwise, a copy will
+        only be made if __array__ returns a copy, if obj is a nested sequence,
+        or if a copy is needed to satisfy any of the other requirements
+        (`dtype`, `order`, etc.).
+    order : {'K', 'A', 'C', 'F'}, optional
+        Specify the memory layout of the array. If object is not an array, the
+        newly created array will be in C order (row major) unless 'F' is
+        specified, in which case it will be in Fortran order (column major).
+        If object is an array the following holds.
+
+        ===== ========= ===================================================
+        order  no copy                     copy=True
+        ===== ========= ===================================================
+        'K'   unchanged F & C order preserved, otherwise most similar order
+        'A'   unchanged F order if input is F and not C, otherwise C order
+        'C'   C order   C order
+        'F'   F order   F order
+        ===== ========= ===================================================
+
+        When ``copy=False`` and a copy is made for other reasons, the result is
+        the same as if ``copy=True``, with some exceptions for `A`, see the
+        Notes section. The default order is 'K'.
+    subok : bool, optional
+        If True, then sub-classes will be passed-through, otherwise
+        the returned array will be forced to be a base-class array (default).
+    ndmin : int, optional
+        Specifies the minimum number of dimensions that the resulting
+        array should have.  Ones will be pre-pended to the shape as
+        needed to meet this requirement.
+
+    Returns
+    -------
+    out : ndarray
+        An array object satisfying the specified requirements.
+
+    See Also
+    --------
+    empty_like : Return an empty array with shape and type of input.
+    ones_like : Return an array of ones with shape and type of input.
+    zeros_like : Return an array of zeros with shape and type of input.
+    full_like : Return a new array with shape of input filled with value.
+    empty : Return a new uninitialized array.
+    ones : Return a new array setting values to one.
+    zeros : Return a new array setting values to zero.
+    full : Return a new array of given shape filled with value.
+
+
+    Notes
+    -----
+    When order is 'A' and `object` is an array in neither 'C' nor 'F' order,
+    and a copy is forced by a change in dtype, then the order of the result is
+    not necessarily 'C' as expected. This is likely a bug.
+
+    Examples
+    --------
+    >>> np.array([1, 2, 3])
+    array([1, 2, 3])
+
+    Upcasting:
+
+    >>> np.array([1, 2, 3.0])
+    array([ 1.,  2.,  3.])
+
+    More than one dimension:
+
+    >>> np.array([[1, 2], [3, 4]])
+    array([[1, 2],
+           [3, 4]])
+
+    Minimum dimensions 2:
+
+    >>> np.array([1, 2, 3], ndmin=2)
+    array([[1, 2, 3]])
+
+    Type provided:
+
+    >>> np.array([1, 2, 3], dtype=complex)
+    array([ 1.+0.j,  2.+0.j,  3.+0.j])
+
+    Data-type consisting of more than one element:
+
+    >>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
+    >>> x['a']
+    array([1, 3])
+
+    Creating an array from sub-classes:
+
+    >>> np.array(np.mat('1 2; 3 4'))
+    array([[1, 2],
+           [3, 4]])
+
+    >>> np.array(np.mat('1 2; 3 4'), subok=True)
+    matrix([[1, 2],
+            [3, 4]])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def logaddexp2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logaddexp2"))))
+(alter-meta! #'logaddexp2 assoc :doc "logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Logarithm of the sum of exponentiations of the inputs in base-2.
+
+Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine
+learning when the calculated probabilities of events may be so small as
+to exceed the range of normal floating point numbers.  In such cases
+the base-2 logarithm of the calculated probability can be used instead.
+This function allows adding probabilities stored in such a fashion.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input values. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+result : ndarray
+    Base-2 logarithm of ``2**x1 + 2**x2``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logaddexp: Logarithm of the sum of exponentiations of the inputs.
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+Examples
+--------
+>>> prob1 = np.log2(1e-50)
+>>> prob2 = np.log2(2.5e-50)
+>>> prob12 = np.logaddexp2(prob1, prob2)
+>>> prob1, prob2, prob12
+(-166.09640474436813, -164.77447664948076, -164.28904982231052)
+>>> 2**prob12
+3.4999999999999914e-50" :arglists '[[self & [args {:as kwargs}]]])
+
+(def transpose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "transpose"))))
+(alter-meta! #'transpose assoc :doc "
+    Permute the dimensions of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axes : list of ints, optional
+        By default, reverse the dimensions, otherwise permute the axes
+        according to the values given.
+
+    Returns
+    -------
+    p : ndarray
+        `a` with its axes permuted.  A view is returned whenever
+        possible.
+
+    See Also
+    --------
+    moveaxis
+    argsort
+
+    Notes
+    -----
+    Use `transpose(a, argsort(axes))` to invert the transposition of tensors
+    when using the `axes` keyword argument.
+
+    Transposing a 1-D array returns an unchanged view of the original array.
+
+    Examples
+    --------
+    >>> x = np.arange(4).reshape((2,2))
+    >>> x
+    array([[0, 1],
+           [2, 3]])
+
+    >>> np.transpose(x)
+    array([[0, 2],
+           [1, 3]])
+
+    >>> x = np.ones((1, 2, 3))
+    >>> np.transpose(x, (1, 0, 2)).shape
+    (2, 1, 3)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def tril_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tril_indices"))))
+(alter-meta! #'tril_indices assoc :doc "
+    Return the indices for the lower-triangle of an (n, m) array.
+
+    Parameters
+    ----------
+    n : int
+        The row dimension of the arrays for which the returned
+        indices will be valid.
+    k : int, optional
+        Diagonal offset (see `tril` for details).
+    m : int, optional
+        .. versionadded:: 1.9.0
+
+        The column dimension of the arrays for which the returned
+        arrays will be valid.
+        By default `m` is taken equal to `n`.
+
+
+    Returns
+    -------
+    inds : tuple of arrays
+        The indices for the triangle. The returned tuple contains two arrays,
+        each with the indices along one dimension of the array.
+
+    See also
+    --------
+    triu_indices : similar function, for upper-triangular.
+    mask_indices : generic function accepting an arbitrary mask function.
+    tril, triu
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    Compute two different sets of indices to access 4x4 arrays, one for the
+    lower triangular part starting at the main diagonal, and one starting two
+    diagonals further right:
+
+    >>> il1 = np.tril_indices(4)
+    >>> il2 = np.tril_indices(4, 2)
+
+    Here is how they can be used with a sample array:
+
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+
+    Both for indexing:
+
+    >>> a[il1]
+    array([ 0,  4,  5, ..., 13, 14, 15])
+
+    And for assigning values:
+
+    >>> a[il1] = -1
+    >>> a
+    array([[-1,  1,  2,  3],
+           [-1, -1,  6,  7],
+           [-1, -1, -1, 11],
+           [-1, -1, -1, -1]])
+
+    These cover almost the whole array (two diagonals right of the main one):
+
+    >>> a[il2] = -10
+    >>> a
+    array([[-10, -10, -10,   3],
+           [-10, -10, -10, -10],
+           [-10, -10, -10, -10],
+           [-10, -10, -10, -10]])
+
+    " :arglists '[[n & [{k :k, m :m}]] [n & [{k :k}]] [n]])
+
+(def asarray_chkfinite (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asarray_chkfinite"))))
+(alter-meta! #'asarray_chkfinite assoc :doc "Convert the input to an array, checking for NaNs or Infs.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data, in any form that can be converted to an array.  This
+        includes lists, lists of tuples, tuples, tuples of tuples, tuples
+        of lists and ndarrays.  Success requires no NaNs or Infs.
+    dtype : data-type, optional
+        By default, the data-type is inferred from the input data.
+    order : {'C', 'F'}, optional
+         Whether to use row-major (C-style) or
+         column-major (Fortran-style) memory representation.
+         Defaults to 'C'.
+
+    Returns
+    -------
+    out : ndarray
+        Array interpretation of `a`.  No copy is performed if the input
+        is already an ndarray.  If `a` is a subclass of ndarray, a base
+        class ndarray is returned.
+
+    Raises
+    ------
+    ValueError
+        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
+
+    See Also
+    --------
+    asarray : Create and array.
+    asanyarray : Similar function which passes through subclasses.
+    ascontiguousarray : Convert input to a contiguous array.
+    asfarray : Convert input to a floating point ndarray.
+    asfortranarray : Convert input to an ndarray with column-major
+                     memory order.
+    fromiter : Create an array from an iterator.
+    fromfunction : Construct an array by executing a function on grid
+                   positions.
+
+    Examples
+    --------
+    Convert a list into an array.  If all elements are finite
+    ``asarray_chkfinite`` is identical to ``asarray``.
+
+    >>> a = [1, 2]
+    >>> np.asarray_chkfinite(a, dtype=float)
+    array([1., 2.])
+
+    Raises ValueError if array_like contains Nans or Infs.
+
+    >>> a = [1, 2, np.inf]
+    >>> try:
+    ...     np.asarray_chkfinite(a)
+    ... except ValueError:
+    ...     print('ValueError')
+    ...
+    ValueError
+
+    " :arglists '[[a & [{dtype :dtype, order :order}]] [a & [{dtype :dtype}]] [a]])
+
+(def arccos (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arccos"))))
+(alter-meta! #'arccos assoc :doc "arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Trigonometric inverse cosine, element-wise.
+
+The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``.
+
+Parameters
+----------
+x : array_like
+    `x`-coordinate on the unit circle.
+    For real arguments, the domain is [-1, 1].
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+angle : ndarray
+    The angle of the ray intersecting the unit circle at the given
+    `x`-coordinate in radians [0, pi].
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+cos, arctan, arcsin, emath.arccos
+
+Notes
+-----
+`arccos` is a multivalued function: for each `x` there are infinitely
+many numbers `z` such that `cos(z) = x`. The convention is to return
+the angle `z` whose real part lies in `[0, pi]`.
+
+For real-valued input data types, `arccos` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arccos` is a complex analytic function that
+has branch cuts `[-inf, -1]` and `[1, inf]` and is continuous from
+above on the former and from below on the latter.
+
+The inverse `cos` is also known as `acos` or cos^-1.
+
+References
+----------
+M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+10th printing, 1964, pp. 79. http://www.math.sfu.ca/~cbm/aands/
+
+Examples
+--------
+We expect the arccos of 1 to be 0, and of -1 to be pi:
+
+>>> np.arccos([1, -1])
+array([ 0.        ,  3.14159265])
+
+Plot arccos:
+
+>>> import matplotlib.pyplot as plt
+>>> x = np.linspace(-1, 1, num=100)
+>>> plt.plot(x, np.arccos(x))
+>>> plt.axis('tight')
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc "
+    A nicer way to build up index tuples for arrays.
+
+    .. note::
+       Use one of the two predefined instances `index_exp` or `s_`
+       rather than directly using `IndexExpression`.
+
+    For any index combination, including slicing and axis insertion,
+    ``a[indices]`` is the same as ``a[np.index_exp[indices]]`` for any
+    array `a`. However, ``np.index_exp[indices]`` can be used anywhere
+    in Python code and returns a tuple of slice objects that can be
+    used in the construction of complex index expressions.
+
+    Parameters
+    ----------
+    maketuple : bool
+        If True, always returns a tuple.
+
+    See Also
+    --------
+    index_exp : Predefined instance that always returns a tuple:
+       `index_exp = IndexExpression(maketuple=True)`.
+    s_ : Predefined instance without tuple conversion:
+       `s_ = IndexExpression(maketuple=False)`.
+
+    Notes
+    -----
+    You can do all this with `slice()` plus a few special objects,
+    but there's a lot to remember and this version is simpler because
+    it uses the standard array indexing syntax.
+
+    Examples
+    --------
+    >>> np.s_[2::2]
+    slice(2, None, 2)
+    >>> np.index_exp[2::2]
+    (slice(2, None, 2),)
+
+    >>> np.array([0, 1, 2, 3, 4])[np.s_[2::2]]
+    array([2, 4])
+
+    "} s_ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "s_"))))
+
+(def ^{:doc "
+Contains the core of NumPy: ndarray, ufuncs, dtypes, etc.
+
+Please note that this module is private.  All functions and objects
+are available in the main ``numpy`` namespace - use that instead.
+
+"} core (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "core"))))
+
+(def complex64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex64"))))
+(alter-meta! #'complex64 assoc :doc "Complex number type composed of two single-precision floating-point
+    numbers.
+    Character code: ``'F'``.
+    Canonical name: ``np.csingle``.
+    Alias: ``np.singlecomplex``.
+    Alias *on this platform*: ``np.complex64``: Complex number type composed of 2 32-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def arccosh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arccosh"))))
+(alter-meta! #'arccosh assoc :doc "arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Inverse hyperbolic cosine, element-wise.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+arccosh : ndarray
+    Array of the same shape as `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+
+cosh, arcsinh, sinh, arctanh, tanh
+
+Notes
+-----
+`arccosh` is a multivalued function: for each `x` there are infinitely
+many numbers `z` such that `cosh(z) = x`. The convention is to return the
+`z` whose imaginary part lies in `[-pi, pi]` and the real part in
+``[0, inf]``.
+
+For real-valued input data types, `arccosh` always returns real output.
+For each value that cannot be expressed as a real number or infinity, it
+yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arccosh` is a complex analytical function that
+has a branch cut `[-inf, 1]` and is continuous from above on it.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Inverse hyperbolic function\",
+       https://en.wikipedia.org/wiki/Arccosh
+
+Examples
+--------
+>>> np.arccosh([np.e, 10.0])
+array([ 1.65745445,  2.99322285])
+>>> np.arccosh(1)
+0.0" :arglists '[[self & [args {:as kwargs}]]])
+
+(def apply_over_axes (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "apply_over_axes"))))
+(alter-meta! #'apply_over_axes assoc :doc "
+    Apply a function repeatedly over multiple axes.
+
+    `func` is called as `res = func(a, axis)`, where `axis` is the first
+    element of `axes`.  The result `res` of the function call must have
+    either the same dimensions as `a` or one less dimension.  If `res`
+    has one less dimension than `a`, a dimension is inserted before
+    `axis`.  The call to `func` is then repeated for each axis in `axes`,
+    with `res` as the first argument.
+
+    Parameters
+    ----------
+    func : function
+        This function must take two arguments, `func(a, axis)`.
+    a : array_like
+        Input array.
+    axes : array_like
+        Axes over which `func` is applied; the elements must be integers.
+
+    Returns
+    -------
+    apply_over_axis : ndarray
+        The output array.  The number of dimensions is the same as `a`,
+        but the shape can be different.  This depends on whether `func`
+        changes the shape of its output with respect to its input.
+
+    See Also
+    --------
+    apply_along_axis :
+        Apply a function to 1-D slices of an array along the given axis.
+
+    Notes
+    ------
+    This function is equivalent to tuple axis arguments to reorderable ufuncs
+    with keepdims=True. Tuple axis arguments to ufuncs have been available since
+    version 1.7.0.
+
+    Examples
+    --------
+    >>> a = np.arange(24).reshape(2,3,4)
+    >>> a
+    array([[[ 0,  1,  2,  3],
+            [ 4,  5,  6,  7],
+            [ 8,  9, 10, 11]],
+           [[12, 13, 14, 15],
+            [16, 17, 18, 19],
+            [20, 21, 22, 23]]])
+
+    Sum over axes 0 and 2. The result has same number of dimensions
+    as the original array:
+
+    >>> np.apply_over_axes(np.sum, a, [0,2])
+    array([[[ 60],
+            [ 92],
+            [124]]])
+
+    Tuple axis arguments to ufuncs are equivalent:
+
+    >>> np.sum(a, axis=(0,2), keepdims=True)
+    array([[[ 60],
+            [ 92],
+            [124]]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def tanh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tanh"))))
+(alter-meta! #'tanh assoc :doc "tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute hyperbolic tangent element-wise.
+
+Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding hyperbolic tangent values.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+If `out` is provided, the function writes the result into it,
+and returns a reference to `out`.  (See Examples)
+
+References
+----------
+.. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
+       New York, NY: Dover, 1972, pg. 83.
+       http://www.math.sfu.ca/~cbm/aands/
+
+.. [2] Wikipedia, \"Hyperbolic function\",
+       https://en.wikipedia.org/wiki/Hyperbolic_function
+
+Examples
+--------
+>>> np.tanh((0, np.pi*1j, np.pi*1j/2))
+array([ 0. +0.00000000e+00j,  0. -1.22460635e-16j,  0. +1.63317787e+16j])
+
+>>> # Example of providing the optional output parameter illustrating
+>>> # that what is returned is a reference to said parameter
+>>> out1 = np.array([0], dtype='d')
+>>> out2 = np.tanh([0.1], out1)
+>>> out2 is out1
+True
+
+>>> # Example of ValueError due to provision of shape mis-matched `out`
+>>> np.tanh(np.zeros((3,3)),np.zeros((2,2)))
+Traceback (most recent call last):
+  File \"<stdin>\", line 1, in <module>
+ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]])
+
+(def frompyfunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "frompyfunc"))))
+(alter-meta! #'frompyfunc assoc :doc "frompyfunc(func, nin, nout)
+
+    Takes an arbitrary Python function and returns a NumPy ufunc.
+
+    Can be used, for example, to add broadcasting to a built-in Python
+    function (see Examples section).
+
+    Parameters
+    ----------
+    func : Python function object
+        An arbitrary Python function.
+    nin : int
+        The number of input arguments.
+    nout : int
+        The number of objects returned by `func`.
+
+    Returns
+    -------
+    out : ufunc
+        Returns a NumPy universal function (``ufunc``) object.
+
+    See Also
+    --------
+    vectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy.
+
+    Notes
+    -----
+    The returned ufunc always returns PyObject arrays.
+
+    Examples
+    --------
+    Use frompyfunc to add broadcasting to the Python function ``oct``:
+
+    >>> oct_array = np.frompyfunc(oct, 1, 1)
+    >>> oct_array(np.array((10, 30, 100)))
+    array(['0o12', '0o36', '0o144'], dtype=object)
+    >>> np.array((oct(10), oct(30), oct(100))) # for comparison
+    array(['0o12', '0o36', '0o144'], dtype='<U5')" :arglists '[[self & [args {:as kwargs}]]])
+
+(def complex256 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex256"))))
+(alter-meta! #'complex256 assoc :doc "Complex number type composed of two extended-precision floating-point
+    numbers.
+    Character code: ``'G'``.
+    Canonical name: ``np.clongdouble``.
+    Alias: ``np.clongfloat``.
+    Alias: ``np.longcomplex``.
+    Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} MAXDIMS (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "MAXDIMS"))))
+
+(def expand_dims (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "expand_dims"))))
+(alter-meta! #'expand_dims assoc :doc "
+    Expand the shape of an array.
+
+    Insert a new axis that will appear at the `axis` position in the expanded
+    array shape.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int or tuple of ints
+        Position in the expanded axes where the new axis (or axes) is placed.
+
+        .. deprecated:: 1.13.0
+            Passing an axis where ``axis > a.ndim`` will be treated as
+            ``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will
+            be treated as ``axis == 0``. This behavior is deprecated.
+
+        .. versionchanged:: 1.18.0
+            A tuple of axes is now supported.  Out of range axes as
+            described above are now forbidden and raise an `AxisError`.
+
+    Returns
+    -------
+    result : ndarray
+        View of `a` with the number of dimensions increased.
+
+    See Also
+    --------
+    squeeze : The inverse operation, removing singleton dimensions
+    reshape : Insert, remove, and combine dimensions, and resize existing ones
+    doc.indexing, atleast_1d, atleast_2d, atleast_3d
+
+    Examples
+    --------
+    >>> x = np.array([1, 2])
+    >>> x.shape
+    (2,)
+
+    The following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``:
+
+    >>> y = np.expand_dims(x, axis=0)
+    >>> y
+    array([[1, 2]])
+    >>> y.shape
+    (1, 2)
+
+    The following is equivalent to ``x[:, np.newaxis]``:
+
+    >>> y = np.expand_dims(x, axis=1)
+    >>> y
+    array([[1],
+           [2]])
+    >>> y.shape
+    (2, 1)
+
+    ``axis`` may also be a tuple:
+
+    >>> y = np.expand_dims(x, axis=(0, 1))
+    >>> y
+    array([[[1, 2]]])
+
+    >>> y = np.expand_dims(x, axis=(2, 0))
+    >>> y
+    array([[[1],
+            [2]]])
+
+    Note that some examples may use ``None`` instead of ``np.newaxis``.  These
+    are the same objects:
+
+    >>> np.newaxis is None
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def fliplr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fliplr"))))
+(alter-meta! #'fliplr assoc :doc "
+    Flip array in the left/right direction.
+
+    Flip the entries in each row in the left/right direction.
+    Columns are preserved, but appear in a different order than before.
+
+    Parameters
+    ----------
+    m : array_like
+        Input array, must be at least 2-D.
+
+    Returns
+    -------
+    f : ndarray
+        A view of `m` with the columns reversed.  Since a view
+        is returned, this operation is :math:`\\mathcal O(1)`.
+
+    See Also
+    --------
+    flipud : Flip array in the up/down direction.
+    rot90 : Rotate array counterclockwise.
+
+    Notes
+    -----
+    Equivalent to m[:,::-1]. Requires the array to be at least 2-D.
+
+    Examples
+    --------
+    >>> A = np.diag([1.,2.,3.])
+    >>> A
+    array([[1.,  0.,  0.],
+           [0.,  2.,  0.],
+           [0.,  0.,  3.]])
+    >>> np.fliplr(A)
+    array([[0.,  0.,  1.],
+           [0.,  2.,  0.],
+           [3.,  0.,  0.]])
+
+    >>> A = np.random.randn(2,3,5)
+    >>> np.all(np.fliplr(A) == A[:,::-1,...])
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def tri (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tri"))))
+(alter-meta! #'tri assoc :doc "
+    An array with ones at and below the given diagonal and zeros elsewhere.
+
+    Parameters
+    ----------
+    N : int
+        Number of rows in the array.
+    M : int, optional
+        Number of columns in the array.
+        By default, `M` is taken equal to `N`.
+    k : int, optional
+        The sub-diagonal at and below which the array is filled.
+        `k` = 0 is the main diagonal, while `k` < 0 is below it,
+        and `k` > 0 is above.  The default is 0.
+    dtype : dtype, optional
+        Data type of the returned array.  The default is float.
+
+    Returns
+    -------
+    tri : ndarray of shape (N, M)
+        Array with its lower triangle filled with ones and zero elsewhere;
+        in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise.
+
+    Examples
+    --------
+    >>> np.tri(3, 5, 2, dtype=int)
+    array([[1, 1, 1, 0, 0],
+           [1, 1, 1, 1, 0],
+           [1, 1, 1, 1, 1]])
+
+    >>> np.tri(3, 5, -1)
+    array([[0.,  0.,  0.,  0.,  0.],
+           [1.,  0.,  0.,  0.,  0.],
+           [1.,  1.,  0.,  0.,  0.]])
+
+    " :arglists '[[N & [{M :M, k :k, dtype :dtype}]] [N & [{M :M, k :k}]] [N & [{M :M}]] [N]])
+
+(def absolute (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "absolute"))))
+(alter-meta! #'absolute assoc :doc "absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Calculate the absolute value element-wise.
+
+``np.abs`` is a shorthand for this function.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+absolute : ndarray
+    An ndarray containing the absolute value of
+    each element in `x`.  For complex input, ``a + ib``, the
+    absolute value is :math:`\\sqrt{ a^2 + b^2 }`.
+    This is a scalar if `x` is a scalar.
+
+Examples
+--------
+>>> x = np.array([-1.2, 1.2])
+>>> np.absolute(x)
+array([ 1.2,  1.2])
+>>> np.absolute(1.2 + 1j)
+1.5620499351813308
+
+Plot the function over ``[-10, 10]``:
+
+>>> import matplotlib.pyplot as plt
+
+>>> x = np.linspace(start=-10, stop=10, num=101)
+>>> plt.plot(x, np.absolute(x))
+>>> plt.show()
+
+Plot the function over the complex plane:
+
+>>> xx = x + 1j * x[:, np.newaxis]
+>>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
+
+(def pv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "pv"))))
+(alter-meta! #'pv assoc :doc "
+    Compute the present value.
+
+    .. deprecated:: 1.18
+
+       `pv` is deprecated; for details, see NEP 32 [1]_.
+       Use the corresponding function in the numpy-financial library,
+       https://pypi.org/project/numpy-financial.
+
+    Given:
+     * a future value, `fv`
+     * an interest `rate` compounded once per period, of which
+       there are
+     * `nper` total
+     * a (fixed) payment, `pmt`, paid either
+     * at the beginning (`when` = {'begin', 1}) or the end
+       (`when` = {'end', 0}) of each period
+
+    Return:
+       the value now
+
+    Parameters
+    ----------
+    rate : array_like
+        Rate of interest (per period)
+    nper : array_like
+        Number of compounding periods
+    pmt : array_like
+        Payment
+    fv : array_like, optional
+        Future value
+    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
+        When payments are due ('begin' (1) or 'end' (0))
+
+    Returns
+    -------
+    out : ndarray, float
+        Present value of a series of payments or investments.
+
+    Notes
+    -----
+    The present value is computed by solving the equation::
+
+     fv +
+     pv*(1 + rate)**nper +
+     pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) = 0
+
+    or, when ``rate = 0``::
+
+     fv + pv + pmt * nper = 0
+
+    for `pv`, which is then returned.
+
+    References
+    ----------
+    .. [1] NumPy Enhancement Proposal (NEP) 32,
+       https://numpy.org/neps/nep-0032-remove-financial-functions.html
+    .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).
+       Open Document Format for Office Applications (OpenDocument)v1.2,
+       Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,
+       Pre-Draft 12. Organization for the Advancement of Structured Information
+       Standards (OASIS). Billerica, MA, USA. [ODT Document].
+       Available:
+       http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula
+       OpenDocument-formula-20090508.odt
+
+    Examples
+    --------
+    What is the present value (e.g., the initial investment)
+    of an investment that needs to total $15692.93
+    after 10 years of saving $100 every month?  Assume the
+    interest rate is 5% (annually) compounded monthly.
+
+    >>> np.pv(0.05/12, 10*12, -100, 15692.93)
+    -100.00067131625819
+
+    By convention, the negative sign represents cash flow out
+    (i.e., money not available today).  Thus, to end up with
+    $15,692.93 in 10 years saving $100 a month at 5% annual
+    interest, one's initial deposit should also be $100.
+
+    If any input is array_like, ``pv`` returns an array of equal shape.
+    Let's compare different interest rates in the example above:
+
+    >>> a = np.array((0.05, 0.04, 0.03))/12
+    >>> np.pv(a, 10*12, -100, 15692.93)
+    array([ -100.00067132,  -649.26771385, -1273.78633713]) # may vary
+
+    So, to end up with the same $15692.93 under the same $100 per month
+    \"savings plan,\" for annual interest rates of 4% and 3%, one would
+    need initial investments of $649.27 and $1273.79, respectively.
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def hsplit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hsplit"))))
+(alter-meta! #'hsplit assoc :doc "
+    Split an array into multiple sub-arrays horizontally (column-wise).
+
+    Please refer to the `split` documentation.  `hsplit` is equivalent
+    to `split` with ``axis=1``, the array is always split along the second
+    axis regardless of the array dimension.
+
+    See Also
+    --------
+    split : Split an array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> x = np.arange(16.0).reshape(4, 4)
+    >>> x
+    array([[ 0.,   1.,   2.,   3.],
+           [ 4.,   5.,   6.,   7.],
+           [ 8.,   9.,  10.,  11.],
+           [12.,  13.,  14.,  15.]])
+    >>> np.hsplit(x, 2)
+    [array([[  0.,   1.],
+           [  4.,   5.],
+           [  8.,   9.],
+           [12.,  13.]]),
+     array([[  2.,   3.],
+           [  6.,   7.],
+           [10.,  11.],
+           [14.,  15.]])]
+    >>> np.hsplit(x, np.array([3, 6]))
+    [array([[ 0.,   1.,   2.],
+           [ 4.,   5.,   6.],
+           [ 8.,   9.,  10.],
+           [12.,  13.,  14.]]),
+     array([[ 3.],
+           [ 7.],
+           [11.],
+           [15.]]),
+     array([], shape=(4, 0), dtype=float64)]
+
+    With a higher dimensional array the split is still along the second axis.
+
+    >>> x = np.arange(8.0).reshape(2, 2, 2)
+    >>> x
+    array([[[0.,  1.],
+            [2.,  3.]],
+           [[4.,  5.],
+            [6.,  7.]]])
+    >>> np.hsplit(x, 2)
+    [array([[[0.,  1.]],
+           [[4.,  5.]]]),
+     array([[[2.,  3.]],
+           [[6.,  7.]]])]
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def pmt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "pmt"))))
+(alter-meta! #'pmt assoc :doc "
+    Compute the payment against loan principal plus interest.
+
+    .. deprecated:: 1.18
+
+       `pmt` is deprecated; for details, see NEP 32 [1]_.
+       Use the corresponding function in the numpy-financial library,
+       https://pypi.org/project/numpy-financial.
+
+    Given:
+     * a present value, `pv` (e.g., an amount borrowed)
+     * a future value, `fv` (e.g., 0)
+     * an interest `rate` compounded once per period, of which
+       there are
+     * `nper` total
+     * and (optional) specification of whether payment is made
+       at the beginning (`when` = {'begin', 1}) or the end
+       (`when` = {'end', 0}) of each period
+
+    Return:
+       the (fixed) periodic payment.
+
+    Parameters
+    ----------
+    rate : array_like
+        Rate of interest (per period)
+    nper : array_like
+        Number of compounding periods
+    pv : array_like
+        Present value
+    fv : array_like,  optional
+        Future value (default = 0)
+    when : {{'begin', 1}, {'end', 0}}, {string, int}
+        When payments are due ('begin' (1) or 'end' (0))
+
+    Returns
+    -------
+    out : ndarray
+        Payment against loan plus interest.  If all input is scalar, returns a
+        scalar float.  If any input is array_like, returns payment for each
+        input element. If multiple inputs are array_like, they all must have
+        the same shape.
+
+    Notes
+    -----
+    The payment is computed by solving the equation::
+
+     fv +
+     pv*(1 + rate)**nper +
+     pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) == 0
+
+    or, when ``rate == 0``::
+
+      fv + pv + pmt * nper == 0
+
+    for ``pmt``.
+
+    Note that computing a monthly mortgage payment is only
+    one use for this function.  For example, pmt returns the
+    periodic deposit one must make to achieve a specified
+    future balance given an initial deposit, a fixed,
+    periodically compounded interest rate, and the total
+    number of periods.
+
+    References
+    ----------
+    .. [1] NumPy Enhancement Proposal (NEP) 32,
+       https://numpy.org/neps/nep-0032-remove-financial-functions.html
+    .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).
+       Open Document Format for Office Applications (OpenDocument)v1.2,
+       Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,
+       Pre-Draft 12. Organization for the Advancement of Structured Information
+       Standards (OASIS). Billerica, MA, USA. [ODT Document].
+       Available:
+       http://www.oasis-open.org/committees/documents.php
+       ?wg_abbrev=office-formulaOpenDocument-formula-20090508.odt
+
+    Examples
+    --------
+    What is the monthly payment needed to pay off a $200,000 loan in 15
+    years at an annual interest rate of 7.5%?
+
+    >>> np.pmt(0.075/12, 12*15, 200000)
+    -1854.0247200054619
+
+    In order to pay-off (i.e., have a future-value of 0) the $200,000 obtained
+    today, a monthly payment of $1,854.02 would be required.  Note that this
+    example illustrates usage of `fv` having a default value of 0.
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def byte (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "byte"))))
+(alter-meta! #'byte assoc :doc "Signed integer type, compatible with C ``char``.
+    Character code: ``'b'``.
+    Canonical name: ``np.byte``.
+    Alias *on this platform*: ``np.int8``: 8-bit signed integer (-128 to 127)." :arglists '[[self & [args {:as kwargs}]]])
+
+(def seterrobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "seterrobj"))))
+(alter-meta! #'seterrobj assoc :doc "seterrobj(errobj)
+
+    Set the object that defines floating-point error handling.
+
+    The error object contains all information that defines the error handling
+    behavior in NumPy. `seterrobj` is used internally by the other
+    functions that set error handling behavior (`seterr`, `seterrcall`).
+
+    Parameters
+    ----------
+    errobj : list
+        The error object, a list containing three elements:
+        [internal numpy buffer size, error mask, error callback function].
+
+        The error mask is a single integer that holds the treatment information
+        on all four floating point errors. The information for each error type
+        is contained in three bits of the integer. If we print it in base 8, we
+        can see what treatment is set for \"invalid\", \"under\", \"over\", and
+        \"divide\" (in that order). The printed string can be interpreted with
+
+        * 0 : 'ignore'
+        * 1 : 'warn'
+        * 2 : 'raise'
+        * 3 : 'call'
+        * 4 : 'print'
+        * 5 : 'log'
+
+    See Also
+    --------
+    geterrobj, seterr, geterr, seterrcall, geterrcall
+    getbufsize, setbufsize
+
+    Notes
+    -----
+    For complete documentation of the types of floating-point exceptions and
+    treatment options, see `seterr`.
+
+    Examples
+    --------
+    >>> old_errobj = np.geterrobj()  # first get the defaults
+    >>> old_errobj
+    [8192, 521, None]
+
+    >>> def err_handler(type, flag):
+    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
+    ...
+    >>> new_errobj = [20000, 12, err_handler]
+    >>> np.seterrobj(new_errobj)
+    >>> np.base_repr(12, 8)  # int for divide=4 ('print') and over=1 ('warn')
+    '14'
+    >>> np.geterr()
+    {'over': 'warn', 'divide': 'print', 'invalid': 'ignore', 'under': 'ignore'}
+    >>> np.geterrcall() is err_handler
+    True" :arglists '[[self & [args {:as kwargs}]]])
+
+(def log2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log2"))))
+(alter-meta! #'log2 assoc :doc "log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Base-2 logarithm of `x`.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    Base-2 logarithm of `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+log, log10, log1p, emath.log2
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+Logarithm is a multivalued function: for each `x` there is an infinite
+number of `z` such that `2**z = x`. The convention is to return the `z`
+whose imaginary part lies in `[-pi, pi]`.
+
+For real-valued input data types, `log2` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `log2` is a complex analytical function that
+has a branch cut `[-inf, 0]` and is continuous from above on it. `log2`
+handles the floating-point negative zero as an infinitesimal negative
+number, conforming to the C99 standard.
+
+Examples
+--------
+>>> x = np.array([0, 1, 2, 2**4])
+>>> np.log2(x)
+array([-Inf,   0.,   1.,   4.])
+
+>>> xi = np.array([0+1.j, 1, 2+0.j, 4.j])
+>>> np.log2(xi)
+array([ 0.+2.26618007j,  0.+0.j        ,  1.+0.j        ,  2.+2.26618007j])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def left_shift (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "left_shift"))))
+(alter-meta! #'left_shift assoc :doc "left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Shift the bits of an integer to the left.
+
+Bits are shifted to the left by appending `x2` 0s at the right of `x1`.
+Since the internal representation of numbers is in binary format, this
+operation is equivalent to multiplying `x1` by ``2**x2``.
+
+Parameters
+----------
+x1 : array_like of integer type
+    Input values.
+x2 : array_like of integer type
+    Number of zeros to append to `x1`. Has to be non-negative.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : array of integer type
+    Return `x1` with bits shifted `x2` times to the left.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+right_shift : Shift the bits of an integer to the right.
+binary_repr : Return the binary representation of the input number
+    as a string.
+
+Examples
+--------
+>>> np.binary_repr(5)
+'101'
+>>> np.left_shift(5, 2)
+20
+>>> np.binary_repr(20)
+'10100'
+
+>>> np.left_shift(5, [1,2,3])
+array([10, 20, 40])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ascontiguousarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ascontiguousarray"))))
+(alter-meta! #'ascontiguousarray assoc :doc "
+    Return a contiguous array (ndim >= 1) in memory (C order).
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    dtype : str or dtype object, optional
+        Data-type of returned array.
+
+    Returns
+    -------
+    out : ndarray
+        Contiguous array of same shape and content as `a`, with type `dtype`
+        if specified.
+
+    See Also
+    --------
+    asfortranarray : Convert input to an ndarray with column-major
+                     memory order.
+    require : Return an ndarray that satisfies requirements.
+    ndarray.flags : Information about the memory layout of the array.
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2,3)
+    >>> np.ascontiguousarray(x, dtype=np.float32)
+    array([[0., 1., 2.],
+           [3., 4., 5.]], dtype=float32)
+    >>> x.flags['C_CONTIGUOUS']
+    True
+
+    Note: This function returns an array with at least one-dimension (1-d) 
+    so it will not preserve 0-d arrays.  
+
+    " :arglists '[[a & [{dtype :dtype}]] [a]])
+
+(def row_stack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "row_stack"))))
+(alter-meta! #'row_stack assoc :doc "
+    Stack arrays in sequence vertically (row wise).
+
+    This is equivalent to concatenation along the first axis after 1-D arrays
+    of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
+    `vsplit`.
+
+    This function makes most sense for arrays with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of ndarrays
+        The arrays must have the same shape along all but the first axis.
+        1-D arrays must have the same length.
+
+    Returns
+    -------
+    stacked : ndarray
+        The array formed by stacking the given arrays, will be at least 2-D.
+
+    See Also
+    --------
+    stack : Join a sequence of arrays along a new axis.
+    hstack : Stack arrays in sequence horizontally (column wise).
+    dstack : Stack arrays in sequence depth wise (along third dimension).
+    concatenate : Join a sequence of arrays along an existing axis.
+    vsplit : Split array into a list of multiple sub-arrays vertically.
+    block : Assemble arrays from blocks.
+
+    Examples
+    --------
+    >>> a = np.array([1, 2, 3])
+    >>> b = np.array([2, 3, 4])
+    >>> np.vstack((a,b))
+    array([[1, 2, 3],
+           [2, 3, 4]])
+
+    >>> a = np.array([[1], [2], [3]])
+    >>> b = np.array([[2], [3], [4]])
+    >>> np.vstack((a,b))
+    array([[1],
+           [2],
+           [3],
+           [2],
+           [3],
+           [4]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def savez (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "savez"))))
+(alter-meta! #'savez assoc :doc "Save several arrays into a single file in uncompressed ``.npz`` format.
+
+    If arguments are passed in with no keywords, the corresponding variable
+    names, in the ``.npz`` file, are 'arr_0', 'arr_1', etc. If keyword
+    arguments are given, the corresponding variable names, in the ``.npz``
+    file will match the keyword names.
+
+    Parameters
+    ----------
+    file : str or file
+        Either the filename (string) or an open file (file-like object)
+        where the data will be saved. If file is a string or a Path, the
+        ``.npz`` extension will be appended to the filename if it is not
+        already there.
+    args : Arguments, optional
+        Arrays to save to the file. Since it is not possible for Python to
+        know the names of the arrays outside `savez`, the arrays will be saved
+        with names \"arr_0\", \"arr_1\", and so on. These arguments can be any
+        expression.
+    kwds : Keyword arguments, optional
+        Arrays to save to the file. Arrays will be saved in the file with the
+        keyword names.
+
+    Returns
+    -------
+    None
+
+    See Also
+    --------
+    save : Save a single array to a binary file in NumPy format.
+    savetxt : Save an array to a file as plain text.
+    savez_compressed : Save several arrays into a compressed ``.npz`` archive
+
+    Notes
+    -----
+    The ``.npz`` file format is a zipped archive of files named after the
+    variables they contain.  The archive is not compressed and each file
+    in the archive contains one variable in ``.npy`` format. For a
+    description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.
+
+    When opening the saved ``.npz`` file with `load` a `NpzFile` object is
+    returned. This is a dictionary-like object which can be queried for
+    its list of arrays (with the ``.files`` attribute), and for the arrays
+    themselves.
+
+    When saving dictionaries, the dictionary keys become filenames
+    inside the ZIP archive. Therefore, keys should be valid filenames.
+    E.g., avoid keys that begin with ``/`` or contain ``.``.
+
+    Examples
+    --------
+    >>> from tempfile import TemporaryFile
+    >>> outfile = TemporaryFile()
+    >>> x = np.arange(10)
+    >>> y = np.sin(x)
+
+    Using `savez` with \\*args, the arrays are saved with default names.
+
+    >>> np.savez(outfile, x, y)
+    >>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file
+    >>> npzfile = np.load(outfile)
+    >>> npzfile.files
+    ['arr_0', 'arr_1']
+    >>> npzfile['arr_0']
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+    Using `savez` with \\**kwds, the arrays are saved with the keyword names.
+
+    >>> outfile = TemporaryFile()
+    >>> np.savez(outfile, x=x, y=y)
+    >>> _ = outfile.seek(0)
+    >>> npzfile = np.load(outfile)
+    >>> sorted(npzfile.files)
+    ['x', 'y']
+    >>> npzfile['x']
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def typename (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "typename"))))
+(alter-meta! #'typename assoc :doc "
+    Return a description for the given data type code.
+
+    Parameters
+    ----------
+    char : str
+        Data type code.
+
+    Returns
+    -------
+    out : str
+        Description of the input data type code.
+
+    See Also
+    --------
+    dtype, typecodes
+
+    Examples
+    --------
+    >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',
+    ...              'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']
+    >>> for typechar in typechars:
+    ...     print(typechar, ' : ', np.typename(typechar))
+    ...
+    S1  :  character
+    ?  :  bool
+    B  :  unsigned char
+    D  :  complex double precision
+    G  :  complex long double precision
+    F  :  complex single precision
+    I  :  unsigned integer
+    H  :  unsigned short
+    L  :  unsigned long integer
+    O  :  object
+    Q  :  unsigned long long integer
+    S  :  string
+    U  :  unicode
+    V  :  void
+    b  :  signed char
+    d  :  double precision
+    g  :  long precision
+    f  :  single precision
+    i  :  integer
+    h  :  short
+    l  :  long integer
+    q  :  long long integer
+
+    " :arglists '[[char]])
+
+(def test (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "test"))))
+(alter-meta! #'test assoc :doc "
+    Pytest test runner.
+
+    A test function is typically added to a package's __init__.py like so::
+
+      from numpy._pytesttester import PytestTester
+      test = PytestTester(__name__).test
+      del PytestTester
+
+    Calling this test function finds and runs all tests associated with the
+    module and all its sub-modules.
+
+    Attributes
+    ----------
+    module_name : str
+        Full path to the package to test.
+
+    Parameters
+    ----------
+    module_name : module name
+        The name of the module to test.
+
+    Notes
+    -----
+    Unlike the previous ``nose``-based implementation, this class is not
+    publicly exposed as it performs some ``numpy``-specific warning
+    suppression.
+
+    " :arglists '[[self module_name]])
+
+(def ^{:doc ""} __package__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__package__"))))
+
+(def array_equiv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_equiv"))))
+(alter-meta! #'array_equiv assoc :doc "
+    Returns True if input arrays are shape consistent and all elements equal.
+
+    Shape consistent means they are either the same shape, or one input array
+    can be broadcasted to create the same shape as the other one.
+
+    Parameters
+    ----------
+    a1, a2 : array_like
+        Input arrays.
+
+    Returns
+    -------
+    out : bool
+        True if equivalent, False otherwise.
+
+    Examples
+    --------
+    >>> np.array_equiv([1, 2], [1, 2])
+    True
+    >>> np.array_equiv([1, 2], [1, 3])
+    False
+
+    Showing the shape equivalence:
+
+    >>> np.array_equiv([1, 2], [[1, 2], [1, 2]])
+    True
+    >>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])
+    False
+
+    >>> np.array_equiv([1, 2], [[1, 2], [1, 3]])
+    False
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def stack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "stack"))))
+(alter-meta! #'stack assoc :doc "
+    Join a sequence of arrays along a new axis.
+
+    The ``axis`` parameter specifies the index of the new axis in the
+    dimensions of the result. For example, if ``axis=0`` it will be the first
+    dimension and if ``axis=-1`` it will be the last dimension.
+
+    .. versionadded:: 1.10.0
+
+    Parameters
+    ----------
+    arrays : sequence of array_like
+        Each array must have the same shape.
+
+    axis : int, optional
+        The axis in the result array along which the input arrays are stacked.
+
+    out : ndarray, optional
+        If provided, the destination to place the result. The shape must be
+        correct, matching that of what stack would have returned if no
+        out argument were specified.
+
+    Returns
+    -------
+    stacked : ndarray
+        The stacked array has one more dimension than the input arrays.
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays along an existing axis.
+    split : Split array into a list of multiple sub-arrays of equal size.
+    block : Assemble arrays from blocks.
+
+    Examples
+    --------
+    >>> arrays = [np.random.randn(3, 4) for _ in range(10)]
+    >>> np.stack(arrays, axis=0).shape
+    (10, 3, 4)
+
+    >>> np.stack(arrays, axis=1).shape
+    (3, 10, 4)
+
+    >>> np.stack(arrays, axis=2).shape
+    (3, 4, 10)
+
+    >>> a = np.array([1, 2, 3])
+    >>> b = np.array([2, 3, 4])
+    >>> np.stack((a, b))
+    array([[1, 2, 3],
+           [2, 3, 4]])
+
+    >>> np.stack((a, b), axis=-1)
+    array([[1, 2],
+           [2, 3],
+           [3, 4]])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def right_shift (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "right_shift"))))
+(alter-meta! #'right_shift assoc :doc "right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Shift the bits of an integer to the right.
+
+Bits are shifted to the right `x2`.  Because the internal
+representation of numbers is in binary format, this operation is
+equivalent to dividing `x1` by ``2**x2``.
+
+Parameters
+----------
+x1 : array_like, int
+    Input values.
+x2 : array_like, int
+    Number of bits to remove at the right of `x1`. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray, int
+    Return `x1` with bits shifted `x2` times to the right.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+left_shift : Shift the bits of an integer to the left.
+binary_repr : Return the binary representation of the input number
+    as a string.
+
+Examples
+--------
+>>> np.binary_repr(10)
+'1010'
+>>> np.right_shift(10, 1)
+5
+>>> np.binary_repr(5)
+'101'
+
+>>> np.right_shift(10, [1,2,3])
+array([5, 2, 1])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def nanvar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanvar"))))
+(alter-meta! #'nanvar assoc :doc "
+    Compute the variance along the specified axis, while ignoring NaNs.
+
+    Returns the variance of the array elements, a measure of the spread of
+    a distribution.  The variance is computed for the flattened array by
+    default, otherwise over the specified axis.
+
+    For all-NaN slices or slices with zero degrees of freedom, NaN is
+    returned and a `RuntimeWarning` is raised.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose variance is desired.  If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the variance is computed.  The default is to compute
+        the variance of the flattened array.
+    dtype : data-type, optional
+        Type to use in computing the variance.  For arrays of integer type
+        the default is `float64`; for arrays of float types it is the same as
+        the array type.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  It must have
+        the same shape as the expected output, but the type is cast if
+        necessary.
+    ddof : int, optional
+        \"Delta Degrees of Freedom\": the divisor used in the calculation is
+        ``N - ddof``, where ``N`` represents the number of non-NaN
+        elements. By default `ddof` is zero.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+
+    Returns
+    -------
+    variance : ndarray, see dtype parameter above
+        If `out` is None, return a new array containing the variance,
+        otherwise return a reference to the output array. If ddof is >= the
+        number of non-NaN elements in a slice or the slice contains only
+        NaNs, then the result for that slice is NaN.
+
+    See Also
+    --------
+    std : Standard deviation
+    mean : Average
+    var : Variance while not ignoring NaNs
+    nanstd, nanmean
+    ufuncs-output-type
+
+    Notes
+    -----
+    The variance is the average of the squared deviations from the mean,
+    i.e.,  ``var = mean(abs(x - x.mean())**2)``.
+
+    The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``.
+    If, however, `ddof` is specified, the divisor ``N - ddof`` is used
+    instead.  In standard statistical practice, ``ddof=1`` provides an
+    unbiased estimator of the variance of a hypothetical infinite
+    population.  ``ddof=0`` provides a maximum likelihood estimate of the
+    variance for normally distributed variables.
+
+    Note that for complex numbers, the absolute value is taken before
+    squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the variance is computed using the same
+    precision the input has.  Depending on the input data, this can cause
+    the results to be inaccurate, especially for `float32` (see example
+    below).  Specifying a higher-accuracy accumulator using the ``dtype``
+    keyword can alleviate this issue.
+
+    For this function to work on sub-classes of ndarray, they must define
+    `sum` with the kwarg `keepdims`
+
+    Examples
+    --------
+    >>> a = np.array([[1, np.nan], [3, 4]])
+    >>> np.nanvar(a)
+    1.5555555555555554
+    >>> np.nanvar(a, axis=0)
+    array([1.,  0.])
+    >>> np.nanvar(a, axis=1)
+    array([0.,  0.25])  # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc "
+A sub-package for efficiently dealing with polynomials.
+
+Within the documentation for this sub-package, a \"finite power series,\"
+i.e., a polynomial (also referred to simply as a \"series\") is represented
+by a 1-D numpy array of the polynomial's coefficients, ordered from lowest
+order term to highest.  For example, array([1,2,3]) represents
+``P_0 + 2*P_1 + 3*P_2``, where P_n is the n-th order basis polynomial
+applicable to the specific module in question, e.g., `polynomial` (which
+\"wraps\" the \"standard\" basis) or `chebyshev`.  For optimal performance,
+all operations on polynomials, including evaluation at an argument, are
+implemented as operations on the coefficients.  Additional (module-specific)
+information can be found in the docstring for the module of interest.
+
+"} polynomial (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "polynomial"))))
+
+(def polyder (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyder"))))
+(alter-meta! #'polyder assoc :doc "
+    Return the derivative of the specified order of a polynomial.
+
+    Parameters
+    ----------
+    p : poly1d or sequence
+        Polynomial to differentiate.
+        A sequence is interpreted as polynomial coefficients, see `poly1d`.
+    m : int, optional
+        Order of differentiation (default: 1)
+
+    Returns
+    -------
+    der : poly1d
+        A new polynomial representing the derivative.
+
+    See Also
+    --------
+    polyint : Anti-derivative of a polynomial.
+    poly1d : Class for one-dimensional polynomials.
+
+    Examples
+    --------
+    The derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is:
+
+    >>> p = np.poly1d([1,1,1,1])
+    >>> p2 = np.polyder(p)
+    >>> p2
+    poly1d([3, 2, 1])
+
+    which evaluates to:
+
+    >>> p2(2.)
+    17.0
+
+    We can verify this, approximating the derivative with
+    ``(f(x + h) - f(x))/h``:
+
+    >>> (p(2. + 0.001) - p(2.)) / 0.001
+    17.007000999997857
+
+    The fourth-order derivative of a 3rd-order polynomial is zero:
+
+    >>> np.polyder(p, 2)
+    poly1d([6, 2])
+    >>> np.polyder(p, 3)
+    poly1d([6])
+    >>> np.polyder(p, 4)
+    poly1d([0.])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def moveaxis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "moveaxis"))))
+(alter-meta! #'moveaxis assoc :doc "
+    Move axes of an array to new positions.
+
+    Other axes remain in their original order.
+
+    .. versionadded:: 1.11.0
+
+    Parameters
+    ----------
+    a : np.ndarray
+        The array whose axes should be reordered.
+    source : int or sequence of int
+        Original positions of the axes to move. These must be unique.
+    destination : int or sequence of int
+        Destination positions for each of the original axes. These must also be
+        unique.
+
+    Returns
+    -------
+    result : np.ndarray
+        Array with moved axes. This array is a view of the input array.
+
+    See Also
+    --------
+    transpose: Permute the dimensions of an array.
+    swapaxes: Interchange two axes of an array.
+
+    Examples
+    --------
+
+    >>> x = np.zeros((3, 4, 5))
+    >>> np.moveaxis(x, 0, -1).shape
+    (4, 5, 3)
+    >>> np.moveaxis(x, -1, 0).shape
+    (5, 3, 4)
+
+    These all achieve the same result:
+
+    >>> np.transpose(x).shape
+    (5, 4, 3)
+    >>> np.swapaxes(x, 0, -1).shape
+    (5, 4, 3)
+    >>> np.moveaxis(x, [0, 1], [-1, -2]).shape
+    (5, 4, 3)
+    >>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape
+    (5, 4, 3)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def concatenate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "concatenate"))))
+(alter-meta! #'concatenate assoc :doc "
+    concatenate((a1, a2, ...), axis=0, out=None)
+
+    Join a sequence of arrays along an existing axis.
+
+    Parameters
+    ----------
+    a1, a2, ... : sequence of array_like
+        The arrays must have the same shape, except in the dimension
+        corresponding to `axis` (the first, by default).
+    axis : int, optional
+        The axis along which the arrays will be joined.  If axis is None,
+        arrays are flattened before use.  Default is 0.
+    out : ndarray, optional
+        If provided, the destination to place the result. The shape must be
+        correct, matching that of what concatenate would have returned if no
+        out argument were specified.
+
+    Returns
+    -------
+    res : ndarray
+        The concatenated array.
+
+    See Also
+    --------
+    ma.concatenate : Concatenate function that preserves input masks.
+    array_split : Split an array into multiple sub-arrays of equal or
+                  near-equal size.
+    split : Split array into a list of multiple sub-arrays of equal size.
+    hsplit : Split array into multiple sub-arrays horizontally (column wise)
+    vsplit : Split array into multiple sub-arrays vertically (row wise)
+    dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
+    stack : Stack a sequence of arrays along a new axis.
+    hstack : Stack arrays in sequence horizontally (column wise)
+    vstack : Stack arrays in sequence vertically (row wise)
+    dstack : Stack arrays in sequence depth wise (along third dimension)
+    block : Assemble arrays from blocks.
+
+    Notes
+    -----
+    When one or more of the arrays to be concatenated is a MaskedArray,
+    this function will return a MaskedArray object instead of an ndarray,
+    but the input masks are *not* preserved. In cases where a MaskedArray
+    is expected as input, use the ma.concatenate function from the masked
+    array module instead.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> b = np.array([[5, 6]])
+    >>> np.concatenate((a, b), axis=0)
+    array([[1, 2],
+           [3, 4],
+           [5, 6]])
+    >>> np.concatenate((a, b.T), axis=1)
+    array([[1, 2, 5],
+           [3, 4, 6]])
+    >>> np.concatenate((a, b), axis=None)
+    array([1, 2, 3, 4, 5, 6])
+
+    This function will not preserve masking of MaskedArray inputs.
+
+    >>> a = np.ma.arange(3)
+    >>> a[1] = np.ma.masked
+    >>> b = np.arange(2, 5)
+    >>> a
+    masked_array(data=[0, --, 2],
+                 mask=[False,  True, False],
+           fill_value=999999)
+    >>> b
+    array([2, 3, 4])
+    >>> np.concatenate([a, b])
+    masked_array(data=[0, 1, 2, 2, 3, 4],
+                 mask=False,
+           fill_value=999999)
+    >>> np.ma.concatenate([a, b])
+    masked_array(data=[0, --, 2, 2, 3, 4],
+                 mask=[False,  True, False, False, False, False],
+           fill_value=999999)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def zeros_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "zeros_like"))))
+(alter-meta! #'zeros_like assoc :doc "
+    Return an array of zeros with the same shape and type as a given array.
+
+    Parameters
+    ----------
+    a : array_like
+        The shape and data-type of `a` define these same attributes of
+        the returned array.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+
+        .. versionadded:: 1.6.0
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible.
+
+        .. versionadded:: 1.6.0
+    subok : bool, optional.
+        If True, then the newly created array will use the sub-class
+        type of 'a', otherwise it will be a base-class array. Defaults
+        to True.
+    shape : int or sequence of ints, optional.
+        Overrides the shape of the result. If order='K' and the number of
+        dimensions is unchanged, will try to keep order, otherwise,
+        order='C' is implied.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of zeros with the same shape and type as `a`.
+
+    See Also
+    --------
+    empty_like : Return an empty array with shape and type of input.
+    ones_like : Return an array of ones with shape and type of input.
+    full_like : Return a new array with shape of input filled with value.
+    zeros : Return a new array setting values to zero.
+
+    Examples
+    --------
+    >>> x = np.arange(6)
+    >>> x = x.reshape((2, 3))
+    >>> x
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.zeros_like(x)
+    array([[0, 0, 0],
+           [0, 0, 0]])
+
+    >>> y = np.arange(3, dtype=float)
+    >>> y
+    array([0., 1., 2.])
+    >>> np.zeros_like(y)
+    array([0.,  0.,  0.])
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def rint (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rint"))))
+(alter-meta! #'rint assoc :doc "rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Round elements of the array to the nearest integer.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array is same shape and type as `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+ceil, floor, trunc
+
+Examples
+--------
+>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
+>>> np.rint(a)
+array([-2., -2., -0.,  0.,  2.,  2.,  2.])" :arglists '[[self & [args {:as kwargs}]]])
+
+(def arcsin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arcsin"))))
+(alter-meta! #'arcsin assoc :doc "arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Inverse sine, element-wise.
+
+Parameters
+----------
+x : array_like
+    `y`-coordinate on the unit circle.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+angle : ndarray
+    The inverse sine of each element in `x`, in radians and in the
+    closed interval ``[-pi/2, pi/2]``.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+sin, cos, arccos, tan, arctan, arctan2, emath.arcsin
+
+Notes
+-----
+`arcsin` is a multivalued function: for each `x` there are infinitely
+many numbers `z` such that :math:`sin(z) = x`.  The convention is to
+return the angle `z` whose real part lies in [-pi/2, pi/2].
+
+For real-valued input data types, *arcsin* always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arcsin` is a complex analytic function that
+has, by convention, the branch cuts [-inf, -1] and [1, inf]  and is
+continuous from above on the former and from below on the latter.
+
+The inverse sine is also known as `asin` or sin^{-1}.
+
+References
+----------
+Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
+10th printing, New York: Dover, 1964, pp. 79ff.
+http://www.math.sfu.ca/~cbm/aands/
+
+Examples
+--------
+>>> np.arcsin(1)     # pi/2
+1.5707963267948966
+>>> np.arcsin(-1)    # -pi/2
+-1.5707963267948966
+>>> np.arcsin(0)
+0.0" :arglists '[[self & [args {:as kwargs}]]])
+
+(def byte_bounds (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "byte_bounds"))))
+(alter-meta! #'byte_bounds assoc :doc "
+    Returns pointers to the end-points of an array.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input array. It must conform to the Python-side of the array
+        interface.
+
+    Returns
+    -------
+    (low, high) : tuple of 2 integers
+        The first integer is the first byte of the array, the second
+        integer is just past the last byte of the array.  If `a` is not
+        contiguous it will not use every byte between the (`low`, `high`)
+        values.
+
+    Examples
+    --------
+    >>> I = np.eye(2, dtype='f'); I.dtype
+    dtype('float32')
+    >>> low, high = np.byte_bounds(I)
+    >>> high - low == I.size*I.itemsize
+    True
+    >>> I = np.eye(2); I.dtype
+    dtype('float64')
+    >>> low, high = np.byte_bounds(I)
+    >>> high - low == I.size*I.itemsize
+    True
+
+    " :arglists '[[a]])
+
+(def indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "indices"))))
+(alter-meta! #'indices assoc :doc "
+    Return an array representing the indices of a grid.
+
+    Compute an array where the subarrays contain index values 0, 1, ...
+    varying only along the corresponding axis.
+
+    Parameters
+    ----------
+    dimensions : sequence of ints
+        The shape of the grid.
+    dtype : dtype, optional
+        Data type of the result.
+    sparse : boolean, optional
+        Return a sparse representation of the grid instead of a dense
+        representation. Default is False.
+
+        .. versionadded:: 1.17
+
+    Returns
+    -------
+    grid : one ndarray or tuple of ndarrays
+        If sparse is False:
+            Returns one array of grid indices,
+            ``grid.shape = (len(dimensions),) + tuple(dimensions)``.
+        If sparse is True:
+            Returns a tuple of arrays, with
+            ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with
+            dimensions[i] in the ith place
+
+    See Also
+    --------
+    mgrid, ogrid, meshgrid
+
+    Notes
+    -----
+    The output shape in the dense case is obtained by prepending the number
+    of dimensions in front of the tuple of dimensions, i.e. if `dimensions`
+    is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is
+    ``(N, r0, ..., rN-1)``.
+
+    The subarrays ``grid[k]`` contains the N-D array of indices along the
+    ``k-th`` axis. Explicitly::
+
+        grid[k, i0, i1, ..., iN-1] = ik
+
+    Examples
+    --------
+    >>> grid = np.indices((2, 3))
+    >>> grid.shape
+    (2, 2, 3)
+    >>> grid[0]        # row indices
+    array([[0, 0, 0],
+           [1, 1, 1]])
+    >>> grid[1]        # column indices
+    array([[0, 1, 2],
+           [0, 1, 2]])
+
+    The indices can be used as an index into an array.
+
+    >>> x = np.arange(20).reshape(5, 4)
+    >>> row, col = np.indices((2, 3))
+    >>> x[row, col]
+    array([[0, 1, 2],
+           [4, 5, 6]])
+
+    Note that it would be more straightforward in the above example to
+    extract the required elements directly with ``x[:2, :3]``.
+
+    If sparse is set to true, the grid will be returned in a sparse
+    representation.
+
+    >>> i, j = np.indices((2, 3), sparse=True)
+    >>> i.shape
+    (2, 1)
+    >>> j.shape
+    (1, 3)
+    >>> i        # row indices
+    array([[0],
+           [1]])
+    >>> j        # column indices
+    array([[0, 1, 2]])
+
+    " :arglists '[[dimensions & [{dtype :dtype, sparse :sparse}]] [dimensions & [{dtype :dtype}]] [dimensions]])
+
+(def meshgrid (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "meshgrid"))))
+(alter-meta! #'meshgrid assoc :doc "
+    Return coordinate matrices from coordinate vectors.
+
+    Make N-D coordinate arrays for vectorized evaluations of
+    N-D scalar/vector fields over N-D grids, given
+    one-dimensional coordinate arrays x1, x2,..., xn.
+
+    .. versionchanged:: 1.9
+       1-D and 0-D cases are allowed.
+
+    Parameters
+    ----------
+    x1, x2,..., xn : array_like
+        1-D arrays representing the coordinates of a grid.
+    indexing : {'xy', 'ij'}, optional
+        Cartesian ('xy', default) or matrix ('ij') indexing of output.
+        See Notes for more details.
+
+        .. versionadded:: 1.7.0
+    sparse : bool, optional
+        If True a sparse grid is returned in order to conserve memory.
+        Default is False.
+
+        .. versionadded:: 1.7.0
+    copy : bool, optional
+        If False, a view into the original arrays are returned in order to
+        conserve memory.  Default is True.  Please note that
+        ``sparse=False, copy=False`` will likely return non-contiguous
+        arrays.  Furthermore, more than one element of a broadcast array
+        may refer to a single memory location.  If you need to write to the
+        arrays, make copies first.
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    X1, X2,..., XN : ndarray
+        For vectors `x1`, `x2`,..., 'xn' with lengths ``Ni=len(xi)`` ,
+        return ``(N1, N2, N3,...Nn)`` shaped arrays if indexing='ij'
+        or ``(N2, N1, N3,...Nn)`` shaped arrays if indexing='xy'
+        with the elements of `xi` repeated to fill the matrix along
+        the first dimension for `x1`, the second for `x2` and so on.
+
+    Notes
+    -----
+    This function supports both indexing conventions through the indexing
+    keyword argument.  Giving the string 'ij' returns a meshgrid with
+    matrix indexing, while 'xy' returns a meshgrid with Cartesian indexing.
+    In the 2-D case with inputs of length M and N, the outputs are of shape
+    (N, M) for 'xy' indexing and (M, N) for 'ij' indexing.  In the 3-D case
+    with inputs of length M, N and P, outputs are of shape (N, M, P) for
+    'xy' indexing and (M, N, P) for 'ij' indexing.  The difference is
+    illustrated by the following code snippet::
+
+        xv, yv = np.meshgrid(x, y, sparse=False, indexing='ij')
+        for i in range(nx):
+            for j in range(ny):
+                # treat xv[i,j], yv[i,j]
+
+        xv, yv = np.meshgrid(x, y, sparse=False, indexing='xy')
+        for i in range(nx):
+            for j in range(ny):
+                # treat xv[j,i], yv[j,i]
+
+    In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
+
+    See Also
+    --------
+    index_tricks.mgrid : Construct a multi-dimensional \"meshgrid\"
+                     using indexing notation.
+    index_tricks.ogrid : Construct an open multi-dimensional \"meshgrid\"
+                     using indexing notation.
+
+    Examples
+    --------
+    >>> nx, ny = (3, 2)
+    >>> x = np.linspace(0, 1, nx)
+    >>> y = np.linspace(0, 1, ny)
+    >>> xv, yv = np.meshgrid(x, y)
+    >>> xv
+    array([[0. , 0.5, 1. ],
+           [0. , 0.5, 1. ]])
+    >>> yv
+    array([[0.,  0.,  0.],
+           [1.,  1.,  1.]])
+    >>> xv, yv = np.meshgrid(x, y, sparse=True)  # make sparse output arrays
+    >>> xv
+    array([[0. ,  0.5,  1. ]])
+    >>> yv
+    array([[0.],
+           [1.]])
+
+    `meshgrid` is very useful to evaluate functions on a grid.
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.arange(-5, 5, 0.1)
+    >>> y = np.arange(-5, 5, 0.1)
+    >>> xx, yy = np.meshgrid(x, y, sparse=True)
+    >>> z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2)
+    >>> h = plt.contourf(x,y,z)
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def datetime64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "datetime64"))))
+(alter-meta! #'datetime64 assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
+
+(def copyto (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "copyto"))))
+(alter-meta! #'copyto assoc :doc "
+    copyto(dst, src, casting='same_kind', where=True)
+
+    Copies values from one array to another, broadcasting as necessary.
+
+    Raises a TypeError if the `casting` rule is violated, and if
+    `where` is provided, it selects which elements to copy.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    dst : ndarray
+        The array into which values are copied.
+    src : array_like
+        The array from which values are copied.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur when copying.
+
+          * 'no' means the data types should not be cast at all.
+          * 'equiv' means only byte-order changes are allowed.
+          * 'safe' means only casts which can preserve values are allowed.
+          * 'same_kind' means only safe casts or casts within a kind,
+            like float64 to float32, are allowed.
+          * 'unsafe' means any data conversions may be done.
+    where : array_like of bool, optional
+        A boolean array which is broadcasted to match the dimensions
+        of `dst`, and selects elements to copy from `src` to `dst`
+        wherever it contains the value True.
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def polydiv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polydiv"))))
+(alter-meta! #'polydiv assoc :doc "
+    Returns the quotient and remainder of polynomial division.
+
+    The input arrays are the coefficients (including any coefficients
+    equal to zero) of the \"numerator\" (dividend) and \"denominator\"
+    (divisor) polynomials, respectively.
+
+    Parameters
+    ----------
+    u : array_like or poly1d
+        Dividend polynomial's coefficients.
+
+    v : array_like or poly1d
+        Divisor polynomial's coefficients.
+
+    Returns
+    -------
+    q : ndarray
+        Coefficients, including those equal to zero, of the quotient.
+    r : ndarray
+        Coefficients, including those equal to zero, of the remainder.
+
+    See Also
+    --------
+    poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub
+    polyval
+
+    Notes
+    -----
+    Both `u` and `v` must be 0-d or 1-d (ndim = 0 or 1), but `u.ndim` need
+    not equal `v.ndim`. In other words, all four possible combinations -
+    ``u.ndim = v.ndim = 0``, ``u.ndim = v.ndim = 1``,
+    ``u.ndim = 1, v.ndim = 0``, and ``u.ndim = 0, v.ndim = 1`` - work.
+
+    Examples
+    --------
+    .. math:: \\frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25
+
+    >>> x = np.array([3.0, 5.0, 2.0])
+    >>> y = np.array([2.0, 1.0])
+    >>> np.polydiv(x, y)
+    (array([1.5 , 1.75]), array([0.25]))
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def ^{:doc ""} ERR_PRINT (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_PRINT"))))
+
+(def modf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "modf"))))
+(alter-meta! #'modf assoc :doc "modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the fractional and integral parts of an array, element-wise.
+
+The fractional and integral parts are negative if the given number is
+negative.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y1 : ndarray
+    Fractional part of `x`.
+    This is a scalar if `x` is a scalar.
+y2 : ndarray
+    Integral part of `x`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+For integer input the return values are floats.
+
+See Also
+--------
+divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values
+         switched, except it always has a positive remainder.
+
+Examples
+--------
+>>> np.modf([0, 3.5])
+(array([ 0. ,  0.5]), array([ 0.,  3.]))
+>>> np.modf(-0.5)
+(-0.5, -0)" :arglists '[[self & [args {:as kwargs}]]])
+
+(def busdaycalendar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "busdaycalendar"))))
+(alter-meta! #'busdaycalendar assoc :doc "busdaycalendar(weekmask='1111100', holidays=None)
+
+    A business day calendar object that efficiently stores information
+    defining valid days for the busday family of functions.
+
+    The default valid days are Monday through Friday (\"business days\").
+    A busdaycalendar object can be specified with any set of weekly
+    valid days, plus an optional \"holiday\" dates that always will be invalid.
+
+    Once a busdaycalendar object is created, the weekmask and holidays
+    cannot be modified.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    weekmask : str or array_like of bool, optional
+        A seven-element array indicating which of Monday through Sunday are
+        valid days. May be specified as a length-seven list or array, like
+        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
+        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
+        weekdays, optionally separated by white space. Valid abbreviations
+        are: Mon Tue Wed Thu Fri Sat Sun
+    holidays : array_like of datetime64[D], optional
+        An array of dates to consider as invalid dates, no matter which
+        weekday they fall upon.  Holiday dates may be specified in any
+        order, and NaT (not-a-time) dates are ignored.  This list is
+        saved in a normalized form that is suited for fast calculations
+        of valid days.
+
+    Returns
+    -------
+    out : busdaycalendar
+        A business day calendar object containing the specified
+        weekmask and holidays values.
+
+    See Also
+    --------
+    is_busday : Returns a boolean array indicating valid days.
+    busday_offset : Applies an offset counted in valid days.
+    busday_count : Counts how many valid days are in a half-open date range.
+
+    Attributes
+    ----------
+    Note: once a busdaycalendar object is created, you cannot modify the
+    weekmask or holidays.  The attributes return copies of internal data.
+    weekmask : (copy) seven-element array of bool
+    holidays : (copy) sorted array of datetime64[D]
+
+    Examples
+    --------
+    >>> # Some important days in July
+    ... bdd = np.busdaycalendar(
+    ...             holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
+    >>> # Default is Monday to Friday weekdays
+    ... bdd.weekmask
+    array([ True,  True,  True,  True,  True, False, False])
+    >>> # Any holidays already on the weekend are removed
+    ... bdd.holidays
+    array(['2011-07-01', '2011-07-04'], dtype='datetime64[D]')" :arglists '[[self & [args {:as kwargs}]]])
+
+(def deg2rad (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "deg2rad"))))
+(alter-meta! #'deg2rad assoc :doc "deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Convert angles from degrees to radians.
+
+Parameters
+----------
+x : array_like
+    Angles in degrees.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding angle in radians.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+rad2deg : Convert angles from radians to degrees.
+unwrap : Remove large jumps in angle by wrapping.
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+``deg2rad(x)`` is ``x * pi / 180``.
+
+Examples
+--------
+>>> np.deg2rad(180)
+3.1415926535897931" :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc ""} FPE_UNDERFLOW (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "FPE_UNDERFLOW"))))
+
+(def longlong (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longlong"))))
+(alter-meta! #'longlong assoc :doc "Signed integer type, compatible with C ``long long``.
+    Character code: ``'q'``." :arglists '[[self & [args {:as kwargs}]]])
+
+(def ^{:doc " Distributor init file
+
+Distributors: you can add custom code here to support particular distributions
+of numpy.
+
+For example, this is a good place to put any checks for hardware requirements.
+
+The numpy standard source distribution will not put code in this file, so you
+can safely replace this file with your own version.
+"} _distributor_init (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_distributor_init"))))
+
+(def add_docstring (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add_docstring"))))
+(alter-meta! #'add_docstring assoc :doc "add_docstring(obj, docstring)
+
+    Add a docstring to a built-in obj if possible.
+    If the obj already has a docstring raise a RuntimeError
+    If this routine does not know how to add a docstring to the object
+    raise a TypeError" :arglists '[[self & [args {:as kwargs}]]])
+
+(def median (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "median"))))
+(alter-meta! #'median assoc :doc "
+    Compute the median along the specified axis.
+
+    Returns the median of the array elements.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : {int, sequence of int, None}, optional
+        Axis or axes along which the medians are computed. The default
+        is to compute the median along a flattened version of the array.
+        A sequence of axes is supported since version 1.9.0.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+       If True, then allow use of memory of input array `a` for
+       calculations. The input array will be modified by the call to
+       `median`. This will save memory when you do not need to preserve
+       the contents of the input array. Treat the input as undefined,
+       but it will probably be fully or partially sorted. Default is
+       False. If `overwrite_input` is ``True`` and `a` is not already an
+       `ndarray`, an error will be raised.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `arr`.
+
+        .. versionadded:: 1.9.0
+
+    Returns
+    -------
+    median : ndarray
+        A new array holding the result. If the input contains integers
+        or floats smaller than ``float64``, then the output data-type is
+        ``np.float64``.  Otherwise, the data-type of the output is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean, percentile
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the median of ``V`` is the
+    middle value of a sorted copy of ``V``, ``V_sorted`` - i
+    e., ``V_sorted[(N-1)/2]``, when ``N`` is odd, and the average of the
+    two middle values of ``V_sorted`` when ``N`` is even.
+
+    Examples
+    --------
+    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
+    >>> a
+    array([[10,  7,  4],
+           [ 3,  2,  1]])
+    >>> np.median(a)
+    3.5
+    >>> np.median(a, axis=0)
+    array([6.5, 4.5, 2.5])
+    >>> np.median(a, axis=1)
+    array([7.,  2.])
+    >>> m = np.median(a, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.median(a, axis=0, out=m)
+    array([6.5,  4.5,  2.5])
+    >>> m
+    array([6.5,  4.5,  2.5])
+    >>> b = a.copy()
+    >>> np.median(b, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a==b)
+    >>> b = a.copy()
+    >>> np.median(b, axis=None, overwrite_input=True)
+    3.5
+    >>> assert not np.all(a==b)
+
+    " :arglists '[[& [args {:as kwargs}]]])
+
+(def bitwise_xor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_xor"))))
+(alter-meta! #'bitwise_xor assoc :doc "bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the bit-wise XOR of two arrays element-wise.
+
+Computes the bit-wise XOR of the underlying binary representation of
+the integers in the input arrays. This ufunc implements the C/Python
+operator ``^``.
+
+Parameters
+----------
+x1, x2 : array_like
+    Only integer and boolean types are handled. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Result.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_xor
+bitwise_and
+bitwise_or
+binary_repr :
+    Return the binary representation of the input number as a string.
+
+Examples
+--------
+The number 13 is represented by ``00001101``. Likewise, 17 is
+represented by ``00010001``.  The bit-wise XOR of 13 and 17 is
+therefore ``00011100``, or 28:
+
+>>> np.bitwise_xor(13, 17)
+28
+>>> np.binary_repr(28)
+'11100'
+
+>>> np.bitwise_xor(31, 5)
+26
+>>> np.bitwise_xor([31,3], 5)
+array([26,  6])
+
+>>> np.bitwise_xor([31,3], [5,6])
+array([26,  5])
+>>> np.bitwise_xor([True, True], [False, True])
+array([ True, False])" :arglists '[[self & [args {:as kwargs}]]])
\ No newline at end of file

From df90c526bed393329a5300c2a5a0c7c7d15acdb6 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 5 Mar 2021 13:14:07 -0700
Subject: [PATCH 282/456] 2.00-beta-4

---
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.python.html          |  2 +-
 docs/libpython-clj2.python.np-array.html |  4 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/python.builtins.html                |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 project.clj                              |  2 +-
 src/libpython_clj2/python/np_array.clj   | 97 ++++++++++++------------
 12 files changed, 61 insertions(+), 60 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index ac3b93e..cf045fe 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index b2c322c..d15e58a 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/index.html b/docs/index.html
index 659570e..975704c 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-4-SNAPSHOT</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-beta-4-SNAPSHOT"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-4</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-beta-4"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 22b6dd8..149a1b5 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 81c289e..798ccd4 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index c8d9e6e..317af09 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
-<p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L134">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L149">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index d8059b3..a47e329 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index 8eabc86..94526d9 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 3808ecd..e067a65 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 83259d3..ce73da2 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index c5ac013..8902a8b 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-4-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-beta-4"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
diff --git a/src/libpython_clj2/python/np_array.clj b/src/libpython_clj2/python/np_array.clj
index 51e09f2..c6b211e 100644
--- a/src/libpython_clj2/python/np_array.clj
+++ b/src/libpython_clj2/python/np_array.clj
@@ -58,10 +58,10 @@
     (let [ctypes (py-proto/as-jvm (py-proto/get-attr np-obj "ctypes") {})
           np-dtype (-> (py-proto/as-jvm (py-proto/get-attr np-obj "dtype") {})
                        (obj-dtype->dtype))
-          shape (-> (py-proto/get-attr ctypes "shape")
+          shape (-> (delay (py-proto/get-attr ctypes "shape"))
                     (py-bridge/generic-python-as-list)
                     vec)
-          strides (-> (py-proto/get-attr ctypes "strides")
+          strides (-> (delay (py-proto/get-attr ctypes "strides"))
                       (py-bridge/generic-python-as-list)
                       vec)
           long-addr (py-proto/get-attr ctypes "data")]
@@ -83,52 +83,53 @@
 
 (defmethod py-proto/pyobject-as-jvm :ndarray
   [pyobj opts]
-  (py-bridge/bridge-pyobject
-   pyobj
-   Iterable
-   (iterator [this] (py-bridge/python->jvm-iterator pyobj py-base/as-jvm))
-   dtype-proto/PToTensor
-   (as-tensor [item]
-              (-> (numpy->desc item)
-                  (dtt/nd-buffer-descriptor->tensor)))
-   dtype-proto/PElemwiseDatatype
-   (elemwise-datatype
-    [this]
-    (py-ffi/with-gil
-      (-> (py-proto/get-attr pyobj "dtype")
-          (py-proto/as-jvm {})
-          (obj-dtype->dtype))))
-   dtype-proto/PECount
-   (ecount [this] (apply * (dtype-proto/shape this)))
-
-   dtype-proto/PShape
-   (shape
-    [this]
-    (py-ffi/with-gil
-      (-> (py-proto/get-attr pyobj "shape")
-          (py-proto/->jvm {}))))
-
-   dtype-proto/PToNativeBuffer
-   (convertible-to-native-buffer? [item] true)
-   (->native-buffer
-    [item]
-    (py-ffi/with-gil
-      (dtype-proto/->native-buffer
-       (dtype-proto/as-tensor item))))
-
-   dtype-proto/PSubBuffer
-   (sub-buffer
-    [buffer offset length]
-    (py-ffi/with-gil
-      (-> (dtype-proto/as-tensor buffer)
-          (dtype-proto/sub-buffer offset length))))
-
-   dtype-proto/PToNDBufferDesc
-   (convertible-to-nd-buffer-desc? [item] true)
-   (->nd-buffer-descriptor
-    [item]
-    (py-ffi/with-gil
-      (numpy->desc item)))))
+  (let [pyobj* (delay pyobj)]
+    (py-bridge/bridge-pyobject
+     pyobj*
+     Iterable
+     (iterator [this] (py-bridge/python->jvm-iterator @pyobj* py-base/as-jvm))
+     dtype-proto/PToTensor
+     (as-tensor [item]
+                (-> (numpy->desc item)
+                    (dtt/nd-buffer-descriptor->tensor)))
+     dtype-proto/PElemwiseDatatype
+     (elemwise-datatype
+      [this]
+      (py-ffi/with-gil
+        (-> (py-proto/get-attr pyobj "dtype")
+            (py-proto/as-jvm {})
+            (obj-dtype->dtype))))
+     dtype-proto/PECount
+     (ecount [this] (apply * (dtype-proto/shape this)))
+
+     dtype-proto/PShape
+     (shape
+      [this]
+      (py-ffi/with-gil
+        (-> (py-proto/get-attr @pyobj* "shape")
+            (py-proto/->jvm {}))))
+
+     dtype-proto/PToNativeBuffer
+     (convertible-to-native-buffer? [item] true)
+     (->native-buffer
+      [item]
+      (py-ffi/with-gil
+        (dtype-proto/->native-buffer
+         (dtype-proto/as-tensor item))))
+
+     dtype-proto/PSubBuffer
+     (sub-buffer
+      [buffer offset length]
+      (py-ffi/with-gil
+        (-> (dtype-proto/as-tensor buffer)
+            (dtype-proto/sub-buffer offset length))))
+
+     dtype-proto/PToNDBufferDesc
+     (convertible-to-nd-buffer-desc? [item] true)
+     (->nd-buffer-descriptor
+      [item]
+      (py-ffi/with-gil
+        (numpy->desc item))))))
 
 
 (defn datatype->ptr-type-name

From 296a28ae55f904dae9388ed11998427541f27009 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 5 Mar 2021 13:14:17 -0700
Subject: [PATCH 283/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 8902a8b..df6a9b0 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-4"
+(defproject clj-python/libpython-clj "2.00-beta-5-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 01232c572c4ee86a2e584467c483728bbec3d178 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 5 Mar 2021 13:25:49 -0700
Subject: [PATCH 284/456] Updating docs.

---
 CHANGELOG.md | 7 +++++++
 README.md    | 3 +++
 2 files changed, 10 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8d7b4a0..99ccdd2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-4
+ * [static namespace generation](https://clj-python.github.io/libpython-clj/libpython-clj2.codegen.html#var-write-namespace.21) - Generate AOT-safe clojure code that will
+ dynamically find the symbol and cache it upon first call.
+ 
+## 2.00-beta-3
+ * Fixes to allow Conda to work - [cnuernber/facial-rec](https://github.com/cnuernber/facial-rec) lives again!!
+
 ## 2.00-beta-2
  * Fix for [numpy.all returns false](https://github.com/clj-python/libpython-clj/issues/148)
 
diff --git a/README.md b/README.md
index e18f1f7..e9acba7 100644
--- a/README.md
+++ b/README.md
@@ -25,6 +25,9 @@
  * This library, which has received the efforts of many excellent people, is built mainly upon
    [cnuernber/dtype-next](https://github.com/cnuernber/dtype-next/) and the 
    [JNA library](https://github.com/java-native-access/jna).
+ * [Static code generation](https://clj-python.github.io/libpython-clj/libpython-clj2.codegen.html#var-write-namespace.21) - generate clojure namespaces 
+   wrapping python modules that are safe to use with AOT and load much faster than analogous `require-python` calls.  These namespace will not
+   automatically initialize the python subsystem -- initialize! must be called first (or a nice exception is throw).
 
 ## libpython-clj features
 

From 72bb0d74ef9ea4e5707de45197dbadfb54cadcbc Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 6 Mar 2021 10:03:11 -0700
Subject: [PATCH 285/456] 2.00-beta-5

---
 docs/Usage.html                          |     2 +-
 docs/design.html                         |     2 +-
 docs/environments.html                   |    15 +
 docs/index.html                          |     2 +-
 docs/libpython-clj2.codegen.html         |     2 +-
 docs/libpython-clj2.python.html          |     2 +-
 docs/libpython-clj2.python.np-array.html |     2 +-
 docs/libpython-clj2.require.html         |    32 +
 docs/new-to-clojure.html                 |     2 +-
 docs/python.builtins.html                |     2 +-
 docs/python.numpy.html                   | 12587 +++++++++++++++++++++
 docs/scopes-and-gc.html                  |     2 +-
 docs/slicing.html                        |     2 +-
 project.clj                              |    11 +-
 topics/environments.md                   |    16 +
 15 files changed, 12666 insertions(+), 15 deletions(-)
 create mode 100644 docs/environments.html
 create mode 100644 docs/libpython-clj2.require.html
 create mode 100644 docs/python.numpy.html
 create mode 100644 topics/environments.md

diff --git a/docs/Usage.html b/docs/Usage.html
index cf045fe..c04b4c9 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index d15e58a..b302531 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/environments.html b/docs/environments.html
new file mode 100644
index 0000000..1923104
--- /dev/null
+++ b/docs/environments.html
@@ -0,0 +1,15 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
+<p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
+<ul>
+  <li><a href="https://github.com/pyenv/pyenv/issues/392">pyenv shared library issue</a></li>
+  <li><a href="https://github.com/clj-python/libpython-clj/issues/123">libpython-clj related issue</a></li>
+</ul>
+<h2><a href="#conda" name="conda"></a>Conda</h2>
+<p>Conda requires that we set the LD_LIBRARY_PATH to the conda install.</p>
+<ul>
+  <li><a href="https://github.com/clj-python/libpython-clj/blob/master/scripts/conda-repl">example conda repl launcher</a></li>
+  <li><a href="https://github.com/clj-python/libpython-clj/issues/18">libpython-clj issue for Conda</a></li>
+</ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/index.html b/docs/index.html
index 975704c..2712141 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-4</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></h1><h5 class="license">Released under the <a href="http://www.eclipse.org/legal/epl-v10.html">Eclipse Public License</a></h5><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Installation</h2><p>To install, add the following dependency to your project or build file:</p><pre class="deps">[clj-python/libpython-clj "2.00-beta-4"]</pre><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-5</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></h1><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 149a1b5..ae8d0b4 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 798ccd4..7fe9724 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 317af09..d035b58 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
new file mode 100644
index 0000000..51f301f
--- /dev/null
+++ b/docs/libpython-clj2.require.html
@@ -0,0 +1,32 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
+<p>(require-python ’[math :as maaaath])</p>
+<p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
+<p>(require-python ‘math ‘csv) (require-python ’[math :as pymath] ‘csv)) (require-python ’[math :as pymath] ’[csv :as py-csv]) (require-python ‘concurrent.futures) (require-python ’[concurrent.futures :as fs]) (require-python ’(concurrent [futures :as fs]))</p>
+<p>(require-python ’[requests :refer [get post]])</p>
+<p>(requests/get “https//www.google.com”) ;;=&gt; &lt;Response [200]&gt; (get “https//www.google.com”) ;;=&gt; &lt;Response [200]&gt;</p>
+<p>In some cases we may generate invalid arglists metadata for the clojure compiler. In those cases we have a flag, :no-arglists that will disable adding arglists to the generated metadata for the vars. Use the reload flag below if you need to force reload a namespace where invalid arglists have been generated.</p>
+<p>(require-python ’[numpy :refer [linspace] :no-arglists :as np])</p>
+<p>If you would like to bind the Python module to the namespace, use the :bind-ns flag.</p>
+<p>(require-python ‘[requests :bind-ns true]) or (require-python ’[requests :bind-ns])</p>
+<h2><a href="#use-with-custom-modules" name="use-with-custom-modules"></a>Use with custom modules</h2>
+<p>For use with a custom namespace foo.py while developing, you can use:</p>
+<p>(require-python ’[foo :reload])</p>
+<p>NOTE: unless you specify the :reload flag,  ..: the module will NOT reload. If the :reload flag is set,  ..: the behavior mimics importlib.reload</p>
+<h2><a href="#setting-up-classpath-for-custom-modules" name="setting-up-classpath-for-custom-modules"></a>Setting up classpath for custom modules</h2>
+<p>Note: you may need to setup your PYTHONPATH correctly. One technique to do this is, if your foo.py lives at /path/to/foodir/foo.py:</p>
+<p>(require-python ’sys) (py/call-attr (py/get-attr sys “path”)  “append”  “/path/to/foodir”)</p>
+<p>Another option is</p>
+<p>(require-python ’os) (os/chdir “/path/to/foodir”)</p>
+<h2><a href="#prefix-lists" name="prefix-lists"></a>prefix lists</h2>
+<p>For convenience, if you are loading multiple Python modules with the same prefix, you can use the following notation:</p>
+<p>(require-python ’(a b c)) is equivalent to (require-python ’a.b ’a.c)</p>
+<p>(require-python ‘(foo [bar :as baz :refer [qux]])) is equivalent to (require-python ’[foo.bar :as baz :refer [qux]])</p>
+<p>(require-python ‘(foo [bar :as baz :refer [qux]] buster)) (require-python ’[foo.bar :as baz :refer [qux]] ’foo.buster))</p>
+<h2><a href="#for-library-developers" name="for-library-developers"></a>For library developers</h2>
+<p>If you want to intern all symbols to your current namespace, you can do the following –</p>
+<p>(require-python ’[math :refer :all])</p>
+<p>However, if you only want to use those things designated by the module under the <strong>all</strong> attribute, you can do</p>
+<p>(require-python ’[operators :refer :*])</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L173">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index a47e329..61e9439 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index 94526d9..460d68d 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
new file mode 100644
index 0000000..47fa465
--- /dev/null
+++ b/docs/python.numpy.html
@@ -0,0 +1,12587 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
+<p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
+<p><code>name</code> is the absolute name of the module. <code>loader</code> is the loader to use when loading the module. <code>parent</code> is the name of the package the module is in. The parent is derived from the name.</p>
+<p><code>is_package</code> determines if the module is considered a package or not. On modules this is reflected by the <code>__path__</code> attribute.</p>
+<p><code>origin</code> is the specific location used by the loader from which to load the module, if that information is available. When filename is set, origin will match.</p>
+<p><code>has_location</code> indicates that a spec’s “origin” reflects a location. When this is True, <code>__file__</code> attribute of the module is set.</p>
+<p><code>cached</code> is the location of the cached bytecode file, if any. It corresponds to the <code>__cached__</code> attribute.</p>
+<p><code>submodule_search_locations</code> is the sequence of path entries to search when importing submodules. If set, is_package should be True–and False otherwise.</p>
+<p>Packages are simply modules that (may) have submodules. If a spec has a non-None value in <code>submodule_search_locations</code>, the import system will consider modules loaded from the spec as packages.</p>
+<p>Only finders (see importlib.abc.MetaPathFinder and importlib.abc.PathEntryFinder) should modify ModuleSpec instances.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18000">view source</a></div></div><div class="public anchor" id="var-__version__"><h3>__version__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21898">view source</a></div></div><div class="public anchor" id="var-_add_newdoc_ufunc"><h3>_add_newdoc_ufunc</h3><div class="usage"><code>(_add_newdoc_ufunc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>add_ufunc_docstring(ufunc, new_docstring)</p>
+<p>Replace the docstring for a ufunc with new_docstring. This method will only work if the current docstring for the ufunc is NULL. (At the C level, i.e. when ufunc-&gt;doc is NULL.)</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>ufunc : numpy.ufunc  A ufunc whose current doc is NULL. new_docstring : string  The new docstring for the ufunc.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This method allocates memory for new_docstring on the heap. Technically this creates a mempory leak, since this memory will not be reclaimed until the end of the program even if the ufunc itself is removed. However this will only be a problem if the user is repeatedly creating ufuncs with no documentation, adding documentation via add_newdoc_ufunc, and then throwing away the ufunc.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21334">view source</a></div></div><div class="public anchor" id="var-_distributor_init"><h3>_distributor_init</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Distributor init file</p>
+<p>Distributors: you can add custom code here to support particular distributions of numpy.</p>
+<p>For example, this is a good place to put any checks for hardware requirements.</p>
+<p>The numpy standard source distribution will not put code in this file, so you can safely replace this file with your own version.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28970">view source</a></div></div><div class="public anchor" id="var-_globals"><h3>_globals</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Module defining global singleton classes.</p>
+<p>This module raises a RuntimeError if an attempt to reload it is made. In that way the identities of the classes defined here are fixed and will remain so even if numpy itself is reloaded. In particular, a function like the following will still work correctly after numpy is reloaded::</p>
+<pre><code>def foo(arg=np._NoValue):
+    if arg is np._NoValue:
+        ...
+</code></pre>
+<p>That was not the case when the singleton classes were defined in the numpy <code>__init__.py</code> file. See gh-7844 for a discussion of the reload problem that motivated this module.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20801">view source</a></div></div><div class="public anchor" id="var-_mat"><h3>_mat</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Sub-package containing the matrix class and related functions.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3786">view source</a></div></div><div class="public anchor" id="var-_NoValue"><h3>_NoValue</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Special keyword value.</p>
+<p>The instance of this class may be used as the default value assigned to a deprecated keyword in order to check if it has been given a user defined value.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13726">view source</a></div></div><div class="public anchor" id="var-_pytesttester"><h3>_pytesttester</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Pytest test running.</p>
+<p>This module implements the <code>test()</code> function for NumPy modules. The usual boiler plate for doing that is to put the following in the module <code>__init__.py</code> file::</p>
+<pre><code>from numpy._pytesttester import PytestTester
+test = PytestTester(__name__).test
+del PytestTester
+</code></pre>
+<p>Warnings filtering and other runtime settings should be dealt with in the <code>pytest.ini</code> file in the numpy repo root. The behavior of the test depends on whether or not that file is found as follows:</p>
+<ul>
+  <li><code>pytest.ini</code> is present (develop mode) All warnings except those explicily filtered out are raised as error.</li>
+  <li><code>pytest.ini</code> is absent (release mode) DeprecationWarnings and PendingDeprecationWarnings are ignored, other warnings are passed through.</li>
+</ul>
+<p>In practice, tests run from the numpy repo are run in develop mode. That includes the standard <code>python runtests.py</code> invocation.</p>
+<p>This module is imported by every numpy subpackage, so lies at the top level to simplify circular import issues. For the same reason, it contains no numpy imports at module scope, instead importing numpy within function calls.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14837">view source</a></div></div><div class="public anchor" id="var-_UFUNC_API"><h3>_UFUNC_API</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Capsule objects let you wrap a C "void *" pointer in a Python object. They’re a way of passing data through the Python interpreter without creating your own custom type.</p>
+<p>Capsules are used for communication between extension modules. They provide a way for an extension module to export a C interface to other extension modules, so that extension modules can use the Python import mechanism to link to one another.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8207">view source</a></div></div><div class="public anchor" id="var-abs"><h3>abs</h3><div class="usage"><code>(abs self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>absolute(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Calculate the absolute value element-wise.</p>
+<p><code>np.abs</code> is a shorthand for this function.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>absolute : ndarray  An ndarray containing the absolute value of  each element in <code>x</code>. For complex input, <code>a + ib</code>, the  absolute value is :math:<code>\sqrt{ a^2 + b^2 }</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([-1.2, 1.2]) np.absolute(x) array([ 1.2, 1.2]) np.absolute(1.2 + 1j) 1.5620499351813308</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot the function over <code>[-10, 10]</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt</p>
+      <p>x = np.linspace(start=-10, stop=10, num=101) plt.plot(x, np.absolute(x)) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot the function over the complex plane:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>xx = x + 1j * x[:, np.newaxis] plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap=‘gray’) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20709">view source</a></div></div><div class="public anchor" id="var-absolute"><h3>absolute</h3><div class="usage"><code>(absolute self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>absolute(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Calculate the absolute value element-wise.</p>
+<p><code>np.abs</code> is a shorthand for this function.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>absolute : ndarray  An ndarray containing the absolute value of  each element in <code>x</code>. For complex input, <code>a + ib</code>, the  absolute value is :math:<code>\sqrt{ a^2 + b^2 }</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([-1.2, 1.2]) np.absolute(x) array([ 1.2, 1.2]) np.absolute(1.2 + 1j) 1.5620499351813308</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot the function over <code>[-10, 10]</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt</p>
+      <p>x = np.linspace(start=-10, stop=10, num=101) plt.plot(x, np.absolute(x)) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot the function over the complex plane:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>xx = x + 1j * x[:, np.newaxis] plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap=‘gray’) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27150">view source</a></div></div><div class="public anchor" id="var-absolute_import"><h3>absolute_import</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3784">view source</a></div></div><div class="public anchor" id="var-add"><h3>add</h3><div class="usage"><code>(add self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>add(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Add arguments element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  The arrays to be added. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>add : ndarray or scalar  The sum of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Equivalent to <code>x1</code> + <code>x2</code> in terms of array broadcasting.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.add(1.0, 4.0) 5.0 x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.add(x1, x2) array(<a href="null">  0.,   2.,   4.],
+       [  3.,   5.,   7.],
+       [  6.,   8.,  10.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22784">view source</a></div></div><div class="public anchor" id="var-add_docstring"><h3>add_docstring</h3><div class="usage"><code>(add_docstring self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>add_docstring(obj, docstring)</p>
+<p>Add a docstring to a built-in obj if possible. If the obj already has a docstring raise a RuntimeError If this routine does not know how to add a docstring to the object raise a TypeError</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28981">view source</a></div></div><div class="public anchor" id="var-add_newdoc"><h3>add_newdoc</h3><div class="usage"><code>(add_newdoc place obj doc &amp; [{warn_on_python :warn_on_python}])</code><code>(add_newdoc place obj doc)</code></div><div class="doc"><div class="markdown"><p>Add documentation to an existing object, typically one defined in C</p>
+<p>The purpose is to allow easier editing of the docstrings without requiring a re-compile. This exists primarily for internal use within numpy itself.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>place : str  The absolute name of the module to import from obj : str  The name of the object to add documentation to, typically a class or  function name doc : {str, Tuple[str, str], List[Tuple[str, str]]}  If a string, the documentation to apply to <code>obj</code></p>
+<pre><code>If a tuple, then the first element is interpreted as an attribute of
+`obj` and the second as the docstring to apply - ``(method, docstring)``
+
+If a list, then each element of the list should be a tuple of length
+two - ``[(method1, docstring1), (method2, docstring2), ...]``
+</code></pre>
+<p>warn_on_python : bool  If True, the default, emit <code>UserWarning</code> if this is used to attach  documentation to a pure-python object.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This routine never raises an error if the docstring can’t be written, but will raise an error if the object being documented does not exist.</p>
+<p>This routine cannot modify read-only docstrings, as appear in new-style classes or built-in functions. Because this routine never raises an error the caller must check manually that the docstrings were changed.</p>
+<p>Since this function grabs the <code>char *</code> from a c-level str object and puts it into the <code>tp_doc</code> slot of the type of <code>obj</code>, it violates a number of C-API best-practices, by:</p>
+<ul>
+  <li>modifying a <code>PyTypeObject</code> after calling <code>PyType_Ready</code></li>
+  <li>calling <code>Py_INCREF</code> on the str and losing the reference, so the str  will never be released</li>
+</ul>
+<p>If possible it should be avoided.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3737">view source</a></div></div><div class="public anchor" id="var-add_newdoc_ufunc"><h3>add_newdoc_ufunc</h3><div class="usage"><code>(add_newdoc_ufunc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>add_ufunc_docstring(ufunc, new_docstring)</p>
+<p>Replace the docstring for a ufunc with new_docstring. This method will only work if the current docstring for the ufunc is NULL. (At the C level, i.e. when ufunc-&gt;doc is NULL.)</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>ufunc : numpy.ufunc  A ufunc whose current doc is NULL. new_docstring : string  The new docstring for the ufunc.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This method allocates memory for new_docstring on the heap. Technically this creates a mempory leak, since this memory will not be reclaimed until the end of the program even if the ufunc itself is removed. However this will only be a problem if the user is repeatedly creating ufuncs with no documentation, adding documentation via add_newdoc_ufunc, and then throwing away the ufunc.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8568">view source</a></div></div><div class="public anchor" id="var-alen"><h3>alen</h3><div class="usage"><code>(alen &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the length of the first dimension of the input array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>alen : int  Length of the first dimension of <code>a</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>shape, size</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.zeros((7,4,5)) a.shape[0] 7 np.alen(a) 7</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1399">view source</a></div></div><div class="public anchor" id="var-all"><h3>all</h3><div class="usage"><code>(all &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Test whether all array elements along a given axis evaluate to True.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array or object that can be converted to an array. axis : None or int or tuple of ints, optional  Axis or axes along which a logical AND reduction is performed.  The default (<code>axis=None</code>) is to perform a logical AND over all  the dimensions of the input array. <code>axis</code> may be negative, in  which case it counts from the last to the first axis.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If this is a tuple of ints, a reduction is performed on multiple
+axes, instead of a single axis or all the axes as before.
+</code></pre>
+<p>out : ndarray, optional  Alternate output array in which to place the result.  It must have the same shape as the expected output and its  type is preserved (e.g., if <code>dtype(out)</code> is float, the result  will consist of 0.0’s and 1.0’s). See <code>ufuncs-output-type</code> for more  details.</p>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `all` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>all : ndarray, bool  A new boolean or array is returned unless <code>out</code> is specified,  in which case a reference to <code>out</code> is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.all : equivalent method</p>
+<p>any : Test whether any element along a given axis evaluates to True.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Not a Number (NaN), positive infinity and negative infinity evaluate to <code>True</code> because these are not equal to zero.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.all(<a href="null">True,False],[True,True</a>) False</p>
+      <p>np.all(<a href="null">True,False],[True,True</a>, axis=0) array([ True, False])</p>
+      <p>np.all([-1, 4, 5]) True</p>
+      <p>np.all([1.0, np.nan]) True</p>
+      <p>o=np.array(False) z=np.all([-1, 4, 5], out=o) id(z), id(o), z (28293632, 28293632, array(True)) # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23411">view source</a></div></div><div class="public anchor" id="var-allclose"><h3>allclose</h3><div class="usage"><code>(allclose &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns True if two arrays are element-wise equal within a tolerance.</p>
+<p>The tolerance values are positive, typically very small numbers. The relative difference (<code>rtol</code> * abs(<code>b</code>)) and the absolute difference <code>atol</code> are added together to compare against the absolute difference between <code>a</code> and <code>b</code>.</p>
+<p>NaNs are treated as equal if they are in the same place and if <code>equal_nan=True</code>. Infs are treated as equal if they are in the same place and of the same sign in both arrays.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a, b : array_like  Input arrays to compare. rtol : float  The relative tolerance parameter (see Notes). atol : float  The absolute tolerance parameter (see Notes). equal_nan : bool  Whether to compare NaN’s as equal. If True, NaN’s in <code>a</code> will be  considered equal to NaN’s in <code>b</code> in the output array.</p>
+<pre><code>.. versionadded:: 1.10.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>allclose : bool  Returns True if the two arrays are equal within the given  tolerance; False otherwise.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>isclose, all, any, equal</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If the following equation is element-wise True, then allclose returns True.</p>
+<p>absolute(<code>a</code> - <code>b</code>) &lt;= (<code>atol</code> + <code>rtol</code> * absolute(<code>b</code>))</p>
+<p>The above equation is not symmetric in <code>a</code> and <code>b</code>, so that <code>allclose(a, b)</code> might be different from <code>allclose(b, a)</code> in some rare cases.</p>
+<p>The comparison of <code>a</code> and <code>b</code> uses standard broadcasting, which means that <code>a</code> and <code>b</code> need not have the same shape in order for <code>allclose(a, b)</code> to evaluate to True. The same is true for <code>equal</code> but not <code>array_equal</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.allclose([1e10,1e-7], [1.00001e10,1e-8]) False np.allclose([1e10,1e-8], [1.00001e10,1e-9]) True np.allclose([1e10,1e-8], [1.0001e10,1e-9]) False np.allclose([1.0, np.nan], [1.0, np.nan]) False np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23992">view source</a></div></div><div class="public anchor" id="var-ALLOW_THREADS"><h3>ALLOW_THREADS</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16466">view source</a></div></div><div class="public anchor" id="var-alltrue"><h3>alltrue</h3><div class="usage"><code>(alltrue &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Check if all elements of input array are true.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.all : Equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6907">view source</a></div></div><div class="public anchor" id="var-amax"><h3>amax</h3><div class="usage"><code>(amax &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the maximum of an array or maximum along an axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  Axis or axes along which to operate. By default, flattened input is  used.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If this is a tuple of ints, the maximum is selected over multiple axes,
+instead of a single axis or all the axes as before.
+</code></pre>
+<p>out : ndarray, optional  Alternative output array in which to place the result. Must  be of the same shape and buffer length as the expected output.  See <code>ufuncs-output-type</code> for more details.</p>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `amax` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<p>initial : scalar, optional  The minimum value of an output element. Must be present to allow  computation on empty slice. See <code>~numpy.ufunc.reduce</code> for details.</p>
+<pre><code>.. versionadded:: 1.15.0
+</code></pre>
+<p>where : array_like of bool, optional  Elements to compare for the maximum. See <code>~numpy.ufunc.reduce</code>  for details.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>amax : ndarray or scalar  Maximum of <code>a</code>. If <code>axis</code> is None, the result is a scalar value.  If <code>axis</code> is given, the result is an array of dimension  <code>a.ndim - 1</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>amin :  The minimum value of an array along a given axis, propagating any NaNs. nanmax :  The maximum value of an array along a given axis, ignoring any NaNs. maximum :  Element-wise maximum of two arrays, propagating any NaNs. fmax :  Element-wise maximum of two arrays, ignoring any NaNs. argmax :  Return the indices of the maximum values.</p>
+<p>nanmin, minimum, fmin</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>NaN values are propagated, that is if at least one item is NaN, the corresponding max value will be NaN as well. To ignore NaN values (MATLAB behavior), please use nanmax.</p>
+<p>Don’t use <code>amax</code> for element-wise comparison of 2 arrays; when <code>a.shape[0]</code> is 2, <code>maximum(a[0], a[1])</code> is faster than <code>amax(a, axis=0)</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(4).reshape((2,2)) a array(<a href="null">0, 1],
+       [2, 3</a>) np.amax(a) # Maximum of the flattened array 3 np.amax(a, axis=0) # Maxima along the first axis array([2, 3]) np.amax(a, axis=1) # Maxima along the second axis array([1, 3]) np.amax(a, where=[False, True], initial=-1, axis=0) array([-1, 3]) b = np.arange(5, dtype=float) b[2] = np.NaN np.amax(b) nan np.amax(b, where=~np.isnan(b), initial=-1) 4.0 np.nanmax(b) 4.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>You can use an initial value to compute the maximum of an empty slice, or to initialize it to a different value:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.max(<a href="null">-50], [10</a>, axis=-1, initial=0) array([ 0, 10])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Notice that the initial value is used as one of the elements for which the maximum is determined, unlike for the default argument Python’s max function, which is only used for empty iterables.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.max([5], initial=6) 6 max([5], default=6) 5</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23296">view source</a></div></div><div class="public anchor" id="var-amin"><h3>amin</h3><div class="usage"><code>(amin &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the minimum of an array or minimum along an axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  Axis or axes along which to operate. By default, flattened input is  used.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If this is a tuple of ints, the minimum is selected over multiple axes,
+instead of a single axis or all the axes as before.
+</code></pre>
+<p>out : ndarray, optional  Alternative output array in which to place the result. Must  be of the same shape and buffer length as the expected output.  See <code>ufuncs-output-type</code> for more details.</p>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `amin` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<p>initial : scalar, optional  The maximum value of an output element. Must be present to allow  computation on empty slice. See <code>~numpy.ufunc.reduce</code> for details.</p>
+<pre><code>.. versionadded:: 1.15.0
+</code></pre>
+<p>where : array_like of bool, optional  Elements to compare for the minimum. See <code>~numpy.ufunc.reduce</code>  for details.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>amin : ndarray or scalar  Minimum of <code>a</code>. If <code>axis</code> is None, the result is a scalar value.  If <code>axis</code> is given, the result is an array of dimension  <code>a.ndim - 1</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>amax :  The maximum value of an array along a given axis, propagating any NaNs. nanmin :  The minimum value of an array along a given axis, ignoring any NaNs. minimum :  Element-wise minimum of two arrays, propagating any NaNs. fmin :  Element-wise minimum of two arrays, ignoring any NaNs. argmin :  Return the indices of the minimum values.</p>
+<p>nanmax, maximum, fmax</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>NaN values are propagated, that is if at least one item is NaN, the corresponding min value will be NaN as well. To ignore NaN values (MATLAB behavior), please use nanmin.</p>
+<p>Don’t use <code>amin</code> for element-wise comparison of 2 arrays; when <code>a.shape[0]</code> is 2, <code>minimum(a[0], a[1])</code> is faster than <code>amin(a, axis=0)</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(4).reshape((2,2)) a array(<a href="null">0, 1],
+       [2, 3</a>) np.amin(a) # Minimum of the flattened array 0 np.amin(a, axis=0) # Minima along the first axis array([0, 1]) np.amin(a, axis=1) # Minima along the second axis array([0, 2]) np.amin(a, where=[False, True], initial=10, axis=0) array([10, 1])</p>
+      <p>b = np.arange(5, dtype=float) b[2] = np.NaN np.amin(b) nan np.amin(b, where=~np.isnan(b), initial=10) 0.0 np.nanmin(b) 0.0</p>
+      <p>np.min(<a href="null">-50], [10</a>, axis=-1, initial=0) array([-50, 0])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Notice that the initial value is used as one of the elements for which the minimum is determined, unlike for the default argument Python’s max function, which is only used for empty iterables.</p>
+<p>Notice that this isn’t the same as Python’s <code>default</code> argument.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.min([6], initial=5) 5 min([6], default=5) 6</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24071">view source</a></div></div><div class="public anchor" id="var-angle"><h3>angle</h3><div class="usage"><code>(angle &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the angle of the complex argument.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>z : array_like  A complex number or sequence of complex numbers. deg : bool, optional  Return angle in degrees if True, radians if False (default).</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>angle : ndarray or scalar  The counterclockwise angle from the positive real axis on the complex  plane in the range <code>(-pi, pi]</code>, with dtype as numpy.float64.</p>
+<pre><code>..versionchanged:: 1.16.0
+    This function works on subclasses of ndarray like `ma.array`.
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>arctan2 absolute</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.angle([1.0, 1.0j, 1+1j]) # in radians array([ 0. , 1.57079633, 0.78539816]) # may vary np.angle(1+1j, deg=True) # in degrees 45.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13817">view source</a></div></div><div class="public anchor" id="var-any"><h3>any</h3><div class="usage"><code>(any &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Test whether any array element along a given axis evaluates to True.</p>
+<p>Returns single boolean unless <code>axis</code> is not <code>None</code></p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array or object that can be converted to an array. axis : None or int or tuple of ints, optional  Axis or axes along which a logical OR reduction is performed.  The default (<code>axis=None</code>) is to perform a logical OR over all  the dimensions of the input array. <code>axis</code> may be negative, in  which case it counts from the last to the first axis.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If this is a tuple of ints, a reduction is performed on multiple
+axes, instead of a single axis or all the axes as before.
+</code></pre>
+<p>out : ndarray, optional  Alternate output array in which to place the result. It must have  the same shape as the expected output and its type is preserved  (e.g., if it is of type float, then it will remain so, returning  1.0 for True and 0.0 for False, regardless of the type of <code>a</code>).  See <code>ufuncs-output-type</code> for more details.</p>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `any` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>any : bool or ndarray  A new boolean or <code>ndarray</code> is returned unless <code>out</code> is specified,  in which case a reference to <code>out</code> is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.any : equivalent method</p>
+<p>all : Test whether all elements along a given axis evaluate to True.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Not a Number (NaN), positive infinity and negative infinity evaluate to <code>True</code> because these are not equal to zero.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.any(<a href="null">True, False], [True, True</a>) True</p>
+      <p>np.any(<a href="null">True, False], [False, False</a>, axis=0) array([ True, False])</p>
+      <p>np.any([-1, 0, 5]) True</p>
+      <p>np.any(np.nan) True</p>
+      <p>o=np.array(False) z=np.any([-1, 4, 5], out=o) z, o (array(True), array(True))</p>
+      <h1><a href="#check-now-that-z-is-a-reference-to-o" name="check-now-that-z-is-a-reference-to-o"></a>Check now that z is a reference to o</h1>
+      <p>z is o True id(z), id(o) # identity of z and o # doctest: +SKIP (191614240, 191614240)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13736">view source</a></div></div><div class="public anchor" id="var-append"><h3>append</h3><div class="usage"><code>(append &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Append values to the end of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr : array_like  Values are appended to a copy of this array. values : array_like  These values are appended to a copy of <code>arr</code>. It must be of the  correct shape (the same shape as <code>arr</code>, excluding <code>axis</code>). If  <code>axis</code> is not specified, <code>values</code> can be any shape and will be  flattened before use. axis : int, optional  The axis along which <code>values</code> are appended. If <code>axis</code> is not  given, both <code>arr</code> and <code>values</code> are flattened before use.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>append : ndarray  A copy of <code>arr</code> with <code>values</code> appended to <code>axis</code>. Note that  <code>append</code> does not occur in-place: a new array is allocated and  filled. If <code>axis</code> is None, <code>out</code> is a flattened array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>insert : Insert elements into an array. delete : Delete elements from an array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.append([1, 2, 3], <a href="null">4, 5, 6], [7, 8, 9</a>) array([1, 2, 3, …, 7, 8, 9])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>When <code>axis</code> is specified, <code>values</code> must have the correct shape.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.append(<a href="null">1, 2, 3], [4, 5, 6</a>, <a href="null">7, 8, 9</a>, axis=0) array(<a href="null">1, 2, 3],
+       [4, 5, 6],
+       [7, 8, 9</a>) np.append(<a href="null">1, 2, 3], [4, 5, 6</a>, [7, 8, 9], axis=0) Traceback (most recent call last):  … ValueError: all the input arrays must have same number of dimensions</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21358">view source</a></div></div><div class="public anchor" id="var-apply_along_axis"><h3>apply_along_axis</h3><div class="usage"><code>(apply_along_axis &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Apply a function to 1-D slices along the given axis.</p>
+<p>Execute <code>func1d(a, *args)</code> where <code>func1d</code> operates on 1-D arrays and <code>a</code> is a 1-D slice of <code>arr</code> along <code>axis</code>.</p>
+<p>This is equivalent to (but faster than) the following use of <code>ndindex</code> and <code>s_</code>, which sets each of <code>ii</code>, <code>jj</code>, and <code>kk</code> to a tuple of indices::</p>
+<pre><code>Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+for ii in ndindex(Ni):
+    for kk in ndindex(Nk):
+        f = func1d(arr[ii + s_[:,] + kk])
+        Nj = f.shape
+        for jj in ndindex(Nj):
+            out[ii + jj + kk] = f[jj]
+</code></pre>
+<p>Equivalently, eliminating the inner loop, this can be expressed as::</p>
+<pre><code>Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+for ii in ndindex(Ni):
+    for kk in ndindex(Nk):
+        out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])
+</code></pre>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>func1d : function (M,) -&gt; (Nj…)  This function should accept 1-D arrays. It is applied to 1-D  slices of <code>arr</code> along the specified axis. axis : integer  Axis along which <code>arr</code> is sliced. arr : ndarray (Ni…, M, Nk…)  Input array. args : any  Additional arguments to <code>func1d</code>. kwargs : any  Additional named arguments to <code>func1d</code>.</p>
+<pre><code>.. versionadded:: 1.9.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray (Ni…, Nj…, Nk…)  The output array. The shape of <code>out</code> is identical to the shape of  <code>arr</code>, except along the <code>axis</code> dimension. This axis is removed, and  replaced with new dimensions equal to the shape of the return value  of <code>func1d</code>. So if <code>func1d</code> returns a scalar <code>out</code> will have one  fewer dimensions than <code>arr</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>apply_over_axes : Apply a function repeatedly over multiple axes.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>def my_func(a): … ""“Average first and last element of a 1-D array”"" … return (a[0] + a[-1]) * 0.5 b = np.array(<a href="null">1,2,3], [4,5,6], [7,8,9</a>) np.apply_along_axis(my_func, 0, b) array([4., 5., 6.]) np.apply_along_axis(my_func, 1, b) array([2., 5., 8.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>For a function that returns a 1D array, the number of dimensions in <code>outarr</code> is the same as <code>arr</code>.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>b = np.array(<a href="null">8,1,7], [4,3,9], [5,2,6</a>) np.apply_along_axis(sorted, 1, b) array(<a href="null">1, 7, 8],
+       [3, 4, 9],
+       [2, 5, 6</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>For a function that returns a higher dimensional array, those dimensions are inserted in place of the <code>axis</code> dimension.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>b = np.array(<a href="null">1,2,3], [4,5,6], [7,8,9</a>) np.apply_along_axis(np.diag, -1, b) array(<a href="null">[1, 0, 0],
+        [0, 2, 0],
+        [0, 0, 3</a>,  <a href="null">4, 0, 0],
+        [0, 5, 0],
+        [0, 0, 6</a>,  <a href="null">7, 0, 0],
+        [0, 8, 0],
+        [0, 0, 9</a>])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25038">view source</a></div></div><div class="public anchor" id="var-apply_over_axes"><h3>apply_over_axes</h3><div class="usage"><code>(apply_over_axes &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Apply a function repeatedly over multiple axes.</p>
+<p><code>func</code> is called as <code>res = func(a, axis)</code>, where <code>axis</code> is the first element of <code>axes</code>. The result <code>res</code> of the function call must have either the same dimensions as <code>a</code> or one less dimension. If <code>res</code> has one less dimension than <code>a</code>, a dimension is inserted before <code>axis</code>. The call to <code>func</code> is then repeated for each axis in <code>axes</code>, with <code>res</code> as the first argument.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>func : function  This function must take two arguments, <code>func(a, axis)</code>. a : array_like  Input array. axes : array_like  Axes over which <code>func</code> is applied; the elements must be integers.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>apply_over_axis : ndarray  The output array. The number of dimensions is the same as <code>a</code>,  but the shape can be different. This depends on whether <code>func</code>  changes the shape of its output with respect to its input.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>apply_along_axis :  Apply a function to 1-D slices of an array along the given axis.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This function is equivalent to tuple axis arguments to reorderable ufuncs with keepdims=True. Tuple axis arguments to ufuncs have been available since version 1.7.0.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(24).reshape(2,3,4) a array(<a href="null">[ 0,  1,  2,  3],
+        [ 4,  5,  6,  7],
+        [ 8,  9, 10, 11</a>,  <a href="null">12, 13, 14, 15],
+        [16, 17, 18, 19],
+        [20, 21, 22, 23</a>])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Sum over axes 0 and 2. The result has same number of dimensions as the original array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.apply_over_axes(np.sum, a, [0,2]) array(<a href="null">[ 60],
+        [ 92],
+        [124</a>])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Tuple axis arguments to ufuncs are equivalent:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sum(a, axis=(0,2), keepdims=True) array(<a href="null">[ 60],
+        [ 92],
+        [124</a>])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26809">view source</a></div></div><div class="public anchor" id="var-arange"><h3>arange</h3><div class="usage"><code>(arange self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arange([start,] stop[, step,], dtype=None)</p>
+<p>Return evenly spaced values within a given interval.</p>
+<p>Values are generated within the half-open interval <code>[start, stop)</code> (in other words, the interval including <code>start</code> but excluding <code>stop</code>). For integer arguments the function is equivalent to the Python built-in <code>range</code> function, but returns an ndarray rather than a list.</p>
+<p>When using a non-integer step, such as 0.1, the results will often not be consistent. It is better to use <code>numpy.linspace</code> for these cases.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>start : number, optional  Start of interval. The interval includes this value. The default  start value is 0. stop : number  End of interval. The interval does not include this value, except  in some cases where <code>step</code> is not an integer and floating point  round-off affects the length of <code>out</code>. step : number, optional  Spacing between values. For any output <code>out</code>, this is the distance  between two adjacent values, <code>out[i+1] - out[i]</code>. The default  step size is 1. If <code>step</code> is specified as a position argument,  <code>start</code> must also be given. dtype : dtype  The type of the output array. If <code>dtype</code> is not given, infer the data  type from the other input arguments.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>arange : ndarray  Array of evenly spaced values.</p>
+<pre><code>For floating point arguments, the length of the result is
+``ceil((stop - start)/step)``.  Because of floating point overflow,
+this rule may result in the last element of `out` being greater
+than `stop`.
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.linspace : Evenly spaced numbers with careful handling of endpoints. numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions. numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.arange(3) array([0, 1, 2]) np.arange(3.0) array([ 0., 1., 2.]) np.arange(3,7) array([3, 4, 5, 6]) np.arange(3,7,2) array([3, 5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20949">view source</a></div></div><div class="public anchor" id="var-arccos"><h3>arccos</h3><div class="usage"><code>(arccos self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arccos(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Trigonometric inverse cosine, element-wise.</p>
+<p>The inverse of <code>cos</code> so that, if <code>y = cos(x)</code>, then <code>x = arccos(y)</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  <code>x</code>-coordinate on the unit circle.  For real arguments, the domain is [-1, 1]. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>angle : ndarray  The angle of the ray intersecting the unit circle at the given  <code>x</code>-coordinate in radians [0, pi].  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>cos, arctan, arcsin, emath.arccos</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>arccos</code> is a multivalued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that <code>cos(z) = x</code>. The convention is to return the angle <code>z</code> whose real part lies in <code>[0, pi]</code>.</p>
+<p>For real-valued input data types, <code>arccos</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
+<p>For complex-valued input, <code>arccos</code> is a complex analytic function that has branch cuts <code>[-inf, -1]</code> and <code>[1, inf]</code> and is continuous from above on the former and from below on the latter.</p>
+<p>The inverse <code>cos</code> is also known as <code>acos</code> or cos^-1.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”, 10th printing, 1964, pp. 79. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>We expect the arccos of 1 to be 0, and of -1 to be pi:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.arccos([1, -1]) array([ 0. , 3.14159265])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot arccos:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt x = np.linspace(-1, 1, num=100) plt.plot(x, np.arccos(x)) plt.axis(‘tight’) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26611">view source</a></div></div><div class="public anchor" id="var-arccosh"><h3>arccosh</h3><div class="usage"><code>(arccosh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arccosh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Inverse hyperbolic cosine, element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>arccosh : ndarray  Array of the same shape as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>cosh, arcsinh, sinh, arctanh, tanh</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>arccosh</code> is a multivalued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that <code>cosh(z) = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi, pi]</code> and the real part in <code>[0, inf]</code>.</p>
+<p>For real-valued input data types, <code>arccosh</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
+<p>For complex-valued input, <code>arccosh</code> is a complex analytical function that has a branch cut <code>[-inf, 1]</code> and is continuous from above on it.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 86. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Inverse hyperbolic function”,  <a href="https://en.wikipedia.org/wiki/Arccosh">https://en.wikipedia.org/wiki/Arccosh</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.arccosh([np.e, 10.0]) array([ 1.65745445, 2.99322285]) np.arccosh(1) 0.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26745">view source</a></div></div><div class="public anchor" id="var-arcsin"><h3>arcsin</h3><div class="usage"><code>(arcsin self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arcsin(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Inverse sine, element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  <code>y</code>-coordinate on the unit circle. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>angle : ndarray  The inverse sine of each element in <code>x</code>, in radians and in the  closed interval <code>[-pi/2, pi/2]</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>sin, cos, arccos, tan, arctan, arctan2, emath.arcsin</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>arcsin</code> is a multivalued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that :math:<code>sin(z) = x</code>. The convention is to return the angle <code>z</code> whose real part lies in [-pi/2, pi/2].</p>
+<p>For real-valued input data types, <em>arcsin</em> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
+<p>For complex-valued input, <code>arcsin</code> is a complex analytic function that has, by convention, the branch cuts [-inf, -1] and [1, inf] and is continuous from above on the former and from below on the latter.</p>
+<p>The inverse sine is also known as <code>asin</code> or sin^{-1}.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>Abramowitz, M. and Stegun, I. A., <em>Handbook of Mathematical Functions</em>, 10th printing, New York: Dover, 1964, pp. 79ff. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.arcsin(1) # pi/2 1.5707963267948966 np.arcsin(-1) # -pi/2 -1.5707963267948966 np.arcsin(0) 0.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28429">view source</a></div></div><div class="public anchor" id="var-arcsinh"><h3>arcsinh</h3><div class="usage"><code>(arcsinh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arcsinh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Inverse hyperbolic sine element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Array of the same shape as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>arcsinh</code> is a multivalued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that <code>sinh(z) = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi/2, pi/2]</code>.</p>
+<p>For real-valued input data types, <code>arcsinh</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it returns <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
+<p>For complex-valued input, <code>arccos</code> is a complex analytical function that has branch cuts <code>[1j, infj]</code> and <code>[-1j, -infj]</code> and is continuous from the right on the former and from the left on the latter.</p>
+<p>The inverse hyperbolic sine is also known as <code>asinh</code> or <code>sinh^-1</code>.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 86. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Inverse hyperbolic function”,  <a href="https://en.wikipedia.org/wiki/Arcsinh">https://en.wikipedia.org/wiki/Arcsinh</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.arcsinh(np.array([np.e, 10.0])) array([ 1.72538256, 2.99822295])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18038">view source</a></div></div><div class="public anchor" id="var-arctan"><h3>arctan</h3><div class="usage"><code>(arctan self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arctan(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Trigonometric inverse tangent, element-wise.</p>
+<p>The inverse of tan, so that if <code>y = tan(x)</code> then <code>x = arctan(y)</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Out has the same shape as <code>x</code>. Its real part is in  <code>[-pi/2, pi/2]</code> (<code>arctan(+/-inf)</code> returns <code>+/-pi/2</code>).  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>arctan2 : The “four quadrant” arctan of the angle formed by (<code>x</code>, <code>y</code>)  and the positive <code>x</code>-axis. angle : Argument of complex values.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>arctan</code> is a multi-valued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that tan(<code>z</code>) = <code>x</code>. The convention is to return the angle <code>z</code> whose real part lies in [-pi/2, pi/2].</p>
+<p>For real-valued input data types, <code>arctan</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
+<p>For complex-valued input, <code>arctan</code> is a complex analytic function that has [<code>1j, infj</code>] and [<code>-1j, -infj</code>] as branch cuts, and is continuous from the left on the former and from the right on the latter.</p>
+<p>The inverse tangent is also known as <code>atan</code> or tan^{-1}.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>Abramowitz, M. and Stegun, I. A., <em>Handbook of Mathematical Functions</em>, 10th printing, New York: Dover, 1964, pp. 79. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>We expect the arctan of 0 to be 0, and of 1 to be pi/4:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.arctan([0, 1]) array([ 0. , 0.78539816])</p>
+      <p>np.pi/4 0.78539816339744828</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot arctan:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt x = np.linspace(-10, 10) plt.plot(x, np.arctan(x)) plt.axis(‘tight’) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13590">view source</a></div></div><div class="public anchor" id="var-arctan2"><h3>arctan2</h3><div class="usage"><code>(arctan2 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arctan2(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Element-wise arc tangent of <code>x1/x2</code> choosing the quadrant correctly.</p>
+<p>The quadrant (i.e., branch) is chosen so that <code>arctan2(x1, x2)</code> is the signed angle in radians between the ray ending at the origin and passing through the point (1,0), and the ray ending at the origin and passing through the point (<code>x2</code>, <code>x1</code>). (Note the role reversal: the “<code>y</code>-coordinate” is the first function parameter, the “<code>x</code>-coordinate” is the second.) By IEEE convention, this function is defined for <code>x2</code> = +/-0 and for either or both of <code>x1</code> and <code>x2</code> = +/-inf (see Notes for specific values).</p>
+<p>This function is not defined for complex-valued arguments; for the so-called argument of complex values, use <code>angle</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like, real-valued  <code>y</code>-coordinates. x2 : array_like, real-valued  <code>x</code>-coordinates. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>angle : ndarray  Array of angles in radians, in the range <code>[-pi, pi]</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>arctan, tan, angle</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><em>arctan2</em> is identical to the <code>atan2</code> function of the underlying C library. The following special values are defined in the C standard: [1]_</p>
+<p>====== ====== ================ <code>x1</code> <code>x2</code> <code>arctan2(x1,x2)</code> ====== ====== ================ +/- 0 +0 +/- 0 +/- 0 -0 +/- pi  &gt; 0 +/-inf +0 / +pi  &lt; 0 +/-inf -0 / -pi +/-inf +inf +/- (pi/4) +/-inf -inf +/- (3*pi/4) ====== ====== ================</p>
+<p>Note that +0 and -0 are distinct floating point numbers, as are +inf and -inf.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] ISO/IEC standard 9899:1999, “Programming language C.”</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Consider four points in different quadrants:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([-1, +1, +1, -1]) y = np.array([-1, -1, +1, +1]) np.arctan2(y, x) * 180 / np.pi array([-135., -45., 45., 135.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note the order of the parameters. <code>arctan2</code> is defined also when <code>x2</code> = 0 and at several other special points, obtaining values in the range <code>[-pi, pi]</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.arctan2([1., -1.], [0., 0.]) array([ 1.57079633, -1.57079633]) np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) array([ 0. , 3.14159265, 0.78539816])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L575">view source</a></div></div><div class="public anchor" id="var-arctanh"><h3>arctanh</h3><div class="usage"><code>(arctanh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arctanh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Inverse hyperbolic tangent element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Array of the same shape as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>emath.arctanh</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>arctanh</code> is a multivalued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that <code>tanh(z) = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi/2, pi/2]</code>.</p>
+<p>For real-valued input data types, <code>arctanh</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
+<p>For complex-valued input, <code>arctanh</code> is a complex analytical function that has branch cuts <code>[-1, -inf]</code> and <code>[1, inf]</code> and is continuous from above on the former and from below on the latter.</p>
+<p>The inverse hyperbolic tangent is also known as <code>atanh</code> or <code>tanh^-1</code>.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 86. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Inverse hyperbolic function”,  <a href="https://en.wikipedia.org/wiki/Arctanh">https://en.wikipedia.org/wiki/Arctanh</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.arctanh([0, -0.5]) array([ 0. , -0.54930614])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11725">view source</a></div></div><div class="public anchor" id="var-argmax"><h3>argmax</h3><div class="usage"><code>(argmax &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the indices of the maximum values along an axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. axis : int, optional  By default, the index is into the flattened array, otherwise  along the specified axis. out : array, optional  If provided, the result will be inserted into this array. It should  be of the appropriate shape and dtype.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>index_array : ndarray of ints  Array of indices into the array. It has the same shape as <code>a.shape</code>  with the dimension along <code>axis</code> removed.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.argmax, argmin amax : The maximum value along a given axis. unravel_index : Convert a flat index into an index tuple. take_along_axis : Apply <code>np.expand_dims(index_array, axis)</code>  from argmax to an array as if by calling max.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>In case of multiple occurrences of the maximum values, the indices corresponding to the first occurrence are returned.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(6).reshape(2,3) + 10 a array(<a href="null">10, 11, 12],
+       [13, 14, 15</a>) np.argmax(a) 5 np.argmax(a, axis=0) array([1, 1, 1]) np.argmax(a, axis=1) array([2, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Indexes of the maximal elements of a N-dimensional array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>ind = np.unravel_index(np.argmax(a, axis=None), a.shape) ind (1, 2) a[ind] 15</p>
+      <p>b = np.arange(6) b[1] = 5 b array([0, 5, 2, 3, 4, 5]) np.argmax(b) # Only the first occurrence is returned. 1</p>
+      <p>x = np.array(<a href="null">4,2,3], [1,0,3</a>) index_array = np.argmax(x, axis=-1)</p>
+      <h1><a href="#same-as-np-max-x-axis-1-keepdims-true-" name="same-as-np-max-x-axis-1-keepdims-true-"></a>Same as np.max(x, axis=-1, keepdims=True)</h1>
+      <p>np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) array(<a href="null">4],
+       [3</a>)</p>
+      <h1><a href="#same-as-np-max-x-axis-1-" name="same-as-np-max-x-axis-1-"></a>Same as np.max(x, axis=-1)</h1>
+      <p>np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1) array([4, 3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6499">view source</a></div></div><div class="public anchor" id="var-argmin"><h3>argmin</h3><div class="usage"><code>(argmin &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the indices of the minimum values along an axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. axis : int, optional  By default, the index is into the flattened array, otherwise  along the specified axis. out : array, optional  If provided, the result will be inserted into this array. It should  be of the appropriate shape and dtype.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>index_array : ndarray of ints  Array of indices into the array. It has the same shape as <code>a.shape</code>  with the dimension along <code>axis</code> removed.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.argmin, argmax amin : The minimum value along a given axis. unravel_index : Convert a flat index into an index tuple. take_along_axis : Apply <code>np.expand_dims(index_array, axis)</code>  from argmin to an array as if by calling min.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>In case of multiple occurrences of the minimum values, the indices corresponding to the first occurrence are returned.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(6).reshape(2,3) + 10 a array(<a href="null">10, 11, 12],
+       [13, 14, 15</a>) np.argmin(a) 0 np.argmin(a, axis=0) array([0, 0, 0]) np.argmin(a, axis=1) array([0, 0])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Indices of the minimum elements of a N-dimensional array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>ind = np.unravel_index(np.argmin(a, axis=None), a.shape) ind (0, 0) a[ind] 10</p>
+      <p>b = np.arange(6) + 10 b[4] = 10 b array([10, 11, 12, 13, 10, 15]) np.argmin(b) # Only the first occurrence is returned. 0</p>
+      <p>x = np.array(<a href="null">4,2,3], [1,0,3</a>) index_array = np.argmin(x, axis=-1)</p>
+      <h1><a href="#same-as-np-min-x-axis-1-keepdims-true-" name="same-as-np-min-x-axis-1-keepdims-true-"></a>Same as np.min(x, axis=-1, keepdims=True)</h1>
+      <p>np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) array(<a href="null">2],
+       [0</a>)</p>
+      <h1><a href="#same-as-np-max-x-axis-1-" name="same-as-np-max-x-axis-1-"></a>Same as np.max(x, axis=-1)</h1>
+      <p>np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1) array([2, 0])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11197">view source</a></div></div><div class="public anchor" id="var-argpartition"><h3>argpartition</h3><div class="usage"><code>(argpartition &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Perform an indirect partition along the given axis using the algorithm specified by the <code>kind</code> keyword. It returns an array of indices of the same shape as <code>a</code> that index data along the given axis in partitioned order.</p>
+<p>.. versionadded:: 1.8.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array to sort. kth : int or sequence of ints  Element index to partition by. The k-th element will be in its  final sorted position and all smaller elements will be moved  before it and all larger elements behind it. The order all  elements in the partitions is undefined. If provided with a  sequence of k-th it will partition all of them into their sorted  position at once. axis : int or None, optional  Axis along which to sort. The default is -1 (the last axis). If  None, the flattened array is used. kind : {‘introselect’}, optional  Selection algorithm. Default is ‘introselect’ order : str or list of str, optional  When <code>a</code> is an array with fields defined, this argument  specifies which fields to compare first, second, etc. A single  field can be specified as a string, and not all fields need be  specified, but unspecified fields will still be used, in the  order in which they come up in the dtype, to break ties.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>index_array : ndarray, int  Array of indices that partition <code>a</code> along the specified axis.  If <code>a</code> is one-dimensional, <code>a[index_array]</code> yields a partitioned <code>a</code>.  More generally, <code>np.take_along_axis(a, index_array, axis=a)</code> always  yields the partitioned <code>a</code>, irrespective of dimensionality.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>partition : Describes partition algorithms used. ndarray.partition : Inplace partition. argsort : Full indirect sort. take_along_axis : Apply <code>index_array</code> from argpartition  to an array as if by calling partition.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>See <code>partition</code> for notes on the different selection algorithms.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>One dimensional array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([3, 4, 2, 1]) x[np.argpartition(x, 3)] array([2, 1, 3, 4]) x[np.argpartition(x, (1, 3))] array([1, 2, 3, 4])</p>
+      <p>x = [3, 4, 2, 1] np.array(x)[np.argpartition(x, 3)] array([2, 1, 3, 4])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Multi-dimensional array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">3, 4, 2], [1, 3, 1</a>) index_array = np.argpartition(x, kth=1, axis=-1) np.take_along_axis(x, index_array, axis=-1) # same as np.partition(x, kth=1) array(<a href="null">2, 3, 4],
+       [1, 1, 3</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20870">view source</a></div></div><div class="public anchor" id="var-argsort"><h3>argsort</h3><div class="usage"><code>(argsort &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the indices that would sort an array.</p>
+<p>Perform an indirect sort along the given axis using the algorithm specified by the <code>kind</code> keyword. It returns an array of indices of the same shape as <code>a</code> that index data along the given axis in sorted order.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array to sort. axis : int or None, optional  Axis along which to sort. The default is -1 (the last axis). If None,  the flattened array is used. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, optional  Sorting algorithm. The default is ‘quicksort’. Note that both ‘stable’  and ‘mergesort’ use timsort under the covers and, in general, the  actual implementation will vary with data type. The ‘mergesort’ option  is retained for backwards compatibility.</p>
+<pre><code>.. versionchanged:: 1.15.0.
+   The 'stable' option was added.
+</code></pre>
+<p>order : str or list of str, optional  When <code>a</code> is an array with fields defined, this argument specifies  which fields to compare first, second, etc. A single field can  be specified as a string, and not all fields need be specified,  but unspecified fields will still be used, in the order in which  they come up in the dtype, to break ties.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>index_array : ndarray, int  Array of indices that sort <code>a</code> along the specified <code>axis</code>.  If <code>a</code> is one-dimensional, <code>a[index_array]</code> yields a sorted <code>a</code>.  More generally, <code>np.take_along_axis(a, index_array, axis=axis)</code>  always yields the sorted <code>a</code>, irrespective of dimensionality.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>sort : Describes sorting algorithms used. lexsort : Indirect stable sort with multiple keys. ndarray.sort : Inplace sort. argpartition : Indirect partial sort. take_along_axis : Apply <code>index_array</code> from argsort  to an array as if by calling sort.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>See <code>sort</code> for notes on the different sorting algorithms.</p>
+<p>As of NumPy 1.4.0 <code>argsort</code> works with real/complex arrays containing nan values. The enhanced sort order is documented in <code>sort</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>One dimensional array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([3, 1, 2]) np.argsort(x) array([1, 2, 0])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Two-dimensional array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">0, 3], [2, 2</a>) x array(<a href="null">0, 3],
+       [2, 2</a>)</p>
+      <p>ind = np.argsort(x, axis=0) # sorts along first axis (down) ind array(<a href="null">0, 1],
+       [1, 0</a>) np.take_along_axis(x, ind, axis=0) # same as np.sort(x, axis=0) array(<a href="null">0, 2],
+       [2, 3</a>)</p>
+      <p>ind = np.argsort(x, axis=1) # sorts along last axis (across) ind array(<a href="null">0, 1],
+       [0, 1</a>) np.take_along_axis(x, ind, axis=1) # same as np.sort(x, axis=1) array(<a href="null">0, 3],
+       [2, 2</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Indices of the sorted elements of a N-dimensional array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>ind = np.unravel_index(np.argsort(x, axis=None), x.shape) ind (array([0, 1, 1, 0]), array([0, 0, 1, 1])) x[ind] # same as np.sort(x, axis=None) array([0, 2, 2, 3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Sorting with keys:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([(1, 0), (0, 1)], dtype=[(‘x’, ‘&lt;i4’), (‘y’, ‘&lt;i4’)]) x array([(1, 0), (0, 1)],  dtype=[(‘x’, ‘&lt;i4’), (‘y’, ‘&lt;i4’)])</p>
+      <p>np.argsort(x, order=(‘x’,‘y’)) array([1, 0])</p>
+      <p>np.argsort(x, order=(‘y’,‘x’)) array([0, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19413">view source</a></div></div><div class="public anchor" id="var-argwhere"><h3>argwhere</h3><div class="usage"><code>(argwhere &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the indices of array elements that are non-zero, grouped by element.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>index_array : (N, a.ndim) ndarray  Indices of elements that are non-zero. Indices are grouped by element.  This array will have shape <code>(N, a.ndim)</code> where <code>N</code> is the number of  non-zero items.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>where, nonzero</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>np.argwhere(a)</code> is almost the same as <code>np.transpose(np.nonzero(a))</code>, but produces a result of the correct shape for a 0D array.</p>
+<p>The output of <code>argwhere</code> is not suitable for indexing arrays. For this purpose use <code>nonzero(a)</code> instead.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(6).reshape(2,3) x array(<a href="null">0, 1, 2],
+       [3, 4, 5</a>) np.argwhere(x&gt;1) array(<a href="null">0, 2],
+       [1, 0],
+       [1, 1],
+       [1, 2</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21267">view source</a></div></div><div class="public anchor" id="var-around"><h3>around</h3><div class="usage"><code>(around &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Evenly round to the given number of decimals.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. decimals : int, optional  Number of decimal places to round to (default: 0). If  decimals is negative, it specifies the number of positions to  the left of the decimal point. out : ndarray, optional  Alternative output array in which to place the result. It must have  the same shape as the expected output, but the type of the output  values will be cast if necessary. See <code>ufuncs-output-type</code> for more  details.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>rounded_array : ndarray  An array of the same type as <code>a</code>, containing the rounded values.  Unless <code>out</code> was specified, a new array is created. A reference to  the result is returned.</p>
+<pre><code>The real and imaginary parts of complex numbers are rounded
+separately.  The result of rounding a float is a float.
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.round : equivalent method</p>
+<p>ceil, fix, floor, rint, trunc</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>For values exactly halfway between rounded decimal values, NumPy rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, -0.5 and 0.5 round to 0.0, etc.</p>
+<p><code>np.around</code> uses a fast but sometimes inexact algorithm to round floating-point datatypes. For positive <code>decimals</code> it is equivalent to <code>np.true_divide(np.rint(a * 10**decimals), 10**decimals)</code>, which has error due to the inexact representation of decimal fractions in the IEEE floating point standard [1]_ and errors introduced when scaling by powers of ten. For instance, note the extra “1” in the following:</p>
+<pre><code>&gt;&gt;&gt; np.round(56294995342131.5, 3)
+56294995342131.51
+</code></pre>
+<p>If your goal is to print such values with a fixed number of decimals, it is preferable to use numpy’s float printing routines to limit the number of printed decimals:</p>
+<pre><code>&gt;&gt;&gt; np.format_float_positional(56294995342131.5, precision=3)
+'56294995342131.5'
+</code></pre>
+<p>The float printing routines use an accurate but much more computationally demanding algorithm to compute the number of digits after the decimal point.</p>
+<p>Alternatively, Python’s builtin <code>round</code> function uses a more accurate but slower algorithm for 64-bit floating point values:</p>
+<pre><code>&gt;&gt;&gt; round(56294995342131.5, 3)
+56294995342131.5
+&gt;&gt;&gt; np.round(16.055, 2), round(16.055, 2)  # equals 16.0549999999999997
+(16.06, 16.05)
+</code></pre>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] “Lecture Notes on the Status of IEEE 754”, William Kahan,  <a href="https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF">https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF</a> .. [2] “How Futile are Mindless Assessments of  Roundoff in Floating-Point Computation?”, William Kahan,  <a href="https://people.eecs.berkeley.edu/~wkahan/Mindless.pdf">https://people.eecs.berkeley.edu/~wkahan/Mindless.pdf</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.around([0.37, 1.64]) array([0., 2.]) np.around([0.37, 1.64], decimals=1) array([0.4, 1.6]) np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value array([0., 2., 2., 4., 4.]) np.around([1,2,3,11], decimals=1) # ndarray of ints is returned array([ 1, 2, 3, 11]) np.around([1,2,3,11], decimals=-1) array([ 0, 0, 0, 10])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22592">view source</a></div></div><div class="public anchor" id="var-array"><h3>array</h3><div class="usage"><code>(array self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>array(object, dtype=None, copy=True, order=‘K’, subok=False, ndmin=0)</p>
+<p>Create an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>object : array_like  An array, any object exposing the array interface, an object whose  <strong>array</strong> method returns an array, or any (nested) sequence. dtype : data-type, optional  The desired data-type for the array. If not given, then the type will  be determined as the minimum type required to hold the objects in the  sequence. copy : bool, optional  If true (default), then the object is copied. Otherwise, a copy will  only be made if <strong>array</strong> returns a copy, if obj is a nested sequence,  or if a copy is needed to satisfy any of the other requirements  (<code>dtype</code>, <code>order</code>, etc.). order : {‘K’, ‘A’, ‘C’, ‘F’}, optional  Specify the memory layout of the array. If object is not an array, the  newly created array will be in C order (row major) unless ‘F’ is  specified, in which case it will be in Fortran order (column major).  If object is an array the following holds.</p>
+<pre><code>===== ========= ===================================================
+order  no copy                     copy=True
+===== ========= ===================================================
+'K'   unchanged F &amp; C order preserved, otherwise most similar order
+'A'   unchanged F order if input is F and not C, otherwise C order
+'C'   C order   C order
+'F'   F order   F order
+===== ========= ===================================================
+
+When ``copy=False`` and a copy is made for other reasons, the result is
+the same as if ``copy=True``, with some exceptions for `A`, see the
+Notes section. The default order is 'K'.
+</code></pre>
+<p>subok : bool, optional  If True, then sub-classes will be passed-through, otherwise  the returned array will be forced to be a base-class array (default). ndmin : int, optional  Specifies the minimum number of dimensions that the resulting  array should have. Ones will be pre-pended to the shape as  needed to meet this requirement.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  An array object satisfying the specified requirements.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>empty_like : Return an empty array with shape and type of input. ones_like : Return an array of ones with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. full_like : Return a new array with shape of input filled with value. empty : Return a new uninitialized array. ones : Return a new array setting values to one. zeros : Return a new array setting values to zero. full : Return a new array of given shape filled with value.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>When order is ‘A’ and <code>object</code> is an array in neither ‘C’ nor ‘F’ order, and a copy is forced by a change in dtype, then the order of the result is not necessarily ‘C’ as expected. This is likely a bug.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array([1, 2, 3]) array([1, 2, 3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Upcasting:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array([1, 2, 3.0]) array([ 1., 2., 3.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>More than one dimension:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array(<a href="null">1, 2], [3, 4</a>) array(<a href="null">1, 2],
+       [3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Minimum dimensions 2:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array([1, 2, 3], ndmin=2) array(<a href="null">1, 2, 3</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Type provided:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array([1, 2, 3], dtype=complex) array([ 1.+0.j, 2.+0.j, 3.+0.j])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Data-type consisting of more than one element:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([(1,2),(3,4)],dtype=[(‘a’,‘&lt;i4’),(‘b’,‘&lt;i4’)]) x[‘a’] array([1, 3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Creating an array from sub-classes:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array(np.mat(‘1 2; 3 4’)) array(<a href="null">1, 2],
+       [3, 4</a>)</p>
+      <p>np.array(np.mat(‘1 2; 3 4’), subok=True) matrix(<a href="null">1, 2],
+        [3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26260">view source</a></div></div><div class="public anchor" id="var-array2string"><h3>array2string</h3><div class="usage"><code>(array2string &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a string representation of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. max_line_width : int, optional  Inserts newlines if text is longer than <code>max_line_width</code>.  Defaults to <code>numpy.get_printoptions()['linewidth']</code>. precision : int or None, optional  Floating point precision.  Defaults to <code>numpy.get_printoptions()['precision']</code>. suppress_small : bool, optional  Represent numbers “very close” to zero as zero; default is False.  Very close is defined by precision: if the precision is 8, e.g.,  numbers smaller (in absolute value) than 5e-9 are represented as  zero.  Defaults to <code>numpy.get_printoptions()['suppress']</code>. separator : str, optional  Inserted between elements. prefix : str, optional suffix: str, optional  The length of the prefix and suffix strings are used to respectively  align and wrap the output. An array is typically printed as::</p>
+<pre><code>  prefix + array2string(a) + suffix
+
+The output is left-padded by the length of the prefix string, and
+wrapping is forced at the column ``max_line_width - len(suffix)``.
+It should be noted that the content of prefix and suffix strings are
+not included in the output.
+</code></pre>
+<p>style : _NoValue, optional  Has no effect, do not use.</p>
+<pre><code>.. deprecated:: 1.14.0
+</code></pre>
+<p>formatter : dict of callables, optional  If not None, the keys should indicate the type(s) that the respective  formatting function applies to. Callables should return a string.  Types that are not specified (by their corresponding keys) are handled  by the default formatters. Individual types for which a formatter  can be set are:</p>
+<pre><code>- 'bool'
+- 'int'
+- 'timedelta' : a `numpy.timedelta64`
+- 'datetime' : a `numpy.datetime64`
+- 'float'
+- 'longfloat' : 128-bit floats
+- 'complexfloat'
+- 'longcomplexfloat' : composed of two 128-bit floats
+- 'void' : type `numpy.void`
+- 'numpystr' : types `numpy.string_` and `numpy.unicode_`
+- 'str' : all other strings
+
+Other keys that can be used to set a group of types at once are:
+
+- 'all' : sets all types
+- 'int_kind' : sets 'int'
+- 'float_kind' : sets 'float' and 'longfloat'
+- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
+- 'str_kind' : sets 'str' and 'numpystr'
+</code></pre>
+<p>threshold : int, optional  Total number of array elements which trigger summarization  rather than full repr.  Defaults to <code>numpy.get_printoptions()['threshold']</code>. edgeitems : int, optional  Number of array items in summary at beginning and end of  each dimension.  Defaults to <code>numpy.get_printoptions()['edgeitems']</code>. sign : string, either ‘-’, ‘+’, or ‘ ’, optional  Controls printing of the sign of floating-point types. If ‘+’, always  print the sign of positive values. If ‘ ’, always prints a space  (whitespace character) in the sign position of positive values. If  ‘-’, omit the sign character of positive values.  Defaults to <code>numpy.get_printoptions()['sign']</code>. floatmode : str, optional  Controls the interpretation of the <code>precision</code> option for  floating-point types.  Defaults to <code>numpy.get_printoptions()['floatmode']</code>.  Can take the following values:</p>
+<pre><code>- 'fixed': Always print exactly `precision` fractional digits,
+  even if this would print more or fewer digits than
+  necessary to specify the value uniquely.
+- 'unique': Print the minimum number of fractional digits necessary
+  to represent each value uniquely. Different elements may
+  have a different number of digits.  The value of the
+  `precision` option is ignored.
+- 'maxprec': Print at most `precision` fractional digits, but if
+  an element can be uniquely represented with fewer digits
+  only print it with that many.
+- 'maxprec_equal': Print at most `precision` fractional digits,
+  but if every element in the array can be uniquely
+  represented with an equal number of fewer digits, use that
+  many digits for all elements.
+</code></pre>
+<p>legacy : string or <code>False</code>, optional  If set to the string <code>'1.13'</code> enables 1.13 legacy printing mode. This  approximates numpy 1.13 print output by including a space in the sign  position of floats and different behavior for 0d arrays. If set to  <code>False</code>, disables legacy mode. Unrecognized strings will be ignored  with a warning for forward compatibility.</p>
+<pre><code>.. versionadded:: 1.14.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>array_str : str  String representation of the array.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>TypeError  if a callable in <code>formatter</code> does not return a string.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>array_str, array_repr, set_printoptions, get_printoptions</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If a formatter is specified for a certain type, the <code>precision</code> keyword is ignored for that type.</p>
+<p>This is a very flexible function; <code>array_repr</code> and <code>array_str</code> are using <code>array2string</code> internally so keywords with the same name should work identically in all three functions.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([1e-16,1,2,3]) np.array2string(x, precision=2, separator=‘,’, … suppress_small=True) ‘[0.,1.,2.,3.]’</p>
+      <p>x = np.arange(3.) np.array2string(x, formatter={‘float_kind’:lambda x: “%.2f” % x}) ‘[0.00 1.00 2.00]’</p>
+      <p>x = np.arange(3) np.array2string(x, formatter={‘int’:lambda x: hex(x)}) ‘[0x0 0x1 0x2]’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14133">view source</a></div></div><div class="public anchor" id="var-array_equal"><h3>array_equal</h3><div class="usage"><code>(array_equal &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>True if two arrays have the same shape and elements, False otherwise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a1, a2 : array_like  Input arrays.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>b : bool  Returns True if the arrays are equal.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>allclose: Returns True if two arrays are element-wise equal within a  tolerance. array_equiv: Returns True if input arrays are shape consistent and all  elements equal.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array_equal([1, 2], [1, 2]) True np.array_equal(np.array([1, 2]), np.array([1, 2])) True np.array_equal([1, 2], [1, 2, 3]) False np.array_equal([1, 2], [1, 4]) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9298">view source</a></div></div><div class="public anchor" id="var-array_equiv"><h3>array_equiv</h3><div class="usage"><code>(array_equiv &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns True if input arrays are shape consistent and all elements equal.</p>
+<p>Shape consistent means they are either the same shape, or one input array can be broadcasted to create the same shape as the other one.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a1, a2 : array_like  Input arrays.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : bool  True if equivalent, False otherwise.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array_equiv([1, 2], [1, 2]) True np.array_equiv([1, 2], [1, 3]) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Showing the shape equivalence:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array_equiv([1, 2], <a href="null">1, 2], [1, 2</a>) True np.array_equiv([1, 2], <a href="null">1, 2, 1, 2], [1, 2, 1, 2</a>) False</p>
+      <p>np.array_equiv([1, 2], <a href="null">1, 2], [1, 3</a>) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27883">view source</a></div></div><div class="public anchor" id="var-array_repr"><h3>array_repr</h3><div class="usage"><code>(array_repr &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the string representation of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr : ndarray  Input array. max_line_width : int, optional  Inserts newlines if text is longer than <code>max_line_width</code>.  Defaults to <code>numpy.get_printoptions()['linewidth']</code>. precision : int, optional  Floating point precision.  Defaults to <code>numpy.get_printoptions()['precision']</code>. suppress_small : bool, optional  Represent numbers “very close” to zero as zero; default is False.  Very close is defined by precision: if the precision is 8, e.g.,  numbers smaller (in absolute value) than 5e-9 are represented as  zero.  Defaults to <code>numpy.get_printoptions()['suppress']</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>string : str  The string representation of an array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>array_str, array2string, set_printoptions</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array_repr(np.array([1,2])) ‘array([1, 2])’ np.array_repr(np.ma.array([0.])) ‘MaskedArray([0.])’ np.array_repr(np.array([], np.int32)) ‘array([], dtype=int32)’</p>
+      <p>x = np.array([1e-6, 4e-7, 2, 3]) np.array_repr(x, precision=6, suppress_small=True) ‘array([0.000001, 0. , 2. , 3. ])’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21936">view source</a></div></div><div class="public anchor" id="var-array_split"><h3>array_split</h3><div class="usage"><code>(array_split &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Split an array into multiple sub-arrays.</p>
+<p>Please refer to the <code>split</code> documentation. The only difference between these functions is that <code>array_split</code> allows <code>indices_or_sections</code> to be an integer that does <em>not</em> equally divide the axis. For an array of length l that should be split into n sections, it returns l % n sub-arrays of size l//n + 1 and the rest of size l//n.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>split : Split array into multiple sub-arrays of equal size.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(8.0) np.array_split(x, 3)  [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])]</p>
+      <p>x = np.arange(7.0) np.array_split(x, 3)  [array([0., 1., 2.]), array([3., 4.]), array([5., 6.])]</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1221">view source</a></div></div><div class="public anchor" id="var-array_str"><h3>array_str</h3><div class="usage"><code>(array_str &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a string representation of the data in an array.</p>
+<p>The data in the array is returned as a single string. This function is similar to <code>array_repr</code>, the difference being that <code>array_repr</code> also returns information on the kind of array and its data type.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : ndarray  Input array. max_line_width : int, optional  Inserts newlines if text is longer than <code>max_line_width</code>.  Defaults to <code>numpy.get_printoptions()['linewidth']</code>. precision : int, optional  Floating point precision.  Defaults to <code>numpy.get_printoptions()['precision']</code>. suppress_small : bool, optional  Represent numbers “very close” to zero as zero; default is False.  Very close is defined by precision: if the precision is 8, e.g.,  numbers smaller (in absolute value) than 5e-9 are represented as  zero.  Defaults to <code>numpy.get_printoptions()['suppress']</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>array2string, array_repr, set_printoptions</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array_str(np.arange(3)) ‘[0 1 2]’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2036">view source</a></div></div><div class="public anchor" id="var-asanyarray"><h3>asanyarray</h3><div class="usage"><code>(asanyarray a &amp; [{dtype :dtype, order :order}])</code><code>(asanyarray a &amp; [{dtype :dtype}])</code><code>(asanyarray a)</code></div><div class="doc"><div class="markdown"><p>Convert the input to an ndarray, but pass ndarray subclasses through.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data, in any form that can be converted to an array. This  includes scalars, lists, lists of tuples, tuples, tuples of tuples,  tuples of lists, and ndarrays. dtype : data-type, optional  By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional  Whether to use row-major (C-style) or column-major  (Fortran-style) memory representation. Defaults to ‘C’.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or an ndarray subclass  Array interpretation of <code>a</code>. If <code>a</code> is an ndarray or a subclass  of ndarray, it is returned as-is and no copy is performed.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>asarray : Similar function which always returns ndarrays. ascontiguousarray : Convert input to a contiguous array. asfarray : Convert input to a floating point ndarray. asfortranarray : Convert input to an ndarray with column-major  memory order. asarray_chkfinite : Similar function which checks input for NaNs and  Infs. fromiter : Create an array from an iterator. fromfunction : Construct an array by executing a function on grid  positions.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Convert a list into an array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = [1, 2] np.asanyarray(a) array([1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Instances of <code>ndarray</code> subclasses are passed through as-is:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([(1.0, 2), (3.0, 4)], dtype=‘f4,i4’).view(np.recarray) np.asanyarray(a) is a True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21617">view source</a></div></div><div class="public anchor" id="var-asarray"><h3>asarray</h3><div class="usage"><code>(asarray a &amp; [{dtype :dtype, order :order}])</code><code>(asarray a &amp; [{dtype :dtype}])</code><code>(asarray a)</code></div><div class="doc"><div class="markdown"><p>Convert the input to an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data, in any form that can be converted to an array. This  includes lists, lists of tuples, tuples, tuples of tuples, tuples  of lists and ndarrays. dtype : data-type, optional  By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional  Whether to use row-major (C-style) or  column-major (Fortran-style) memory representation.  Defaults to ‘C’.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Array interpretation of <code>a</code>. No copy is performed if the input  is already an ndarray with matching dtype and order. If <code>a</code> is a  subclass of ndarray, a base class ndarray is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>asanyarray : Similar function which passes through subclasses. ascontiguousarray : Convert input to a contiguous array. asfarray : Convert input to a floating point ndarray. asfortranarray : Convert input to an ndarray with column-major  memory order. asarray_chkfinite : Similar function which checks input for NaNs and Infs. fromiter : Create an array from an iterator. fromfunction : Construct an array by executing a function on grid  positions.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Convert a list into an array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = [1, 2] np.asarray(a) array([1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Existing arrays are not copied:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1, 2]) np.asarray(a) is a True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>If <code>dtype</code> is set, array is copied only if dtype does not match:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1, 2], dtype=np.float32) np.asarray(a, dtype=np.float32) is a True np.asarray(a, dtype=np.float64) is a False</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Contrary to <code>asanyarray</code>, ndarray subclasses are not passed through:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>issubclass(np.recarray, np.ndarray) True a = np.array([(1.0, 2), (3.0, 4)], dtype=‘f4,i4’).view(np.recarray) np.asarray(a) is a False np.asanyarray(a) is a True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22285">view source</a></div></div><div class="public anchor" id="var-asarray_chkfinite"><h3>asarray_chkfinite</h3><div class="usage"><code>(asarray_chkfinite a &amp; [{dtype :dtype, order :order}])</code><code>(asarray_chkfinite a &amp; [{dtype :dtype}])</code><code>(asarray_chkfinite a)</code></div><div class="doc"><div class="markdown"><p>Convert the input to an array, checking for NaNs or Infs.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data, in any form that can be converted to an array. This  includes lists, lists of tuples, tuples, tuples of tuples, tuples  of lists and ndarrays. Success requires no NaNs or Infs. dtype : data-type, optional  By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional  Whether to use row-major (C-style) or  column-major (Fortran-style) memory representation.  Defaults to ‘C’.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Array interpretation of <code>a</code>. No copy is performed if the input  is already an ndarray. If <code>a</code> is a subclass of ndarray, a base  class ndarray is returned.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  Raises ValueError if <code>a</code> contains NaN (Not a Number) or Inf (Infinity).</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>asarray : Create and array. asanyarray : Similar function which passes through subclasses. ascontiguousarray : Convert input to a contiguous array. asfarray : Convert input to a floating point ndarray. asfortranarray : Convert input to an ndarray with column-major  memory order. fromiter : Create an array from an iterator. fromfunction : Construct an array by executing a function on grid  positions.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Convert a list into an array. If all elements are finite <code>asarray_chkfinite</code> is identical to <code>asarray</code>.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = [1, 2] np.asarray_chkfinite(a, dtype=float) array([1., 2.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Raises ValueError if array_like contains Nans or Infs.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = [1, 2, np.inf] try: … np.asarray_chkfinite(a) … except ValueError: … print(‘ValueError’) … ValueError</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26550">view source</a></div></div><div class="public anchor" id="var-ascontiguousarray"><h3>ascontiguousarray</h3><div class="usage"><code>(ascontiguousarray a &amp; [{dtype :dtype}])</code><code>(ascontiguousarray a)</code></div><div class="doc"><div class="markdown"><p>Return a contiguous array (ndim &gt;= 1) in memory (C order).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. dtype : str or dtype object, optional  Data-type of returned array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Contiguous array of same shape and content as <code>a</code>, with type <code>dtype</code>  if specified.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>asfortranarray : Convert input to an ndarray with column-major  memory order. require : Return an ndarray that satisfies requirements. ndarray.flags : Information about the memory layout of the array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(6).reshape(2,3) np.ascontiguousarray(x, dtype=np.float32) array(<a href="null">0., 1., 2.],
+       [3., 4., 5.</a>, dtype=float32) x.flags[‘C_CONTIGUOUS’] True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note: This function returns an array with at least one-dimension (1-d) so it will not preserve 0-d arrays. </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27630">view source</a></div></div><div class="public anchor" id="var-asfarray"><h3>asfarray</h3><div class="usage"><code>(asfarray &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an array converted to a float type.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  The input array. dtype : str or dtype object, optional  Float type code to coerce input array <code>a</code>. If <code>dtype</code> is one of the  ‘int’ dtypes, it is replaced with float64.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  The input <code>a</code> as a float ndarray.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.asfarray([2, 3]) array([2., 3.]) np.asfarray([2, 3], dtype=‘float’) array([2., 3.]) np.asfarray([2, 3], dtype=‘int8’) array([2., 3.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17279">view source</a></div></div><div class="public anchor" id="var-asfortranarray"><h3>asfortranarray</h3><div class="usage"><code>(asfortranarray a &amp; [{dtype :dtype}])</code><code>(asfortranarray a)</code></div><div class="doc"><div class="markdown"><p>Return an array (ndim &gt;= 1) laid out in Fortran order in memory.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. dtype : str or dtype object, optional  By default, the data-type is inferred from the input data.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  The input <code>a</code> in Fortran, or column-major, order.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ascontiguousarray : Convert input to a contiguous (C order) array. asanyarray : Convert input to an ndarray with either row or  column-major memory order. require : Return an ndarray that satisfies requirements. ndarray.flags : Information about the memory layout of the array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(6).reshape(2,3) y = np.asfortranarray(x) x.flags[‘F_CONTIGUOUS’] False y.flags[‘F_CONTIGUOUS’] True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note: This function returns an array with at least one-dimension (1-d) so it will not preserve 0-d arrays. </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L726">view source</a></div></div><div class="public anchor" id="var-asmatrix"><h3>asmatrix</h3><div class="usage"><code>(asmatrix data &amp; [{dtype :dtype}])</code><code>(asmatrix data)</code></div><div class="doc"><div class="markdown"><p>Interpret the input as a matrix.</p>
+<p>Unlike <code>matrix</code>, <code>asmatrix</code> does not make a copy if the input is already a matrix or an ndarray. Equivalent to <code>matrix(data, copy=False)</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>data : array_like  Input data. dtype : data-type  Data-type of the output matrix.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>mat : matrix  <code>data</code> interpreted as a matrix.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">1, 2], [3, 4</a>)</p>
+      <p>m = np.asmatrix(x)</p>
+      <p>x[0,0] = 5</p>
+      <p>m matrix(<a href="null">5, 2],
+        [3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6635">view source</a></div></div><div class="public anchor" id="var-asscalar"><h3>asscalar</h3><div class="usage"><code>(asscalar &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Convert an array of size 1 to its scalar equivalent.</p>
+<p>.. deprecated:: 1.16</p>
+<pre><code>Deprecated, use `numpy.ndarray.item()` instead.
+</code></pre>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : ndarray  Input array of size 1.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : scalar  Scalar representation of <code>a</code>. The output data type is the same type  returned by the input’s <code>item</code> method.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.asscalar(np.array([24])) 24</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16835">view source</a></div></div><div class="public anchor" id="var-atleast_1d"><h3>atleast_1d</h3><div class="usage"><code>(atleast_1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Convert inputs to arrays with at least one dimension.</p>
+<p>Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arys1, arys2, … : array_like  One or more input arrays.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>ret : ndarray  An array, or list of arrays, each with <code>a.ndim &gt;= 1</code>.  Copies are made only if necessary.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>atleast_2d, atleast_3d</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.atleast_1d(1.0) array([1.])</p>
+      <p>x = np.arange(9.0).reshape(3,3) np.atleast_1d(x) array(<a href="null">0., 1., 2.],
+       [3., 4., 5.],
+       [6., 7., 8.</a>) np.atleast_1d(x) is x True</p>
+      <p>np.atleast_1d(1, [3, 4]) [array([1]), array([3, 4])]</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21575">view source</a></div></div><div class="public anchor" id="var-atleast_2d"><h3>atleast_2d</h3><div class="usage"><code>(atleast_2d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>View inputs as arrays with at least two dimensions.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arys1, arys2, … : array_like  One or more array-like sequences. Non-array inputs are converted  to arrays. Arrays that already have two or more dimensions are  preserved.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>res, res2, … : ndarray  An array, or list of arrays, each with <code>a.ndim &gt;= 2</code>.  Copies are avoided where possible, and views with two or more  dimensions are returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>atleast_1d, atleast_3d</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.atleast_2d(3.0) array(<a href="null">3.</a>)</p>
+      <p>x = np.arange(3.0) np.atleast_2d(x) array(<a href="null">0., 1., 2.</a>) np.atleast_2d(x).base is x True</p>
+      <p>np.atleast_2d(1, [1, 2], <a href="null">1, 2</a>) [array([[1]]), array([[1, 2]]), array([[1, 2]])]</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16632">view source</a></div></div><div class="public anchor" id="var-atleast_3d"><h3>atleast_3d</h3><div class="usage"><code>(atleast_3d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>View inputs as arrays with at least three dimensions.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arys1, arys2, … : array_like  One or more array-like sequences. Non-array inputs are converted to  arrays. Arrays that already have three or more dimensions are  preserved.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>res1, res2, … : ndarray  An array, or list of arrays, each with <code>a.ndim &gt;= 3</code>. Copies are  avoided where possible, and views with three or more dimensions are  returned. For example, a 1-D array of shape <code>(N,)</code> becomes a view  of shape <code>(1, N, 1)</code>, and a 2-D array of shape <code>(M, N)</code> becomes a  view of shape <code>(M, N, 1)</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>atleast_1d, atleast_2d</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.atleast_3d(3.0) array(<a href="null">[3.</a>])</p>
+      <p>x = np.arange(3.0) np.atleast_3d(x).shape (1, 3, 1)</p>
+      <p>x = np.arange(12.0).reshape(4,3) np.atleast_3d(x).shape (4, 3, 1) np.atleast_3d(x).base is x.base # x is a reshape, so not base itself True</p>
+      <p>for arr in np.atleast_3d([1, 2], <a href="null">1, 2</a>, <a href="null">[1, 2</a>]): … print(arr, arr.shape) # doctest: +SKIP … <a href="null">[1]
+  [2</a>] (1, 2, 1) <a href="null">[1]
+  [2</a>] (1, 2, 1) <a href="null">[1 2</a>] (1, 1, 2)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13347">view source</a></div></div><div class="public anchor" id="var-average"><h3>average</h3><div class="usage"><code>(average &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the weighted average along the specified axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array containing data to be averaged. If <code>a</code> is not an array, a  conversion is attempted. axis : None or int or tuple of ints, optional  Axis or axes along which to average <code>a</code>. The default,  axis=None, will average over all of the elements of the input array.  If axis is negative it counts from the last to the first axis.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If axis is a tuple of ints, averaging is performed on all of the axes
+specified in the tuple instead of a single axis or all the axes as
+before.
+</code></pre>
+<p>weights : array_like, optional  An array of weights associated with the values in <code>a</code>. Each value in  <code>a</code> contributes to the average according to its associated weight.  The weights array can either be 1-D (in which case its length must be  the size of <code>a</code> along the given axis) or of the same shape as <code>a</code>.  If <code>weights=None</code>, then all data in <code>a</code> are assumed to have a  weight equal to one. The 1-D calculation is::</p>
+<pre><code>    avg = sum(a * weights) / sum(weights)
+
+The only constraint on `weights` is that `sum(weights)` must not be 0.
+</code></pre>
+<p>returned : bool, optional  Default is <code>False</code>. If <code>True</code>, the tuple (<code>average</code>, <code>sum_of_weights</code>)  is returned, otherwise only the average is returned.  If <code>weights=None</code>, <code>sum_of_weights</code> is equivalent to the number of  elements over which the average is taken.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>retval, [sum_of_weights] : array_type or double  Return the average along the specified axis. When <code>returned</code> is <code>True</code>,  return a tuple with the average as the first element and the sum  of the weights as the second element. <code>sum_of_weights</code> is of the  same type as <code>retval</code>. The result dtype follows a genereal pattern.  If <code>weights</code> is None, the result dtype will be that of <code>a</code> , or <code>float64</code>  if <code>a</code> is integral. Otherwise, if <code>weights</code> is not None and <code>a</code> is non-  integral, the result type will be the type of lowest precision capable of  representing values of both <code>a</code> and <code>weights</code>. If <code>a</code> happens to be  integral, the previous rules still applies but the result dtype will  at least be <code>float64</code>.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ZeroDivisionError  When all weights along axis are zero. See <code>numpy.ma.average</code> for a  version robust to this type of error. TypeError  When the length of 1D <code>weights</code> is not the same as the shape of <code>a</code>  along axis.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>mean</p>
+<p>ma.average : average for masked arrays – useful if your data contains  “missing” values numpy.result_type : Returns the type that results from applying the  numpy type promotion rules to the arguments.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>data = np.arange(1, 5) data array([1, 2, 3, 4]) np.average(data) 2.5 np.average(np.arange(1, 11), weights=np.arange(10, 0, -1)) 4.0</p>
+      <p>data = np.arange(6).reshape((3,2)) data array(<a href="null">0, 1],
+       [2, 3],
+       [4, 5</a>) np.average(data, axis=1, weights=[1./4, 3./4]) array([0.75, 2.75, 4.75]) np.average(data, weights=[1./4, 3./4]) Traceback (most recent call last):  … TypeError: Axis must be specified when shapes of a and weights differ.</p>
+      <p>a = np.ones(5, dtype=np.float128) w = np.ones(5, dtype=np.complex64) avg = np.average(a, weights=w) print(avg.dtype) complex256</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5179">view source</a></div></div><div class="public anchor" id="var-AxisError"><h3>AxisError</h3><div class="usage"><code>(AxisError self axis &amp; [{ndim :ndim, msg_prefix :msg_prefix}])</code><code>(AxisError self axis &amp; [{ndim :ndim}])</code><code>(AxisError self axis)</code></div><div class="doc"><div class="markdown"><p>Axis supplied was invalid. </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25035">view source</a></div></div><div class="public anchor" id="var-bartlett"><h3>bartlett</h3><div class="usage"><code>(bartlett M)</code></div><div class="doc"><div class="markdown"><p>Return the Bartlett window.</p>
+<p>The Bartlett window is very similar to a triangular window, except that the end points are at zero. It is often used in signal processing for tapering a signal, without generating too much ripple in the frequency domain.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>M : int  Number of points in the output window. If zero or less, an  empty array is returned.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : array  The triangular window, with the maximum value normalized to one  (the value one appears only if the number of samples is odd), with  the first and last samples equal to zero.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>blackman, hamming, hanning, kaiser</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The Bartlett window is defined as</p>
+<p>.. math:: w(n) = \frac{2}{M-1} \left(  \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right|  \right)</p>
+<p>Most references to the Bartlett window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. Note that convolution with this window produces linear interpolation. It is also known as an apodization (which means“removing the foot”, i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function. The fourier transform of the Bartlett is the product of two sinc functions. Note the excellent discussion in Kanasewich.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] M.S. Bartlett, “Periodogram Analysis and Continuous Spectra”,  Biometrika 37, 1-16, 1950. .. [2] E.R. Kanasewich, “Time Sequence Analysis in Geophysics”,  The University of Alberta Press, 1975, pp. 109-110. .. [3] A.V. Oppenheim and R.W. Schafer, “Discrete-Time Signal  Processing”, Prentice-Hall, 1999, pp. 468-471. .. [4] Wikipedia, “Window function”,  <a href="https://en.wikipedia.org/wiki/Window_function">https://en.wikipedia.org/wiki/Window_function</a> .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,  “Numerical Recipes”, Cambridge University Press, 1986, page 429.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt np.bartlett(12) array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary  0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636,  0.18181818, 0. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot the window and its frequency response (requires SciPy and matplotlib):</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from numpy.fft import fft, fftshift window = np.bartlett(51) plt.plot(window) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Bartlett window”) Text(0.5, 1.0, ‘Bartlett window’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“Sample”) Text(0.5, 0, ‘Sample’) plt.show()</p>
+      <p>plt.figure() </p><figure size="" 640x480="" with="" 0="" axes=""> A = fft(window, 2048) / 25.5 mag = np.abs(fftshift(A)) freq = np.linspace(-0.5, 0.5, len(A)) with np.errstate(divide=‘ignore’, invalid=‘ignore’): … response = 20 * np.log10(mag) … response = np.clip(response, -100, 100) plt.plot(freq, response) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Frequency response of Bartlett window”) Text(0.5, 1.0, ‘Frequency response of Bartlett window’) plt.ylabel(“Magnitude [dB]”) Text(0, 0.5, ‘Magnitude [dB]’) plt.xlabel(“Normalized frequency [cycles per sample]”) Text(0.5, 0, ‘Normalized frequency [cycles per sample]’) _ = plt.axis(‘tight’) plt.show()<p></p>
+    </figure></blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25236">view source</a></div></div><div class="public anchor" id="var-base_repr"><h3>base_repr</h3><div class="usage"><code>(base_repr number &amp; [{base :base, padding :padding}])</code><code>(base_repr number &amp; [{base :base}])</code><code>(base_repr number)</code></div><div class="doc"><div class="markdown"><p>Return a string representation of a number in the given base system.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>number : int  The value to convert. Positive and negative values are handled. base : int, optional  Convert <code>number</code> to the <code>base</code> number system. The valid range is 2-36,  the default value is 2. padding : int, optional  Number of zeros padded on the left. Default is 0 (no padding).</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : str  String representation of <code>number</code> in <code>base</code> system.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>binary_repr : Faster version of <code>base_repr</code> for base 2.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.base_repr(5) ‘101’ np.base_repr(6, 5) ‘11’ np.base_repr(7, base=5, padding=3) ‘00012’</p>
+      <p>np.base_repr(10, base=16) ‘A’ np.base_repr(32, base=16) ‘20’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22830">view source</a></div></div><div class="public anchor" id="var-binary_repr"><h3>binary_repr</h3><div class="usage"><code>(binary_repr num &amp; [{width :width}])</code><code>(binary_repr num)</code></div><div class="doc"><div class="markdown"><p>Return the binary representation of the input number as a string.</p>
+<p>For negative numbers, if width is not given, a minus sign is added to the front. If width is given, the two’s complement of the number is returned, with respect to that width.</p>
+<p>In a two’s-complement system negative numbers are represented by the two’s complement of the absolute value. This is the most common method of representing signed integers on computers [1]_. A N-bit two’s-complement system can represent every integer in the range :math:<code>-2^{N-1}</code> to :math:<code>+2^{N-1}-1</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>num : int  Only an integer decimal number can be used. width : int, optional  The length of the returned string if <code>num</code> is positive, or the length  of the two’s complement if <code>num</code> is negative, provided that <code>width</code> is  at least a sufficient number of bits for <code>num</code> to be represented in the  designated form.</p>
+<pre><code>If the `width` value is insufficient, it will be ignored, and `num` will
+be returned in binary (`num` &gt; 0) or two's complement (`num` &lt; 0) form
+with its width equal to the minimum number of bits needed to represent
+the number in the designated form. This behavior is deprecated and will
+later raise an error.
+
+.. deprecated:: 1.12.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>bin : str  Binary representation of <code>num</code> or two’s complement of <code>num</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>base_repr: Return a string representation of a number in the given base  system. bin: Python’s built-in binary representation generator of an integer.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>binary_repr</code> is equivalent to using <code>base_repr</code> with base 2, but about 25x faster.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Wikipedia, “Two’s complement”,  <a href="https://en.wikipedia.org/wiki/Two's_complement">https://en.wikipedia.org/wiki/Two's_complement</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.binary_repr(3) ‘11’ np.binary_repr(-3) ‘-11’ np.binary_repr(3, width=4) ‘0011’</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The two’s complement is returned when the input number is negative and width is specified:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.binary_repr(-3, width=3) ‘101’ np.binary_repr(-3, width=5) ‘11101’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21132">view source</a></div></div><div class="public anchor" id="var-bincount"><h3>bincount</h3><div class="usage"><code>(bincount &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bincount(x, weights=None, minlength=0)</p>
+<p>Count number of occurrences of each value in array of non-negative ints.</p>
+<p>The number of bins (of size 1) is one larger than the largest value in <code>x</code>. If <code>minlength</code> is specified, there will be at least this number of bins in the output array (though it will be longer if necessary, depending on the contents of <code>x</code>). Each bin gives the number of occurrences of its index value in <code>x</code>. If <code>weights</code> is specified the input array is weighted by it, i.e. if a value <code>n</code> is found at position <code>i</code>, <code>out[n] += weight[i]</code> instead of <code>out[n] += 1</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like, 1 dimension, nonnegative ints  Input array. weights : array_like, optional  Weights, array of the same shape as <code>x</code>. minlength : int, optional  A minimum number of bins for the output array.</p>
+<pre><code>.. versionadded:: 1.6.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray of ints  The result of binning the input array.  The length of <code>out</code> is equal to <code>np.amax(x)+1</code>.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If the input is not 1-dimensional, or contains elements with negative  values, or if <code>minlength</code> is negative. TypeError  If the type of the input is float or complex.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>histogram, digitize, unique</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.bincount(np.arange(5)) array([1, 1, 1, 1, 1]) np.bincount(np.array([0, 1, 1, 3, 2, 1, 7])) array([1, 3, 1, 1, 0, 0, 0, 1])</p>
+      <p>x = np.array([0, 1, 1, 3, 2, 1, 7, 23]) np.bincount(x).size == np.amax(x)+1 True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The input array needs to be of integer dtype, otherwise a TypeError is raised:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.bincount(np.arange(5, dtype=float)) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> TypeError: array cannot be safely cast to required type</module></stdin></p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>A possible use of <code>bincount</code> is to perform sums over variable-size chunks of an array, using the <code>weights</code> keyword.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights x = np.array([0, 1, 1, 2, 2, 2]) np.bincount(x, weights=w) array([ 0.3, 0.7, 1.1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18870">view source</a></div></div><div class="public anchor" id="var-bitwise_and"><h3>bitwise_and</h3><div class="usage"><code>(bitwise_and self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bitwise_and(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute the bit-wise AND of two arrays element-wise.</p>
+<p>Computes the bit-wise AND of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>&amp;</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Only integer and boolean types are handled. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Result.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>logical_and bitwise_or bitwise_xor binary_repr :  Return the binary representation of the input number as a string.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>The number 13 is represented by <code>00001101</code>. Likewise, 17 is represented by <code>00010001</code>. The bit-wise AND of 13 and 17 is therefore <code>000000001</code>, or 1:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.bitwise_and(13, 17) 1</p>
+      <p>np.bitwise_and(14, 13) 12 np.binary_repr(12) ‘1100’ np.bitwise_and([14,3], 13) array([12, 1])</p>
+      <p>np.bitwise_and([11,7], [4,25]) array([0, 1]) np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) array([ 2, 4, 16]) np.bitwise_and([True, True], [False, True]) array([False, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15171">view source</a></div></div><div class="public anchor" id="var-bitwise_not"><h3>bitwise_not</h3><div class="usage"><code>(bitwise_not self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>invert(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute bit-wise inversion, or bit-wise NOT, element-wise.</p>
+<p>Computes the bit-wise NOT of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>~</code>.</p>
+<p>For signed integer inputs, the two’s complement is returned. In a two’s-complement system negative numbers are represented by the two’s complement of the absolute value. This is the most common method of representing signed integers on computers [1]_. A N-bit two’s-complement system can represent every integer in the range :math:<code>-2^{N-1}</code> to :math:<code>+2^{N-1}-1</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Only integer and boolean types are handled. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Result.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>bitwise_and, bitwise_or, bitwise_xor logical_not binary_repr :  Return the binary representation of the input number as a string.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>bitwise_not</code> is an alias for <code>invert</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.bitwise_not is np.invert True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Wikipedia, “Two’s complement”,  <a href="https://en.wikipedia.org/wiki/Two's_complement">https://en.wikipedia.org/wiki/Two's_complement</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>We’ve seen that 13 is represented by <code>00001101</code>. The invert or bit-wise NOT of 13 is then:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.invert(np.array(13, dtype=np.uint8)) x 242 np.binary_repr(x, width=8) ‘11110010’</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The result depends on the bit-width:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.invert(np.array(13, dtype=np.uint16)) x 65522 np.binary_repr(x, width=16) ‘1111111111110010’</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>When using signed integer types the result is the two’s complement of the result for the unsigned type:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.invert(np.array([13], dtype=np.int8)) array([-14], dtype=int8) np.binary_repr(-14, width=8) ‘11110010’</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Booleans are accepted as well:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.invert(np.array([True, False])) array([False, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22436">view source</a></div></div><div class="public anchor" id="var-bitwise_or"><h3>bitwise_or</h3><div class="usage"><code>(bitwise_or self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bitwise_or(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute the bit-wise OR of two arrays element-wise.</p>
+<p>Computes the bit-wise OR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>|</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Only integer and boolean types are handled. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Result.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>logical_or bitwise_and bitwise_xor binary_repr :  Return the binary representation of the input number as a string.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>The number 13 has the binaray representation <code>00001101</code>. Likewise, 16 is represented by <code>00010000</code>. The bit-wise OR of 13 and 16 is then <code>000111011</code>, or 29:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.bitwise_or(13, 16) 29 np.binary_repr(29) ‘11101’</p>
+      <p>np.bitwise_or(32, 2) 34 np.bitwise_or([33, 4], 1) array([33, 5]) np.bitwise_or([33, 4], [1, 2]) array([33, 6])</p>
+      <p>np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) array([ 6, 5, 255]) np.array([2, 5, 255]) | np.array([4, 4, 4]) array([ 6, 5, 255]) np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), … np.array([4, 4, 4, 2147483647], dtype=np.int32)) array([ 6, 5, 255, 2147483647]) np.bitwise_or([True, True], [False, True]) array([ True, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6197">view source</a></div></div><div class="public anchor" id="var-bitwise_xor"><h3>bitwise_xor</h3><div class="usage"><code>(bitwise_xor self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bitwise_xor(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute the bit-wise XOR of two arrays element-wise.</p>
+<p>Computes the bit-wise XOR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>^</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Only integer and boolean types are handled. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Result.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>logical_xor bitwise_and bitwise_or binary_repr :  Return the binary representation of the input number as a string.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>The number 13 is represented by <code>00001101</code>. Likewise, 17 is represented by <code>00010001</code>. The bit-wise XOR of 13 and 17 is therefore <code>00011100</code>, or 28:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.bitwise_xor(13, 17) 28 np.binary_repr(28) ‘11100’</p>
+      <p>np.bitwise_xor(31, 5) 26 np.bitwise_xor([31,3], 5) array([26, 6])</p>
+      <p>np.bitwise_xor([31,3], [5,6]) array([26, 5]) np.bitwise_xor([True, True], [False, True]) array([ True, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L29071">view source</a></div></div><div class="public anchor" id="var-blackman"><h3>blackman</h3><div class="usage"><code>(blackman M)</code></div><div class="doc"><div class="markdown"><p>Return the Blackman window.</p>
+<p>The Blackman window is a taper formed by using the first three terms of a summation of cosines. It was designed to have close to the minimal leakage possible. It is close to optimal, only slightly worse than a Kaiser window.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>M : int  Number of points in the output window. If zero or less, an empty  array is returned.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  The window, with the maximum value normalized to one (the value one  appears only if the number of samples is odd).</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>bartlett, hamming, hanning, kaiser</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The Blackman window is defined as</p>
+<p>.. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M)</p>
+<p>Most references to the Blackman window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means “removing the foot”, i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function. It is known as a “near optimal” tapering function, almost as good (by some measures) as the kaiser window.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, Dover Publications, New York.</p>
+<p>Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt np.blackman(12) array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary  4.14397981e-01, 7.36045180e-01, 9.67046769e-01,  9.67046769e-01, 7.36045180e-01, 4.14397981e-01,  1.59903635e-01, 3.26064346e-02, -1.38777878e-17])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot the window and the frequency response:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from numpy.fft import fft, fftshift window = np.blackman(51) plt.plot(window) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Blackman window”) Text(0.5, 1.0, ‘Blackman window’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“Sample”) Text(0.5, 0, ‘Sample’) plt.show()</p>
+      <p>plt.figure() </p><figure size="" 640x480="" with="" 0="" axes=""> A = fft(window, 2048) / 25.5 mag = np.abs(fftshift(A)) freq = np.linspace(-0.5, 0.5, len(A)) with np.errstate(divide=‘ignore’, invalid=‘ignore’): … response = 20 * np.log10(mag) … response = np.clip(response, -100, 100) plt.plot(freq, response) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Frequency response of Blackman window”) Text(0.5, 1.0, ‘Frequency response of Blackman window’) plt.ylabel(“Magnitude [dB]”) Text(0, 0.5, ‘Magnitude [dB]’) plt.xlabel(“Normalized frequency [cycles per sample]”) Text(0.5, 0, ‘Normalized frequency [cycles per sample]’) _ = plt.axis(‘tight’) plt.show()<p></p>
+    </figure></blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16060">view source</a></div></div><div class="public anchor" id="var-block"><h3>block</h3><div class="usage"><code>(block &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Assemble an nd-array from nested lists of blocks.</p>
+<p>Blocks in the innermost lists are concatenated (see <code>concatenate</code>) along the last dimension (-1), then these are concatenated along the second-last dimension (-2), and so on until the outermost list is reached.</p>
+<p>Blocks can be of any dimension, but will not be broadcasted using the normal rules. Instead, leading axes of size 1 are inserted, to make <code>block.ndim</code> the same for all blocks. This is primarily useful for working with scalars, and means that code like <code>np.block([v, 1])</code> is valid, where <code>v.ndim == 1</code>.</p>
+<p>When the nested list is two levels deep, this allows block matrices to be constructed from their components.</p>
+<p>.. versionadded:: 1.13.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arrays : nested list of array_like or scalars (but not tuples)  If passed a single ndarray or scalar (a nested list of depth 0), this  is returned unmodified (and not copied).</p>
+<pre><code>Elements shapes must match along the appropriate axes (without
+broadcasting), but leading 1s will be prepended to the shape as
+necessary to make the dimensions match.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>block_array : ndarray  The array assembled from the given blocks.</p>
+<pre><code>The dimensionality of the output is equal to the greatest of:
+* the dimensionality of all the inputs
+* the depth to which the input list is nested
+</code></pre>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  * If list depths are mismatched - for instance, <code>[[a, b], c]</code> is  illegal, and should be spelt <code>[[a, b], [c]]</code>  * If lists are empty - for instance, <code>[[a, b], []]</code></p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>concatenate : Join a sequence of arrays together. stack : Stack arrays in sequence along a new dimension. hstack : Stack arrays in sequence horizontally (column wise). vstack : Stack arrays in sequence vertically (row wise). dstack : Stack arrays in sequence depth wise (along third dimension). vsplit : Split array into a list of multiple sub-arrays vertically.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>When called with only scalars, <code>np.block</code> is equivalent to an ndarray call. So <code>np.block([[1, 2], [3, 4]])</code> is equivalent to <code>np.array([[1, 2], [3, 4]])</code>.</p>
+<p>This function does not enforce that the blocks lie on a fixed grid. <code>np.block([[a, b], [c, d]])</code> is not restricted to arrays of the form::</p>
+<pre><code>AAAbb
+AAAbb
+cccDD
+</code></pre>
+<p>But is also allowed to produce, for some <code>a, b, c, d</code>::</p>
+<pre><code>AAAbb
+AAAbb
+cDDDD
+</code></pre>
+<p>Since concatenation happens along the last axis first, <code>block</code> is <em>not</em> capable of producing the following directly::</p>
+<pre><code>AAAbb
+cccbb
+cccDD
+</code></pre>
+<p>Matlab’s “square bracket stacking”, <code>[A, B, ...; p, q, ...]</code>, is equivalent to <code>np.block([[A, B, ...], [p, q, ...]])</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>The most common use of this function is to build a block matrix</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>A = np.eye(2) * 2 B = np.eye(3) * 3 np.block([ … [A, np.zeros((2, 3))], … [np.ones((3, 2)), B ] … ]) array(<a href="null">2., 0., 0., 0., 0.],
+       [0., 2., 0., 0., 0.],
+       [1., 1., 3., 0., 0.],
+       [1., 1., 0., 3., 0.],
+       [1., 1., 0., 0., 3.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>With a list of depth 1, <code>block</code> can be used as <code>hstack</code></p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.block([1, 2, 3]) # hstack([1, 2, 3]) array([1, 2, 3])</p>
+      <p>a = np.array([1, 2, 3]) b = np.array([2, 3, 4]) np.block([a, b, 10]) # hstack([a, b, 10]) array([ 1, 2, 3, 2, 3, 4, 10])</p>
+      <p>A = np.ones((2, 2), int) B = 2 * A np.block([A, B]) # hstack([A, B]) array(<a href="null">1, 1, 2, 2],
+       [1, 1, 2, 2</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>With a list of depth 2, <code>block</code> can be used in place of <code>vstack</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1, 2, 3]) b = np.array([2, 3, 4]) np.block(<a href="null">a], [b</a>) # vstack([a, b]) array(<a href="null">1, 2, 3],
+       [2, 3, 4</a>)</p>
+      <p>A = np.ones((2, 2), int) B = 2 * A np.block(<a href="null">A], [B</a>) # vstack([A, B]) array(<a href="null">1, 1],
+       [1, 1],
+       [2, 2],
+       [2, 2</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>It can also be used in places of <code>atleast_1d</code> and <code>atleast_2d</code></p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(0) b = np.array([1]) np.block([a]) # atleast_1d(a) array([0]) np.block([b]) # atleast_1d(b) array([1])</p>
+      <p>np.block(<a href="null">a</a>) # atleast_2d(a) array(<a href="null">0</a>) np.block(<a href="null">b</a>) # atleast_2d(b) array(<a href="null">1</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11534">view source</a></div></div><div class="public anchor" id="var-bmat"><h3>bmat</h3><div class="usage"><code>(bmat obj &amp; [{ldict :ldict, gdict :gdict}])</code><code>(bmat obj &amp; [{ldict :ldict}])</code><code>(bmat obj)</code></div><div class="doc"><div class="markdown"><p>Build a matrix object from a string, nested sequence, or array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>obj : str or array_like  Input data. If a string, variables in the current scope may be  referenced by name. ldict : dict, optional  A dictionary that replaces local operands in current frame.  Ignored if <code>obj</code> is not a string or <code>gdict</code> is None. gdict : dict, optional  A dictionary that replaces global operands in current frame.  Ignored if <code>obj</code> is not a string.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : matrix  Returns a matrix object, which is a specialized 2-D array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>block :  A generalization of this function for N-d arrays, that returns normal  ndarrays.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>A = np.mat(‘1 1; 1 1’) B = np.mat(‘2 2; 2 2’) C = np.mat(‘3 4; 5 6’) D = np.mat(‘7 8; 9 0’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>All the following expressions construct the same block matrix:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.bmat(<a href="null">A, B], [C, D</a>) matrix(<a href="null">1, 1, 2, 2],
+        [1, 1, 2, 2],
+        [3, 4, 7, 8],
+        [5, 6, 9, 0</a>) np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) matrix(<a href="null">1, 1, 2, 2],
+        [1, 1, 2, 2],
+        [3, 4, 7, 8],
+        [5, 6, 9, 0</a>) np.bmat(‘A,B; C,D’) matrix(<a href="null">1, 1, 2, 2],
+        [1, 1, 2, 2],
+        [3, 4, 7, 8],
+        [5, 6, 9, 0</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4204">view source</a></div></div><div class="public anchor" id="var-bool"><h3>bool</h3><div class="usage"><code>(bool self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bool(x) -&gt; bool</p>
+<p>Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16053">view source</a></div></div><div class="public anchor" id="var-bool8"><h3>bool8</h3><div class="usage"><code>(bool8 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Boolean type (True or False), stored as a byte. Character code: <code>'?'</code>. Alias: <code>np.bool8</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25337">view source</a></div></div><div class="public anchor" id="var-bool_"><h3>bool_</h3><div class="usage"><code>(bool_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Boolean type (True or False), stored as a byte. Character code: <code>'?'</code>. Alias: <code>np.bool8</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2336">view source</a></div></div><div class="public anchor" id="var-broadcast"><h3>broadcast</h3><div class="usage"><code>(broadcast self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Produce an object that mimics broadcasting.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>in1, in2, … : array_like  Input parameters.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>b : broadcast object  Broadcast the input parameters against one another, and  return an object that encapsulates the result.  Amongst others, it has <code>shape</code> and <code>nd</code> properties, and  may be used as an iterator.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>broadcast_arrays broadcast_to</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Manually adding two vectors, using broadcasting:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">1], [2], [3</a>) y = np.array([4, 5, 6]) b = np.broadcast(x, y)</p>
+      <p>out = np.empty(b.shape) out.flat = [u+v for (u,v) in b] out array(<a href="null">5.,  6.,  7.],
+       [6.,  7.,  8.],
+       [7.,  8.,  9.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Compare against built-in broadcasting:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x + y array(<a href="null">5, 6, 7],
+       [6, 7, 8],
+       [7, 8, 9</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16237">view source</a></div></div><div class="public anchor" id="var-broadcast_arrays"><h3>broadcast_arrays</h3><div class="usage"><code>(broadcast_arrays &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Broadcast any number of arrays against each other.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p><code>*args</code> : array_likes  The arrays to broadcast.</p>
+<p>subok : bool, optional  If True, then sub-classes will be passed-through, otherwise  the returned arrays will be forced to be a base-class array (default).</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>broadcasted : list of arrays  These arrays are views on the original arrays. They are typically  not contiguous. Furthermore, more than one element of a  broadcasted array may refer to a single memory location. If you need  to write to the arrays, make copies first. While you can set the  <code>writable</code> flag True, writing to a single output value may end up  changing more than one location in the output array.</p>
+<pre><code>.. deprecated:: 1.17
+    The output is currently marked so that if written to, a deprecation
+    warning will be emitted. A future version will set the
+    ``writable`` flag False so writing to it will raise an error.
+</code></pre>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">1,2,3</a>) y = np.array(<a href="null">4],[5</a>) np.broadcast_arrays(x, y) [array([[1, 2, 3],  [1, 2, 3]]), array([[4, 4, 4],  [5, 5, 5]])]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Here is a useful idiom for getting contiguous copies instead of non-contiguous views.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>[np.array(a) for a in np.broadcast_arrays(x, y)]
+[array([[1, 2, 3],  [1, 2, 3]]), array([[4, 4, 4],  [5, 5, 5]])]</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19994">view source</a></div></div><div class="public anchor" id="var-broadcast_to"><h3>broadcast_to</h3><div class="usage"><code>(broadcast_to &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Broadcast an array to a new shape.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>array : array_like  The array to broadcast. shape : tuple  The shape of the desired array. subok : bool, optional  If True, then sub-classes will be passed-through, otherwise  the returned array will be forced to be a base-class array (default).</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>broadcast : array  A readonly view on the original array with the given shape. It is  typically not contiguous. Furthermore, more than one element of a  broadcasted array may refer to a single memory location.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If the array is not compatible with the new shape according to NumPy’s  broadcasting rules.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.10.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([1, 2, 3]) np.broadcast_to(x, (3, 3)) array(<a href="null">1, 2, 3],
+       [1, 2, 3],
+       [1, 2, 3</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24634">view source</a></div></div><div class="public anchor" id="var-BUFSIZE"><h3>BUFSIZE</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7966">view source</a></div></div><div class="public anchor" id="var-busday_count"><h3>busday_count</h3><div class="usage"><code>(busday_count &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>busday_count(begindates, enddates, weekmask=‘1111100’, holidays=[], busdaycal=None, out=None)</p>
+<p>Counts the number of valid days between <code>begindates</code> and <code>enddates</code>, not including the day of <code>enddates</code>.</p>
+<p>If <code>enddates</code> specifies a date value that is earlier than the corresponding <code>begindates</code> date value, the count will be negative.</p>
+<p>.. versionadded:: 1.7.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>begindates : array_like of datetime64[D]  The array of the first dates for counting. enddates : array_like of datetime64[D]  The array of the end dates for counting, which are excluded  from the count themselves. weekmask : str or array_like of bool, optional  A seven-element array indicating which of Monday through Sunday are  valid days. May be specified as a length-seven list or array, like  [1,1,1,1,1,0,0]; a length-seven string, like ‘1111100’; or a string  like “Mon Tue Wed Thu Fri”, made up of 3-character abbreviations for  weekdays, optionally separated by white space. Valid abbreviations  are: Mon Tue Wed Thu Fri Sat Sun holidays : array_like of datetime64[D], optional  An array of dates to consider as invalid dates. They may be  specified in any order, and NaT (not-a-time) dates are ignored.  This list is saved in a normalized form that is suited for  fast calculations of valid days. busdaycal : busdaycalendar, optional  A <code>busdaycalendar</code> object which specifies the valid days. If this  parameter is provided, neither weekmask nor holidays may be  provided. out : array of int, optional  If provided, this array is filled with the result.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : array of int  An array with a shape from broadcasting <code>begindates</code> and <code>enddates</code>  together, containing the number of valid days between  the begin and end dates.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>busdaycalendar: An object that specifies a custom set of valid days. is_busday : Returns a boolean array indicating valid days. busday_offset : Applies an offset counted in valid days.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <h1><a href="#number-of-weekdays-in-january-2011" name="number-of-weekdays-in-january-2011"></a>Number of weekdays in January 2011</h1>
+      <p>… np.busday_count(‘2011-01’, ‘2011-02’) 21</p>
+      <h1><a href="#number-of-weekdays-in-2011" name="number-of-weekdays-in-2011"></a>Number of weekdays in 2011</h1>
+      <p>np.busday_count(‘2011’, ‘2012’) 260</p>
+      <h1><a href="#number-of-saturdays-in-2011" name="number-of-saturdays-in-2011"></a>Number of Saturdays in 2011</h1>
+      <p>… np.busday_count(‘2011’, ‘2012’, weekmask=‘Sat’) 53</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9551">view source</a></div></div><div class="public anchor" id="var-busday_offset"><h3>busday_offset</h3><div class="usage"><code>(busday_offset &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>busday_offset(dates, offsets, roll=‘raise’, weekmask=‘1111100’, holidays=None, busdaycal=None, out=None)</p>
+<p>First adjusts the date to fall on a valid day according to the <code>roll</code> rule, then applies offsets to the given dates counted in valid days.</p>
+<p>.. versionadded:: 1.7.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>dates : array_like of datetime64[D]  The array of dates to process. offsets : array_like of int  The array of offsets, which is broadcast with <code>dates</code>. roll : {‘raise’, ‘nat’, ‘forward’, ‘following’, ‘backward’, ‘preceding’, ‘modifiedfollowing’, ‘modifiedpreceding’}, optional  How to treat dates that do not fall on a valid day. The default  is ‘raise’.</p>
+<pre><code>  * 'raise' means to raise an exception for an invalid day.
+  * 'nat' means to return a NaT (not-a-time) for an invalid day.
+  * 'forward' and 'following' mean to take the first valid day
+    later in time.
+  * 'backward' and 'preceding' mean to take the first valid day
+    earlier in time.
+  * 'modifiedfollowing' means to take the first valid day
+    later in time unless it is across a Month boundary, in which
+    case to take the first valid day earlier in time.
+  * 'modifiedpreceding' means to take the first valid day
+    earlier in time unless it is across a Month boundary, in which
+    case to take the first valid day later in time.
+</code></pre>
+<p>weekmask : str or array_like of bool, optional  A seven-element array indicating which of Monday through Sunday are  valid days. May be specified as a length-seven list or array, like  [1,1,1,1,1,0,0]; a length-seven string, like ‘1111100’; or a string  like “Mon Tue Wed Thu Fri”, made up of 3-character abbreviations for  weekdays, optionally separated by white space. Valid abbreviations  are: Mon Tue Wed Thu Fri Sat Sun holidays : array_like of datetime64[D], optional  An array of dates to consider as invalid dates. They may be  specified in any order, and NaT (not-a-time) dates are ignored.  This list is saved in a normalized form that is suited for  fast calculations of valid days. busdaycal : busdaycalendar, optional  A <code>busdaycalendar</code> object which specifies the valid days. If this  parameter is provided, neither weekmask nor holidays may be  provided. out : array of datetime64[D], optional  If provided, this array is filled with the result.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : array of datetime64[D]  An array with a shape from broadcasting <code>dates</code> and <code>offsets</code>  together, containing the dates with offsets applied.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>busdaycalendar: An object that specifies a custom set of valid days. is_busday : Returns a boolean array indicating valid days. busday_count : Counts how many valid days are in a half-open date range.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <h1><a href="#first-business-day-in-october-2011-not-accounting-for-holidays-" name="first-business-day-in-october-2011-not-accounting-for-holidays-"></a>First business day in October 2011 (not accounting for holidays)</h1>
+      <p>… np.busday_offset(‘2011-10’, 0, roll=‘forward’) numpy.datetime64(‘2011-10-03’)</p>
+      <h1><a href="#last-business-day-in-february-2012-not-accounting-for-holidays-" name="last-business-day-in-february-2012-not-accounting-for-holidays-"></a>Last business day in February 2012 (not accounting for holidays)</h1>
+      <p>… np.busday_offset(‘2012-03’, -1, roll=‘forward’) numpy.datetime64(‘2012-02-29’)</p>
+      <h1><a href="#third-wednesday-in-january-2011" name="third-wednesday-in-january-2011"></a>Third Wednesday in January 2011</h1>
+      <p>… np.busday_offset(‘2011-01’, 2, roll=‘forward’, weekmask=‘Wed’) numpy.datetime64(‘2011-01-19’)</p>
+      <h1><a href="#2012-mothers-day-in-canada-and-the-u-s-" name="2012-mothers-day-in-canada-and-the-u-s-"></a>2012 Mother’s Day in Canada and the U.S.</h1>
+      <p>… np.busday_offset(‘2012-05’, 1, roll=‘forward’, weekmask=‘Sun’) numpy.datetime64(‘2012-05-13’)</p>
+      <h1><a href="#first-business-day-on-or-after-a-date" name="first-business-day-on-or-after-a-date"></a>First business day on or after a date</h1>
+      <p>… np.busday_offset(‘2011-03-20’, 0, roll=‘forward’) numpy.datetime64(‘2011-03-21’) np.busday_offset(‘2011-03-22’, 0, roll=‘forward’) numpy.datetime64(‘2011-03-22’)</p>
+      <h1><a href="#first-business-day-after-a-date" name="first-business-day-after-a-date"></a>First business day after a date</h1>
+      <p>… np.busday_offset(‘2011-03-20’, 1, roll=‘backward’) numpy.datetime64(‘2011-03-21’) np.busday_offset(‘2011-03-22’, 1, roll=‘backward’) numpy.datetime64(‘2011-03-23’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17066">view source</a></div></div><div class="public anchor" id="var-busdaycalendar"><h3>busdaycalendar</h3><div class="usage"><code>(busdaycalendar self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>busdaycalendar(weekmask=‘1111100’, holidays=None)</p>
+<p>A business day calendar object that efficiently stores information defining valid days for the busday family of functions.</p>
+<p>The default valid days are Monday through Friday (“business days”). A busdaycalendar object can be specified with any set of weekly valid days, plus an optional “holiday” dates that always will be invalid.</p>
+<p>Once a busdaycalendar object is created, the weekmask and holidays cannot be modified.</p>
+<p>.. versionadded:: 1.7.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>weekmask : str or array_like of bool, optional  A seven-element array indicating which of Monday through Sunday are  valid days. May be specified as a length-seven list or array, like  [1,1,1,1,1,0,0]; a length-seven string, like ‘1111100’; or a string  like “Mon Tue Wed Thu Fri”, made up of 3-character abbreviations for  weekdays, optionally separated by white space. Valid abbreviations  are: Mon Tue Wed Thu Fri Sat Sun holidays : array_like of datetime64[D], optional  An array of dates to consider as invalid dates, no matter which  weekday they fall upon. Holiday dates may be specified in any  order, and NaT (not-a-time) dates are ignored. This list is  saved in a normalized form that is suited for fast calculations  of valid days.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : busdaycalendar  A business day calendar object containing the specified  weekmask and holidays values.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>is_busday : Returns a boolean array indicating valid days. busday_offset : Applies an offset counted in valid days. busday_count : Counts how many valid days are in a half-open date range.</p>
+<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
+<p>Note: once a busdaycalendar object is created, you cannot modify the weekmask or holidays. The attributes return copies of internal data. weekmask : (copy) seven-element array of bool holidays : (copy) sorted array of datetime64[D]</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <h1><a href="#some-important-days-in-july" name="some-important-days-in-july"></a>Some important days in July</h1>
+      <p>… bdd = np.busdaycalendar( … holidays=[‘2011-07-01’, ‘2011-07-04’, ‘2011-07-17’])</p>
+      <h1><a href="#default-is-monday-to-friday-weekdays" name="default-is-monday-to-friday-weekdays"></a>Default is Monday to Friday weekdays</h1>
+      <p>… bdd.weekmask array([ True, True, True, True, True, False, False])</p>
+      <h1><a href="#any-holidays-already-on-the-weekend-are-removed" name="any-holidays-already-on-the-weekend-are-removed"></a>Any holidays already on the weekend are removed</h1>
+      <p>… bdd.holidays array([‘2011-07-01’, ‘2011-07-04’], dtype=‘datetime64[D]’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28855">view source</a></div></div><div class="public anchor" id="var-byte"><h3>byte</h3><div class="usage"><code>(byte self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>char</code>. Character code: <code>'b'</code>. Canonical name: <code>np.byte</code>. Alias <em>on this platform</em>: <code>np.int8</code>: 8-bit signed integer (-128 to 127).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27450">view source</a></div></div><div class="public anchor" id="var-byte_bounds"><h3>byte_bounds</h3><div class="usage"><code>(byte_bounds a)</code></div><div class="doc"><div class="markdown"><p>Returns pointers to the end-points of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : ndarray  Input array. It must conform to the Python-side of the array  interface.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>(low, high) : tuple of 2 integers  The first integer is the first byte of the array, the second  integer is just past the last byte of the array. If <code>a</code> is not  contiguous it will not use every byte between the (<code>low</code>, <code>high</code>)  values.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>I = np.eye(2, dtype=‘f’); I.dtype dtype(‘float32’) low, high = np.byte_bounds(I) high - low == I.size*I.itemsize True I = np.eye(2); I.dtype dtype(‘float64’) low, high = np.byte_bounds(I) high - low == I.size*I.itemsize True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28496">view source</a></div></div><div class="public anchor" id="var-bytes0"><h3>bytes0</h3><div class="usage"><code>(bytes0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25021">view source</a></div></div><div class="public anchor" id="var-bytes_"><h3>bytes_</h3><div class="usage"><code>(bytes_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2344">view source</a></div></div><div class="public anchor" id="var-c_"><h3>c_</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Translates slice objects to concatenation along the second axis.</p>
+<p>This is short-hand for <code>np.r_['-1,2,0', index expression]</code>, which is useful because of its common occurrence. In particular, arrays will be stacked along their last axis after being upgraded to at least 2-D with 1’s post-pended to the shape (column vectors made out of 1-D arrays).</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>column_stack : Stack 1-D arrays as columns into a 2-D array. r_ : For more detailed documentation.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.c_[np.array([1,2,3]), np.array([4,5,6])] array(<a href="null">1, 4],
+       [2, 5],
+       [3, 6</a>) np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])] array(<a href="null">1, 2, 3, ..., 4, 5, 6</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4973">view source</a></div></div><div class="public anchor" id="var-can_cast"><h3>can_cast</h3><div class="usage"><code>(can_cast &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>can_cast(from_, to, casting=‘safe’)</p>
+<p>Returns True if cast between data types can occur according to the casting rule. If from is a scalar or array scalar, also returns True if the scalar value can be cast without overflow or truncation to an integer.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>from_ : dtype, dtype specifier, scalar, or array  Data type, scalar, or array to cast from. to : dtype or dtype specifier  Data type to cast to. casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional  Controls what kind of data casting may occur.</p>
+<pre><code>  * 'no' means the data types should not be cast at all.
+  * 'equiv' means only byte-order changes are allowed.
+  * 'safe' means only casts which can preserve values are allowed.
+  * 'same_kind' means only safe casts or casts within a kind,
+    like float64 to float32, are allowed.
+  * 'unsafe' means any data conversions may be done.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : bool  True if cast can occur according to the casting rule.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionchanged:: 1.17.0  Casting between a simple data type and a structured one is possible only  for “unsafe” casting. Casting to multiple fields is allowed, but  casting from multiple fields is not.</p>
+<p>.. versionchanged:: 1.9.0  Casting from numeric to string types in ‘safe’ casting mode requires  that the string dtype length is long enough to store the maximum  integer/float value converted.</p>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>dtype, result_type</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Basic examples</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.can_cast(np.int32, np.int64) True np.can_cast(np.float64, complex) True np.can_cast(complex, float) False</p>
+      <p>np.can_cast(‘i8’, ‘f8’) True np.can_cast(‘i8’, ‘f4’) False np.can_cast(‘i4’, ‘S4’) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Casting scalars</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.can_cast(100, ‘i1’) True np.can_cast(150, ‘i1’) False np.can_cast(150, ‘u1’) True</p>
+      <p>np.can_cast(3.5e100, np.float32) False np.can_cast(1000.0, np.float32) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Array scalar checks the value, array does not</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.can_cast(np.array(1000.0), np.float32) True np.can_cast(np.array([1000.0]), np.float32) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using the casting rules</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.can_cast(‘i8’, ‘i8’, ‘no’) True np.can_cast(‘&lt;i8’, ‘&gt;i8’, ‘no’) False</p>
+      <p>np.can_cast(‘&lt;i8’, ‘&gt;i8’, ‘equiv’) True np.can_cast(‘&lt;i4’, ‘&gt;i8’, ‘equiv’) False</p>
+      <p>np.can_cast(‘&lt;i4’, ‘&gt;i8’, ‘safe’) True np.can_cast(‘&lt;i8’, ‘&gt;i4’, ‘safe’) False</p>
+      <p>np.can_cast(‘&lt;i8’, ‘&gt;i4’, ‘same_kind’) True np.can_cast(‘&lt;i8’, ‘&gt;u4’, ‘same_kind’) False</p>
+      <p>np.can_cast(‘&lt;i8’, ‘&gt;u4’, ‘unsafe’) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12142">view source</a></div></div><div class="public anchor" id="var-cast"><h3>cast</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Base object for a dictionary for look-up with any alias for an array dtype.</p>
+<p>Instances of <code>_typedict</code> can not be used as dictionaries directly, first they have to be populated.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4010">view source</a></div></div><div class="public anchor" id="var-cbrt"><h3>cbrt</h3><div class="usage"><code>(cbrt self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>cbrt(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the cube-root of an array, element-wise.</p>
+<p>.. versionadded:: 1.10.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  The values whose cube-roots are required. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  An array of the same shape as <code>x</code>, containing the cube  cube-root of each element in <code>x</code>.  If <code>out</code> was provided, <code>y</code> is a reference to it.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.cbrt([1,8,27]) array([ 1., 2., 3.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8004">view source</a></div></div><div class="public anchor" id="var-cdouble"><h3>cdouble</h3><div class="usage"><code>(cdouble self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two double-precision floating-point numbers, compatible with Python <code>complex</code>. Character code: <code>'D'</code>. Canonical name: <code>np.cdouble</code>. Alias: <code>np.cfloat</code>. Alias: <code>np.complex_</code>. Alias <em>on this platform</em>: <code>np.complex128</code>: Complex number type composed of 2 64-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15237">view source</a></div></div><div class="public anchor" id="var-ceil"><h3>ceil</h3><div class="usage"><code>(ceil self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>ceil(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the ceiling of the input, element-wise.</p>
+<p>The ceil of the scalar <code>x</code> is the smallest integer <code>i</code>, such that <code>i &gt;= x</code>. It is often denoted as :math:<code>\lceil x \rceil</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input data. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  The ceiling of each element in <code>x</code>, with <code>float</code> dtype.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>floor, trunc, rint</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.ceil(a) array([-1., -1., -0., 1., 2., 2., 2.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L666">view source</a></div></div><div class="public anchor" id="var-cfloat"><h3>cfloat</h3><div class="usage"><code>(cfloat self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two double-precision floating-point numbers, compatible with Python <code>complex</code>. Character code: <code>'D'</code>. Canonical name: <code>np.cdouble</code>. Alias: <code>np.cfloat</code>. Alias: <code>np.complex_</code>. Alias <em>on this platform</em>: <code>np.complex128</code>: Complex number type composed of 2 64-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25767">view source</a></div></div><div class="public anchor" id="var-char"><h3>char</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>This module contains a set of functions for vectorized string operations and methods.</p>
+<p>.. note::  The <code>chararray</code> class exists for backwards compatibility with  Numarray, it is not recommended for new development. Starting from numpy  1.4, if one needs arrays of strings, it is recommended to use arrays of  <code>dtype</code> <code>object_</code>, <code>string_</code> or <code>unicode_</code>, and use the free functions  in the <code>numpy.char</code> module for fast vectorized string operations.</p>
+<p>Some methods will only be available if the corresponding string method is available in your version of Python.</p>
+<p>The preferred alias for <code>defchararray</code> is <code>numpy.char</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16152">view source</a></div></div><div class="public anchor" id="var-character"><h3>character</h3><div class="usage"><code>(character self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all character string scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15907">view source</a></div></div><div class="public anchor" id="var-chararray"><h3>chararray</h3><div class="usage"><code>(chararray self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,  strides=None, order=None)</p>
+<p>Provides a convenient view on arrays of string and unicode values.</p>
+<p>.. note::  The <code>chararray</code> class exists for backwards compatibility with  Numarray, it is not recommended for new development. Starting from numpy  1.4, if one needs arrays of strings, it is recommended to use arrays of  <code>dtype</code> <code>object_</code>, <code>string_</code> or <code>unicode_</code>, and use the free functions  in the <code>numpy.char</code> module for fast vectorized string operations.</p>
+<p>Versus a regular NumPy array of type <code>str</code> or <code>unicode</code>, this class adds the following functionality:</p>
+<p>1) values automatically have whitespace removed from the end  when indexed</p>
+<p>2) comparison operators automatically remove whitespace from the  end when comparing values</p>
+<p>3) vectorized string operations are provided as methods  (e.g. <code>.endswith</code>) and infix operators (e.g. <code>"+", "*", "%"</code>)</p>
+<p>chararrays should be created using <code>numpy.char.array</code> or <code>numpy.char.asarray</code>, rather than this constructor directly.</p>
+<p>This constructor creates the array, using <code>buffer</code> (with <code>offset</code> and <code>strides</code>) if it is not <code>None</code>. If <code>buffer</code> is <code>None</code>, then constructs a new array with <code>strides</code> in “C order”, unless both <code>len(shape) &gt;= 2</code> and <code>order='F'</code>, in which case <code>strides</code> is in “Fortran order”.</p>
+<h2><a href="#methods" name="methods"></a>Methods</h2>
+<p>astype argsort copy count decode dump dumps encode endswith expandtabs fill find flatten getfield index isalnum isalpha isdecimal isdigit islower isnumeric isspace istitle isupper item join ljust lower lstrip nonzero put ravel repeat replace reshape resize rfind rindex rjust rsplit rstrip searchsorted setfield setflags sort split splitlines squeeze startswith strip swapaxes swapcase take title tofile tolist tostring translate transpose upper view zfill</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>shape : tuple  Shape of the array. itemsize : int, optional  Length of each array element, in number of characters. Default is 1. unicode : bool, optional  Are the array elements of type unicode (True) or string (False).  Default is False. buffer : int, optional  Memory address of the start of the array data. Default is None,  in which case a new array is created. offset : int, optional  Fixed stride displacement from the beginning of an axis?  Default is 0. Needs to be &gt;=0. strides : array_like of ints, optional  Strides for the array (see <code>ndarray.strides</code> for full description).  Default is None. order : {‘C’, ‘F’}, optional  The order in which the array data is stored in memory: ‘C’ -&gt;  “row major” order (the default), ‘F’ -&gt; “column major”  (Fortran) order.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>charar = np.chararray((3, 3)) charar[:] = ‘a’ charar chararray(<a href="null">b'a', b'a', b'a'],
+           [b'a', b'a', b'a'],
+           [b'a', b'a', b'a'</a>, dtype=‘|S1’)</p>
+      <p>charar = np.chararray(charar.shape, itemsize=5) charar[:] = ‘abc’ charar chararray(<a href="null">b'abc', b'abc', b'abc'],
+           [b'abc', b'abc', b'abc'],
+           [b'abc', b'abc', b'abc'</a>, dtype=‘|S5’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11271">view source</a></div></div><div class="public anchor" id="var-choose"><h3>choose</h3><div class="usage"><code>(choose &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Construct an array from an index array and a set of arrays to choose from.</p>
+<p>First of all, if confused or uncertain, definitely look at the Examples - in its full generality, this function is less simple than it might seem from the following code description (below ndi = <code>numpy.lib.index_tricks</code>):</p>
+<p><code>np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])</code>.</p>
+<p>But this omits some subtleties. Here is a fully general summary:</p>
+<p>Given an “index” array (<code>a</code>) of integers and a sequence of <code>n</code> arrays (<code>choices</code>), <code>a</code> and each choice array are first broadcast, as necessary, to arrays of a common shape; calling these <em>Ba</em> and <em>Bchoices[i], i = 0,…,n-1</em> we have that, necessarily, <code>Ba.shape == Bchoices[i].shape</code> for each <code>i</code>. Then, a new array with shape <code>Ba.shape</code> is created as follows:</p>
+<ul>
+  <li>
+  <p>if <code>mode=raise</code> (the default), then, first of all, each element of  <code>a</code> (and thus <code>Ba</code>) must be in the range <code>[0, n-1]</code>; now, suppose that  <code>i</code> (in that range) is the value at the <code>(j0, j1, ..., jm)</code> position  in <code>Ba</code> - then the value at the same position in the new array is the  value in <code>Bchoices[i]</code> at that same position;</p></li>
+  <li>
+  <p>if <code>mode=wrap</code>, values in <code>a</code> (and thus <code>Ba</code>) may be any (signed)  integer; modular arithmetic is used to map integers outside the range  <code>[0, n-1]</code> back into that range; and then the new array is constructed  as above;</p></li>
+  <li>
+  <p>if <code>mode=clip</code>, values in <code>a</code> (and thus <code>Ba</code>) may be any (signed)  integer; negative integers are mapped to 0; values greater than <code>n-1</code>  are mapped to <code>n-1</code>; and then the new array is constructed as above.</p></li>
+</ul>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : int array  This array must contain integers in <code>[0, n-1]</code>, where <code>n</code> is the number  of choices, unless <code>mode=wrap</code> or <code>mode=clip</code>, in which cases any  integers are permissible. choices : sequence of arrays  Choice arrays. <code>a</code> and all of the choices must be broadcastable to the  same shape. If <code>choices</code> is itself an array (not recommended), then  its outermost dimension (i.e., the one corresponding to  <code>choices.shape[0]</code>) is taken as defining the “sequence”. out : array, optional  If provided, the result will be inserted into this array. It should  be of the appropriate shape and dtype. Note that <code>out</code> is always  buffered if <code>mode='raise'</code>; use other modes for better performance. mode : {‘raise’ (default), ‘wrap’, ‘clip’}, optional  Specifies how indices outside <code>[0, n-1]</code> will be treated:</p>
+<pre><code>  * 'raise' : an exception is raised
+  * 'wrap' : value becomes value mod `n`
+  * 'clip' : values &lt; 0 are mapped to 0, values &gt; n-1 are mapped to n-1
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>merged_array : array  The merged result.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError: shape mismatch  If <code>a</code> and each choice array are not all broadcastable to the same  shape.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.choose : equivalent method numpy.take_along_axis : Preferable if <code>choices</code> is an array</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>To reduce the chance of misinterpretation, even though the following “abuse” is nominally supported, <code>choices</code> should neither be, nor be thought of as, a single array, i.e., the outermost sequence-like container should be either a list or a tuple.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>choices = <a href="null">0, 1, 2, 3], [10, 11, 12, 13],
+...   [20, 21, 22, 23], [30, 31, 32, 33</a> np.choose([2, 3, 1, 0], choices … # the first element of the result will be the first element of the … # third (2+1) “array” in choices, namely, 20; the second element … # will be the second element of the fourth (3+1) choice array, i.e., … # 31, etc. … ) array([20, 31, 12, 3]) np.choose([2, 4, 1, 0], choices, mode=‘clip’) # 4 goes to 3 (4-1) array([20, 31, 12, 3])</p>
+      <h1><a href="#because-there-are-4-choice-arrays" name="because-there-are-4-choice-arrays"></a>because there are 4 choice arrays</h1>
+      <p>np.choose([2, 4, 1, 0], choices, mode=‘wrap’) # 4 goes to (4 mod 4) array([20, 1, 12, 3])</p>
+      <h1><a href="#i-e-0" name="i-e-0"></a>i.e., 0</h1>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>A couple examples illustrating how choose broadcasts:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = <a href="null">1, 0, 1], [0, 1, 0], [1, 0, 1</a> choices = [-10, 10] np.choose(a, choices) array(<a href="null"> 10, -10,  10],
+       [-10,  10, -10],
+       [ 10, -10,  10</a>)</p>
+      <h1><a href="#with-thanks-to-anne-archibald" name="with-thanks-to-anne-archibald"></a>With thanks to Anne Archibald</h1>
+      <p>a = np.array([0, 1]).reshape((2,1,1)) c1 = np.array([1, 2, 3]).reshape((1,3,1)) c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5)) np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2 array(<a href="null">[ 1,  1,  1,  1,  1],
+        [ 2,  2,  2,  2,  2],
+        [ 3,  3,  3,  3,  3</a>,  <a href="null">-1, -2, -3, -4, -5],
+        [-1, -2, -3, -4, -5],
+        [-1, -2, -3, -4, -5</a>])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18539">view source</a></div></div><div class="public anchor" id="var-CLIP"><h3>CLIP</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24632">view source</a></div></div><div class="public anchor" id="var-clip"><h3>clip</h3><div class="usage"><code>(clip &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Clip (limit) the values in an array.</p>
+<p>Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of <code>[0, 1]</code> is specified, values smaller than 0 become 0, and values larger than 1 become 1.</p>
+<p>Equivalent to but faster than <code>np.maximum(a_min, np.minimum(a, a_max))</code>. No check is performed to ensure <code>a_min &lt; a_max</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array containing elements to clip. a_min : scalar or array_like or None  Minimum value. If None, clipping is not performed on lower  interval edge. Not more than one of <code>a_min</code> and <code>a_max</code> may be  None. a_max : scalar or array_like or None  Maximum value. If None, clipping is not performed on upper  interval edge. Not more than one of <code>a_min</code> and <code>a_max</code> may be  None. If <code>a_min</code> or <code>a_max</code> are array_like, then the three  arrays will be broadcasted to match their shapes. out : ndarray, optional  The results will be placed in this array. It may be the input  array for in-place clipping. <code>out</code> must be of the right shape  to hold the output. Its type is preserved. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>clipped_array : ndarray  An array with the elements of <code>a</code>, but where values  &lt; <code>a_min</code> are replaced with <code>a_min</code>, and those &gt; <code>a_max</code>  with <code>a_max</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ufuncs-output-type</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(10) np.clip(a, 1, 8) array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8]) a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) np.clip(a, 3, 6, out=a) array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) a = np.arange(10) a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8) array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6424">view source</a></div></div><div class="public anchor" id="var-clongdouble"><h3>clongdouble</h3><div class="usage"><code>(clongdouble self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two extended-precision floating-point numbers. Character code: <code>'G'</code>. Canonical name: <code>np.clongdouble</code>. Alias: <code>np.clongfloat</code>. Alias: <code>np.longcomplex</code>. Alias <em>on this platform</em>: <code>np.complex256</code>: Complex number type composed of 2 128-bit extended-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L970">view source</a></div></div><div class="public anchor" id="var-clongfloat"><h3>clongfloat</h3><div class="usage"><code>(clongfloat self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two extended-precision floating-point numbers. Character code: <code>'G'</code>. Canonical name: <code>np.clongdouble</code>. Alias: <code>np.clongfloat</code>. Alias: <code>np.longcomplex</code>. Alias <em>on this platform</em>: <code>np.complex256</code>: Complex number type composed of 2 128-bit extended-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10250">view source</a></div></div><div class="public anchor" id="var-column_stack"><h3>column_stack</h3><div class="usage"><code>(column_stack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Stack 1-D arrays as columns into a 2-D array.</p>
+<p>Take a sequence of 1-D arrays and stack them as columns to make a single 2-D array. 2-D arrays are stacked as-is, just like with <code>hstack</code>. 1-D arrays are turned into 2-D columns first.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>tup : sequence of 1-D or 2-D arrays.  Arrays to stack. All of them must have the same first dimension.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>stacked : 2-D array  The array formed by stacking the given arrays.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>stack, hstack, vstack, concatenate</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array((1,2,3)) b = np.array((2,3,4)) np.column_stack((a,b)) array(<a href="null">1, 2],
+       [2, 3],
+       [3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23064">view source</a></div></div><div class="public anchor" id="var-common_type"><h3>common_type</h3><div class="usage"><code>(common_type &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a scalar type which is common to the input arrays.</p>
+<p>The return type will always be an inexact (i.e. floating point) scalar type, even if all the arrays are integer arrays. If one of the inputs is an integer array, the minimum precision type that is returned is a 64-bit floating point dtype.</p>
+<p>All input arrays except int64 and uint64 can be safely cast to the returned dtype without loss of information.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>array1, array2, … : ndarrays  Input arrays.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : data type code  Data type code.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>dtype, mintypecode</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.common_type(np.arange(2, dtype=np.float32)) &lt;class ‘numpy.float32’&gt; np.common_type(np.arange(2, dtype=np.float32), np.arange(2)) &lt;class ‘numpy.float64’&gt; np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0])) &lt;class ‘numpy.complex128’&gt;</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L933">view source</a></div></div><div class="public anchor" id="var-compare_chararrays"><h3>compare_chararrays</h3><div class="usage"><code>(compare_chararrays self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>compare_chararrays(a, b, cmp_op, rstrip)</p>
+<p>Performs element-wise comparison of two string arrays using the comparison operator specified by <code>cmp_op</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a, b : array_like  Arrays to be compared. cmp_op : {“&lt;”, “&lt;=”, “==”, “&gt;=”, “&gt;”, “!=”}  Type of comparison. rstrip : Boolean  If True, the spaces at the end of Strings are removed before the comparison.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  The output array of type Boolean with the same shape as a and b.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If <code>cmp_op</code> is not valid. TypeError  If at least one of <code>a</code> or <code>b</code> is a non-string array</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([“a”, “b”, “cde”]) b = np.array([“a”, “a”, “dec”]) np.compare_chararrays(a, b, “&gt;”, True) array([False, True, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21900">view source</a></div></div><div class="public anchor" id="var-compat"><h3>compat</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Compatibility module.</p>
+<p>This module contains duplicated code from Python itself or 3rd party extensions, which may be included for the following reasons:</p>
+<ul>
+  <li>compatibility</li>
+  <li>we may only need a small subset of the copied library/module</li>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9212">view source</a></div></div><div class="public anchor" id="var-complex"><h3>complex</h3><div class="usage"><code>(complex self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create a complex number from a real part and an optional imaginary part.</p>
+<p>This is equivalent to (real + imag*1j) where imag defaults to 0.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25685">view source</a></div></div><div class="public anchor" id="var-complex128"><h3>complex128</h3><div class="usage"><code>(complex128 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two double-precision floating-point numbers, compatible with Python <code>complex</code>. Character code: <code>'D'</code>. Canonical name: <code>np.cdouble</code>. Alias: <code>np.cfloat</code>. Alias: <code>np.complex_</code>. Alias <em>on this platform</em>: <code>np.complex128</code>: Complex number type composed of 2 64-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13027">view source</a></div></div><div class="public anchor" id="var-complex256"><h3>complex256</h3><div class="usage"><code>(complex256 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two extended-precision floating-point numbers. Character code: <code>'G'</code>. Canonical name: <code>np.clongdouble</code>. Alias: <code>np.clongfloat</code>. Alias: <code>np.longcomplex</code>. Alias <em>on this platform</em>: <code>np.complex256</code>: Complex number type composed of 2 128-bit extended-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26980">view source</a></div></div><div class="public anchor" id="var-complex64"><h3>complex64</h3><div class="usage"><code>(complex64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two single-precision floating-point numbers. Character code: <code>'F'</code>. Canonical name: <code>np.csingle</code>. Alias: <code>np.singlecomplex</code>. Alias <em>on this platform</em>: <code>np.complex64</code>: Complex number type composed of 2 32-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26737">view source</a></div></div><div class="public anchor" id="var-complex_"><h3>complex_</h3><div class="usage"><code>(complex_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two double-precision floating-point numbers, compatible with Python <code>complex</code>. Character code: <code>'D'</code>. Canonical name: <code>np.cdouble</code>. Alias: <code>np.cfloat</code>. Alias: <code>np.complex_</code>. Alias <em>on this platform</em>: <code>np.complex128</code>: Complex number type composed of 2 64-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4964">view source</a></div></div><div class="public anchor" id="var-complexfloating"><h3>complexfloating</h3><div class="usage"><code>(complexfloating self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all complex number scalar types that are made up of floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20502">view source</a></div></div><div class="public anchor" id="var-ComplexWarning"><h3>ComplexWarning</h3><div class="usage"><code>(ComplexWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>The warning raised when casting a complex dtype to a real dtype.</p>
+<p>As implemented, casting a complex number to a real discards its imaginary part, but this behavior may not be what the user actually wants.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18140">view source</a></div></div><div class="public anchor" id="var-compress"><h3>compress</h3><div class="usage"><code>(compress &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return selected slices of an array along given axis.</p>
+<p>When working along a given axis, a slice along that axis is returned in <code>output</code> for each index where <code>condition</code> evaluates to True. When working on a 1-D array, <code>compress</code> is equivalent to <code>extract</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>condition : 1-D array of bools  Array that selects which entries to return. If len(condition)  is less than the size of <code>a</code> along the given axis, then output is  truncated to the length of the condition array. a : array_like  Array from which to extract a part. axis : int, optional  Axis along which to take slices. If None (default), work on the  flattened array. out : ndarray, optional  Output array. Its type is preserved and it must be of the right  shape to hold the output.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>compressed_array : ndarray  A copy of <code>a</code> without the slices along axis for which <code>condition</code>  is false.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>take, choose, diag, diagonal, select ndarray.compress : Equivalent method in ndarray np.extract: Equivalent method when working on 1-D arrays ufuncs-output-type</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 2], [3, 4], [5, 6</a>) a array(<a href="null">1, 2],
+       [3, 4],
+       [5, 6</a>) np.compress([0, 1], a, axis=0) array(<a href="null">3, 4</a>) np.compress([False, True, True], a, axis=0) array(<a href="null">3, 4],
+       [5, 6</a>) np.compress([False, True], a, axis=1) array(<a href="null">2],
+       [4],
+       [6</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Working on the flattened array does not return slices along an axis but selects elements.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.compress([False, True], a) array([2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L438">view source</a></div></div><div class="public anchor" id="var-concatenate"><h3>concatenate</h3><div class="usage"><code>(concatenate &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>concatenate((a1, a2, …), axis=0, out=None)</p>
+<p>Join a sequence of arrays along an existing axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a1, a2, … : sequence of array_like  The arrays must have the same shape, except in the dimension  corresponding to <code>axis</code> (the first, by default). axis : int, optional  The axis along which the arrays will be joined. If axis is None,  arrays are flattened before use. Default is 0. out : ndarray, optional  If provided, the destination to place the result. The shape must be  correct, matching that of what concatenate would have returned if no  out argument were specified.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>res : ndarray  The concatenated array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ma.concatenate : Concatenate function that preserves input masks. array_split : Split an array into multiple sub-arrays of equal or  near-equal size. split : Split array into a list of multiple sub-arrays of equal size. hsplit : Split array into multiple sub-arrays horizontally (column wise) vsplit : Split array into multiple sub-arrays vertically (row wise) dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). stack : Stack a sequence of arrays along a new axis. hstack : Stack arrays in sequence horizontally (column wise) vstack : Stack arrays in sequence vertically (row wise) dstack : Stack arrays in sequence depth wise (along third dimension) block : Assemble arrays from blocks.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>When one or more of the arrays to be concatenated is a MaskedArray, this function will return a MaskedArray object instead of an ndarray, but the input masks are <em>not</em> preserved. In cases where a MaskedArray is expected as input, use the ma.concatenate function from the masked array module instead.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 2], [3, 4</a>) b = np.array(<a href="null">5, 6</a>) np.concatenate((a, b), axis=0) array(<a href="null">1, 2],
+       [3, 4],
+       [5, 6</a>) np.concatenate((a, b.T), axis=1) array(<a href="null">1, 2, 5],
+       [3, 4, 6</a>) np.concatenate((a, b), axis=None) array([1, 2, 3, 4, 5, 6])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>This function will not preserve masking of MaskedArray inputs.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.ma.arange(3) a[1] = np.ma.masked b = np.arange(2, 5) a masked_array(data=[0, –, 2],  mask=[False, True, False],  fill_value=999999) b array([2, 3, 4]) np.concatenate([a, b]) masked_array(data=[0, 1, 2, 2, 3, 4],  mask=False,  fill_value=999999) np.ma.concatenate([a, b]) masked_array(data=[0, –, 2, 2, 3, 4],  mask=[False, True, False, False, False, False],  fill_value=999999)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28243">view source</a></div></div><div class="public anchor" id="var-conj"><h3>conj</h3><div class="usage"><code>(conj self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>conjugate(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the complex conjugate, element-wise.</p>
+<p>The complex conjugate of a complex number is obtained by changing the sign of its imaginary part.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input value. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The complex conjugate of <code>x</code>, with same dtype as <code>y</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>conj</code> is an alias for <code>conjugate</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.conj is np.conjugate True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.conjugate(1+2j) (1-2j)</p>
+      <p>x = np.eye(2) + 1j * np.eye(2) np.conjugate(x) array(<a href="null"> 1.-1.j,  0.-0.j],
+       [ 0.-0.j,  1.-1.j</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20819">view source</a></div></div><div class="public anchor" id="var-conjugate"><h3>conjugate</h3><div class="usage"><code>(conjugate self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>conjugate(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the complex conjugate, element-wise.</p>
+<p>The complex conjugate of a complex number is obtained by changing the sign of its imaginary part.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input value. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The complex conjugate of <code>x</code>, with same dtype as <code>y</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>conj</code> is an alias for <code>conjugate</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.conj is np.conjugate True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.conjugate(1+2j) (1-2j)</p>
+      <p>x = np.eye(2) + 1j * np.eye(2) np.conjugate(x) array(<a href="null"> 1.-1.j,  0.-0.j],
+       [ 0.-0.j,  1.-1.j</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11885">view source</a></div></div><div class="public anchor" id="var-convolve"><h3>convolve</h3><div class="usage"><code>(convolve &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the discrete, linear convolution of two one-dimensional sequences.</p>
+<p>The convolution operator is often seen in signal processing, where it models the effect of a linear time-invariant system on a signal [1]_. In probability theory, the sum of two independent random variables is distributed according to the convolution of their individual distributions.</p>
+<p>If <code>v</code> is longer than <code>a</code>, the arrays are swapped before computation.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : (N,) array_like  First one-dimensional input array. v : (M,) array_like  Second one-dimensional input array. mode : {‘full’, ‘valid’, ‘same’}, optional  ‘full’:  By default, mode is ‘full’. This returns the convolution  at each point of overlap, with an output shape of (N+M-1,). At  the end-points of the convolution, the signals do not overlap  completely, and boundary effects may be seen.</p>
+<pre><code>'same':
+  Mode 'same' returns output of length ``max(M, N)``.  Boundary
+  effects are still visible.
+
+'valid':
+  Mode 'valid' returns output of length
+  ``max(M, N) - min(M, N) + 1``.  The convolution product is only given
+  for points where the signals overlap completely.  Values outside
+  the signal boundary have no effect.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Discrete, linear convolution of <code>a</code> and <code>v</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier  Transform. scipy.linalg.toeplitz : Used to construct the convolution operator. polymul : Polynomial multiplication. Same output as convolve, but also  accepts poly1d objects as input.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The discrete convolution operation is defined as</p>
+<p>.. math:: (a * v)[n] = \sum_{m = -\infty}^{\infty} a[m] v[n - m]</p>
+<p>It can be shown that a convolution :math:<code>x(t) * y(t)</code> in time/space is equivalent to the multiplication :math:<code>X(f) Y(f)</code> in the Fourier domain, after appropriate padding (padding is necessary to prevent circular convolution). Since multiplication is more efficient (faster) than convolution, the function <code>scipy.signal.fftconvolve</code> exploits the FFT to calculate the convolution of large data-sets.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Wikipedia, “Convolution”,  <a href="https://en.wikipedia.org/wiki/Convolution">https://en.wikipedia.org/wiki/Convolution</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Note how the convolution operator flips the second array before “sliding” the two across one another:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.convolve([1, 2, 3], [0, 1, 0.5]) array([0. , 1. , 2.5, 4. , 1.5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Only return the middle values of the convolution. Contains boundary effects, where zeros are taken into account:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.convolve([1,2,3],[0,1,0.5], ‘same’) array([1. , 2.5, 4. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The two arrays are of the same length, so there is only one position where they completely overlap:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.convolve([1,2,3],[0,1,0.5], ‘valid’) array([2.5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22686">view source</a></div></div><div class="public anchor" id="var-copy"><h3>copy</h3><div class="usage"><code>(copy &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an array copy of the given object.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. order : {‘C’, ‘F’, ‘A’, ‘K’}, optional  Controls the memory layout of the copy. ‘C’ means C-order,  ‘F’ means F-order, ‘A’ means ‘F’ if <code>a</code> is Fortran contiguous,  ‘C’ otherwise. ‘K’ means match the layout of <code>a</code> as closely  as possible. (Note that this function and :meth:<code>ndarray.copy</code> are very  similar, but have different default values for their order=  arguments.)</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>arr : ndarray  Array interpretation of <code>a</code>.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This is equivalent to:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.array(a, copy=True) #doctest: +SKIP</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Create an array x, with a reference y and a copy z:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([1, 2, 3]) y = x z = np.copy(x)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that, when we modify x, y changes, but not z:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x[0] = 10 x[0] == y[0] True x[0] == z[0] False</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4853">view source</a></div></div><div class="public anchor" id="var-copysign"><h3>copysign</h3><div class="usage"><code>(copysign self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>copysign(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Change the sign of x1 to that of x2, element-wise.</p>
+<p>If <code>x2</code> is a scalar, its sign will be copied to all elements of <code>x1</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  Values to change the sign of. x2 : array_like  The sign of <code>x2</code> is copied to <code>x1</code>. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  The values of <code>x1</code> with the sign of <code>x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.copysign(1.3, -1) -1.3 1/np.copysign(0, 1) inf 1/np.copysign(0, -1) -inf</p>
+      <p>np.copysign([-1, 0, 1], -1.1) array([-1., -0., -1.]) np.copysign([-1, 0, 1], np.arange(3)-1) array([-1., 0., 1.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5653">view source</a></div></div><div class="public anchor" id="var-copyto"><h3>copyto</h3><div class="usage"><code>(copyto &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>copyto(dst, src, casting=‘same_kind’, where=True)</p>
+<p>Copies values from one array to another, broadcasting as necessary.</p>
+<p>Raises a TypeError if the <code>casting</code> rule is violated, and if <code>where</code> is provided, it selects which elements to copy.</p>
+<p>.. versionadded:: 1.7.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>dst : ndarray  The array into which values are copied. src : array_like  The array from which values are copied. casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional  Controls what kind of data casting may occur when copying.</p>
+<pre><code>  * 'no' means the data types should not be cast at all.
+  * 'equiv' means only byte-order changes are allowed.
+  * 'safe' means only casts which can preserve values are allowed.
+  * 'same_kind' means only safe casts or casts within a kind,
+    like float64 to float32, are allowed.
+  * 'unsafe' means any data conversions may be done.
+</code></pre>
+<p>where : array_like of bool, optional  A boolean array which is broadcasted to match the dimensions  of <code>dst</code>, and selects elements to copy from <code>src</code> to <code>dst</code>  wherever it contains the value True.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28722">view source</a></div></div><div class="public anchor" id="var-core"><h3>core</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Contains the core of NumPy: ndarray, ufuncs, dtypes, etc.</p>
+<p>Please note that this module is private. All functions and objects are available in the main <code>numpy</code> namespace - use that instead.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26729">view source</a></div></div><div class="public anchor" id="var-corrcoef"><h3>corrcoef</h3><div class="usage"><code>(corrcoef &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return Pearson product-moment correlation coefficients.</p>
+<p>Please refer to the documentation for <code>cov</code> for more detail. The relationship between the correlation coefficient matrix, <code>R</code>, and the covariance matrix, <code>C</code>, is</p>
+<p>.. math:: R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} * C_{jj} } }</p>
+<p>The values of <code>R</code> are between -1 and 1, inclusive.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  A 1-D or 2-D array containing multiple variables and observations.  Each row of <code>x</code> represents a variable, and each column a single  observation of all those variables. Also see <code>rowvar</code> below. y : array_like, optional  An additional set of variables and observations. <code>y</code> has the same  shape as <code>x</code>. rowvar : bool, optional  If <code>rowvar</code> is True (default), then each row represents a  variable, with observations in the columns. Otherwise, the relationship  is transposed: each column represents a variable, while the rows  contain observations. bias : _NoValue, optional  Has no effect, do not use.</p>
+<pre><code>.. deprecated:: 1.10.0
+</code></pre>
+<p>ddof : _NoValue, optional  Has no effect, do not use.</p>
+<pre><code>.. deprecated:: 1.10.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>R : ndarray  The correlation coefficient matrix of the variables.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>cov : Covariance matrix</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Due to floating point rounding the resulting array may not be Hermitian, the diagonal elements may not be 1, and the elements may not satisfy the inequality abs(a) &lt;= 1. The real and imaginary parts are clipped to the interval [-1, 1] in an attempt to improve on that situation but is not much help in the complex case.</p>
+<p>This function accepts but discards arguments <code>bias</code> and <code>ddof</code>. This is for backwards compatibility with previous versions of this function. These arguments had no effect on the return values of the function and can be safely ignored in this and previous versions of numpy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6106">view source</a></div></div><div class="public anchor" id="var-correlate"><h3>correlate</h3><div class="usage"><code>(correlate &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Cross-correlation of two 1-dimensional sequences.</p>
+<p>This function computes the correlation as generally defined in signal processing texts::</p>
+<pre><code>c_{av}[k] = sum_n a[n+k] * conj(v[n])
+</code></pre>
+<p>with a and v sequences being zero-padded where necessary and conj being the conjugate.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a, v : array_like  Input sequences. mode : {‘valid’, ‘same’, ‘full’}, optional  Refer to the <code>convolve</code> docstring. Note that the default  is ‘valid’, unlike <code>convolve</code>, which uses ‘full’. old_behavior : bool  <code>old_behavior</code> was removed in NumPy 1.10. If you need the old  behavior, use <code>multiarray.correlate</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Discrete cross-correlation of <code>a</code> and <code>v</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>convolve : Discrete, linear convolution of two one-dimensional sequences. multiarray.correlate : Old, no conjugate, version of correlate.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The definition of correlation above is not unique and sometimes correlation may be defined differently. Another common definition is::</p>
+<pre><code>c'_{av}[k] = sum_n a[n] conj(v[n+k])
+</code></pre>
+<p>which is related to <code>c_{av}[k]</code> by <code>c'_{av}[k] = c_{av}[-k]</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.correlate([1, 2, 3], [0, 1, 0.5]) array([3.5]) np.correlate([1, 2, 3], [0, 1, 0.5], “same”) array([2. , 3.5, 3. ]) np.correlate([1, 2, 3], [0, 1, 0.5], “full”) array([0.5, 2. , 3.5, 3. , 0. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using complex sequences:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], ‘full’) array([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that you get the time reversed, complex conjugated result when the two input sequences change places, i.e., <code>c_{va}[k] = c^{*}_{av}[-k]</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], ‘full’) array([ 0.0+0.j , 3.0+1.j , 1.5+1.5j, 1.0+0.j , 0.5+0.5j])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17805">view source</a></div></div><div class="public anchor" id="var-cos"><h3>cos</h3><div class="usage"><code>(cos self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>cos(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Cosine element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array in radians. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The corresponding cosine values.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If <code>out</code> is provided, the function writes the result into it, and returns a reference to <code>out</code>. (See Examples)</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. New York, NY: Dover, 1972.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.cos(np.array([0, np.pi/2, np.pi])) array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00])</p>
+      <h1><a href="#example-of-providing-the-optional-output-parameter" name="example-of-providing-the-optional-output-parameter"></a>Example of providing the optional output parameter</h1>
+      <p>out1 = np.array([0], dtype=‘d’) out2 = np.cos([0.1], out1) out2 is out1 True</p>
+      <h1><a href="#example-of-valueerror-due-to-provision-of-shape-mis-matched" name="example-of-valueerror-due-to-provision-of-shape-mis-matched"></a>Example of ValueError due to provision of shape mis-matched <code>out</code></h1>
+      <p>np.cos(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> ValueError: operands could not be broadcast together with shapes (3,3) (2,2)</module></stdin></p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19177">view source</a></div></div><div class="public anchor" id="var-cosh"><h3>cosh</h3><div class="usage"><code>(cosh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>cosh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Hyperbolic cosine, element-wise.</p>
+<p>Equivalent to <code>1/2 * (np.exp(x) + np.exp(-x))</code> and <code>np.cos(1j*x)</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Output array of same shape as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.cosh(0) 1.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The hyperbolic cosine describes the shape of a hanging cable:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt x = np.linspace(-4, 4, 1000) plt.plot(x, np.cosh(x)) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1488">view source</a></div></div><div class="public anchor" id="var-count_nonzero"><h3>count_nonzero</h3><div class="usage"><code>(count_nonzero &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Counts the number of non-zero values in the array <code>a</code>.</p>
+<p>The word “non-zero” is in reference to the Python 2.x built-in method <code>__nonzero__()</code> (renamed <code>__bool__()</code> in Python 3.x) of Python objects that tests an object’s “truthfulness”. For example, any number is considered truthful if it is nonzero, whereas any string is considered truthful if it is not the empty string. Thus, this function (recursively) counts how many elements in <code>a</code> (and in sub-arrays thereof) have their <code>__nonzero__()</code> or <code>__bool__()</code> method evaluated to <code>True</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  The array for which to count non-zeros. axis : int or tuple, optional  Axis or tuple of axes along which to count non-zeros.  Default is None, meaning that non-zeros will be counted  along a flattened version of <code>a</code>.</p>
+<pre><code>.. versionadded:: 1.12.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>count : int or array of int  Number of non-zero values in the array along a given axis.  Otherwise, the total number of non-zero values in the array  is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>nonzero : Return the coordinates of all the non-zero values.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.count_nonzero(np.eye(4)) 4 np.count_nonzero(<a href="null">0,1,7,0,0],[3,0,0,2,19</a>) 5 np.count_nonzero(<a href="null">0,1,7,0,0],[3,0,0,2,19</a>, axis=0) array([1, 1, 1, 1, 1]) np.count_nonzero(<a href="null">0,1,7,0,0],[3,0,0,2,19</a>, axis=1) array([2, 3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12537">view source</a></div></div><div class="public anchor" id="var-cov"><h3>cov</h3><div class="usage"><code>(cov &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Estimate a covariance matrix, given data and weights.</p>
+<p>Covariance indicates the level to which two variables vary together. If we examine N-dimensional samples, :math:<code>X = [x_1, x_2, ... x_N]^T</code>, then the covariance matrix element :math:<code>C_{ij}</code> is the covariance of :math:<code>x_i</code> and :math:<code>x_j</code>. The element :math:<code>C_{ii}</code> is the variance of :math:<code>x_i</code>.</p>
+<p>See the notes for an outline of the algorithm.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>m : array_like  A 1-D or 2-D array containing multiple variables and observations.  Each row of <code>m</code> represents a variable, and each column a single  observation of all those variables. Also see <code>rowvar</code> below. y : array_like, optional  An additional set of variables and observations. <code>y</code> has the same form  as that of <code>m</code>. rowvar : bool, optional  If <code>rowvar</code> is True (default), then each row represents a  variable, with observations in the columns. Otherwise, the relationship  is transposed: each column represents a variable, while the rows  contain observations. bias : bool, optional  Default normalization (False) is by <code>(N - 1)</code>, where <code>N</code> is the  number of observations given (unbiased estimate). If <code>bias</code> is True,  then normalization is by <code>N</code>. These values can be overridden by using  the keyword <code>ddof</code> in numpy versions &gt;= 1.5. ddof : int, optional  If not <code>None</code> the default value implied by <code>bias</code> is overridden.  Note that <code>ddof=1</code> will return the unbiased estimate, even if both  <code>fweights</code> and <code>aweights</code> are specified, and <code>ddof=0</code> will return  the simple average. See the notes for the details. The default value  is <code>None</code>.</p>
+<pre><code>.. versionadded:: 1.5
+</code></pre>
+<p>fweights : array_like, int, optional  1-D array of integer frequency weights; the number of times each  observation vector should be repeated.</p>
+<pre><code>.. versionadded:: 1.10
+</code></pre>
+<p>aweights : array_like, optional  1-D array of observation vector weights. These relative weights are  typically large for observations considered “important” and smaller for  observations considered less “important”. If <code>ddof=0</code> the array of  weights can be used to assign probabilities to observation vectors.</p>
+<pre><code>.. versionadded:: 1.10
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  The covariance matrix of the variables.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>corrcoef : Normalized covariance matrix</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Assume that the observations are in the columns of the observation array <code>m</code> and let <code>f = fweights</code> and <code>a = aweights</code> for brevity. The steps to compute the weighted covariance are as follows::</p>
+<pre><code>&gt;&gt;&gt; m = np.arange(10, dtype=np.float64)
+&gt;&gt;&gt; f = np.arange(10) * 2
+&gt;&gt;&gt; a = np.arange(10) ** 2.
+&gt;&gt;&gt; ddof = 1
+&gt;&gt;&gt; w = f * a
+&gt;&gt;&gt; v1 = np.sum(w)
+&gt;&gt;&gt; v2 = np.sum(w * a)
+&gt;&gt;&gt; m -= np.sum(m * w, axis=None, keepdims=True) / v1
+&gt;&gt;&gt; cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)
+</code></pre>
+<p>Note that when <code>a == 1</code>, the normalization factor <code>v1 / (v1**2 - ddof * v2)</code> goes over to <code>1 / (np.sum(f) - ddof)</code> as it should.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Consider two variables, :math:<code>x_0</code> and :math:<code>x_1</code>, which correlate perfectly, but in opposite directions:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">0, 2], [1, 1], [2, 0</a>).T x array(<a href="null">0, 1, 2],
+       [2, 1, 0</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note how :math:<code>x_0</code> increases while :math:<code>x_1</code> decreases. The covariance matrix shows this clearly:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.cov(x) array(<a href="null"> 1., -1.],
+       [-1.,  1.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that element :math:<code>C_{0,1}</code>, which shows the correlation between :math:<code>x_0</code> and :math:<code>x_1</code>, is negative.</p>
+<p>Further, note how <code>x</code> and <code>y</code> are combined:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = [-2.1, -1, 4.3] y = [3, 1.1, 0.12] X = np.stack((x, y), axis=0) np.cov(X) array(<a href="null">11.71      , -4.286     ], # may vary
+       [-4.286     ,  2.144133</a>) np.cov(x, y) array(<a href="null">11.71      , -4.286     ], # may vary
+       [-4.286     ,  2.144133</a>) np.cov(x) array(11.71)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23098">view source</a></div></div><div class="public anchor" id="var-cross"><h3>cross</h3><div class="usage"><code>(cross &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cross product of two (arrays of) vectors.</p>
+<p>The cross product of <code>a</code> and <code>b</code> in :math:<code>R^3</code> is a vector perpendicular to both <code>a</code> and <code>b</code>. If <code>a</code> and <code>b</code> are arrays of vectors, the vectors are defined by the last axis of <code>a</code> and <code>b</code> by default, and these axes can have dimensions 2 or 3. Where the dimension of either <code>a</code> or <code>b</code> is 2, the third component of the input vector is assumed to be zero and the cross product calculated accordingly. In cases where both input vectors have dimension 2, the z-component of the cross product is returned.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Components of the first vector(s). b : array_like  Components of the second vector(s). axisa : int, optional  Axis of <code>a</code> that defines the vector(s). By default, the last axis. axisb : int, optional  Axis of <code>b</code> that defines the vector(s). By default, the last axis. axisc : int, optional  Axis of <code>c</code> containing the cross product vector(s). Ignored if  both input vectors have dimension 2, as the return is scalar.  By default, the last axis. axis : int, optional  If defined, the axis of <code>a</code>, <code>b</code> and <code>c</code> that defines the vector(s)  and cross product(s). Overrides <code>axisa</code>, <code>axisb</code> and <code>axisc</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>c : ndarray  Vector cross product(s).</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  When the dimension of the vector(s) in <code>a</code> and/or <code>b</code> does not  equal 2 or 3.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>inner : Inner product outer : Outer product. ix_ : Construct index arrays.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.9.0</p>
+<p>Supports full broadcasting of the inputs.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Vector cross-product.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = [1, 2, 3] y = [4, 5, 6] np.cross(x, y) array([-3, 6, -3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>One vector with dimension 2.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = [1, 2] y = [4, 5, 6] np.cross(x, y) array([12, -6, -3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Equivalently:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = [1, 2, 0] y = [4, 5, 6] np.cross(x, y) array([12, -6, -3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Both vectors with dimension 2.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = [1,2] y = [4,5] np.cross(x, y) array(-3)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Multiple vector cross-products. Note that the direction of the cross product vector is defined by the <code>right-hand rule</code>.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">1,2,3], [4,5,6</a>) y = np.array(<a href="null">4,5,6], [1,2,3</a>) np.cross(x, y) array(<a href="null">-3,  6, -3],
+       [ 3, -6,  3</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The orientation of <code>c</code> can be changed using the <code>axisc</code> keyword.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.cross(x, y, axisc=0) array(<a href="null">-3,  3],
+       [ 6, -6],
+       [-3,  3</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Change the vector definition of <code>x</code> and <code>y</code> using <code>axisa</code> and <code>axisb</code>.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">1,2,3], [4,5,6], [7, 8, 9</a>) y = np.array(<a href="null">7, 8, 9], [4,5,6], [1,2,3</a>) np.cross(x, y) array(<a href="null"> -6,  12,  -6],
+       [  0,   0,   0],
+       [  6, -12,   6</a>) np.cross(x, y, axisa=0, axisb=0) array(<a href="null">-24,  48, -24],
+       [-30,  60, -30],
+       [-36,  72, -36</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8093">view source</a></div></div><div class="public anchor" id="var-csingle"><h3>csingle</h3><div class="usage"><code>(csingle self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two single-precision floating-point numbers. Character code: <code>'F'</code>. Canonical name: <code>np.csingle</code>. Alias: <code>np.singlecomplex</code>. Alias <em>on this platform</em>: <code>np.complex64</code>: Complex number type composed of 2 32-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6189">view source</a></div></div><div class="public anchor" id="var-ctypeslib"><h3>ctypeslib</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>============================</p>
+<h1><a href="#utility-functions" name="utility-functions"></a><code>ctypes</code> Utility Functions</h1>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>load_library : Load a C library. ndpointer : Array restype/argtype with verification. as_ctypes : Create a ctypes array from an ndarray. as_array : Create an ndarray from a ctypes array.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] “SciPy Cookbook: ctypes”, <a href="https://scipy-cookbook.readthedocs.io/items/Ctypes.html">https://scipy-cookbook.readthedocs.io/items/Ctypes.html</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Load the C library:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>_lib = np.ctypeslib.load_library(‘libmystuff’, ‘.’) #doctest: +SKIP</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Our result type, an ndarray that must be of type double, be 1-dimensional and is C-contiguous in memory:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>array_1d_double = np.ctypeslib.ndpointer( … dtype=np.double, … ndim=1, flags=‘CONTIGUOUS’) #doctest: +SKIP</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Our C-function typically takes an array and updates its values in-place. For example::</p>
+<pre><code>void foo_func(double* x, int length)
+{
+    int i;
+    for (i = 0; i &lt; length; i++) {
+        x[i] = i*i;
+    }
+}
+</code></pre>
+<p>We wrap it using:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>_lib.foo_func.restype = None #doctest: +SKIP _lib.foo_func.argtypes = [array_1d_double, c_int] #doctest: +SKIP</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Then, we’re ready to call <code>foo_func</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>out = np.empty(15, dtype=np.double) _lib.foo_func(out, len(out)) #doctest: +SKIP</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2284">view source</a></div></div><div class="public anchor" id="var-cumprod"><h3>cumprod</h3><div class="usage"><code>(cumprod &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cumulative product of elements along a given axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. axis : int, optional  Axis along which the cumulative product is computed. By default  the input is flattened. dtype : dtype, optional  Type of the returned array, as well as of the accumulator in which  the elements are multiplied. If <em>dtype</em> is not specified, it  defaults to the dtype of <code>a</code>, unless <code>a</code> has an integer dtype with  a precision less than that of the default platform integer. In  that case, the default platform integer is used instead. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output  but the type of the resulting values will be cast if necessary.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>cumprod : ndarray  A new array holding the result is returned unless <code>out</code> is  specified, in which case a reference to out is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ufuncs-output-type</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Arithmetic is modular when using integer types, and no error is raised on overflow.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1,2,3]) np.cumprod(a) # intermediate results 1, 1*2 … # total product 1*2*3 = 6 array([1, 2, 6]) a = np.array(<a href="null">1, 2, 3], [4, 5, 6</a>) np.cumprod(a, dtype=float) # specify type of output array([ 1., 2., 6., 24., 120., 720.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The cumulative product for each column (i.e., over the rows) of <code>a</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.cumprod(a, axis=0) array(<a href="null"> 1,  2,  3],
+       [ 4, 10, 18</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The cumulative product for each row (i.e. over the columns) of <code>a</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.cumprod(a,axis=1) array(<a href="null">  1,   2,   6],
+       [  4,  20, 120</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8261">view source</a></div></div><div class="public anchor" id="var-cumproduct"><h3>cumproduct</h3><div class="usage"><code>(cumproduct &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cumulative product over the given axis.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>cumprod : equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24062">view source</a></div></div><div class="public anchor" id="var-cumsum"><h3>cumsum</h3><div class="usage"><code>(cumsum &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cumulative sum of the elements along a given axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. axis : int, optional  Axis along which the cumulative sum is computed. The default  (None) is to compute the cumsum over the flattened array. dtype : dtype, optional  Type of the returned array and of the accumulator in which the  elements are summed. If <code>dtype</code> is not specified, it defaults  to the dtype of <code>a</code>, unless <code>a</code> has an integer dtype with a  precision less than that of the default platform integer. In  that case, the default platform integer is used. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output  but the type will be cast if necessary. See <code>ufuncs-output-type</code> for  more details.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>cumsum_along_axis : ndarray.  A new array holding the result is returned unless <code>out</code> is  specified, in which case a reference to <code>out</code> is returned. The  result has the same size as <code>a</code>, and the same shape as <code>a</code> if  <code>axis</code> is not None or <code>a</code> is a 1-d array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>sum : Sum array elements.</p>
+<p>trapz : Integration of array values using the composite trapezoidal rule.</p>
+<p>diff : Calculate the n-th discrete difference along given axis.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Arithmetic is modular when using integer types, and no error is raised on overflow.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1,2,3], [4,5,6</a>) a array(<a href="null">1, 2, 3],
+       [4, 5, 6</a>) np.cumsum(a) array([ 1, 3, 6, 10, 15, 21]) np.cumsum(a, dtype=float) # specifies type of output value(s) array([ 1., 3., 6., 10., 15., 21.])</p>
+      <p>np.cumsum(a,axis=0) # sum over rows for each of the 3 columns array(<a href="null">1, 2, 3],
+       [5, 7, 9</a>) np.cumsum(a,axis=1) # sum over columns for each of the 2 rows array(<a href="null"> 1,  3,  6],
+       [ 4,  9, 15</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25171">view source</a></div></div><div class="public anchor" id="var-DataSource"><h3>DataSource</h3><div class="usage"><code>(DataSource self &amp; [{destpath :destpath}])</code><code>(DataSource self)</code></div><div class="doc"><div class="markdown"><p>DataSource(destpath=‘.’)</p>
+<p>A generic data source file (file, http, ftp, …).</p>
+<p>DataSources can be local files or remote files/URLs. The files may also be compressed or uncompressed. DataSource hides some of the low-level details of downloading the file, allowing you to simply pass in a valid file path (or URL) and obtain a file object.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>destpath : str or None, optional  Path to the directory where the source file gets downloaded to for  use. If <code>destpath</code> is None, a temporary directory will be created.  The default path is the current directory.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>URLs require a scheme string (<code>http://</code>) to be used, without it they will fail::</p>
+<pre><code>&gt;&gt;&gt; repos = np.DataSource()
+&gt;&gt;&gt; repos.exists('www.google.com/index.html')
+False
+&gt;&gt;&gt; repos.exists('http://www.google.com/index.html')
+True
+</code></pre>
+<p>Temporary directories are deleted when the DataSource is deleted.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>::</p>
+<pre><code>&gt;&gt;&gt; ds = np.DataSource('/home/guido')
+&gt;&gt;&gt; urlname = 'http://www.google.com/'
+&gt;&gt;&gt; gfile = ds.open('http://www.google.com/')
+&gt;&gt;&gt; ds.abspath(urlname)
+'/home/guido/www.google.com/index.html'
+
+&gt;&gt;&gt; ds = np.DataSource(None)  # use with temporary file
+&gt;&gt;&gt; ds.open('/home/guido/foobar.txt')
+&lt;open file '/home/guido.foobar.txt', mode 'r' at 0x91d4430&gt;
+&gt;&gt;&gt; ds.abspath('/home/guido/foobar.txt')
+'/tmp/.../home/guido/foobar.txt'
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19364">view source</a></div></div><div class="public anchor" id="var-datetime64"><h3>datetime64</h3><div class="usage"><code>(datetime64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28719">view source</a></div></div><div class="public anchor" id="var-datetime_as_string"><h3>datetime_as_string</h3><div class="usage"><code>(datetime_as_string &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>datetime_as_string(arr, unit=None, timezone=‘naive’, casting=‘same_kind’)</p>
+<p>Convert an array of datetimes into an array of strings.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr : array_like of datetime64  The array of UTC timestamps to format. unit : str  One of None, ‘auto’, or a :ref:<code>datetime unit &lt;arrays.dtypes.dateunits&gt;</code>. timezone : {‘naive’, ‘UTC’, ‘local’} or tzinfo  Timezone information to use when displaying the datetime. If ‘UTC’, end  with a Z to indicate UTC time. If ‘local’, convert to the local timezone  first, and suffix with a +-#### timezone offset. If a tzinfo object,  then do as with ‘local’, but use the specified timezone. casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}  Casting to allow when changing between datetime units.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>str_arr : ndarray  An array of strings the same shape as <code>arr</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import pytz d = np.arange(‘2002-10-27T04:30’, 4*60, 60, dtype=‘M8[m]’) d array([‘2002-10-27T04:30’, ‘2002-10-27T05:30’, ‘2002-10-27T06:30’,  ‘2002-10-27T07:30’], dtype=‘datetime64[m]’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Setting the timezone to UTC shows the same information, but with a Z suffix</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.datetime_as_string(d, timezone=‘UTC’) array([‘2002-10-27T04:30Z’, ‘2002-10-27T05:30Z’, ‘2002-10-27T06:30Z’,  ‘2002-10-27T07:30Z’], dtype=‘&lt;U35’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that we picked datetimes that cross a DST boundary. Passing in a <code>pytz</code> timezone object will print the appropriate offset</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.datetime_as_string(d, timezone=pytz.timezone(‘US/Eastern’)) array([‘2002-10-27T00:30-0400’, ‘2002-10-27T01:30-0400’,  ‘2002-10-27T01:30-0500’, ‘2002-10-27T02:30-0500’], dtype=‘&lt;U39’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Passing in a unit will change the precision</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.datetime_as_string(d, unit=‘h’) array([‘2002-10-27T04’, ‘2002-10-27T05’, ‘2002-10-27T06’, ‘2002-10-27T07’],  dtype=‘&lt;U32’) np.datetime_as_string(d, unit=‘s’) array([‘2002-10-27T04:30:00’, ‘2002-10-27T05:30:00’, ‘2002-10-27T06:30:00’,  ‘2002-10-27T07:30:00’], dtype=‘&lt;U38’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>‘casting’ can be used to specify whether precision can be changed</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.datetime_as_string(d, unit=‘h’, casting=‘safe’) Traceback (most recent call last):  … TypeError: Cannot create a datetime string as units ‘h’ from a NumPy datetime with units ‘m’ according to the rule ‘safe’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12403">view source</a></div></div><div class="public anchor" id="var-datetime_data"><h3>datetime_data</h3><div class="usage"><code>(datetime_data self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>datetime_data(dtype, /)</p>
+<p>Get information about the step size of a date or time type.</p>
+<p>The returned tuple can be passed as the second argument of <code>numpy.datetime64</code> and <code>numpy.timedelta64</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>dtype : dtype  The dtype object, which must be a <code>datetime64</code> or <code>timedelta64</code> type.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>unit : str  The :ref:<code>datetime unit &lt;arrays.dtypes.dateunits&gt;</code> on which this dtype  is based. count : int  The number of base units in a step.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>dt_25s = np.dtype(‘timedelta64[25s]’) np.datetime_data(dt_25s) (‘s’, 25) np.array(10, dt_25s).astype(‘timedelta64[s]’) array(250, dtype=‘timedelta64[s]’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The result can be used to construct a datetime that uses the same units as a timedelta</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.datetime64(‘2010’, np.datetime_data(dt_25s)) numpy.datetime64(‘2010-01-01T00:00:00’,‘25s’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12467">view source</a></div></div><div class="public anchor" id="var-deg2rad"><h3>deg2rad</h3><div class="usage"><code>(deg2rad self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>deg2rad(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Convert angles from degrees to radians.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Angles in degrees. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The corresponding angle in radians.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>rad2deg : Convert angles from radians to degrees. unwrap : Remove large jumps in angle by wrapping.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.3.0</p>
+<p><code>deg2rad(x)</code> is <code>x * pi / 180</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.deg2rad(180) 3.1415926535897931</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28917">view source</a></div></div><div class="public anchor" id="var-degrees"><h3>degrees</h3><div class="usage"><code>(degrees self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>degrees(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Convert angles from radians to degrees.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array in radians. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray of floats  The corresponding degree values; if <code>out</code> was supplied this is a  reference to it.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>rad2deg : equivalent function</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Convert a radian array to degrees</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>rad = np.arange(12.)*np.pi/6 np.degrees(rad) array([ 0., 30., 60., 90., 120., 150., 180., 210., 240.,  270., 300., 330.])</p>
+      <p>out = np.zeros((rad.shape)) r = np.degrees(rad, out) np.all(r == out) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10964">view source</a></div></div><div class="public anchor" id="var-delete"><h3>delete</h3><div class="usage"><code>(delete &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a new array with sub-arrays along an axis deleted. For a one dimensional array, this returns those entries not returned by <code>arr[obj]</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr : array_like  Input array. obj : slice, int or array of ints  Indicate indices of sub-arrays to remove along the specified axis. axis : int, optional  The axis along which to delete the subarray defined by <code>obj</code>.  If <code>axis</code> is None, <code>obj</code> is applied to the flattened array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  A copy of <code>arr</code> with the elements specified by <code>obj</code> removed. Note  that <code>delete</code> does not occur in-place. If <code>axis</code> is None, <code>out</code> is  a flattened array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>insert : Insert elements into an array. append : Append elements at the end of an array.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Often it is preferable to use a boolean mask. For example:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>arr = np.arange(12) + 1 mask = np.ones(len(arr), dtype=bool) mask<a href="null">0,2,4</a> = False result = arr[mask,…]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Is equivalent to <code>np.delete(arr, [0,2,4], axis=0)</code>, but allows further use of <code>mask</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>arr = np.array(<a href="null">1,2,3,4], [5,6,7,8], [9,10,11,12</a>) arr array(<a href="null"> 1,  2,  3,  4],
+       [ 5,  6,  7,  8],
+       [ 9, 10, 11, 12</a>) np.delete(arr, 1, 0) array(<a href="null"> 1,  2,  3,  4],
+       [ 9, 10, 11, 12</a>)</p>
+      <p>np.delete(arr, np.s_[::2], 1) array(<a href="null"> 2,  4],
+       [ 6,  8],
+       [10, 12</a>) np.delete(arr, [1,3,5], None) array([ 1, 3, 5, 7, 8, 9, 10, 11, 12])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5708">view source</a></div></div><div class="public anchor" id="var-deprecate"><h3>deprecate</h3><div class="usage"><code>(deprecate &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Issues a DeprecationWarning, adds warning to <code>old_name</code>’s docstring, rebinds <code>old_name.__name__</code> and returns the new function object.</p>
+<p>This function may also be used as a decorator.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>func : function  The function to be deprecated. old_name : str, optional  The name of the function to be deprecated. Default is None, in  which case the name of <code>func</code> is used. new_name : str, optional  The new name for the function. Default is None, in which case the  deprecation message is that <code>old_name</code> is deprecated. If given, the  deprecation message is that <code>old_name</code> is deprecated and <code>new_name</code>  should be used instead. message : str, optional  Additional explanation of the deprecation. Displayed in the  docstring after the warning.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>old_func : function  The deprecated function.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Note that <code>olduint</code> returns a value after printing Deprecation Warning:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>olduint = np.deprecate(np.uint) DeprecationWarning: <code>uint64</code> is deprecated! # may vary olduint(6) 6</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2741">view source</a></div></div><div class="public anchor" id="var-deprecate_with_doc"><h3>deprecate_with_doc</h3><div class="usage"><code>(deprecate_with_doc msg)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6315">view source</a></div></div><div class="public anchor" id="var-diag"><h3>diag</h3><div class="usage"><code>(diag &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Extract a diagonal or construct a diagonal array.</p>
+<p>See the more detailed documentation for <code>numpy.diagonal</code> if you use this function to extract a diagonal and wish to write to the resulting array; whether it returns a copy or a view depends on what version of numpy you are using.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>v : array_like  If <code>v</code> is a 2-D array, return a copy of its <code>k</code>-th diagonal.  If <code>v</code> is a 1-D array, return a 2-D array with <code>v</code> on the <code>k</code>-th  diagonal. k : int, optional  Diagonal in question. The default is 0. Use <code>k&gt;0</code> for diagonals  above the main diagonal, and <code>k&lt;0</code> for diagonals below the main  diagonal.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  The extracted diagonal or constructed diagonal array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>diagonal : Return specified diagonals. diagflat : Create a 2-D array with the flattened input as a diagonal. trace : Sum along diagonals. triu : Upper triangle of an array. tril : Lower triangle of an array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(9).reshape((3,3)) x array(<a href="null">0, 1, 2],
+       [3, 4, 5],
+       [6, 7, 8</a>)</p>
+      <p>np.diag(x) array([0, 4, 8]) np.diag(x, k=1) array([1, 5]) np.diag(x, k=-1) array([3, 7])</p>
+      <p>np.diag(np.diag(x)) array(<a href="null">0, 0, 0],
+       [0, 4, 0],
+       [0, 0, 8</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L979">view source</a></div></div><div class="public anchor" id="var-diag_indices"><h3>diag_indices</h3><div class="usage"><code>(diag_indices n &amp; [{ndim :ndim}])</code><code>(diag_indices n)</code></div><div class="doc"><div class="markdown"><p>Return the indices to access the main diagonal of an array.</p>
+<p>This returns a tuple of indices that can be used to access the main diagonal of an array <code>a</code> with <code>a.ndim &gt;= 2</code> dimensions and shape (n, n, …, n). For <code>a.ndim = 2</code> this is the usual diagonal, for <code>a.ndim &gt; 2</code> this is the set of indices to access <code>a[i, i, ..., i]</code> for <code>i = [0..n-1]</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>n : int  The size, along each dimension, of the arrays for which the returned  indices can be used.</p>
+<p>ndim : int, optional  The number of dimensions.</p>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>diag_indices_from</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.4.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Create a set of indices to access the diagonal of a (4, 4) array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>di = np.diag_indices(4) di (array([0, 1, 2, 3]), array([0, 1, 2, 3])) a = np.arange(16).reshape(4, 4) a array(<a href="null"> 0,  1,  2,  3],
+       [ 4,  5,  6,  7],
+       [ 8,  9, 10, 11],
+       [12, 13, 14, 15</a>) a[di] = 100 a array(<a href="null">100,   1,   2,   3],
+       [  4, 100,   6,   7],
+       [  8,   9, 100,  11],
+       [ 12,  13,  14, 100</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Now, we create indices to manipulate a 3-D array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>d3 = np.diag_indices(2, 3) d3 (array([0, 1]), array([0, 1]), array([0, 1]))</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>And use it to set the diagonal of an array of zeros to 1:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.zeros((2, 2, 2), dtype=int) a[d3] = 1 a array(<a href="null">[1, 0],
+        [0, 0</a>,  <a href="null">0, 0],
+        [0, 1</a>])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24280">view source</a></div></div><div class="public anchor" id="var-diag_indices_from"><h3>diag_indices_from</h3><div class="usage"><code>(diag_indices_from &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices to access the main diagonal of an n-dimensional array.</p>
+<p>See <code>diag_indices</code> for full details.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr : array, at least 2-D</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>diag_indices</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.4.0</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13203">view source</a></div></div><div class="public anchor" id="var-diagflat"><h3>diagflat</h3><div class="usage"><code>(diagflat &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create a two-dimensional array with the flattened input as a diagonal.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>v : array_like  Input data, which is flattened and set as the <code>k</code>-th  diagonal of the output. k : int, optional  Diagonal to set; 0, the default, corresponds to the “main” diagonal,  a positive (negative) <code>k</code> giving the number of the diagonal above  (below) the main.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  The 2-D output array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>diag : MATLAB work-alike for 1-D and 2-D arrays. diagonal : Return specified diagonals. trace : Sum along diagonals.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.diagflat(<a href="null">1,2], [3,4</a>) array(<a href="null">1, 0, 0, 0],
+       [0, 2, 0, 0],
+       [0, 0, 3, 0],
+       [0, 0, 0, 4</a>)</p>
+      <p>np.diagflat([1,2], 1) array(<a href="null">0, 1, 0],
+       [0, 0, 2],
+       [0, 0, 0</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25645">view source</a></div></div><div class="public anchor" id="var-diagonal"><h3>diagonal</h3><div class="usage"><code>(diagonal &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return specified diagonals.</p>
+<p>If <code>a</code> is 2-D, returns the diagonal of <code>a</code> with the given offset, i.e., the collection of elements of the form <code>a[i, i+offset]</code>. If <code>a</code> has more than two dimensions, then the axes specified by <code>axis1</code> and <code>axis2</code> are used to determine the 2-D sub-array whose diagonal is returned. The shape of the resulting array can be determined by removing <code>axis1</code> and <code>axis2</code> and appending an index to the right equal to the size of the resulting diagonals.</p>
+<p>In versions of NumPy prior to 1.7, this function always returned a new, independent array containing a copy of the values in the diagonal.</p>
+<p>In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal, but depending on this fact is deprecated. Writing to the resulting array continues to work as it used to, but a FutureWarning is issued.</p>
+<p>Starting in NumPy 1.9 it returns a read-only view on the original array. Attempting to write to the resulting array will produce an error.</p>
+<p>In some future release, it will return a read/write view and writing to the returned array will alter your original array. The returned array will have the same type as the input array.</p>
+<p>If you don’t write to the array returned by this function, then you can just ignore all of the above.</p>
+<p>If you depend on the current behavior, then we suggest copying the returned array explicitly, i.e., use <code>np.diagonal(a).copy()</code> instead of just <code>np.diagonal(a)</code>. This will work with both past and future versions of NumPy.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array from which the diagonals are taken. offset : int, optional  Offset of the diagonal from the main diagonal. Can be positive or  negative. Defaults to main diagonal (0). axis1 : int, optional  Axis to be used as the first axis of the 2-D sub-arrays from which  the diagonals should be taken. Defaults to first axis (0). axis2 : int, optional  Axis to be used as the second axis of the 2-D sub-arrays from  which the diagonals should be taken. Defaults to second axis (1).</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>array_of_diagonals : ndarray  If <code>a</code> is 2-D, then a 1-D array containing the diagonal and of the  same type as <code>a</code> is returned unless <code>a</code> is a <code>matrix</code>, in which case  a 1-D array rather than a (2-D) <code>matrix</code> is returned in order to  maintain backward compatibility.</p>
+<pre><code>If ``a.ndim &gt; 2``, then the dimensions specified by `axis1` and `axis2`
+are removed, and a new axis inserted at the end corresponding to the
+diagonal.
+</code></pre>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If the dimension of <code>a</code> is less than 2.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>diag : MATLAB work-a-like for 1-D and 2-D arrays. diagflat : Create diagonal arrays. trace : Sum along diagonals.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(4).reshape(2,2) a array(<a href="null">0, 1],
+       [2, 3</a>) a.diagonal() array([0, 3]) a.diagonal(1) array([1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>A 3-D example:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(8).reshape(2,2,2); a array(<a href="null">[0, 1],
+        [2, 3</a>,  <a href="null">4, 5],
+        [6, 7</a>]) a.diagonal(0, # Main diagonals of two arrays created by skipping … 0, # across the outer(left)-most axis last and … 1) # the “middle” (row) axis first. array(<a href="null">0, 6],
+       [1, 7</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The sub-arrays whose main diagonals we just obtained; note that each corresponds to fixing the right-most (column) axis, and that the diagonals are “packed” in rows.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a[:,:,0] # main diagonal is [0 6] array(<a href="null">0, 2],
+       [4, 6</a>) a[:,:,1] # main diagonal is [1 7] array(<a href="null">1, 3],
+       [5, 7</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The anti-diagonal can be obtained by reversing the order of elements using either <code>numpy.flipud</code> or <code>numpy.fliplr</code>.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(9).reshape(3, 3) a array(<a href="null">0, 1, 2],
+       [3, 4, 5],
+       [6, 7, 8</a>) np.fliplr(a).diagonal() # Horizontal flip array([2, 4, 6]) np.flipud(a).diagonal() # Vertical flip array([6, 4, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that the order in which the diagonal is retrieved varies depending on the flip function.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9790">view source</a></div></div><div class="public anchor" id="var-diff"><h3>diff</h3><div class="usage"><code>(diff &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Calculate the n-th discrete difference along the given axis.</p>
+<p>The first difference is given by <code>out[i] = a[i+1] - a[i]</code> along the given axis, higher differences are calculated by using <code>diff</code> recursively.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array n : int, optional  The number of times values are differenced. If zero, the input  is returned as-is. axis : int, optional  The axis along which the difference is taken, default is the  last axis. prepend, append : array_like, optional  Values to prepend or append to <code>a</code> along axis prior to  performing the difference. Scalar values are expanded to  arrays with length 1 in the direction of axis and the shape  of the input array in along all other axes. Otherwise the  dimension and shape must match <code>a</code> except along axis.</p>
+<pre><code>.. versionadded:: 1.16.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>diff : ndarray  The n-th differences. The shape of the output is the same as <code>a</code>  except along <code>axis</code> where the dimension is smaller by <code>n</code>. The  type of the output is the same as the type of the difference  between any two elements of <code>a</code>. This is the same as the type of  <code>a</code> in most cases. A notable exception is <code>datetime64</code>, which  results in a <code>timedelta64</code> output array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>gradient, ediff1d, cumsum</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Type is preserved for boolean arrays, so the result will contain <code>False</code> when consecutive elements are the same and <code>True</code> when they differ.</p>
+<p>For unsigned integer arrays, the results will also be unsigned. This should not be surprising, as the result is consistent with calculating the difference directly:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>u8_arr = np.array([1, 0], dtype=np.uint8) np.diff(u8_arr) array([255], dtype=uint8) u8_arr[1,…] - u8_arr[0,…] 255</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>If this is not desirable, then the array should be cast to a larger integer type first:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>i16_arr = u8_arr.astype(np.int16) np.diff(i16_arr) array([-1], dtype=int16)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([1, 2, 4, 7, 0]) np.diff(x) array([ 1, 2, 3, -7]) np.diff(x, n=2) array([ 1, 1, -10])</p>
+      <p>x = np.array(<a href="null">1, 3, 6, 10], [0, 5, 6, 8</a>) np.diff(x) array(<a href="null">2, 3, 4],
+       [5, 1, 2</a>) np.diff(x, axis=0) array(<a href="null">-1,  2,  0, -2</a>)</p>
+      <p>x = np.arange(‘1066-10-13’, ‘1066-10-16’, dtype=np.datetime64) np.diff(x) array([1, 1], dtype=‘timedelta64[D]’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11016">view source</a></div></div><div class="public anchor" id="var-digitize"><h3>digitize</h3><div class="usage"><code>(digitize &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices of the bins to which each value in input array belongs.</p>
+<p>========= ============= ============================ <code>right</code> order of bins returned index <code>i</code> satisfies ========= ============= ============================ <code>False</code> increasing <code>bins[i-1] &lt;= x &lt; bins[i]</code> <code>True</code> increasing <code>bins[i-1] &lt; x &lt;= bins[i]</code> <code>False</code> decreasing <code>bins[i-1] &gt; x &gt;= bins[i]</code> <code>True</code> decreasing <code>bins[i-1] &gt;= x &gt; bins[i]</code> ========= ============= ============================</p>
+<p>If values in <code>x</code> are beyond the bounds of <code>bins</code>, 0 or <code>len(bins)</code> is returned as appropriate.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array to be binned. Prior to NumPy 1.10.0, this array had to  be 1-dimensional, but can now have any shape. bins : array_like  Array of bins. It has to be 1-dimensional and monotonic. right : bool, optional  Indicating whether the intervals include the right or the left bin  edge. Default behavior is (right==False) indicating that the interval  does not include the right edge. The left bin end is open in this  case, i.e., bins[i-1] &lt;= x &lt; bins[i] is the default behavior for  monotonically increasing bins.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>indices : ndarray of ints  Output array of indices, of same shape as <code>x</code>.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If <code>bins</code> is not monotonic. TypeError  If the type of the input is complex.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>bincount, histogram, unique, searchsorted</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If values in <code>x</code> are such that they fall outside the bin range, attempting to index <code>bins</code> with the indices that <code>digitize</code> returns will result in an IndexError.</p>
+<p>.. versionadded:: 1.10.0</p>
+<p><code>np.digitize</code> is implemented in terms of <code>np.searchsorted</code>. This means that a binary search is used to bin the values, which scales much better for larger number of bins than the previous linear search. It also removes the requirement for the input array to be 1-dimensional.</p>
+<p>For monotonically <em>increasing</em> <code>bins</code>, the following are equivalent::</p>
+<pre><code>np.digitize(x, bins, right=True)
+np.searchsorted(bins, x, side='left')
+</code></pre>
+<p>Note that as the order of the arguments are reversed, the side must be too. The <code>searchsorted</code> call is marginally faster, as it does not do any monotonicity checks. Perhaps more importantly, it supports all dtypes.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([0.2, 6.4, 3.0, 1.6]) bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0]) inds = np.digitize(x, bins) inds array([1, 4, 3, 2]) for n in range(x.size): … print(bins[inds[n]-1], “&lt;=”, x[n], “&lt;”, bins[inds[n]]) … 0.0 &lt;= 0.2 &lt; 1.0 4.0 &lt;= 6.4 &lt; 10.0 2.5 &lt;= 3.0 &lt; 4.0 1.0 &lt;= 1.6 &lt; 2.5</p>
+      <p>x = np.array([1.2, 10.0, 12.4, 15.5, 20.]) bins = np.array([0, 5, 10, 15, 20]) np.digitize(x,bins,right=True) array([1, 2, 3, 4, 4]) np.digitize(x,bins,right=False) array([1, 3, 3, 4, 5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1130">view source</a></div></div><div class="public anchor" id="var-disp"><h3>disp</h3><div class="usage"><code>(disp mesg &amp; [{device :device, linefeed :linefeed}])</code><code>(disp mesg &amp; [{device :device}])</code><code>(disp mesg)</code></div><div class="doc"><div class="markdown"><p>Display a message on a device.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>mesg : str  Message to display. device : object  Device to write message. If None, defaults to <code>sys.stdout</code> which is  very similar to <code>print</code>. <code>device</code> needs to have <code>write()</code> and  <code>flush()</code> methods. linefeed : bool, optional  Option whether to print a line feed or not. Defaults to True.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>AttributeError  If <code>device</code> does not have a <code>write()</code> or <code>flush()</code> method.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Besides <code>sys.stdout</code>, a file-like object can also be used as it has both required methods:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from io import StringIO buf = StringIO() np.disp(u’“Display” in a file’, device=buf) buf.getvalue() ‘“Display” in a file\n’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14279">view source</a></div></div><div class="public anchor" id="var-divide"><h3>divide</h3><div class="usage"><code>(divide self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>true_divide(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Returns a true division of the inputs, element-wise.</p>
+<p>Instead of the Python traditional ‘floor division’, this returns a true division. True division adjusts the output type to present the best answer, regardless of input types.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  Dividend array. x2 : array_like  Divisor array. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The floor division operator <code>//</code> was added in Python 2.2 making <code>//</code> and <code>/</code> equivalent operators. The default floor division operation of <code>/</code> can be replaced by true division with <code>from
+__future__ import division</code>.</p>
+<p>In Python 3.0, <code>//</code> is the floor division operator and <code>/</code> the true division operator. The <code>true_divide(x1, x2)</code> function is equivalent to true division in Python.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(5) np.true_divide(x, 4) array([ 0. , 0.25, 0.5 , 0.75, 1. ])</p>
+      <p>x//4 array([0, 0, 0, 0, 1])</p>
+      <p>from <strong>future</strong> import division x/4 array([ 0. , 0.25, 0.5 , 0.75, 1. ]) x//4 array([0, 0, 0, 0, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21713">view source</a></div></div><div class="public anchor" id="var-division"><h3>division</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13397">view source</a></div></div><div class="public anchor" id="var-divmod"><h3>divmod</h3><div class="usage"><code>(divmod self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return element-wise quotient and remainder simultaneously.</p>
+<p>.. versionadded:: 1.13.0</p>
+<p><code>np.divmod(x, y)</code> is equivalent to <code>(x // y, x % y)</code>, but faster because it avoids redundant work. It is used to implement the Python built-in function <code>divmod</code> on NumPy arrays.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  Dividend array. x2 : array_like  Divisor array. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out1 : ndarray  Element-wise quotient resulting from floor division.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars. out2 : ndarray  Element-wise remainder from floor division.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>floor_divide : Equivalent to Python’s <code>//</code> operator. remainder : Equivalent to Python’s <code>%</code> operator. modf : Equivalent to <code>divmod(x, 1)</code> for positive <code>x</code> with the return  values switched.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.divmod(np.arange(5), 3) (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13147">view source</a></div></div><div class="public anchor" id="var-dot"><h3>dot</h3><div class="usage"><code>(dot &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>dot(a, b, out=None)</p>
+<p>Dot product of two arrays. Specifically,</p>
+<ul>
+  <li>
+  <p>If both <code>a</code> and <code>b</code> are 1-D arrays, it is inner product of vectors  (without complex conjugation).</p></li>
+  <li>
+  <p>If both <code>a</code> and <code>b</code> are 2-D arrays, it is matrix multiplication,  but using :func:<code>matmul</code> or <code>a @ b</code> is preferred.</p></li>
+  <li>
+  <p>If either <code>a</code> or <code>b</code> is 0-D (scalar), it is equivalent to :func:<code>multiply</code>  and using <code>numpy.multiply(a, b)</code> or <code>a * b</code> is preferred.</p></li>
+  <li>
+  <p>If <code>a</code> is an N-D array and <code>b</code> is a 1-D array, it is a sum product over  the last axis of <code>a</code> and <code>b</code>.</p></li>
+  <li>
+    <p>If <code>a</code> is an N-D array and <code>b</code> is an M-D array (where <code>M&gt;=2</code>), it is a  sum product over the last axis of <code>a</code> and the second-to-last axis of <code>b</code>::</p>
+    <p>dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])</p>
+  </li>
+</ul>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  First argument. b : array_like  Second argument. out : ndarray, optional  Output argument. This must have the exact kind that would be returned  if it was not used. In particular, it must have the right type, must be  C-contiguous, and its dtype must be the dtype that would be returned  for <code>dot(a,b)</code>. This is a performance feature. Therefore, if these  conditions are not met, an exception is raised, instead of attempting  to be flexible.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>output : ndarray  Returns the dot product of <code>a</code> and <code>b</code>. If <code>a</code> and <code>b</code> are both  scalars or both 1-D arrays then a scalar is returned; otherwise  an array is returned.  If <code>out</code> is given, then it is returned.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If the last dimension of <code>a</code> is not the same size as  the second-to-last dimension of <code>b</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>vdot : Complex-conjugating dot product. tensordot : Sum products over arbitrary axes. einsum : Einstein summation convention. matmul : ‘@’ operator as method with out parameter.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dot(3, 4) 12</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Neither argument is complex-conjugated:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dot([2j, 3j], [2j, 3j]) (-13+0j)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>For 2-D arrays it is the matrix product:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = <a href="null">1, 0], [0, 1</a> b = <a href="null">4, 1], [2, 2</a> np.dot(a, b) array(<a href="null">4, 1],
+       [2, 2</a>)</p>
+      <p>a = np.arange(3*4*5*6).reshape((3,4,5,6)) b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3)) np.dot(a, b)[2,3,2,1,2,2] 499128 sum(a[2,3,2,:] * b[1,2,:,2]) 499128</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7733">view source</a></div></div><div class="public anchor" id="var-double"><h3>double</h3><div class="usage"><code>(double self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Double-precision floating-point number type, compatible with Python <code>float</code> and C <code>double</code>. Character code: <code>'d'</code>. Canonical name: <code>np.double</code>. Alias: <code>np.float_</code>. Alias <em>on this platform</em>: <code>np.float64</code>: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21204">view source</a></div></div><div class="public anchor" id="var-dsplit"><h3>dsplit</h3><div class="usage"><code>(dsplit &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Split array into multiple sub-arrays along the 3rd axis (depth).</p>
+<p>Please refer to the <code>split</code> documentation. <code>dsplit</code> is equivalent to <code>split</code> with <code>axis=2</code>, the array is always split along the third axis provided the array dimension is greater than or equal to 3.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>split : Split an array into multiple sub-arrays of equal size.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(16.0).reshape(2, 2, 4) x array(<a href="null">[ 0.,   1.,   2.,   3.],
+        [ 4.,   5.,   6.,   7.</a>,  <a href="null"> 8.,   9.,  10.,  11.],
+        [12.,  13.,  14.,  15.</a>]) np.dsplit(x, 2) [array([[[ 0., 1.],  [ 4., 5.]],  [[ 8., 9.],  [12., 13.]]]), array([[[ 2., 3.],  [ 6., 7.]],  [[10., 11.],  [14., 15.]]])] np.dsplit(x, np.array([3, 6])) [array([[[ 0., 1., 2.],  [ 4., 5., 6.]],  [[ 8., 9., 10.],  [12., 13., 14.]]]),  array([[[ 3.],  [ 7.]],  [[11.],  [15.]]]), array([], shape=(2, 2, 0), dtype=float64)]</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24545">view source</a></div></div><div class="public anchor" id="var-dstack"><h3>dstack</h3><div class="usage"><code>(dstack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Stack arrays in sequence depth wise (along third axis).</p>
+<p>This is equivalent to concatenation along the third axis after 2-D arrays of shape <code>(M,N)</code> have been reshaped to <code>(M,N,1)</code> and 1-D arrays of shape <code>(N,)</code> have been reshaped to <code>(1,N,1)</code>. Rebuilds arrays divided by <code>dsplit</code>.</p>
+<p>This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions <code>concatenate</code>, <code>stack</code> and <code>block</code> provide more general stacking and concatenation operations.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>tup : sequence of arrays  The arrays must have the same shape along all but the third axis.  1-D or 2-D arrays must have the same shape.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>stacked : ndarray  The array formed by stacking the given arrays, will be at least 3-D.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>stack : Join a sequence of arrays along a new axis. vstack : Stack along first axis. hstack : Stack along second axis. concatenate : Join a sequence of arrays along an existing axis. dsplit : Split array along third axis.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array((1,2,3)) b = np.array((2,3,4)) np.dstack((a,b)) array(<a href="null">[1, 2],
+        [2, 3],
+        [3, 4</a>])</p>
+      <p>a = np.array(<a href="null">1],[2],[3</a>) b = np.array(<a href="null">2],[3],[4</a>) np.dstack((a,b)) array(<a href="null">[1, 2</a>,  <a href="null">2, 3</a>,  <a href="null">3, 4</a>])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22018">view source</a></div></div><div class="public anchor" id="var-dtype"><h3>dtype</h3><div class="usage"><code>(dtype self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>dtype(obj, align=False, copy=False)</p>
+<p>Create a data type object.</p>
+<p>A numpy array is homogeneous, and contains elements described by a dtype object. A dtype object can be constructed from different combinations of fundamental numeric types.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>obj  Object to be converted to a data type object. align : bool, optional  Add padding to the fields to match what a C compiler would output  for a similar C-struct. Can be <code>True</code> only if <code>obj</code> is a dictionary  or a comma-separated string. If a struct dtype is being created,  this also sets a sticky alignment flag <code>isalignedstruct</code>. copy : bool, optional  Make a new copy of the data-type object. If <code>False</code>, the result  may just be a reference to a built-in data-type object.</p>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>result_type</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Using array-scalar type:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dtype(np.int16) dtype(‘int16’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Structured type, one field name ‘f1’, containing int16:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dtype([(‘f1’, np.int16)]) dtype([(‘f1’, ‘&lt;i2’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Structured type, one field named ‘f1’, in itself containing a structured type with one field:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dtype([(‘f1’, [(‘f1’, np.int16)])]) dtype([(‘f1’, [(‘f1’, ‘&lt;i2’)])])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Structured type, two fields: the first field contains an unsigned int, the second an int32:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dtype([(‘f1’, np.uint64), (‘f2’, np.int32)]) dtype([(‘f1’, ‘&lt;u8’), (‘f2’, ‘&lt;i4’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using array-protocol type strings:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dtype([(‘a’,‘f8’),(‘b’,‘S10’)]) dtype([(‘a’, ‘&lt;f8’), (‘b’, ‘S10’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using comma-separated field formats. The shape is (2,3):</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dtype(“i4, (2,3)f8”) dtype([(‘f0’, ‘&lt;i4’), (‘f1’, ‘&lt;f8’, (2, 3))])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using tuples. <code>int</code> is a fixed type, 3 the field’s shape. <code>void</code> is a flexible type, here of size 10:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dtype([(‘hello’,(np.int64,3)),(‘world’,np.void,10)]) dtype([(‘hello’, ‘&lt;i8’, (3,)), (‘world’, ‘V10’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Subdivide <code>int16</code> into 2 <code>int8</code>’s, called x and y. 0 and 1 are the offsets in bytes:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dtype((np.int16, {‘x’:(np.int8,0), ‘y’:(np.int8,1)})) dtype((numpy.int16, [(‘x’, ‘i1’), (‘y’, ‘i1’)]))</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using dictionaries. Two fields named ‘gender’ and ‘age’:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dtype({‘names’:[‘gender’,‘age’], ‘formats’:[‘S1’,np.uint8]}) dtype([(‘gender’, ‘S1’), (‘age’, ‘u1’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Offsets in bytes, here 0 and 25:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.dtype({‘surname’:(‘S25’,0),‘age’:(np.uint8,25)}) dtype([(‘surname’, ‘S25’), (‘age’, ‘u1’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25417">view source</a></div></div><div class="public anchor" id="var-e"><h3>e</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4383">view source</a></div></div><div class="public anchor" id="var-ediff1d"><h3>ediff1d</h3><div class="usage"><code>(ediff1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>The differences between consecutive elements of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>ary : array_like  If necessary, will be flattened before the differences are taken. to_end : array_like, optional  Number(s) to append at the end of the returned differences. to_begin : array_like, optional  Number(s) to prepend at the beginning of the returned differences.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>ediff1d : ndarray  The differences. Loosely, this is <code>ary.flat[1:] - ary.flat[:-1]</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>diff, gradient</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>When applied to masked arrays, this function drops the mask information if the <code>to_begin</code> and/or <code>to_end</code> parameters are used.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([1, 2, 4, 7, 0]) np.ediff1d(x) array([ 1, 2, 3, -7])</p>
+      <p>np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99])) array([-99, 1, 2, …, -7, 88, 99])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The returned array is always 1D.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>y = <a href="null">1, 2, 4], [1, 6, 24</a> np.ediff1d(y) array([ 1, 2, -3, 5, 18])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5881">view source</a></div></div><div class="public anchor" id="var-einsum"><h3>einsum</h3><div class="usage"><code>(einsum &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>einsum(subscripts, *operands, out=None, dtype=None, order=‘K’,  casting=‘safe’, optimize=False)</p>
+<p>Evaluates the Einstein summation convention on the operands.</p>
+<p>Using the Einstein summation convention, many common multi-dimensional, linear algebraic array operations can be represented in a simple fashion. In <em>implicit</em> mode <code>einsum</code> computes these values.</p>
+<p>In <em>explicit</em> mode, <code>einsum</code> provides further flexibility to compute other array operations that might not be considered classical Einstein summation operations, by disabling, or forcing summation over specified subscript labels.</p>
+<p>See the notes and examples for clarification.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>subscripts : str  Specifies the subscripts for summation as comma separated list of  subscript labels. An implicit (classical Einstein summation)  calculation is performed unless the explicit indicator ‘-&gt;’ is  included as well as subscript labels of the precise output form. operands : list of array_like  These are the arrays for the operation. out : ndarray, optional  If provided, the calculation is done into this array. dtype : {data-type, None}, optional  If provided, forces the calculation to use the data type specified.  Note that you may have to also give a more liberal <code>casting</code>  parameter to allow the conversions. Default is None. order : {‘C’, ‘F’, ‘A’, ‘K’}, optional  Controls the memory layout of the output. ‘C’ means it should  be C contiguous. ‘F’ means it should be Fortran contiguous,  ‘A’ means it should be ‘F’ if the inputs are all ‘F’, ‘C’ otherwise.  ‘K’ means it should be as close to the layout as the inputs as  is possible, including arbitrarily permuted axes.  Default is ‘K’. casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional  Controls what kind of data casting may occur. Setting this to  ‘unsafe’ is not recommended, as it can adversely affect accumulations.</p>
+<pre><code>  * 'no' means the data types should not be cast at all.
+  * 'equiv' means only byte-order changes are allowed.
+  * 'safe' means only casts which can preserve values are allowed.
+  * 'same_kind' means only safe casts or casts within a kind,
+    like float64 to float32, are allowed.
+  * 'unsafe' means any data conversions may be done.
+
+Default is 'safe'.
+</code></pre>
+<p>optimize : {False, True, ‘greedy’, ‘optimal’}, optional  Controls if intermediate optimization should occur. No optimization  will occur if False and True will default to the ‘greedy’ algorithm.  Also accepts an explicit contraction list from the <code>np.einsum_path</code>  function. See <code>np.einsum_path</code> for more details. Defaults to False.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>output : ndarray  The calculation based on the Einstein summation convention.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>einsum_path, dot, inner, outer, tensordot, linalg.multi_dot</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.6.0</p>
+<p>The Einstein summation convention can be used to compute many multi-dimensional, linear algebraic array operations. <code>einsum</code> provides a succinct way of representing these.</p>
+<p>A non-exhaustive list of these operations, which can be computed by <code>einsum</code>, is shown below along with examples:</p>
+<ul>
+  <li>Trace of an array, :py:func:<code>numpy.trace</code>.</li>
+  <li>Return a diagonal, :py:func:<code>numpy.diag</code>.</li>
+  <li>Array axis summations, :py:func:<code>numpy.sum</code>.</li>
+  <li>Transpositions and permutations, :py:func:<code>numpy.transpose</code>.</li>
+  <li>Matrix multiplication and dot product, :py:func:<code>numpy.matmul</code> :py:func:<code>numpy.dot</code>.</li>
+  <li>Vector inner and outer products, :py:func:<code>numpy.inner</code> :py:func:<code>numpy.outer</code>.</li>
+  <li>Broadcasting, element-wise and scalar multiplication, :py:func:<code>numpy.multiply</code>.</li>
+  <li>Tensor contractions, :py:func:<code>numpy.tensordot</code>.</li>
+  <li>Chained array operations, in efficient calculation order, :py:func:<code>numpy.einsum_path</code>.</li>
+</ul>
+<p>The subscripts string is a comma-separated list of subscript labels, where each label refers to a dimension of the corresponding operand. Whenever a label is repeated it is summed, so <code>np.einsum('i,i', a, b)</code> is equivalent to :py:func:<code>np.inner(a,b) &lt;numpy.inner&gt;</code>. If a label appears only once, it is not summed, so <code>np.einsum('i', a)</code> produces a view of <code>a</code> with no changes. A further example <code>np.einsum('ij,jk', a, b)</code> describes traditional matrix multiplication and is equivalent to :py:func:<code>np.matmul(a,b) &lt;numpy.matmul&gt;</code>. Repeated subscript labels in one operand take the diagonal. For example, <code>np.einsum('ii', a)</code> is equivalent to :py:func:<code>np.trace(a) &lt;numpy.trace&gt;</code>.</p>
+<p>In <em>implicit mode</em>, the chosen subscripts are important since the axes of the output are reordered alphabetically. This means that <code>np.einsum('ij', a)</code> doesn’t affect a 2D array, while <code>np.einsum('ji', a)</code> takes its transpose. Additionally, <code>np.einsum('ij,jk', a, b)</code> returns a matrix multiplication, while, <code>np.einsum('ij,jh', a, b)</code> returns the transpose of the multiplication since subscript ‘h’ precedes subscript ‘i’.</p>
+<p>In <em>explicit mode</em> the output can be directly controlled by specifying output subscript labels. This requires the identifier ‘-&gt;’ as well as the list of output subscript labels. This feature increases the flexibility of the function since summing can be disabled or forced when required. The call <code>np.einsum('i-&gt;', a)</code> is like :py:func:<code>np.sum(a, axis=-1) &lt;numpy.sum&gt;</code>, and <code>np.einsum('ii-&gt;i', a)</code> is like :py:func:<code>np.diag(a) &lt;numpy.diag&gt;</code>. The difference is that <code>einsum</code> does not allow broadcasting by default. Additionally <code>np.einsum('ij,jh-&gt;ih', a, b)</code> directly specifies the order of the output subscript labels and therefore returns matrix multiplication, unlike the example above in implicit mode.</p>
+<p>To enable and control broadcasting, use an ellipsis. Default NumPy-style broadcasting is done by adding an ellipsis to the left of each term, like <code>np.einsum('...ii-&gt;...i', a)</code>. To take the trace along the first and last axes, you can do <code>np.einsum('i...i', a)</code>, or to do a matrix-matrix product with the left-most indices instead of rightmost, one can do <code>np.einsum('ij...,jk...-&gt;ik...', a, b)</code>.</p>
+<p>When there is only one operand, no axes are summed, and no output parameter is provided, a view into the operand is returned instead of a new array. Thus, taking the diagonal as <code>np.einsum('ii-&gt;i', a)</code> produces a view (changed in version 1.10.0).</p>
+<p><code>einsum</code> also provides an alternative way to provide the subscripts and operands as <code>einsum(op0, sublist0, op1, sublist1, ..., [sublistout])</code>. If the output shape is not provided in this format <code>einsum</code> will be calculated in implicit mode, otherwise it will be performed explicitly. The examples below have corresponding <code>einsum</code> calls with the two parameter methods.</p>
+<p>.. versionadded:: 1.10.0</p>
+<p>Views returned from einsum are now writeable whenever the input array is writeable. For example, <code>np.einsum('ijk...-&gt;kji...', a)</code> will now have the same effect as :py:func:<code>np.swapaxes(a, 0, 2) &lt;numpy.swapaxes&gt;</code> and <code>np.einsum('ii-&gt;i', a)</code> will return a writeable view of the diagonal of a 2D array.</p>
+<p>.. versionadded:: 1.12.0</p>
+<p>Added the <code>optimize</code> argument which will optimize the contraction order of an einsum expression. For a contraction with three or more operands this can greatly increase the computational efficiency at the cost of a larger memory footprint during computation.</p>
+<p>Typically a ‘greedy’ algorithm is applied which empirical tests have shown returns the optimal path in the majority of cases. In some cases ‘optimal’ will return the superlative path through a more expensive, exhaustive search. For iterative calculations it may be advisable to calculate the optimal path once and reuse that path by supplying it as an argument. An example is given below.</p>
+<p>See :py:func:<code>numpy.einsum_path</code> for more details.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(25).reshape(5,5) b = np.arange(5) c = np.arange(6).reshape(2,3)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Trace of a matrix:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.einsum(‘ii’, a) 60 np.einsum(a, [0,0]) 60 np.trace(a) 60</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Extract the diagonal (requires explicit form):</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.einsum(‘ii-&gt;i’, a) array([ 0, 6, 12, 18, 24]) np.einsum(a, [0,0], [0]) array([ 0, 6, 12, 18, 24]) np.diag(a) array([ 0, 6, 12, 18, 24])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Sum over an axis (requires explicit form):</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.einsum(‘ij-&gt;i’, a) array([ 10, 35, 60, 85, 110]) np.einsum(a, [0,1], [0]) array([ 10, 35, 60, 85, 110]) np.sum(a, axis=1) array([ 10, 35, 60, 85, 110])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>For higher dimensional arrays summing a single axis can be done with ellipsis:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.einsum(‘…j-&gt;…’, a) array([ 10, 35, 60, 85, 110]) np.einsum(a, [Ellipsis,1], [Ellipsis]) array([ 10, 35, 60, 85, 110])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Compute a matrix transpose, or reorder any number of axes:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.einsum(‘ji’, c) array(<a href="null">0, 3],
+       [1, 4],
+       [2, 5</a>) np.einsum(‘ij-&gt;ji’, c) array(<a href="null">0, 3],
+       [1, 4],
+       [2, 5</a>) np.einsum(c, [1,0]) array(<a href="null">0, 3],
+       [1, 4],
+       [2, 5</a>) np.transpose(c) array(<a href="null">0, 3],
+       [1, 4],
+       [2, 5</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Vector inner products:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.einsum(‘i,i’, b, b) 30 np.einsum(b, [0], b, [0]) 30 np.inner(b,b) 30</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Matrix vector multiplication:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.einsum(‘ij,j’, a, b) array([ 30, 80, 130, 180, 230]) np.einsum(a, [0,1], b, [1]) array([ 30, 80, 130, 180, 230]) np.dot(a, b) array([ 30, 80, 130, 180, 230]) np.einsum(‘…j,j’, a, b) array([ 30, 80, 130, 180, 230])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Broadcasting and scalar multiplication:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.einsum(‘…, …’, 3, c) array(<a href="null"> 0,  3,  6],
+       [ 9, 12, 15</a>) np.einsum(‘,ij’, 3, c) array(<a href="null"> 0,  3,  6],
+       [ 9, 12, 15</a>) np.einsum(3, [Ellipsis], c, [Ellipsis]) array(<a href="null"> 0,  3,  6],
+       [ 9, 12, 15</a>) np.multiply(3, c) array(<a href="null"> 0,  3,  6],
+       [ 9, 12, 15</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Vector outer product:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.einsum(‘i,j’, np.arange(2)+1, b) array(<a href="null">0, 1, 2, 3, 4],
+       [0, 2, 4, 6, 8</a>) np.einsum(np.arange(2)+1, [0], b, [1]) array(<a href="null">0, 1, 2, 3, 4],
+       [0, 2, 4, 6, 8</a>) np.outer(np.arange(2)+1, b) array(<a href="null">0, 1, 2, 3, 4],
+       [0, 2, 4, 6, 8</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Tensor contraction:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(60.).reshape(3,4,5) b = np.arange(24.).reshape(4,3,2) np.einsum(‘ijk,jil-&gt;kl’, a, b) array(<a href="null">4400., 4730.],
+       [4532., 4874.],
+       [4664., 5018.],
+       [4796., 5162.],
+       [4928., 5306.</a>) np.einsum(a, [0,1,2], b, [1,0,3], [2,3]) array(<a href="null">4400., 4730.],
+       [4532., 4874.],
+       [4664., 5018.],
+       [4796., 5162.],
+       [4928., 5306.</a>) np.tensordot(a,b, axes=([1,0],[0,1])) array(<a href="null">4400., 4730.],
+       [4532., 4874.],
+       [4664., 5018.],
+       [4796., 5162.],
+       [4928., 5306.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Writeable returned arrays (since version 1.10.0):</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.zeros((3, 3)) np.einsum(‘ii-&gt;i’, a)[:] = 1 a array(<a href="null">1., 0., 0.],
+       [0., 1., 0.],
+       [0., 0., 1.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Example of ellipsis use:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(6).reshape((3,2)) b = np.arange(12).reshape((4,3)) np.einsum(‘ki,jk-&gt;ij’, a, b) array(<a href="null">10, 28, 46, 64],
+       [13, 40, 67, 94</a>) np.einsum(‘ki,…k-&gt;i…’, a, b) array(<a href="null">10, 28, 46, 64],
+       [13, 40, 67, 94</a>) np.einsum(‘k…,jk’, a, b) array(<a href="null">10, 28, 46, 64],
+       [13, 40, 67, 94</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Chained array operations. For more complicated contractions, speed ups might be achieved by repeatedly computing a ‘greedy’ path or pre-computing the ‘optimal’ path and repeatedly applying it, using an <code>einsum_path</code> insertion (since version 1.12.0). Performance improvements can be particularly significant with larger arrays:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.ones(64).reshape(2,4,8)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Basic <code>einsum</code>: ~1520ms (benchmarked on 3.1GHz Intel i5.)</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>for iteration in range(500): … _ = np.einsum(‘ijk,ilm,njm,nlk,abc-&gt;’,a,a,a,a,a)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Sub-optimal <code>einsum</code> (due to repeated path calculation time): ~330ms</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>for iteration in range(500): … _ = np.einsum(‘ijk,ilm,njm,nlk,abc-&gt;’,a,a,a,a,a, optimize=‘optimal’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Greedy <code>einsum</code> (faster optimal path approximation): ~160ms</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>for iteration in range(500): … _ = np.einsum(‘ijk,ilm,njm,nlk,abc-&gt;’,a,a,a,a,a, optimize=‘greedy’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Optimal <code>einsum</code> (best usage pattern in some use cases): ~110ms</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>path = np.einsum_path(‘ijk,ilm,njm,nlk,abc-&gt;’,a,a,a,a,a, optimize=‘optimal’)[0] for iteration in range(500): … _ = np.einsum(‘ijk,ilm,njm,nlk,abc-&gt;’,a,a,a,a,a, optimize=path)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24673">view source</a></div></div><div class="public anchor" id="var-einsum_path"><h3>einsum_path</h3><div class="usage"><code>(einsum_path &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>einsum_path(subscripts, *operands, optimize=‘greedy’)</p>
+<p>Evaluates the lowest cost contraction order for an einsum expression by considering the creation of intermediate arrays.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>subscripts : str  Specifies the subscripts for summation. *operands : list of array_like  These are the arrays for the operation. optimize : {bool, list, tuple, ‘greedy’, ‘optimal’}  Choose the type of path. If a tuple is provided, the second argument is  assumed to be the maximum intermediate size created. If only a single  argument is provided the largest input or output array size is used  as a maximum intermediate size.</p>
+<pre><code>* if a list is given that starts with ``einsum_path``, uses this as the
+  contraction path
+* if False no optimization is taken
+* if True defaults to the 'greedy' algorithm
+* 'optimal' An algorithm that combinatorially explores all possible
+  ways of contracting the listed tensors and choosest the least costly
+  path. Scales exponentially with the number of terms in the
+  contraction.
+* 'greedy' An algorithm that chooses the best pair contraction
+  at each step. Effectively, this algorithm searches the largest inner,
+  Hadamard, and then outer products at each step. Scales cubically with
+  the number of terms in the contraction. Equivalent to the 'optimal'
+  path for most contractions.
+
+Default is 'greedy'.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>path : list of tuples  A list representation of the einsum path. string_repr : str  A printable representation of the einsum path.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The resulting path indicates which terms of the input contraction should be contracted first, the result of this contraction is then appended to the end of the contraction list. This list can then be iterated over until all intermediate contractions are complete.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>einsum, linalg.multi_dot</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>We can begin with a chain dot example. In this case, it is optimal to contract the <code>b</code> and <code>c</code> tensors first as represented by the first element of the path <code>(1, 2)</code>. The resulting tensor is added to the end of the contraction and the remaining contraction <code>(0, 1)</code> is then completed.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.random.seed(123) a = np.random.rand(2, 2) b = np.random.rand(2, 5) c = np.random.rand(5, 2) path_info = np.einsum_path(‘ij,jk,kl-&gt;il’, a, b, c, optimize=‘greedy’) print(path_info[0]) [‘einsum_path’, (1, 2), (0, 1)] print(path_info[1])  Complete contraction: ij,jk,kl-&gt;il # may vary  Naive scaling: 4  Optimized scaling: 3  Naive FLOP count: 1.600e+02  Optimized FLOP count: 5.600e+01  Theoretical speedup: 2.857</p>
+      <h2><a href="#largest-intermediate-4-000e-00-elements" name="largest-intermediate-4-000e-00-elements"></a> Largest intermediate: 4.000e+00 elements</h2>
+      <h2><a href="#scaling-current-remaining" name="scaling-current-remaining"></a>scaling current remaining</h2>
+      <p>3 kl,jk-&gt;jl ij,jl-&gt;il  3 jl,ij-&gt;il il-&gt;il</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>A more complex index transformation example.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>I = np.random.rand(10, 10, 10, 10) C = np.random.rand(10, 10) path_info = np.einsum_path(‘ea,fb,abcd,gc,hd-&gt;efgh’, C, C, I, C, C, … optimize=‘greedy’)</p>
+      <p>print(path_info[0]) [‘einsum_path’, (0, 2), (0, 3), (0, 2), (0, 1)] print(path_info[1])  Complete contraction: ea,fb,abcd,gc,hd-&gt;efgh # may vary  Naive scaling: 8  Optimized scaling: 5  Naive FLOP count: 8.000e+08  Optimized FLOP count: 8.000e+05  Theoretical speedup: 1000.000</p>
+      <h2><a href="#largest-intermediate-1-000e-04-elements" name="largest-intermediate-1-000e-04-elements"></a> Largest intermediate: 1.000e+04 elements</h2>
+      <h2><a href="#scaling-current-remaining" name="scaling-current-remaining"></a>scaling current remaining</h2>
+      <p>5 abcd,ea-&gt;bcde fb,gc,hd,bcde-&gt;efgh  5 bcde,fb-&gt;cdef gc,hd,cdef-&gt;efgh  5 cdef,gc-&gt;defg hd,defg-&gt;efgh  5 defg,hd-&gt;efgh efgh-&gt;efgh</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10008">view source</a></div></div><div class="public anchor" id="var-emath"><h3>emath</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Wrapper functions to more user-friendly calling of certain math functions whose output data-type is different than the input data-type in certain domains of the input.</p>
+<p>For example, for functions like <code>log</code> with branch cuts, the versions in this module provide the mathematically valid answers in the complex plane::</p>
+<p>&gt;&gt;&gt; import math  &gt;&gt;&gt; from numpy.lib import scimath  &gt;&gt;&gt; scimath.log(-math.exp(1)) == (1+1j*math.pi)  True</p>
+<p>Similarly, <code>sqrt</code>, other base logarithms, <code>power</code> and trig functions are correctly handled. See their respective docstrings for specific examples.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6791">view source</a></div></div><div class="public anchor" id="var-empty"><h3>empty</h3><div class="usage"><code>(empty self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>empty(shape, dtype=float, order=‘C’)</p>
+<p>Return a new array of given shape and type, without initializing entries.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>shape : int or tuple of int  Shape of the empty array, e.g., <code>(2, 3)</code> or <code>2</code>. dtype : data-type, optional  Desired output data-type for the array, e.g, <code>numpy.int8</code>. Default is  <code>numpy.float64</code>. order : {‘C’, ‘F’}, optional, default: ‘C’  Whether to store multi-dimensional data in row-major  (C-style) or column-major (Fortran-style) order in  memory.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Array of uninitialized (arbitrary) data of the given shape, dtype, and  order. Object arrays will be initialized to None.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>empty_like : Return an empty array with shape and type of input. ones : Return a new array setting values to one. zeros : Return a new array setting values to zero. full : Return a new array of given shape filled with value.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>empty</code>, unlike <code>zeros</code>, does not set the array values to zero, and may therefore be marginally faster. On the other hand, it requires the user to manually set all the values in the array, and should be used with caution.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.empty([2, 2]) array(<a href="null"> -9.74499359e+001,   6.69583040e-309],
+       [  2.13182611e-314,   3.06959433e-309</a>) #uninitialized</p>
+      <p>np.empty([2, 2], dtype=int) array(<a href="null">-1073741821, -1067949133],
+       [  496041986,    19249760</a>) #uninitialized</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18292">view source</a></div></div><div class="public anchor" id="var-empty_like"><h3>empty_like</h3><div class="usage"><code>(empty_like &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>empty_like(prototype, dtype=None, order=‘K’, subok=True, shape=None)</p>
+<p>Return a new array with the same shape and type as a given array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>prototype : array_like  The shape and data-type of <code>prototype</code> define these same attributes  of the returned array. dtype : data-type, optional  Overrides the data type of the result.</p>
+<pre><code>.. versionadded:: 1.6.0
+</code></pre>
+<p>order : {‘C’, ‘F’, ‘A’, or ‘K’}, optional  Overrides the memory layout of the result. ‘C’ means C-order,  ‘F’ means F-order, ‘A’ means ‘F’ if <code>prototype</code> is Fortran  contiguous, ‘C’ otherwise. ‘K’ means match the layout of <code>prototype</code>  as closely as possible.</p>
+<pre><code>.. versionadded:: 1.6.0
+</code></pre>
+<p>subok : bool, optional.  If True, then the newly created array will use the sub-class  type of ‘a’, otherwise it will be a base-class array. Defaults  to True. shape : int or sequence of ints, optional.  Overrides the shape of the result. If order=‘K’ and the number of  dimensions is unchanged, will try to keep order, otherwise,  order=‘C’ is implied.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Array of uninitialized (arbitrary) data with the same  shape and type as <code>prototype</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ones_like : Return an array of ones with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. full_like : Return a new array with shape of input filled with value. empty : Return a new uninitialized array.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This function does <em>not</em> initialize the returned array; to do that use <code>zeros_like</code> or <code>ones_like</code> instead. It may be marginally faster than the functions that do set the array values.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = ([1,2,3], [4,5,6]) # a is array-like np.empty_like(a) array(<a href="null">-1073741821, -1073741821,           3],    # uninitialized
+       [          0,           0, -1073741821</a>) a = np.array(<a href="null">1., 2., 3.],[4.,5.,6.</a>) np.empty_like(a) array(<a href="null"> -2.00000715e+000,   1.48219694e-323,  -2.00000572e+000], # uninitialized
+       [  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17329">view source</a></div></div><div class="public anchor" id="var-equal"><h3>equal</h3><div class="usage"><code>(equal self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>equal(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return (x1 == x2) element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>not_equal, greater_equal, less_equal, greater, less</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.equal([0, 1, 3], np.arange(3)) array([ True, True, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>What is compared are values, not types. So an int (1) and an array of length one can evaluate as True:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.equal(1, np.ones(1)) array([ True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24585">view source</a></div></div><div class="public anchor" id="var-ERR_CALL"><h3>ERR_CALL</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2424">view source</a></div></div><div class="public anchor" id="var-ERR_DEFAULT"><h3>ERR_DEFAULT</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13201">view source</a></div></div><div class="public anchor" id="var-ERR_IGNORE"><h3>ERR_IGNORE</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17197">view source</a></div></div><div class="public anchor" id="var-ERR_LOG"><h3>ERR_LOG</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20435">view source</a></div></div><div class="public anchor" id="var-ERR_PRINT"><h3>ERR_PRINT</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28800">view source</a></div></div><div class="public anchor" id="var-ERR_RAISE"><h3>ERR_RAISE</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8949">view source</a></div></div><div class="public anchor" id="var-ERR_WARN"><h3>ERR_WARN</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14367">view source</a></div></div><div class="public anchor" id="var-errstate"><h3>errstate</h3><div class="usage"><code>(errstate self &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>errstate(**kwargs)</p>
+<p>Context manager for floating-point error handling.</p>
+<p>Using an instance of <code>errstate</code> as a context manager allows statements in that context to execute with a known error handling behavior. Upon entering the context the error handling is set with <code>seterr</code> and <code>seterrcall</code>, and upon exiting it is reset to what it was before.</p>
+<p>.. versionchanged:: 1.17.0  <code>errstate</code> is also usable as a function decorator, saving  a level of indentation if an entire function is wrapped.  See :py:class:<code>contextlib.ContextDecorator</code> for more information.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>kwargs : {divide, over, under, invalid}  Keyword arguments. The valid keywords are the possible floating-point  exceptions. Each keyword should have a string value that defines the  treatment for the particular error. Possible values are  {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>seterr, geterr, seterrcall, geterrcall</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>For complete documentation of the types of floating-point exceptions and treatment options, see <code>seterr</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from collections import OrderedDict olderr = np.seterr(all=‘ignore’) # Set error handling to known state.</p>
+      <p>np.arange(3) / 0. array([nan, inf, inf]) with np.errstate(divide=‘warn’): … np.arange(3) / 0. array([nan, inf, inf])</p>
+      <p>np.sqrt(-1) nan with np.errstate(invalid=‘raise’): … np.sqrt(-1) Traceback (most recent call last):  File “<stdin>”, line 2, in <module> FloatingPointError: invalid value encountered in sqrt</module></stdin></p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Outside the context the error handling behavior has not changed:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>OrderedDict(sorted(np.geterr().items())) OrderedDict([(‘divide’, ‘ignore’), (‘invalid’, ‘ignore’), (‘over’, ‘ignore’), (‘under’, ‘ignore’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10858">view source</a></div></div><div class="public anchor" id="var-euler_gamma"><h3>euler_gamma</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25765">view source</a></div></div><div class="public anchor" id="var-exp"><h3>exp</h3><div class="usage"><code>(exp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>exp(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Calculate the exponential of all elements in the input array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Output array, element-wise exponential of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>expm1 : Calculate <code>exp(x) - 1</code> for all elements in the array. exp2 : Calculate <code>2**x</code> for all elements in the array.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The irrational number <code>e</code> is also known as Euler’s number. It is approximately 2.718281, and is the base of the natural logarithm, <code>ln</code> (this means that, if :math:<code>x = \ln y = \log_e y</code>, then :math:<code>e^x = y</code>. For real input, <code>exp(x)</code> is always positive.</p>
+<p>For complex arguments, <code>x = a + ib</code>, we can write :math:<code>e^x = e^a e^{ib}</code>. The first term, :math:<code>e^a</code>, is already known (it is the real argument, described above). The second term, :math:<code>e^{ib}</code>, is :math:<code>\cos b + i \sin b</code>, a function with magnitude 1 and a periodic phase.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Wikipedia, “Exponential function”,  <a href="https://en.wikipedia.org/wiki/Exponential_function">https://en.wikipedia.org/wiki/Exponential_function</a> .. [2] M. Abramovitz and I. A. Stegun, “Handbook of Mathematical Functions  with Formulas, Graphs, and Mathematical Tables,” Dover, 1964, p. 69,  <a href="http://www.math.sfu.ca/~cbm/aands/page_69.htm">http://www.math.sfu.ca/~cbm/aands/page_69.htm</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Plot the magnitude and phase of <code>exp(x)</code> in the complex plane:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt</p>
+      <p>x = np.linspace(-2*np.pi, 2*np.pi, 100) xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane out = np.exp(xx)</p>
+      <p>plt.subplot(121) plt.imshow(np.abs(out), … extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap=‘gray’) plt.title(‘Magnitude of exp(x)’)</p>
+      <p>plt.subplot(122) plt.imshow(np.angle(out), … extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap=‘hsv’) plt.title(‘Phase (angle) of exp(x)’) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16468">view source</a></div></div><div class="public anchor" id="var-exp2"><h3>exp2</h3><div class="usage"><code>(exp2 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>exp2(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Calculate <code>2**p</code> for all <code>p</code> in the input array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Element-wise 2 to the power <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>power</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.3.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.exp2([2, 3]) array([ 4., 8.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22166">view source</a></div></div><div class="public anchor" id="var-expand_dims"><h3>expand_dims</h3><div class="usage"><code>(expand_dims &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Expand the shape of an array.</p>
+<p>Insert a new axis that will appear at the <code>axis</code> position in the expanded array shape.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. axis : int or tuple of ints  Position in the expanded axes where the new axis (or axes) is placed.</p>
+<pre><code>.. deprecated:: 1.13.0
+    Passing an axis where ``axis &gt; a.ndim`` will be treated as
+    ``axis == a.ndim``, and passing ``axis &lt; -a.ndim - 1`` will
+    be treated as ``axis == 0``. This behavior is deprecated.
+
+.. versionchanged:: 1.18.0
+    A tuple of axes is now supported.  Out of range axes as
+    described above are now forbidden and raise an `AxisError`.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>result : ndarray  View of <code>a</code> with the number of dimensions increased.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>squeeze : The inverse operation, removing singleton dimensions reshape : Insert, remove, and combine dimensions, and resize existing ones doc.indexing, atleast_1d, atleast_2d, atleast_3d</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([1, 2]) x.shape (2,)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The following is equivalent to <code>x[np.newaxis, :]</code> or <code>x[np.newaxis]</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>y = np.expand_dims(x, axis=0) y array(<a href="null">1, 2</a>) y.shape (1, 2)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The following is equivalent to <code>x[:, np.newaxis]</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>y = np.expand_dims(x, axis=1) y array(<a href="null">1],
+       [2</a>) y.shape (2, 1)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p><code>axis</code> may also be a tuple:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>y = np.expand_dims(x, axis=(0, 1)) y array(<a href="null">[1, 2</a>])</p>
+      <p>y = np.expand_dims(x, axis=(2, 0)) y array(<a href="null">[1],
+        [2</a>])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that some examples may use <code>None</code> instead of <code>np.newaxis</code>. These are the same objects:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.newaxis is None True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26991">view source</a></div></div><div class="public anchor" id="var-expm1"><h3>expm1</h3><div class="usage"><code>(expm1 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>expm1(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Calculate <code>exp(x) - 1</code> for all elements in the array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Element-wise exponential minus one: <code>out = exp(x) - 1</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>log1p : <code>log(1 + x)</code>, the inverse of expm1.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This function provides greater precision than <code>exp(x) - 1</code> for small values of <code>x</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>The true value of <code>exp(1e-10) - 1</code> is <code>1.00000000005e-10</code> to about 32 significant digits. This example shows the superiority of expm1 in this case.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.expm1(1e-10) 1.00000000005e-10 np.exp(1e-10) - 1 1.000000082740371e-10</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21080">view source</a></div></div><div class="public anchor" id="var-extract"><h3>extract</h3><div class="usage"><code>(extract &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the elements of an array that satisfy some condition.</p>
+<p>This is equivalent to <code>np.compress(ravel(condition), ravel(arr))</code>. If <code>condition</code> is boolean <code>np.extract</code> is equivalent to <code>arr[condition]</code>.</p>
+<p>Note that <code>place</code> does the exact opposite of <code>extract</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>condition : array_like  An array whose nonzero or True entries indicate the elements of <code>arr</code>  to extract. arr : array_like  Input array of the same size as <code>condition</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>extract : ndarray  Rank 1 array of values from <code>arr</code> where <code>condition</code> is True.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>take, put, copyto, compress, place</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>arr = np.arange(12).reshape((3, 4)) arr array(<a href="null"> 0,  1,  2,  3],
+       [ 4,  5,  6,  7],
+       [ 8,  9, 10, 11</a>) condition = np.mod(arr, 3)==0 condition array(<a href="null"> True, False, False,  True],
+       [False, False,  True, False],
+       [False,  True, False, False</a>) np.extract(condition, arr) array([0, 3, 6, 9])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>If <code>condition</code> is boolean:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>arr[condition] array([0, 3, 6, 9])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15957">view source</a></div></div><div class="public anchor" id="var-eye"><h3>eye</h3><div class="usage"><code>(eye N &amp; [{M :M, k :k, dtype :dtype, order :order}])</code><code>(eye N &amp; [{M :M, k :k, dtype :dtype}])</code><code>(eye N &amp; [{M :M, k :k}])</code><code>(eye N &amp; [{M :M}])</code><code>(eye N)</code></div><div class="doc"><div class="markdown"><p>Return a 2-D array with ones on the diagonal and zeros elsewhere.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>N : int  Number of rows in the output. M : int, optional  Number of columns in the output. If None, defaults to <code>N</code>. k : int, optional  Index of the diagonal: 0 (the default) refers to the main diagonal,  a positive value refers to an upper diagonal, and a negative value  to a lower diagonal. dtype : data-type, optional  Data-type of the returned array. order : {‘C’, ‘F’}, optional  Whether the output should be stored in row-major (C-style) or  column-major (Fortran-style) order in memory.</p>
+<pre><code>.. versionadded:: 1.14.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>I : ndarray of shape (N,M)  An array where all elements are equal to zero, except for the <code>k</code>-th  diagonal, whose values are equal to one.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>identity : (almost) equivalent function diag : diagonal 2-D array from a 1-D array specified by the user.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.eye(2, dtype=int) array(<a href="null">1, 0],
+       [0, 1</a>) np.eye(3, k=1) array(<a href="null">0.,  1.,  0.],
+       [0.,  0.,  1.],
+       [0.,  0.,  0.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16964">view source</a></div></div><div class="public anchor" id="var-fabs"><h3>fabs</h3><div class="usage"><code>(fabs self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fabs(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute the absolute values element-wise.</p>
+<p>This function returns the absolute values (positive magnitude) of the data in <code>x</code>. Complex values are not handled, use <code>absolute</code> to find the absolute values of complex data.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  The array of numbers for which the absolute values are required. If  <code>x</code> is a scalar, the result <code>y</code> will also be a scalar. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  The absolute values of <code>x</code>, the returned values are always floats.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>absolute : Absolute values including <code>complex</code> types.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.fabs(-1) 1.0 np.fabs([-1.2, 1.2]) array([ 1.2, 1.2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14867">view source</a></div></div><div class="public anchor" id="var-fastCopyAndTranspose"><h3>fastCopyAndTranspose</h3><div class="usage"><code>(fastCopyAndTranspose self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>_fastCopyAndTranspose(a)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22354">view source</a></div></div><div class="public anchor" id="var-fft"><h3>fft</h3><div class="usage"></div><div class="doc"><div class="markdown"><h1><a href="#discrete-fourier-transform-mod-" name="discrete-fourier-transform-mod-"></a>Discrete Fourier Transform (:mod:<code>numpy.fft</code>)</h1>
+<p>.. currentmodule:: numpy.fft</p>
+<h2><a href="#standard-ffts" name="standard-ffts"></a>Standard FFTs</h2>
+<p>.. autosummary::  :toctree: generated/</p>
+<p>fft Discrete Fourier transform.  ifft Inverse discrete Fourier transform.  fft2 Discrete Fourier transform in two dimensions.  ifft2 Inverse discrete Fourier transform in two dimensions.  fftn Discrete Fourier transform in N-dimensions.  ifftn Inverse discrete Fourier transform in N dimensions.</p>
+<h2><a href="#real-ffts" name="real-ffts"></a>Real FFTs</h2>
+<p>.. autosummary::  :toctree: generated/</p>
+<p>rfft Real discrete Fourier transform.  irfft Inverse real discrete Fourier transform.  rfft2 Real discrete Fourier transform in two dimensions.  irfft2 Inverse real discrete Fourier transform in two dimensions.  rfftn Real discrete Fourier transform in N dimensions.  irfftn Inverse real discrete Fourier transform in N dimensions.</p>
+<h2><a href="#hermitian-ffts" name="hermitian-ffts"></a>Hermitian FFTs</h2>
+<p>.. autosummary::  :toctree: generated/</p>
+<p>hfft Hermitian discrete Fourier transform.  ihfft Inverse Hermitian discrete Fourier transform.</p>
+<h2><a href="#helper-routines" name="helper-routines"></a>Helper routines</h2>
+<p>.. autosummary::  :toctree: generated/</p>
+<p>fftfreq Discrete Fourier Transform sample frequencies.  rfftfreq DFT sample frequencies (for usage with rfft, irfft).  fftshift Shift zero-frequency component to center of spectrum.  ifftshift Inverse of fftshift.</p>
+<h2><a href="#background-information" name="background-information"></a>Background information</h2>
+<p>Fourier analysis is fundamentally a method for expressing a function as a sum of periodic components, and for recovering the function from those components. When both the function and its Fourier transform are replaced with discretized counterparts, it is called the discrete Fourier transform (DFT). The DFT has become a mainstay of numerical computing in part because of a very fast algorithm for computing it, called the Fast Fourier Transform (FFT), which was known to Gauss (1805) and was brought to light in its current form by Cooley and Tukey [CT]_. Press et al. [NR]_ provide an accessible introduction to Fourier analysis and its applications.</p>
+<p>Because the discrete Fourier transform separates its input into components that contribute at discrete frequencies, it has a great number of applications in digital signal processing, e.g., for filtering, and in this context the discretized input to the transform is customarily referred to as a <em>signal</em>, which exists in the <em>time domain</em>. The output is called a <em>spectrum</em> or <em>transform</em> and exists in the <em>frequency domain</em>.</p>
+<h2><a href="#implementation-details" name="implementation-details"></a>Implementation details</h2>
+<p>There are many ways to define the DFT, varying in the sign of the exponent, normalization, etc. In this implementation, the DFT is defined as</p>
+<p>.. math::  A_k = \sum_{m=0}^{n-1} a_m \exp\left{-2\pi i{mk \over n}\right}  \qquad k = 0,\ldots,n-1.</p>
+<p>The DFT is in general defined for complex inputs and outputs, and a single-frequency component at linear frequency :math:<code>f</code> is represented by a complex exponential :math:<code>a_m = \exp\{2\pi i\,f m\Delta t\}</code>, where :math:<code>\Delta t</code> is the sampling interval.</p>
+<p>The values in the result follow so-called “standard” order: If <code>A =
+fft(a, n)</code>, then <code>A[0]</code> contains the zero-frequency term (the sum of the signal), which is always purely real for real inputs. Then <code>A[1:n/2]</code> contains the positive-frequency terms, and <code>A[n/2+1:]</code> contains the negative-frequency terms, in order of decreasingly negative frequency. For an even number of input points, <code>A[n/2]</code> represents both positive and negative Nyquist frequency, and is also purely real for real input. For an odd number of input points, <code>A[(n-1)/2]</code> contains the largest positive frequency, while <code>A[(n+1)/2]</code> contains the largest negative frequency. The routine <code>np.fft.fftfreq(n)</code> returns an array giving the frequencies of corresponding elements in the output. The routine <code>np.fft.fftshift(A)</code> shifts transforms and their frequencies to put the zero-frequency components in the middle, and <code>np.fft.ifftshift(A)</code> undoes that shift.</p>
+<p>When the input <code>a</code> is a time-domain signal and <code>A = fft(a)</code>, <code>np.abs(A)</code> is its amplitude spectrum and <code>np.abs(A)**2</code> is its power spectrum. The phase spectrum is obtained by <code>np.angle(A)</code>.</p>
+<p>The inverse DFT is defined as</p>
+<p>.. math::  a_m = \frac{1}{n}\sum_{k=0}^{n-1}A_k\exp\left{2\pi i{mk\over n}\right}  \qquad m = 0,\ldots,n-1.</p>
+<p>It differs from the forward transform by the sign of the exponential argument and the default normalization by :math:<code>1/n</code>.</p>
+<h2><a href="#type-promotion" name="type-promotion"></a>Type Promotion</h2>
+<p><code>numpy.fft</code> promotes <code>float32</code> and <code>complex64</code> arrays to <code>float64</code> and <code>complex128</code> arrays respectively. For an FFT implementation that does not promote input arrays, see <code>scipy.fftpack</code>.</p>
+<h2><a href="#normalization" name="normalization"></a>Normalization</h2>
+<p>The default normalization has the direct transforms unscaled and the inverse transforms are scaled by :math:<code>1/n</code>. It is possible to obtain unitary transforms by setting the keyword argument <code>norm</code> to <code>"ortho"</code> (default is <code>None</code>) so that both direct and inverse transforms will be scaled by :math:<code>1/\sqrt{n}</code>.</p>
+<h2><a href="#real-and-hermitian-transforms" name="real-and-hermitian-transforms"></a>Real and Hermitian transforms</h2>
+<p>When the input is purely real, its transform is Hermitian, i.e., the component at frequency :math:<code>f_k</code> is the complex conjugate of the component at frequency :math:<code>-f_k</code>, which means that for real inputs there is no information in the negative frequency components that is not already available from the positive frequency components. The family of <code>rfft</code> functions is designed to operate on real inputs, and exploits this symmetry by computing only the positive frequency components, up to and including the Nyquist frequency. Thus, <code>n</code> input points produce <code>n/2+1</code> complex output points. The inverses of this family assumes the same symmetry of its input, and for an output of <code>n</code> points uses <code>n/2+1</code> input points.</p>
+<p>Correspondingly, when the spectrum is purely real, the signal is Hermitian. The <code>hfft</code> family of functions exploits this symmetry by using <code>n/2+1</code> complex points in the input (time) domain for <code>n</code> real points in the frequency domain.</p>
+<p>In higher dimensions, FFTs are used, e.g., for image analysis and filtering. The computational efficiency of the FFT means that it can also be a faster way to compute large convolutions, using the property that a convolution in the time domain is equivalent to a point-by-point multiplication in the frequency domain.</p>
+<h2><a href="#higher-dimensions" name="higher-dimensions"></a>Higher dimensions</h2>
+<p>In two dimensions, the DFT is defined as</p>
+<p>.. math::  A_{kl} = \sum_{m=0}^{M-1} \sum_{n=0}^{N-1}  a_{mn}\exp\left{-2\pi i \left({mk\over M}+{nl\over N}\right)\right}  \qquad k = 0, \ldots, M-1;\quad l = 0, \ldots, N-1,</p>
+<p>which extends in the obvious way to higher dimensions, and the inverses in higher dimensions also extend in the same way.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [CT] Cooley, James W., and John W. Tukey, 1965, “An algorithm for the  machine calculation of complex Fourier series,” <em>Math. Comput.</em>  19: 297-301.</p>
+<p>.. [NR] Press, W., Teukolsky, S., Vetterline, W.T., and Flannery, B.P.,  2007, <em>Numerical Recipes: The Art of Scientific Computing</em>, ch.  12-13. Cambridge Univ. Press, Cambridge, UK.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>For examples, see the various functions.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25971">view source</a></div></div><div class="public anchor" id="var-fill_diagonal"><h3>fill_diagonal</h3><div class="usage"><code>(fill_diagonal &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Fill the main diagonal of the given array of any dimensionality.</p>
+<p>For an array <code>a</code> with <code>a.ndim &gt;= 2</code>, the diagonal is the list of locations with indices <code>a[i, ..., i]</code> all identical. This function modifies the input array in-place, it does not return a value.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array, at least 2-D.  Array whose diagonal is to be filled, it gets modified in-place.</p>
+<p>val : scalar  Value to be written on the diagonal, its type must be compatible with  that of the array a.</p>
+<p>wrap : bool  For tall matrices in NumPy version up to 1.6.2, the  diagonal “wrapped” after N columns. You can have this behavior  with this option. This affects only tall matrices.</p>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>diag_indices, diag_indices_from</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.4.0</p>
+<p>This functionality can be obtained via <code>diag_indices</code>, but internally this version uses a much faster implementation that never constructs the indices and uses simple slicing.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.zeros((3, 3), int) np.fill_diagonal(a, 5) a array(<a href="null">5, 0, 0],
+       [0, 5, 0],
+       [0, 0, 5</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The same function can operate on a 4-D array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.zeros((3, 3, 3, 3), int) np.fill_diagonal(a, 4)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>We only show a few blocks for clarity:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a[0, 0] array(<a href="null">4, 0, 0],
+       [0, 0, 0],
+       [0, 0, 0</a>) a[1, 1] array(<a href="null">0, 0, 0],
+       [0, 4, 0],
+       [0, 0, 0</a>) a[2, 2] array(<a href="null">0, 0, 0],
+       [0, 0, 0],
+       [0, 0, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The wrap option affects only tall matrices:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <h1><a href="#tall-matrices-no-wrap" name="tall-matrices-no-wrap"></a>tall matrices no wrap</h1>
+      <p>a = np.zeros((5, 3), int) np.fill_diagonal(a, 4) a array(<a href="null">4, 0, 0],
+       [0, 4, 0],
+       [0, 0, 4],
+       [0, 0, 0],
+       [0, 0, 0</a>)</p>
+      <h1><a href="#tall-matrices-wrap" name="tall-matrices-wrap"></a>tall matrices wrap</h1>
+      <p>a = np.zeros((5, 3), int) np.fill_diagonal(a, 4, wrap=True) a array(<a href="null">4, 0, 0],
+       [0, 4, 0],
+       [0, 0, 4],
+       [0, 0, 0],
+       [4, 0, 0</a>)</p>
+      <h1><a href="#wide-matrices" name="wide-matrices"></a>wide matrices</h1>
+      <p>a = np.zeros((3, 5), int) np.fill_diagonal(a, 4, wrap=True) a array(<a href="null">4, 0, 0, 0, 0],
+       [0, 4, 0, 0, 0],
+       [0, 0, 4, 0, 0</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The anti-diagonal can be filled by reversing the order of elements using either <code>numpy.flipud</code> or <code>numpy.fliplr</code>.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.zeros((3, 3), int); np.fill_diagonal(np.fliplr(a), [1,2,3]) # Horizontal flip a array(<a href="null">0, 0, 1],
+       [0, 2, 0],
+       [3, 0, 0</a>) np.fill_diagonal(np.flipud(a), [1,2,3]) # Vertical flip a array(<a href="null">0, 0, 3],
+       [0, 2, 0],
+       [1, 0, 0</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that the order in which the diagonal is filled varies depending on the flip function.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19631">view source</a></div></div><div class="public anchor" id="var-find_common_type"><h3>find_common_type</h3><div class="usage"><code>(find_common_type array_types scalar_types)</code></div><div class="doc"><div class="markdown"><p>Determine common type following standard coercion rules.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>array_types : sequence  A list of dtypes or dtype convertible objects representing arrays. scalar_types : sequence  A list of dtypes or dtype convertible objects representing scalars.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>datatype : dtype  The common data type, which is the maximum of <code>array_types</code> ignoring  <code>scalar_types</code>, unless the maximum of <code>scalar_types</code> is of a  different kind (<code>dtype.kind</code>). If the kind is not understood, then  None is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>dtype, common_type, can_cast, mintypecode</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.find_common_type([], [np.int64, np.float32, complex]) dtype(‘complex128’) np.find_common_type([np.int64, np.float32], []) dtype(‘float64’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The standard casting rules ensure that a scalar cannot up-cast an array unless the scalar is of a fundamentally different kind of data (i.e. under a different hierarchy in the data type hierarchy) then the array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.find_common_type([np.float32], [np.int64, np.float64]) dtype(‘float32’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Complex is of a different type, so it up-casts the float in the <code>array_types</code> argument:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.find_common_type([np.float32], [complex]) dtype(‘complex128’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Type specifier strings are convertible to dtypes and can therefore be used instead of dtypes:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.find_common_type([‘f4’, ‘f4’, ‘i4’], [‘c8’]) dtype(‘complex128’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4018">view source</a></div></div><div class="public anchor" id="var-finfo"><h3>finfo</h3><div class="usage"><code>(finfo self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>finfo(dtype)</p>
+<p>Machine limits for floating point types.</p>
+<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
+<p>bits : int  The number of bits occupied by the type. eps : float  The smallest representable positive number such that  <code>1.0 + eps != 1.0</code>. Type of <code>eps</code> is an appropriate floating  point type. epsneg : floating point number of the appropriate type  The smallest representable positive number such that  <code>1.0 - epsneg != 1.0</code>. iexp : int  The number of bits in the exponent portion of the floating point  representation. machar : MachAr  The object which calculated these parameters and holds more  detailed information. machep : int  The exponent that yields <code>eps</code>. max : floating point number of the appropriate type  The largest representable number. maxexp : int  The smallest positive power of the base (2) that causes overflow. min : floating point number of the appropriate type  The smallest representable number, typically <code>-max</code>. minexp : int  The most negative power of the base (2) consistent with there  being no leading 0’s in the mantissa. negep : int  The exponent that yields <code>epsneg</code>. nexp : int  The number of bits in the exponent including its sign and bias. nmant : int  The number of bits in the mantissa. precision : int  The approximate number of decimal digits to which this kind of  float is precise. resolution : floating point number of the appropriate type  The approximate decimal resolution of this type, i.e.,  <code>10**-precision</code>. tiny : float  The smallest positive usable number. Type of <code>tiny</code> is an  appropriate floating point type.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>dtype : float, dtype, or instance  Kind of floating point data-type about which to get information.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>MachAr : The implementation of the tests that produce this information. iinfo : The equivalent for integer data types.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>For developers of NumPy: do not instantiate this at the module level. The initial calculation of these parameters is expensive and negatively impacts import times. These objects are cached, so calling <code>finfo()</code> repeatedly inside your functions is not a problem.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26164">view source</a></div></div><div class="public anchor" id="var-fix"><h3>fix</h3><div class="usage"><code>(fix &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Round to nearest integer towards zero.</p>
+<p>Round an array of floats element-wise to nearest integer towards zero. The rounded values are returned as floats.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  An array of floats to be rounded y : ndarray, optional  Output array</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray of floats  The array of rounded numbers</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>trunc, floor, ceil around : Round to given number of decimals</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.fix(3.14) 3.0 np.fix(3) 3.0 np.fix([2.1, 2.9, -2.1, -2.9]) array([ 2., 2., -2., -2.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3545">view source</a></div></div><div class="public anchor" id="var-flatiter"><h3>flatiter</h3><div class="usage"><code>(flatiter self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Flat iterator object to iterate over arrays.</p>
+<p>A <code>flatiter</code> iterator is returned by <code>x.flat</code> for any array <code>x</code>. It allows iterating over the array as if it were a 1-D array, either in a for-loop or by calling its <code>next</code> method.</p>
+<p>Iteration is done in row-major, C-style order (the last index varying the fastest). The iterator can also be indexed using basic slicing or advanced indexing.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.flat : Return a flat iterator over an array. ndarray.flatten : Returns a flattened copy of an array.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>A <code>flatiter</code> iterator can not be constructed directly from Python code by calling the <code>flatiter</code> constructor.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(6).reshape(2, 3) fl = x.flat type(fl) &lt;class ‘numpy.flatiter’&gt; for item in fl: … print(item) … 0 1 2 3 4 5</p>
+      <p>fl[2:4] array([2, 3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9493">view source</a></div></div><div class="public anchor" id="var-flatnonzero"><h3>flatnonzero</h3><div class="usage"><code>(flatnonzero &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return indices that are non-zero in the flattened version of a.</p>
+<p>This is equivalent to np.nonzero(np.ravel(a))[0].</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>res : ndarray  Output array, containing the indices of the elements of <code>a.ravel()</code>  that are non-zero.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>nonzero : Return the indices of the non-zero elements of the input array. ravel : Return a 1-D array containing the elements of the input array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(-2, 3) x array([-2, -1, 0, 1, 2]) np.flatnonzero(x) array([0, 1, 3, 4])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Use the indices of the non-zero elements as an index array to extract these elements:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x.ravel()[np.flatnonzero(x)] array([-2, -1, 1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L819">view source</a></div></div><div class="public anchor" id="var-flexible"><h3>flexible</h3><div class="usage"><code>(flexible self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all scalar types without predefined length. The actual size of these types depends on the specific <code>np.dtype</code> instantiation.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L353">view source</a></div></div><div class="public anchor" id="var-flip"><h3>flip</h3><div class="usage"><code>(flip &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Reverse the order of elements in an array along the given axis.</p>
+<p>The shape of the array is preserved, but the elements are reordered.</p>
+<p>.. versionadded:: 1.12.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>m : array_like  Input array. axis : None or int or tuple of ints, optional  Axis or axes along which to flip over. The default,  axis=None, will flip over all of the axes of the input array.  If axis is negative it counts from the last to the first axis.</p>
+<pre><code> If axis is a tuple of ints, flipping is performed on all of the axes
+ specified in the tuple.
+
+ .. versionchanged:: 1.15.0
+    None and tuples of axes are supported
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : array_like  A view of <code>m</code> with the entries of axis reversed. Since a view is  returned, this operation is done in constant time.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>flipud : Flip an array vertically (axis=0). fliplr : Flip an array horizontally (axis=1).</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>flip(m, 0) is equivalent to flipud(m).</p>
+<p>flip(m, 1) is equivalent to fliplr(m).</p>
+<p>flip(m, n) corresponds to <code>m[...,::-1,...]</code> with <code>::-1</code> at position n.</p>
+<p>flip(m) corresponds to <code>m[::-1,::-1,...,::-1]</code> with <code>::-1</code> at all positions.</p>
+<p>flip(m, (0, 1)) corresponds to <code>m[::-1,::-1,...]</code> with <code>::-1</code> at position 0 and position 1.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>A = np.arange(8).reshape((2,2,2)) A array(<a href="null">[0, 1],
+        [2, 3</a>,  <a href="null">4, 5],
+        [6, 7</a>]) np.flip(A, 0) array(<a href="null">[4, 5],
+        [6, 7</a>,  <a href="null">0, 1],
+        [2, 3</a>]) np.flip(A, 1) array(<a href="null">[2, 3],
+        [0, 1</a>,  <a href="null">6, 7],
+        [4, 5</a>]) np.flip(A) array(<a href="null">[7, 6],
+        [5, 4</a>,  <a href="null">3, 2],
+        [1, 0</a>]) np.flip(A, (0, 2)) array(<a href="null">[5, 4],
+        [7, 6</a>,  <a href="null">1, 0],
+        [3, 2</a>]) A = np.random.randn(3,4,5) np.all(np.flip(A,2) == A[:,:,::-1,…]) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11453">view source</a></div></div><div class="public anchor" id="var-fliplr"><h3>fliplr</h3><div class="usage"><code>(fliplr &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Flip array in the left/right direction.</p>
+<p>Flip the entries in each row in the left/right direction. Columns are preserved, but appear in a different order than before.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>m : array_like  Input array, must be at least 2-D.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>f : ndarray  A view of <code>m</code> with the columns reversed. Since a view  is returned, this operation is :math:<code>\mathcal O(1)</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>flipud : Flip array in the up/down direction. rot90 : Rotate array counterclockwise.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Equivalent to m[:,::-1]. Requires the array to be at least 2-D.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>A = np.diag([1.,2.,3.]) A array(<a href="null">1.,  0.,  0.],
+       [0.,  2.,  0.],
+       [0.,  0.,  3.</a>) np.fliplr(A) array(<a href="null">0.,  0.,  1.],
+       [0.,  2.,  0.],
+       [3.,  0.,  0.</a>)</p>
+      <p>A = np.random.randn(2,3,5) np.all(np.fliplr(A) == A[:,::-1,…]) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27067">view source</a></div></div><div class="public anchor" id="var-flipud"><h3>flipud</h3><div class="usage"><code>(flipud &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Flip array in the up/down direction.</p>
+<p>Flip the entries in each column in the up/down direction. Rows are preserved, but appear in a different order than before.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>m : array_like  Input array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : array_like  A view of <code>m</code> with the rows reversed. Since a view is  returned, this operation is :math:<code>\mathcal O(1)</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>fliplr : Flip array in the left/right direction. rot90 : Rotate array counterclockwise.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Equivalent to <code>m[::-1,...]</code>. Does not require the array to be two-dimensional.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>A = np.diag([1.0, 2, 3]) A array(<a href="null">1.,  0.,  0.],
+       [0.,  2.,  0.],
+       [0.,  0.,  3.</a>) np.flipud(A) array(<a href="null">0.,  0.,  3.],
+       [0.,  2.,  0.],
+       [1.,  0.,  0.</a>)</p>
+      <p>A = np.random.randn(2,3,5) np.all(np.flipud(A) == A[::-1,…]) True</p>
+      <p>np.flipud([1,2]) array([2, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14719">view source</a></div></div><div class="public anchor" id="var-float"><h3>float</h3><div class="usage"><code>(float self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Convert a string or number to a floating point number, if possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L79">view source</a></div></div><div class="public anchor" id="var-float128"><h3>float128</h3><div class="usage"><code>(float128 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Extended-precision floating-point number type, compatible with C <code>long double</code> but not necessarily with IEEE 754 quadruple-precision. Character code: <code>'g'</code>. Canonical name: <code>np.longdouble</code>. Alias: <code>np.longfloat</code>. Alias <em>on this platform</em>: <code>np.float128</code>: 128-bit extended-precision floating-point number type.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12586">view source</a></div></div><div class="public anchor" id="var-float16"><h3>float16</h3><div class="usage"><code>(float16 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Half-precision floating-point number type. Character code: <code>'e'</code>. Canonical name: <code>np.half</code>. Alias <em>on this platform</em>: <code>np.float16</code>: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15803">view source</a></div></div><div class="public anchor" id="var-float32"><h3>float32</h3><div class="usage"><code>(float32 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Single-precision floating-point number type, compatible with C <code>float</code>. Character code: <code>'f'</code>. Canonical name: <code>np.single</code>. Alias <em>on this platform</em>: <code>np.float32</code>: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3790">view source</a></div></div><div class="public anchor" id="var-float64"><h3>float64</h3><div class="usage"><code>(float64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Double-precision floating-point number type, compatible with Python <code>float</code> and C <code>double</code>. Character code: <code>'d'</code>. Canonical name: <code>np.double</code>. Alias: <code>np.float_</code>. Alias <em>on this platform</em>: <code>np.float64</code>: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5102">view source</a></div></div><div class="public anchor" id="var-float_"><h3>float_</h3><div class="usage"><code>(float_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Double-precision floating-point number type, compatible with Python <code>float</code> and C <code>double</code>. Character code: <code>'d'</code>. Canonical name: <code>np.double</code>. Alias: <code>np.float_</code>. Alias <em>on this platform</em>: <code>np.float64</code>: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2536">view source</a></div></div><div class="public anchor" id="var-float_power"><h3>float_power</h3><div class="usage"><code>(float_power self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>float_power(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>First array elements raised to powers from second array, element-wise.</p>
+<p>Raise each base in <code>x1</code> to the positionally-corresponding power in <code>x2</code>. <code>x1</code> and <code>x2</code> must be broadcastable to the same shape. This differs from the power function in that integers, float16, and float32 are promoted to floats with a minimum precision of float64 so that the result is always inexact. The intent is that the function will return a usable result for negative powers and seldom overflow for positive powers.</p>
+<p>.. versionadded:: 1.12.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  The bases. x2 : array_like  The exponents. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The bases in <code>x1</code> raised to the exponents in <code>x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>power : power function that preserves type</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Cube each element in a list.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x1 = range(6) x1 [0, 1, 2, 3, 4, 5] np.float_power(x1, 3) array([ 0., 1., 8., 27., 64., 125.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Raise the bases to different exponents.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] np.float_power(x1, x2) array([ 0., 1., 8., 27., 16., 5.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The effect of broadcasting.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x2 = np.array(<a href="null">1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1</a>) x2 array(<a href="null">1, 2, 3, 3, 2, 1],
+       [1, 2, 3, 3, 2, 1</a>) np.float_power(x1, x2) array(<a href="null">  0.,   1.,   8.,  27.,  16.,   5.],
+       [  0.,   1.,   8.,  27.,  16.,   5.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23815">view source</a></div></div><div class="public anchor" id="var-floating"><h3>floating</h3><div class="usage"><code>(floating self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all floating-point scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13587">view source</a></div></div><div class="public anchor" id="var-FLOATING_POINT_SUPPORT"><h3>FLOATING_POINT_SUPPORT</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6422">view source</a></div></div><div class="public anchor" id="var-floor"><h3>floor</h3><div class="usage"><code>(floor self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>floor(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the floor of the input, element-wise.</p>
+<p>The floor of the scalar <code>x</code> is the largest integer <code>i</code>, such that <code>i &lt;= x</code>. It is often denoted as :math:<code>\lfloor x \rfloor</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input data. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  The floor of each element in <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ceil, trunc, rint</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Some spreadsheet programs calculate the “floor-towards-zero”, in other words <code>floor(-2.5) == -2</code>. NumPy instead uses the definition of <code>floor</code> where <code>floor(-2.5) == -3</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.floor(a) array([-2., -2., -1., 0., 1., 1., 2.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L386">view source</a></div></div><div class="public anchor" id="var-floor_divide"><h3>floor_divide</h3><div class="usage"><code>(floor_divide self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>floor_divide(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the largest integer smaller or equal to the division of the inputs. It is equivalent to the Python <code>//</code> operator and pairs with the Python <code>%</code> (<code>remainder</code>), function so that <code>a = a % b + b * (a // b)</code> up to roundoff.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  Numerator. x2 : array_like  Denominator. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  y = floor(<code>x1</code>/<code>x2</code>)  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>remainder : Remainder complementary to floor_divide. divmod : Simultaneous floor division and remainder. divide : Standard division. floor : Round a number to the nearest integer toward minus infinity. ceil : Round a number to the nearest integer toward infinity.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.floor_divide(7,3) 2 np.floor_divide([1., 2., 3., 4.], 2.5) array([ 0., 0., 1., 1.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2226">view source</a></div></div><div class="public anchor" id="var-fmax"><h3>fmax</h3><div class="usage"><code>(fmax self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fmax(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Element-wise maximum of array elements.</p>
+<p>Compare two arrays and returns a new array containing the element-wise maxima. If one of the elements being compared is a NaN, then the non-nan element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are ignored when possible.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  The arrays holding the elements to be compared. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  The maximum of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>fmin :  Element-wise minimum of two arrays, ignores NaNs. maximum :  Element-wise maximum of two arrays, propagates NaNs. amax :  The maximum value of an array along a given axis, propagates NaNs. nanmax :  The maximum value of an array along a given axis, ignores NaNs.</p>
+<p>minimum, amin, nanmin</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.3.0</p>
+<p>The fmax is equivalent to <code>np.where(x1 &gt;= x2, x1, x2)</code> when neither x1 nor x2 are NaNs, but it is faster and does proper broadcasting.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.fmax([2, 3, 4], [1, 5, 2]) array([ 2., 5., 4.])</p>
+      <p>np.fmax(np.eye(2), [0.5, 2]) array(<a href="null"> 1. ,  2. ],
+       [ 0.5,  2. </a>)</p>
+      <p>np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) array([ 0., 0., nan])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17634">view source</a></div></div><div class="public anchor" id="var-fmin"><h3>fmin</h3><div class="usage"><code>(fmin self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fmin(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Element-wise minimum of array elements.</p>
+<p>Compare two arrays and returns a new array containing the element-wise minima. If one of the elements being compared is a NaN, then the non-nan element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are ignored when possible.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  The arrays holding the elements to be compared. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  The minimum of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>fmax :  Element-wise maximum of two arrays, ignores NaNs. minimum :  Element-wise minimum of two arrays, propagates NaNs. amin :  The minimum value of an array along a given axis, propagates NaNs. nanmin :  The minimum value of an array along a given axis, ignores NaNs.</p>
+<p>maximum, amax, nanmax</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.3.0</p>
+<p>The fmin is equivalent to <code>np.where(x1 &lt;= x2, x1, x2)</code> when neither x1 nor x2 are NaNs, but it is faster and does proper broadcasting.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.fmin([2, 3, 4], [1, 5, 2]) array([1, 3, 2])</p>
+      <p>np.fmin(np.eye(2), [0.5, 2]) array(<a href="null"> 0.5,  0. ],
+       [ 0. ,  1. </a>)</p>
+      <p>np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) array([ 0., 0., nan])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15282">view source</a></div></div><div class="public anchor" id="var-fmod"><h3>fmod</h3><div class="usage"><code>(fmod self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fmod(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the element-wise remainder of division.</p>
+<p>This is the NumPy implementation of the C library function fmod, the remainder has the same sign as the dividend <code>x1</code>. It is equivalent to the Matlab(TM) <code>rem</code> function and should not be confused with the Python modulus operator <code>x1 % x2</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  Dividend. x2 : array_like  Divisor. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : array_like  The remainder of the division of <code>x1</code> by <code>x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>remainder : Equivalent to the Python <code>%</code> operator. divide</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The result of the modulo operation for negative dividend and divisors is bound by conventions. For <code>fmod</code>, the sign of result is the sign of the dividend, while for <code>remainder</code> the sign of the result is the sign of the divisor. The <code>fmod</code> function is equivalent to the Matlab(TM) <code>rem</code> function.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.fmod([-3, -2, -1, 1, 2, 3], 2) array([-1, 0, -1, 1, 0, 1]) np.remainder([-3, -2, -1, 1, 2, 3], 2) array([1, 0, 1, 1, 0, 1])</p>
+      <p>np.fmod([5, 3], [2, 2.]) array([ 1., 1.]) a = np.arange(-3, 3).reshape(3, 2) a array(<a href="null">-3, -2],
+       [-1,  0],
+       [ 1,  2</a>) np.fmod(a, [2,2]) array(<a href="null">-1,  0],
+       [-1,  0],
+       [ 1,  0</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12072">view source</a></div></div><div class="public anchor" id="var-format_float_positional"><h3>format_float_positional</h3><div class="usage"><code>(format_float_positional x &amp; [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign, pad_left :pad_left, pad_right :pad_right}])</code><code>(format_float_positional x &amp; [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign, pad_left :pad_left}])</code><code>(format_float_positional x &amp; [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign}])</code><code>(format_float_positional x &amp; [{precision :precision, unique :unique, fractional :fractional, trim :trim}])</code><code>(format_float_positional x &amp; [{precision :precision, unique :unique, fractional :fractional}])</code><code>(format_float_positional x &amp; [{precision :precision, unique :unique}])</code><code>(format_float_positional x &amp; [{precision :precision}])</code><code>(format_float_positional x)</code></div><div class="doc"><div class="markdown"><p>Format a floating-point scalar as a decimal string in positional notation.</p>
+<p>Provides control over rounding, trimming and padding. Uses and assumes IEEE unbiased rounding. Uses the “Dragon4” algorithm.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : python float or numpy floating scalar  Value to format. precision : non-negative integer or None, optional  Maximum number of digits to print. May be None if <code>unique</code> is  <code>True</code>, but must be an integer if unique is <code>False</code>. unique : boolean, optional  If <code>True</code>, use a digit-generation strategy which gives the shortest  representation which uniquely identifies the floating-point number from  other values of the same type, by judicious rounding. If <code>precision</code>  was omitted, print out all necessary digits, otherwise digit generation  is cut off after <code>precision</code> digits and the remaining value is rounded.  If <code>False</code>, digits are generated as if printing an infinite-precision  value and stopping after <code>precision</code> digits, rounding the remaining  value. fractional : boolean, optional  If <code>True</code>, the cutoff of <code>precision</code> digits refers to the total number  of digits after the decimal point, including leading zeros.  If <code>False</code>, <code>precision</code> refers to the total number of significant  digits, before or after the decimal point, ignoring leading zeros. trim : one of ‘k’, ‘.’, ‘0’, ‘-’, optional  Controls post-processing trimming of trailing digits, as follows:</p>
+<pre><code>* 'k' : keep trailing zeros, keep decimal point (no trimming)
+* '.' : trim all trailing zeros, leave decimal point
+* '0' : trim all but the zero before the decimal point. Insert the
+  zero if it is missing.
+* '-' : trim trailing zeros and any trailing decimal point
+</code></pre>
+<p>sign : boolean, optional  Whether to show the sign for positive values. pad_left : non-negative integer, optional  Pad the left side of the string with whitespace until at least that  many characters are to the left of the decimal point. pad_right : non-negative integer, optional  Pad the right side of the string with whitespace until at least that  many characters are to the right of the decimal point.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>rep : string  The string representation of the floating point value</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>format_float_scientific</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.format_float_positional(np.float32(np.pi)) ‘3.1415927’ np.format_float_positional(np.float16(np.pi)) ‘3.14’ np.format_float_positional(np.float16(0.3)) ‘0.3’ np.format_float_positional(np.float16(0.3), unique=False, precision=10) ‘0.3000488281’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15352">view source</a></div></div><div class="public anchor" id="var-format_float_scientific"><h3>format_float_scientific</h3><div class="usage"><code>(format_float_scientific x &amp; [{precision :precision, unique :unique, trim :trim, sign :sign, pad_left :pad_left, exp_digits :exp_digits}])</code><code>(format_float_scientific x &amp; [{precision :precision, unique :unique, trim :trim, sign :sign, pad_left :pad_left}])</code><code>(format_float_scientific x &amp; [{precision :precision, unique :unique, trim :trim, sign :sign}])</code><code>(format_float_scientific x &amp; [{precision :precision, unique :unique, trim :trim}])</code><code>(format_float_scientific x &amp; [{precision :precision, unique :unique}])</code><code>(format_float_scientific x &amp; [{precision :precision}])</code><code>(format_float_scientific x)</code></div><div class="doc"><div class="markdown"><p>Format a floating-point scalar as a decimal string in scientific notation.</p>
+<p>Provides control over rounding, trimming and padding. Uses and assumes IEEE unbiased rounding. Uses the “Dragon4” algorithm.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : python float or numpy floating scalar  Value to format. precision : non-negative integer or None, optional  Maximum number of digits to print. May be None if <code>unique</code> is  <code>True</code>, but must be an integer if unique is <code>False</code>. unique : boolean, optional  If <code>True</code>, use a digit-generation strategy which gives the shortest  representation which uniquely identifies the floating-point number from  other values of the same type, by judicious rounding. If <code>precision</code>  was omitted, print all necessary digits, otherwise digit generation is  cut off after <code>precision</code> digits and the remaining value is rounded.  If <code>False</code>, digits are generated as if printing an infinite-precision  value and stopping after <code>precision</code> digits, rounding the remaining  value. trim : one of ‘k’, ‘.’, ‘0’, ‘-’, optional  Controls post-processing trimming of trailing digits, as follows:</p>
+<pre><code>* 'k' : keep trailing zeros, keep decimal point (no trimming)
+* '.' : trim all trailing zeros, leave decimal point
+* '0' : trim all but the zero before the decimal point. Insert the
+  zero if it is missing.
+* '-' : trim trailing zeros and any trailing decimal point
+</code></pre>
+<p>sign : boolean, optional  Whether to show the sign for positive values. pad_left : non-negative integer, optional  Pad the left side of the string with whitespace until at least that  many characters are to the left of the decimal point. exp_digits : non-negative integer, optional  Pad the exponent with zeros until it contains at least this many digits.  If omitted, the exponent will be at least 2 digits.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>rep : string  The string representation of the floating point value</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>format_float_positional</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.format_float_scientific(np.float32(np.pi)) ‘3.1415927e+00’ s = np.float32(1.23e24) np.format_float_scientific(s, unique=False, precision=15) ‘1.230000071797338e+24’ np.format_float_scientific(s, exp_digits=4) ‘1.23e+0024’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18943">view source</a></div></div><div class="public anchor" id="var-format_parser"><h3>format_parser</h3><div class="usage"><code>(format_parser self formats names titles &amp; [{aligned :aligned, byteorder :byteorder}])</code><code>(format_parser self formats names titles &amp; [{aligned :aligned}])</code><code>(format_parser self formats names titles)</code></div><div class="doc"><div class="markdown"><p>Class to convert formats, names, titles description to a dtype.</p>
+<p>After constructing the format_parser object, the dtype attribute is the converted data-type: <code>dtype = format_parser(formats, names, titles).dtype</code></p>
+<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
+<p>dtype : dtype  The converted data-type.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>formats : str or list of str  The format description, either specified as a string with  comma-separated format descriptions in the form <code>'f8, i4, a5'</code>, or  a list of format description strings in the form  <code>['f8', 'i4', 'a5']</code>. names : str or list/tuple of str  The field names, either specified as a comma-separated string in the  form <code>'col1, col2, col3'</code>, or as a list or tuple of strings in the  form <code>['col1', 'col2', 'col3']</code>.  An empty list can be used, in that case default field names  (‘f0’, ‘f1’, …) are used. titles : sequence  Sequence of title strings. An empty list can be used to leave titles  out. aligned : bool, optional  If True, align the fields by padding as the C-compiler would.  Default is False. byteorder : str, optional  If specified, all the fields will be changed to the  provided byte-order. Otherwise, the default byte-order is  used. For all available string specifiers, see <code>dtype.newbyteorder</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>dtype, typename, sctype2char</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.format_parser([‘&lt;f8’, ‘&lt;i4’, ‘&lt;a5’], [‘col1’, ‘col2’, ‘col3’], … [‘T1’, ‘T2’, ‘T3’]).dtype dtype([((‘T1’, ‘col1’), ‘&lt;f8’), ((‘T2’, ‘col2’), ‘&lt;i4’), ((‘T3’, ‘col3’), ‘S5’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p><code>names</code> and/or <code>titles</code> can be empty lists. If <code>titles</code> is an empty list, titles will simply not appear. If <code>names</code> is empty, default field names will be used.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.format_parser([‘f8’, ‘i4’, ‘a5’], [‘col1’, ‘col2’, ‘col3’], … []).dtype dtype([(‘col1’, ‘&lt;f8’), (‘col2’, ‘&lt;i4’), (‘col3’, ‘&lt;S5’)]) np.format_parser([‘&lt;f8’, ‘&lt;i4’, ‘&lt;a5’], [], []).dtype dtype([(‘f0’, ‘&lt;f8’), (‘f1’, ‘&lt;i4’), (‘f2’, ‘S5’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3678">view source</a></div></div><div class="public anchor" id="var-FPE_DIVIDEBYZERO"><h3>FPE_DIVIDEBYZERO</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10118">view source</a></div></div><div class="public anchor" id="var-FPE_INVALID"><h3>FPE_INVALID</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23619">view source</a></div></div><div class="public anchor" id="var-FPE_OVERFLOW"><h3>FPE_OVERFLOW</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16804">view source</a></div></div><div class="public anchor" id="var-FPE_UNDERFLOW"><h3>FPE_UNDERFLOW</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28964">view source</a></div></div><div class="public anchor" id="var-frexp"><h3>frexp</h3><div class="usage"><code>(frexp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Decompose the elements of x into mantissa and twos exponent.</p>
+<p>Returns (<code>mantissa</code>, <code>exponent</code>), where `x = mantissa * 2**exponent``. The mantissa is lies in the open interval(-1, 1), while the twos exponent is a signed integer.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Array of numbers to be decomposed. out1 : ndarray, optional  Output array for the mantissa. Must have the same shape as <code>x</code>. out2 : ndarray, optional  Output array for the exponent. Must have the same shape as <code>x</code>. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>mantissa : ndarray  Floating values between -1 and 1.  This is a scalar if <code>x</code> is a scalar. exponent : ndarray  Integer exponents of 2.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ldexp : Compute <code>y = x1 * 2**x2</code>, the inverse of <code>frexp</code>.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Complex dtypes are not supported, they will raise a TypeError.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(9) y1, y2 = np.frexp(x) y1 array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875,  0.5 ]) y2 array([0, 1, 2, 2, 3, 3, 3, 3, 4]) y1 * 2**y2 array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6573">view source</a></div></div><div class="public anchor" id="var-frombuffer"><h3>frombuffer</h3><div class="usage"><code>(frombuffer self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>frombuffer(buffer, dtype=float, count=-1, offset=0)</p>
+<p>Interpret a buffer as a 1-dimensional array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>buffer : buffer_like  An object that exposes the buffer interface. dtype : data-type, optional  Data-type of the returned array; default: float. count : int, optional  Number of items to read. <code>-1</code> means all data in the buffer. offset : int, optional  Start reading the buffer from this offset (in bytes); default: 0.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If the buffer has data that is not in machine byte-order, this should be specified as part of the data-type, e.g.::</p>
+<p>&gt;&gt;&gt; dt = np.dtype(int)  &gt;&gt;&gt; dt = dt.newbyteorder(‘&gt;’)  &gt;&gt;&gt; np.frombuffer(buf, dtype=dt) # doctest: +SKIP</p>
+<p>The data of the resulting array will not be byteswapped, but will be interpreted correctly.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>s = b’hello world’ np.frombuffer(s, dtype=‘S1’, count=5, offset=6) array([b’w’, b’o’, b’r’, b’l’, b’d’], dtype=‘|S1’)</p>
+      <p>np.frombuffer(b’\x01\x02‘, dtype=np.uint8) array([1, 2], dtype=uint8) np.frombuffer(b’\x01\x02\x03\x04\x05’, dtype=np.uint8, count=3) array([1, 2, 3], dtype=uint8)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9454">view source</a></div></div><div class="public anchor" id="var-fromfile"><h3>fromfile</h3><div class="usage"><code>(fromfile self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fromfile(file, dtype=float, count=-1, sep=’’, offset=0)</p>
+<p>Construct an array from data in a text or binary file.</p>
+<p>A highly efficient way of reading binary data with a known data-type, as well as parsing simply formatted text files. Data written using the <code>tofile</code> method can be read using this function.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>file : file or str or Path  Open file object or filename.</p>
+<pre><code>.. versionchanged:: 1.17.0
+    `pathlib.Path` objects are now accepted.
+</code></pre>
+<p>dtype : data-type  Data type of the returned array.  For binary files, it is used to determine the size and byte-order  of the items in the file.  Most builtin numeric types are supported and extension types may be supported.</p>
+<pre><code>.. versionadded:: 1.18.0
+    Complex dtypes.
+</code></pre>
+<p>count : int  Number of items to read. <code>-1</code> means all items (i.e., the complete  file). sep : str  Separator between items if file is a text file.  Empty ("“) separator means the file should be treated as binary.  Spaces (” ") in the separator match zero or more whitespace characters.  A separator consisting only of spaces must match at least one  whitespace. offset : int  The offset (in bytes) from the file’s current position. Defaults to 0.  Only permitted for binary files.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>load, save ndarray.tofile loadtxt : More flexible way of loading data from a text file.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Do not rely on the combination of <code>tofile</code> and <code>fromfile</code> for data storage, as the binary files generated are not platform independent. In particular, no byte-order or data-type information is saved. Data can be stored in the platform independent <code>.npy</code> format using <code>save</code> and <code>load</code> instead.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Construct an ndarray:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>dt = np.dtype([(‘time’, [(‘min’, np.int64), (‘sec’, np.int64)]), … (‘temp’, float)]) x = np.zeros((1,), dtype=dt) x[‘time’][‘min’] = 10; x[‘temp’] = 98.25 x array([((10, 0), 98.25)],  dtype=[(‘time’, [(‘min’, ‘&lt;i8’), (‘sec’, ‘&lt;i8’)]), (‘temp’, ‘&lt;f8’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Save the raw data to disk:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import tempfile fname = tempfile.mkstemp()[1] x.tofile(fname)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Read the raw data from disk:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.fromfile(fname, dtype=dt) array([((10, 0), 98.25)],  dtype=[(‘time’, [(‘min’, ‘&lt;i8’), (‘sec’, ‘&lt;i8’)]), (‘temp’, ‘&lt;f8’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The recommended way to store and load data:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.save(fname, x) np.load(fname + ‘.npy’) array([((10, 0), 98.25)],  dtype=[(‘time’, [(‘min’, ‘&lt;i8’), (‘sec’, ‘&lt;i8’)]), (‘temp’, ‘&lt;f8’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5925">view source</a></div></div><div class="public anchor" id="var-fromfunction"><h3>fromfunction</h3><div class="usage"><code>(fromfunction function shape &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Construct an array by executing a function over each coordinate.</p>
+<p>The resulting array therefore has a value <code>fn(x, y, z)</code> at coordinate <code>(x, y, z)</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>function : callable  The function is called with N parameters, where N is the rank of  <code>shape</code>. Each parameter represents the coordinates of the array  varying along a specific axis. For example, if <code>shape</code>  were <code>(2, 2)</code>, then the parameters would be  <code>array([[0, 0], [1, 1]])</code> and <code>array([[0, 1], [0, 1]])</code> shape : (N,) tuple of ints  Shape of the output array, which also determines the shape of  the coordinate arrays passed to <code>function</code>. dtype : data-type, optional  Data-type of the coordinate arrays passed to <code>function</code>.  By default, <code>dtype</code> is float.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>fromfunction : any  The result of the call to <code>function</code> is passed back directly.  Therefore the shape of <code>fromfunction</code> is completely determined by  <code>function</code>. If <code>function</code> returns a scalar value, the shape of  <code>fromfunction</code> would not match the <code>shape</code> parameter.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>indices, meshgrid</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Keywords other than <code>dtype</code> are passed to <code>function</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) array(<a href="null"> True, False, False],
+       [False,  True, False],
+       [False, False,  True</a>)</p>
+      <p>np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) array(<a href="null">0, 1, 2],
+       [1, 2, 3],
+       [2, 3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13036">view source</a></div></div><div class="public anchor" id="var-fromiter"><h3>fromiter</h3><div class="usage"><code>(fromiter self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fromiter(iterable, dtype, count=-1)</p>
+<p>Create a new 1-dimensional array from an iterable object.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>iterable : iterable object  An iterable object providing data for the array. dtype : data-type  The data-type of the returned array. count : int, optional  The number of items to read from <em>iterable</em>. The default is -1,  which means all data is read.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  The output array.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Specify <code>count</code> to improve performance. It allows <code>fromiter</code> to pre-allocate the output array, instead of resizing it on demand.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>iterable = (x*x for x in range(5)) np.fromiter(iterable, float) array([ 0., 1., 4., 9., 16.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15876">view source</a></div></div><div class="public anchor" id="var-frompyfunc"><h3>frompyfunc</h3><div class="usage"><code>(frompyfunc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>frompyfunc(func, nin, nout)</p>
+<p>Takes an arbitrary Python function and returns a NumPy ufunc.</p>
+<p>Can be used, for example, to add broadcasting to a built-in Python function (see Examples section).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>func : Python function object  An arbitrary Python function. nin : int  The number of input arguments. nout : int  The number of objects returned by <code>func</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ufunc  Returns a NumPy universal function (<code>ufunc</code>) object.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>vectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The returned ufunc always returns PyObject arrays.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Use frompyfunc to add broadcasting to the Python function <code>oct</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>oct_array = np.frompyfunc(oct, 1, 1) oct_array(np.array((10, 30, 100))) array([‘0o12’, ‘0o36’, ‘0o144’], dtype=object) np.array((oct(10), oct(30), oct(100))) # for comparison array([‘0o12’, ‘0o36’, ‘0o144’], dtype=‘&lt;U5’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26940">view source</a></div></div><div class="public anchor" id="var-fromregex"><h3>fromregex</h3><div class="usage"><code>(fromregex file regexp dtype &amp; [{encoding :encoding}])</code><code>(fromregex file regexp dtype)</code></div><div class="doc"><div class="markdown"><p>Construct an array from a text file, using regular expression parsing.</p>
+<p>The returned array is always a structured array, and is constructed from all matches of the regular expression in the file. Groups in the regular expression are converted to fields of the structured array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>file : str or file  Filename or file object to read. regexp : str or regexp  Regular expression used to parse the file.  Groups in the regular expression correspond to fields in the dtype. dtype : dtype or list of dtypes  Dtype for the structured array. encoding : str, optional  Encoding used to decode the inputfile. Does not apply to input streams.</p>
+<pre><code>.. versionadded:: 1.14.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>output : ndarray  The output array, containing the part of the content of <code>file</code> that  was matched by <code>regexp</code>. <code>output</code> is always a structured array.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>TypeError  When <code>dtype</code> is not a valid dtype for a structured array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>fromstring, loadtxt</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Dtypes for structured arrays can be specified in several forms, but all forms specify at least the data type and field name. For details see <code>doc.structured_arrays</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>f = open(‘test.dat’, ‘w’) _ = f.write(“1312 foo\n1534 bar\n444 qux”) f.close()</p>
+      <p>regexp = r“(\d+)\s+(…)” # match [digits, whitespace, anything] output = np.fromregex(‘test.dat’, regexp, … [(‘num’, np.int64), (‘key’, ‘S3’)]) output array([(1312, b’foo’), (1534, b’bar’), ( 444, b’qux’)],  dtype=[(‘num’, ‘&lt;i8’), (‘key’, ‘S3’)]) output[‘num’] array([1312, 1534, 444])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6362">view source</a></div></div><div class="public anchor" id="var-fromstring"><h3>fromstring</h3><div class="usage"><code>(fromstring self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fromstring(string, dtype=float, count=-1, sep=’’)</p>
+<p>A new 1-D array initialized from text data in a string.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>string : str  A string containing the data. dtype : data-type, optional  The data type of the array; default: float. For binary input data,  the data must be in exactly this format. Most builtin numeric types are  supported and extension types may be supported.</p>
+<pre><code>.. versionadded:: 1.18.0
+    Complex dtypes.
+</code></pre>
+<p>count : int, optional  Read this number of <code>dtype</code> elements from the data. If this is  negative (the default), the count will be determined from the  length of the data. sep : str, optional  The string separating numbers in the data; extra whitespace between  elements is also ignored.</p>
+<pre><code>.. deprecated:: 1.14
+    Passing ``sep=''``, the default, is deprecated since it will
+    trigger the deprecated binary mode of this function. This mode
+    interprets `string` as binary bytes, rather than ASCII text with
+    decimal numbers, an operation which is better spelt
+    ``frombuffer(string, dtype, count)``. If `string` contains unicode
+    text, the binary mode of `fromstring` will first encode it into
+    bytes using either utf-8 (python 3) or the default encoding
+    (python 2), neither of which produce sane results.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>arr : ndarray  The constructed array.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If the string is not the correct size to satisfy the requested  <code>dtype</code> and <code>count</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>frombuffer, fromfile, fromiter</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.fromstring(‘1 2’, dtype=int, sep=‘ ’) array([1, 2]) np.fromstring(‘1, 2’, dtype=int, sep=‘,’) array([1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13669">view source</a></div></div><div class="public anchor" id="var-full"><h3>full</h3><div class="usage"><code>(full shape fill_value &amp; [{dtype :dtype, order :order}])</code><code>(full shape fill_value &amp; [{dtype :dtype}])</code><code>(full shape fill_value)</code></div><div class="doc"><div class="markdown"><p>Return a new array of given shape and type, filled with <code>fill_value</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>shape : int or sequence of ints  Shape of the new array, e.g., <code>(2, 3)</code> or <code>2</code>. fill_value : scalar  Fill value. dtype : data-type, optional  The desired data-type for the array The default, None, means  <code>np.array(fill_value).dtype</code>. order : {‘C’, ‘F’}, optional  Whether to store multidimensional data in C- or Fortran-contiguous  (row- or column-wise) order in memory.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Array of <code>fill_value</code> with the given shape, dtype, and order.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>full_like : Return a new array with shape of input filled with value. empty : Return a new uninitialized array. ones : Return a new array setting values to one. zeros : Return a new array setting values to zero.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.full((2, 2), np.inf) array(<a href="null">inf, inf],
+       [inf, inf</a>) np.full((2, 2), 10) array(<a href="null">10, 10],
+       [10, 10</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15917">view source</a></div></div><div class="public anchor" id="var-full_like"><h3>full_like</h3><div class="usage"><code>(full_like &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a full array with the same shape and type as a given array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  The shape and data-type of <code>a</code> define these same attributes of  the returned array. fill_value : scalar  Fill value. dtype : data-type, optional  Overrides the data type of the result. order : {‘C’, ‘F’, ‘A’, or ‘K’}, optional  Overrides the memory layout of the result. ‘C’ means C-order,  ‘F’ means F-order, ‘A’ means ‘F’ if <code>a</code> is Fortran contiguous,  ‘C’ otherwise. ‘K’ means match the layout of <code>a</code> as closely  as possible. subok : bool, optional.  If True, then the newly created array will use the sub-class  type of ‘a’, otherwise it will be a base-class array. Defaults  to True. shape : int or sequence of ints, optional.  Overrides the shape of the result. If order=‘K’ and the number of  dimensions is unchanged, will try to keep order, otherwise,  order=‘C’ is implied.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Array of <code>fill_value</code> with the same shape and type as <code>a</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>empty_like : Return an empty array with shape and type of input. ones_like : Return an array of ones with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. full : Return a new array of given shape filled with value.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(6, dtype=int) np.full_like(x, 1) array([1, 1, 1, 1, 1, 1]) np.full_like(x, 0.1) array([0, 0, 0, 0, 0, 0]) np.full_like(x, 0.1, dtype=np.double) array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) np.full_like(x, np.nan, dtype=np.double) array([nan, nan, nan, nan, nan, nan])</p>
+      <p>y = np.arange(6, dtype=np.double) np.full_like(y, 0.1) array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21516">view source</a></div></div><div class="public anchor" id="var-fv"><h3>fv</h3><div class="usage"><code>(fv &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the future value.</p>
+<p>.. deprecated:: 1.18</p>
+<p><code>fv</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
+<p>Given:  * a present value, <code>pv</code>  * an interest <code>rate</code> compounded once per period, of which  there are  * <code>nper</code> total  * a (fixed) payment, <code>pmt</code>, paid either  * at the beginning (<code>when</code> = {‘begin’, 1}) or the end  (<code>when</code> = {‘end’, 0}) of each period</p>
+<p>Return:  the value at the end of the <code>nper</code> periods</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>rate : scalar or array_like of shape(M, )  Rate of interest as decimal (not per cent) per period nper : scalar or array_like of shape(M, )  Number of compounding periods pmt : scalar or array_like of shape(M, )  Payment pv : scalar or array_like of shape(M, )  Present value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}, optional  When payments are due (‘begin’ (1) or ‘end’ (0)).  Defaults to {‘end’, 0}.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Future values. If all input is scalar, returns a scalar float. If  any input is array_like, returns future values for each input element.  If multiple inputs are array_like, they all must have the same shape.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The future value is computed by solving the equation::</p>
+<p>fv +  pv*(1+rate)**nper +  pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) == 0</p>
+<p>or, when <code>rate == 0</code>::</p>
+<p>fv + pv + pmt * nper == 0</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).  Open Document Format for Office Applications (OpenDocument)v1.2,  Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,  Pre-Draft 12. Organization for the Advancement of Structured Information  Standards (OASIS). Billerica, MA, USA. [ODT Document].  Available:  <a href="http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula">http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula</a>  OpenDocument-formula-20090508.odt</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>What is the future value after 10 years of saving $100 now, with an additional monthly savings of $100. Assume the interest rate is 5% (annually) compounded monthly?</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.fv(0.05/12, 10*12, -100, -100) 15692.928894335748</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>By convention, the negative sign represents cash flow out (i.e. money not available today). Thus, saving $100 a month at 5% annual interest leads to $15,692.93 available to spend in 10 years.</p>
+<p>If any input is array_like, returns an array of equal shape. Let’s compare different interest rates from the example above.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array((0.05, 0.06, 0.07))/12 np.fv(a, 10*12, -100, -100) array([ 15692.92889434, 16569.87435405, 17509.44688102]) # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7818">view source</a></div></div><div class="public anchor" id="var-gcd"><h3>gcd</h3><div class="usage"><code>(gcd self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>gcd(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Returns the greatest common divisor of <code>|x1|</code> and <code>|x2|</code></p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like, int  Arrays of values. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output).</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  The greatest common divisor of the absolute value of the inputs  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>lcm : The lowest common multiple</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.gcd(12, 20) 4 np.gcd.reduce([15, 25, 35]) 5 np.gcd(np.arange(6), 20) array([20, 1, 2, 1, 4, 5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14914">view source</a></div></div><div class="public anchor" id="var-generic"><h3>generic</h3><div class="usage"><code>(generic self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for numpy scalar types.</p>
+<p>Class from which most (all?) numpy scalar types are derived. For consistency, exposes the same API as <code>ndarray</code>, despite many consequent attributes being either “get-only,” or completely irrelevant. This is the class from which it is strongly suggested users should derive custom scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1119">view source</a></div></div><div class="public anchor" id="var-genfromtxt"><h3>genfromtxt</h3><div class="usage"><code>(genfromtxt fname &amp; [{names :names, max_rows :max_rows, encoding :encoding, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, max_rows :max_rows, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, excludelist :excludelist, delimiter :delimiter, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, delimiter :delimiter, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, delimiter :delimiter, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters, missing_values :missing_values, filling_values :filling_values}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters, missing_values :missing_values}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments}])</code><code>(genfromtxt fname &amp; [{dtype :dtype}])</code><code>(genfromtxt fname)</code></div><div class="doc"><div class="markdown"><p>Load data from a text file, with missing values handled as specified.</p>
+<p>Each line past the first <code>skip_header</code> lines is split at the <code>delimiter</code> character, and characters following the <code>comments</code> character are discarded.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>fname : file, str, pathlib.Path, list of str, generator  File, filename, list, or generator to read. If the filename  extension is <code>.gz</code> or <code>.bz2</code>, the file is first decompressed. Note  that generators must return byte strings. The strings  in a list or produced by a generator are treated as lines. dtype : dtype, optional  Data type of the resulting array.  If None, the dtypes will be determined by the contents of each  column, individually. comments : str, optional  The character used to indicate the start of a comment.  All the characters occurring on a line after a comment are discarded delimiter : str, int, or sequence, optional  The string used to separate values. By default, any consecutive  whitespaces act as delimiter. An integer or sequence of integers  can also be provided as width(s) of each field. skiprows : int, optional  <code>skiprows</code> was removed in numpy 1.10. Please use <code>skip_header</code> instead. skip_header : int, optional  The number of lines to skip at the beginning of the file. skip_footer : int, optional  The number of lines to skip at the end of the file. converters : variable, optional  The set of functions that convert the data of a column to a value.  The converters can also be used to provide a default value  for missing data: <code>converters = {3: lambda s: float(s or 0)}</code>. missing : variable, optional  <code>missing</code> was removed in numpy 1.10. Please use <code>missing_values</code>  instead. missing_values : variable, optional  The set of strings corresponding to missing data. filling_values : variable, optional  The set of values to be used as default when the data are missing. usecols : sequence, optional  Which columns to read, with 0 being the first. For example,  <code>usecols = (1, 4, 5)</code> will extract the 2nd, 5th and 6th columns. names : {None, True, str, sequence}, optional  If <code>names</code> is True, the field names are read from the first line after  the first <code>skip_header</code> lines. This line can optionally be proceeded  by a comment delimiter. If <code>names</code> is a sequence or a single-string of  comma-separated names, the names will be used to define the field names  in a structured dtype. If <code>names</code> is None, the names of the dtype  fields will be used, if any. excludelist : sequence, optional  A list of names to exclude. This list is appended to the default list  [‘return’,‘file’,‘print’]. Excluded names are appended an underscore:  for example, <code>file</code> would become <code>file_</code>. deletechars : str, optional  A string combining invalid characters that must be deleted from the  names. defaultfmt : str, optional  A format used to define default field names, such as “f%i” or “f_%02i”. autostrip : bool, optional  Whether to automatically strip white spaces from the variables. replace_space : char, optional  Character(s) used in replacement of white spaces in the variables  names. By default, use a ’_’. case_sensitive : {True, False, ‘upper’, ‘lower’}, optional  If True, field names are case sensitive.  If False or ‘upper’, field names are converted to upper case.  If ‘lower’, field names are converted to lower case. unpack : bool, optional  If True, the returned array is transposed, so that arguments may be  unpacked using <code>x, y, z = loadtxt(...)</code> usemask : bool, optional  If True, return a masked array.  If False, return a regular array. loose : bool, optional  If True, do not raise errors for invalid values. invalid_raise : bool, optional  If True, an exception is raised if an inconsistency is detected in the  number of columns.  If False, a warning is emitted and the offending lines are skipped. max_rows : int, optional  The maximum number of rows to read. Must not be used with skip_footer  at the same time. If given, the value must be at least 1. Default is  to read the entire file.</p>
+<pre><code>.. versionadded:: 1.10.0
+</code></pre>
+<p>encoding : str, optional  Encoding used to decode the inputfile. Does not apply when <code>fname</code> is  a file object. The special value ‘bytes’ enables backward compatibility  workarounds that ensure that you receive byte arrays when possible  and passes latin1 encoded strings to converters. Override this value to  receive unicode arrays and pass strings as input to converters. If set  to None the system default is used. The default value is ‘bytes’.</p>
+<pre><code>.. versionadded:: 1.14.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Data read from the text file. If <code>usemask</code> is True, this is a  masked array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.loadtxt : equivalent function when no data is missing.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<ul>
+  <li>When spaces are used as delimiters, or when no delimiter has been given  as input, there should not be any missing data between two fields.</li>
+  <li>When the variables are named (either by a flexible dtype or with <code>names</code>,  there must not be any header in the file (else a ValueError  exception is raised).</li>
+  <li>Individual values are not stripped of spaces by default.  When using a custom converter, make sure the function does remove spaces.</li>
+</ul>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy User Guide, section <code>I/O with NumPy
+       &lt;https://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html&gt;</code>_.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from io import StringIO import numpy as np</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Comma delimited file with mixed dtype</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>s = StringIO(u“1,1.3,abcde”) data = np.genfromtxt(s, dtype=[(‘myint’,‘i8’),(‘myfloat’,‘f8’), … (‘mystring’,‘S5’)], delimiter=“,”) data array((1, 1.3, b’abcde’),  dtype=[(‘myint’, ‘&lt;i8’), (‘myfloat’, ‘&lt;f8’), (‘mystring’, ‘S5’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using dtype = None</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>_ = s.seek(0) # needed for StringIO example only data = np.genfromtxt(s, dtype=None, … names = [‘myint’,‘myfloat’,‘mystring’], delimiter=“,”) data array((1, 1.3, b’abcde’),  dtype=[(‘myint’, ‘&lt;i8’), (‘myfloat’, ‘&lt;f8’), (‘mystring’, ‘S5’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Specifying dtype and names</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>_ = s.seek(0) data = np.genfromtxt(s, dtype=“i8,f8,S5”, … names=[‘myint’,‘myfloat’,‘mystring’], delimiter=“,”) data array((1, 1.3, b’abcde’),  dtype=[(‘myint’, ‘&lt;i8’), (‘myfloat’, ‘&lt;f8’), (‘mystring’, ‘S5’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>An example with fixed-width columns</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>s = StringIO(u“11.3abcde”) data = np.genfromtxt(s, dtype=None, names=[‘intvar’,‘fltvar’,‘strvar’], … delimiter=[1,3,5]) data array((1, 1.3, b’abcde’),  dtype=[(‘intvar’, ‘&lt;i8’), (‘fltvar’, ‘&lt;f8’), (‘strvar’, ‘S5’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>An example to show comments</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>f = StringIO(’’‘ … text,# of chars … hello world,11 … numpy,5’’‘) np.genfromtxt(f, dtype=‘S12,S12’, delimiter=’,’) array([(b’text’, b’‘), (b’hello world’, b’11‘), (b’numpy’, b’5’)],  dtype=[(‘f0’, ‘S12’), (‘f1’, ‘S12’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10682">view source</a></div></div><div class="public anchor" id="var-geomspace"><h3>geomspace</h3><div class="usage"><code>(geomspace &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return numbers spaced evenly on a log scale (a geometric progression).</p>
+<p>This is similar to <code>logspace</code>, but with endpoints specified directly. Each output sample is a constant multiple of the previous.</p>
+<p>.. versionchanged:: 1.16.0  Non-scalar <code>start</code> and <code>stop</code> are now supported.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>start : array_like  The starting value of the sequence. stop : array_like  The final value of the sequence, unless <code>endpoint</code> is False.  In that case, <code>num + 1</code> values are spaced over the  interval in log-space, of which all but the last (a sequence of  length <code>num</code>) are returned. num : integer, optional  Number of samples to generate. Default is 50. endpoint : boolean, optional  If true, <code>stop</code> is the last sample. Otherwise, it is not included.  Default is True. dtype : dtype  The type of the output array. If <code>dtype</code> is not given, infer the data  type from the other input arguments. axis : int, optional  The axis in the result to store the samples. Relevant only if start  or stop are array-like. By default (0), the samples will be along a  new axis inserted at the beginning. Use -1 to get an axis at the end.</p>
+<pre><code>.. versionadded:: 1.16.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>samples : ndarray  <code>num</code> samples, equally spaced on a log scale.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>logspace : Similar to geomspace, but with endpoints specified using log  and base. linspace : Similar to geomspace, but with arithmetic instead of geometric  progression. arange : Similar to linspace, with the step size specified instead of the  number of samples.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If the inputs or dtype are complex, the output will follow a logarithmic spiral in the complex plane. (There are an infinite number of spirals passing through two points; the output will follow the shortest such path.)</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.geomspace(1, 1000, num=4) array([ 1., 10., 100., 1000.]) np.geomspace(1, 1000, num=3, endpoint=False) array([ 1., 10., 100.]) np.geomspace(1, 1000, num=4, endpoint=False) array([ 1. , 5.62341325, 31.6227766 , 177.827941 ]) np.geomspace(1, 256, num=9) array([ 1., 2., 4., 8., 16., 32., 64., 128., 256.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that the above may not produce exact integers:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.geomspace(1, 256, num=9, dtype=int) array([ 1, 2, 4, 7, 16, 32, 63, 127, 256]) np.around(np.geomspace(1, 256, num=9)).astype(int) array([ 1, 2, 4, 8, 16, 32, 64, 128, 256])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Negative, decreasing, and complex inputs are allowed:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.geomspace(1000, 1, num=4) array([1000., 100., 10., 1.]) np.geomspace(-1000, -1, num=4) array([-1000., -100., -10., -1.]) np.geomspace(1j, 1000j, num=4) # Straight line array([0. +1.j, 0. +10.j, 0. +100.j, 0.+1000.j]) np.geomspace(-1+0j, 1+0j, num=5) # Circle array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,  6.12323400e-17+1.00000000e+00j, 7.07106781e-01+7.07106781e-01j,  1.00000000e+00+0.00000000e+00j])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Graphical illustration of <code>endpoint</code> parameter:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt N = 10 y = np.zeros(N) plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.axis([0.5, 2000, 0, 3]) [0.5, 2000, 0, 3] plt.grid(True, color=‘0.7’, linestyle=‘-’, which=‘both’, axis=‘both’) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25499">view source</a></div></div><div class="public anchor" id="var-get_array_wrap"><h3>get_array_wrap</h3><div class="usage"><code>(get_array_wrap &amp; [args])</code></div><div class="doc"><div class="markdown"><p>Find the wrapper for the array with the highest priority.</p>
+<p>In case of ties, leftmost wins. If no wrapper is found, return None</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6916">view source</a></div></div><div class="public anchor" id="var-get_include"><h3>get_include</h3><div class="usage"><code>(get_include)</code></div><div class="doc"><div class="markdown"><p>Return the directory that contains the NumPy *.h header files.</p>
+<p>Extension modules that need to compile against NumPy should use this function to locate the appropriate include directory.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>When using <code>distutils</code>, for example in <code>setup.py</code>. ::</p>
+<pre><code>import numpy as np
+...
+Extension('extension_name', ...
+        include_dirs=[np.get_include()])
+...
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1373">view source</a></div></div><div class="public anchor" id="var-get_printoptions"><h3>get_printoptions</h3><div class="usage"><code>(get_printoptions)</code></div><div class="doc"><div class="markdown"><p>Return the current print options.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>print_opts : dict  Dictionary of current print options with keys</p>
+<pre><code>  - precision : int
+  - threshold : int
+  - edgeitems : int
+  - linewidth : int
+  - suppress : bool
+  - nanstr : str
+  - infstr : str
+  - formatter : dict of callables
+  - sign : str
+
+For a full description of these options, see `set_printoptions`.
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>set_printoptions, printoptions, set_string_function</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24367">view source</a></div></div><div class="public anchor" id="var-getbufsize"><h3>getbufsize</h3><div class="usage"><code>(getbufsize)</code></div><div class="doc"><div class="markdown"><p>Return the size of the buffer used in ufuncs.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>getbufsize : int  Size of ufunc buffer in bytes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20766">view source</a></div></div><div class="public anchor" id="var-geterr"><h3>geterr</h3><div class="usage"><code>(geterr)</code></div><div class="doc"><div class="markdown"><p>Get the current way of handling floating-point errors.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>res : dict  A dictionary with keys “divide”, “over”, “under”, and “invalid”,  whose values are from the strings “ignore”, “print”, “log”, “warn”,  “raise”, and “call”. The keys represent possible floating-point  exceptions, and the values define how these exceptions are handled.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>geterrcall, seterr, seterrcall</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>For complete documentation of the types of floating-point exceptions and treatment options, see <code>seterr</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from collections import OrderedDict sorted(np.geterr().items()) [(‘divide’, ‘warn’), (‘invalid’, ‘warn’), (‘over’, ‘warn’), (‘under’, ‘ignore’)] np.arange(3.) / np.arange(3.) array([nan, 1., 1.])</p>
+      <p>oldsettings = np.seterr(all=‘warn’, over=‘raise’) OrderedDict(sorted(np.geterr().items())) OrderedDict([(‘divide’, ‘warn’), (‘invalid’, ‘warn’), (‘over’, ‘raise’), (‘under’, ‘warn’)]) np.arange(3.) / np.arange(3.) array([nan, 1., 1.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16927">view source</a></div></div><div class="public anchor" id="var-geterrcall"><h3>geterrcall</h3><div class="usage"><code>(geterrcall)</code></div><div class="doc"><div class="markdown"><p>Return the current callback function used on floating-point errors.</p>
+<p>When the error handling for a floating-point error (one of “divide”, “over”, “under”, or “invalid”) is set to ‘call’ or ‘log’, the function that is called or the log instance that is written to is returned by <code>geterrcall</code>. This function or log instance has been set with <code>seterrcall</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>errobj : callable, log instance or None  The current error handler. If no handler was set through <code>seterrcall</code>,  <code>None</code> is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>seterrcall, seterr, geterr</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>For complete documentation of the types of floating-point exceptions and treatment options, see <code>seterr</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.geterrcall() # we did not yet set a handler, returns None</p>
+      <p>oldsettings = np.seterr(all=‘call’) def err_handler(type, flag): … print(“Floating point error (%s), with flag %s” % (type, flag)) oldhandler = np.seterrcall(err_handler) np.array([1, 2, 3]) / 0.0 Floating point error (divide by zero), with flag 1 array([inf, inf, inf])</p>
+      <p>cur_handler = np.geterrcall() cur_handler is err_handler True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23215">view source</a></div></div><div class="public anchor" id="var-geterrobj"><h3>geterrobj</h3><div class="usage"><code>(geterrobj self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>geterrobj()</p>
+<p>Return the current object that defines floating-point error handling.</p>
+<p>The error object contains all information that defines the error handling behavior in NumPy. <code>geterrobj</code> is used internally by the other functions that get and set error handling behavior (<code>geterr</code>, <code>seterr</code>, <code>geterrcall</code>, <code>seterrcall</code>).</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>errobj : list  The error object, a list containing three elements:  [internal numpy buffer size, error mask, error callback function].</p>
+<pre><code>The error mask is a single integer that holds the treatment information
+on all four floating point errors. The information for each error type
+is contained in three bits of the integer. If we print it in base 8, we
+can see what treatment is set for "invalid", "under", "over", and
+"divide" (in that order). The printed string can be interpreted with
+
+* 0 : 'ignore'
+* 1 : 'warn'
+* 2 : 'raise'
+* 3 : 'call'
+* 4 : 'print'
+* 5 : 'log'
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>seterrobj, seterr, geterr, seterrcall, geterrcall getbufsize, setbufsize</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>For complete documentation of the types of floating-point exceptions and treatment options, see <code>seterr</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.geterrobj() # first get the defaults [8192, 521, None]</p>
+      <p>def err_handler(type, flag): … print(“Floating point error (%s), with flag %s” % (type, flag)) … old_bufsize = np.setbufsize(20000) old_err = np.seterr(divide=‘raise’) old_handler = np.seterrcall(err_handler) np.geterrobj() [8192, 521, <function err_handler="" at="" 0x91dcaac="">]</function></p>
+      <p>old_err = np.seterr(all=‘ignore’) np.base_repr(np.geterrobj()[1], 8) ‘0’ old_err = np.seterr(divide=‘warn’, over=‘log’, under=‘call’, … invalid=‘print’) np.base_repr(np.geterrobj()[1], 8) ‘4351’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20044">view source</a></div></div><div class="public anchor" id="var-gradient"><h3>gradient</h3><div class="usage"><code>(gradient &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the gradient of an N-dimensional array.</p>
+<p>The gradient is computed using second order accurate central differences in the interior points and either first or second order accurate one-sides (forward or backwards) differences at the boundaries. The returned gradient hence has the same shape as the input array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>f : array_like  An N-dimensional array containing samples of a scalar function. varargs : list of scalar or array, optional  Spacing between f values. Default unitary spacing for all dimensions.  Spacing can be specified using:</p>
+<pre><code>1. single scalar to specify a sample distance for all dimensions.
+2. N scalars to specify a constant sample distance for each dimension.
+   i.e. `dx`, `dy`, `dz`, ...
+3. N arrays to specify the coordinates of the values along each
+   dimension of F. The length of the array must match the size of
+   the corresponding dimension
+4. Any combination of N scalars/arrays with the meaning of 2. and 3.
+
+If `axis` is given, the number of varargs must equal the number of axes.
+Default: 1.
+</code></pre>
+<p>edge_order : {1, 2}, optional  Gradient is calculated using N-th order accurate differences  at the boundaries. Default: 1.</p>
+<pre><code>.. versionadded:: 1.9.1
+</code></pre>
+<p>axis : None or int or tuple of ints, optional  Gradient is calculated only along the given axis or axes  The default (axis = None) is to calculate the gradient for all the axes  of the input array. axis may be negative, in which case it counts from  the last to the first axis.</p>
+<pre><code>.. versionadded:: 1.11.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>gradient : ndarray or list of ndarray  A set of ndarrays (or a single ndarray if there is only one dimension)  corresponding to the derivatives of f with respect to each dimension.  Each derivative has the same shape as f.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>f = np.array([1, 2, 4, 7, 11, 16], dtype=float) np.gradient(f) array([1. , 1.5, 2.5, 3.5, 4.5, 5. ]) np.gradient(f, 2) array([0.5 , 0.75, 1.25, 1.75, 2.25, 2.5 ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Spacing can be also specified with an array that represents the coordinates of the values F along the dimensions. For instance a uniform spacing:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(f.size) np.gradient(f, x) array([1. , 1.5, 2.5, 3.5, 4.5, 5. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Or a non uniform one:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float) np.gradient(f, x) array([1. , 3. , 3.5, 6.7, 6.9, 2.5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>For two dimensional arrays, the return will be two arrays ordered by axis. In this example the first array stands for the gradient in rows and the second one in columns direction:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.gradient(np.array(<a href="null">1, 2, 6], [3, 4, 5</a>, dtype=float)) [array([[ 2., 2., -1.],  [ 2., 2., -1.]]), array([[1. , 2.5, 4. ],  [1. , 1. , 1. ]])]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>In this example the spacing is also specified: uniform for axis=0 and non uniform for axis=1</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>dx = 2. y = [1., 1.5, 3.5] np.gradient(np.array(<a href="null">1, 2, 6], [3, 4, 5</a>, dtype=float), dx, y) [array([[ 1. , 1. , -0.5],  [ 1. , 1. , -0.5]]), array([[2. , 2. , 2. ],  [2. , 1.7, 0.5]])]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>It is possible to specify how boundaries are treated using <code>edge_order</code></p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([0, 1, 2, 3, 4]) f = x**2 np.gradient(f, edge_order=1) array([1., 2., 4., 6., 7.]) np.gradient(f, edge_order=2) array([0., 2., 4., 6., 8.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The <code>axis</code> keyword can be used to specify a subset of axes of which the gradient is calculated</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.gradient(np.array(<a href="null">1, 2, 6], [3, 4, 5</a>, dtype=float), axis=0) array(<a href="null"> 2.,  2., -1.],
+       [ 2.,  2., -1.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Assuming that :math:<code>f\in C^{3}</code> (i.e., :math:<code>f</code> has at least 3 continuous derivatives) and let :math:<code>h_{*}</code> be a non-homogeneous stepsize, we minimize the “consistency error” :math:<code>\eta_{i}</code> between the true gradient and its estimate from a linear combination of the neighboring grid-points:</p>
+<p>.. math::</p>
+<pre><code>\eta_{i} = f_{i}^{\left(1\right)} -
+            \left[ \alpha f\left(x_{i}\right) +
+                    \beta f\left(x_{i} + h_{d}\right) +
+                    \gamma f\left(x_{i}-h_{s}\right)
+            \right]
+</code></pre>
+<p>By substituting :math:<code>f(x_{i} + h_{d})</code> and :math:<code>f(x_{i} - h_{s})</code> with their Taylor series expansion, this translates into solving the following the linear system:</p>
+<p>.. math::</p>
+<pre><code>\left\{
+    \begin{array}{r}
+        \alpha+\beta+\gamma=0 \\
+        \beta h_{d}-\gamma h_{s}=1 \\
+        \beta h_{d}^{2}+\gamma h_{s}^{2}=0
+    \end{array}
+\right.
+</code></pre>
+<p>The resulting approximation of :math:<code>f_{i}^{(1)}</code> is the following:</p>
+<p>.. math::</p>
+<pre><code>\hat f_{i}^{(1)} =
+    \frac{
+        h_{s}^{2}f\left(x_{i} + h_{d}\right)
+        + \left(h_{d}^{2} - h_{s}^{2}\right)f\left(x_{i}\right)
+        - h_{d}^{2}f\left(x_{i}-h_{s}\right)}
+        { h_{s}h_{d}\left(h_{d} + h_{s}\right)}
+    + \mathcal{O}\left(\frac{h_{d}h_{s}^{2}
+                        + h_{s}h_{d}^{2}}{h_{d}
+                        + h_{s}}\right)
+</code></pre>
+<p>It is worth noting that if :math:<code>h_{s}=h_{d}</code> (i.e., data are evenly spaced) we find the standard second order approximation:</p>
+<p>.. math::</p>
+<pre><code>\hat f_{i}^{(1)}=
+    \frac{f\left(x_{i+1}\right) - f\left(x_{i-1}\right)}{2h}
+    + \mathcal{O}\left(h^{2}\right)
+</code></pre>
+<p>With a similar procedure the forward/backward approximations used for boundaries can be derived.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics  (Texts in Applied Mathematics). New York: Springer. .. [2] Durran D. R. (1999) Numerical Methods for Wave Equations  in Geophysical Fluid Dynamics. New York: Springer. .. [3] Fornberg B. (1988) Generation of Finite Difference Formulas on  Arbitrarily Spaced Grids,  Mathematics of Computation 51, no. 184 : 699-706.  <code>PDF &lt;http://www.ams.org/journals/mcom/1988-51-184/
+        S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf&gt;</code>_.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3796">view source</a></div></div><div class="public anchor" id="var-greater"><h3>greater</h3><div class="usage"><code>(greater self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>greater(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the truth value of (x1 &gt; x2) element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>greater_equal, less, less_equal, equal, not_equal</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.greater([4,2],[2,2]) array([ True, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>If the inputs are ndarrays, then np.greater is equivalent to ‘&gt;’.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([4,2]) b = np.array([2,2]) a &gt; b array([ True, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12594">view source</a></div></div><div class="public anchor" id="var-greater_equal"><h3>greater_equal</h3><div class="usage"><code>(greater_equal self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>greater_equal(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the truth value of (x1 &gt;= x2) element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : bool or ndarray of bool  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>greater, less, less_equal, equal, not_equal</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.greater_equal([4, 2, 1], [2, 2, 2]) array([ True, True, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17156">view source</a></div></div><div class="public anchor" id="var-half"><h3>half</h3><div class="usage"><code>(half self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Half-precision floating-point number type. Character code: <code>'e'</code>. Canonical name: <code>np.half</code>. Alias <em>on this platform</em>: <code>np.float16</code>: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16281">view source</a></div></div><div class="public anchor" id="var-hamming"><h3>hamming</h3><div class="usage"><code>(hamming M)</code></div><div class="doc"><div class="markdown"><p>Return the Hamming window.</p>
+<p>The Hamming window is a taper formed by using a weighted cosine.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>M : int  Number of points in the output window. If zero or less, an  empty array is returned.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  The window, with the maximum value normalized to one (the value  one appears only if the number of samples is odd).</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>bartlett, blackman, hanning, kaiser</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The Hamming window is defined as</p>
+<p>.. math:: w(n) = 0.54 - 0.46cos\left(\frac{2\pi{n}}{M-1}\right)  \qquad 0 \leq n \leq M-1</p>
+<p>The Hamming was named for R. W. Hamming, an associate of J. W. Tukey and is described in Blackman and Tukey. It was recommended for smoothing the truncated autocovariance function in the time domain. Most references to the Hamming window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means “removing the foot”, i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power  spectra, Dover Publications, New York. .. [2] E.R. Kanasewich, “Time Sequence Analysis in Geophysics”, The  University of Alberta Press, 1975, pp. 109-110. .. [3] Wikipedia, “Window function”,  <a href="https://en.wikipedia.org/wiki/Window_function">https://en.wikipedia.org/wiki/Window_function</a> .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,  “Numerical Recipes”, Cambridge University Press, 1986, page 425.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.hamming(12) array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary  0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909,  0.15302337, 0.08 ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot the window and the frequency response:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt from numpy.fft import fft, fftshift window = np.hamming(51) plt.plot(window) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Hamming window”) Text(0.5, 1.0, ‘Hamming window’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“Sample”) Text(0.5, 0, ‘Sample’) plt.show()</p>
+      <p>plt.figure() </p><figure size="" 640x480="" with="" 0="" axes=""> A = fft(window, 2048) / 25.5 mag = np.abs(fftshift(A)) freq = np.linspace(-0.5, 0.5, len(A)) response = 20 * np.log10(mag) response = np.clip(response, -100, 100) plt.plot(freq, response) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Frequency response of Hamming window”) Text(0.5, 1.0, ‘Frequency response of Hamming window’) plt.ylabel(“Magnitude [dB]”) Text(0, 0.5, ‘Magnitude [dB]’) plt.xlabel(“Normalized frequency [cycles per sample]”) Text(0.5, 0, ‘Normalized frequency [cycles per sample]’) plt.axis(‘tight’) … plt.show()<p></p>
+    </figure></blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14035">view source</a></div></div><div class="public anchor" id="var-hanning"><h3>hanning</h3><div class="usage"><code>(hanning M)</code></div><div class="doc"><div class="markdown"><p>Return the Hanning window.</p>
+<p>The Hanning window is a taper formed by using a weighted cosine.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>M : int  Number of points in the output window. If zero or less, an  empty array is returned.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray, shape(M,)  The window, with the maximum value normalized to one (the value  one appears only if <code>M</code> is odd).</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>bartlett, blackman, hamming, kaiser</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The Hanning window is defined as</p>
+<p>.. math:: w(n) = 0.5 - 0.5cos\left(\frac{2\pi{n}}{M-1}\right)  \qquad 0 \leq n \leq M-1</p>
+<p>The Hanning was named for Julius von Hann, an Austrian meteorologist. It is also known as the Cosine Bell. Some authors prefer that it be called a Hann window, to help avoid confusion with the very similar Hamming window.</p>
+<p>Most references to the Hanning window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means “removing the foot”, i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power  spectra, Dover Publications, New York. .. [2] E.R. Kanasewich, “Time Sequence Analysis in Geophysics”,  The University of Alberta Press, 1975, pp. 106-108. .. [3] Wikipedia, “Window function”,  <a href="https://en.wikipedia.org/wiki/Window_function">https://en.wikipedia.org/wiki/Window_function</a> .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,  “Numerical Recipes”, Cambridge University Press, 1986, page 425.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.hanning(12) array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037,  0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249,  0.07937323, 0. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot the window and its frequency response:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt from numpy.fft import fft, fftshift window = np.hanning(51) plt.plot(window) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Hann window”) Text(0.5, 1.0, ‘Hann window’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“Sample”) Text(0.5, 0, ‘Sample’) plt.show()</p>
+      <p>plt.figure() </p><figure size="" 640x480="" with="" 0="" axes=""> A = fft(window, 2048) / 25.5 mag = np.abs(fftshift(A)) freq = np.linspace(-0.5, 0.5, len(A)) with np.errstate(divide=‘ignore’, invalid=‘ignore’): … response = 20 * np.log10(mag) … response = np.clip(response, -100, 100) plt.plot(freq, response) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Frequency response of the Hann window”) Text(0.5, 1.0, ‘Frequency response of the Hann window’) plt.ylabel(“Magnitude [dB]”) Text(0, 0.5, ‘Magnitude [dB]’) plt.xlabel(“Normalized frequency [cycles per sample]”) Text(0.5, 0, ‘Normalized frequency [cycles per sample]’) plt.axis(‘tight’) … plt.show()<p></p>
+    </figure></blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23621">view source</a></div></div><div class="public anchor" id="var-heaviside"><h3>heaviside</h3><div class="usage"><code>(heaviside self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>heaviside(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute the Heaviside step function.</p>
+<p>The Heaviside step function is defined as::</p>
+<pre><code>                      0   if x1 &lt; 0
+heaviside(x1, x2) =  x2   if x1 == 0
+                      1   if x1 &gt; 0
+</code></pre>
+<p>where <code>x2</code> is often taken to be 0.5, but 0 and 1 are also sometimes used.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  Input values. x2 : array_like  The value of the function when x1 is 0. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  The output array, element-wise Heaviside step function of <code>x1</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.13.0</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. Wikipedia, “Heaviside step function”,  <a href="https://en.wikipedia.org/wiki/Heaviside_step_function">https://en.wikipedia.org/wiki/Heaviside_step_function</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.heaviside([-1.5, 0, 2.0], 0.5) array([ 0. , 0.5, 1. ]) np.heaviside([-1.5, 0, 2.0], 1) array([ 0., 1., 1.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17009">view source</a></div></div><div class="public anchor" id="var-histogram"><h3>histogram</h3><div class="usage"><code>(histogram &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the histogram of a set of data.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. The histogram is computed over the flattened array. bins : int or sequence of scalars or str, optional  If <code>bins</code> is an int, it defines the number of equal-width  bins in the given range (10, by default). If <code>bins</code> is a  sequence, it defines a monotonically increasing array of bin edges,  including the rightmost edge, allowing for non-uniform bin widths.</p>
+<pre><code>.. versionadded:: 1.11.0
+
+If `bins` is a string, it defines the method used to calculate the
+optimal bin width, as defined by `histogram_bin_edges`.
+</code></pre>
+<p>range : (float, float), optional  The lower and upper range of the bins. If not provided, range  is simply <code>(a.min(), a.max())</code>. Values outside the range are  ignored. The first element of the range must be less than or  equal to the second. <code>range</code> affects the automatic bin  computation as well. While bin width is computed to be optimal  based on the actual data within <code>range</code>, the bin count will fill  the entire range including portions containing no data. normed : bool, optional</p>
+<pre><code>.. deprecated:: 1.6.0
+
+This is equivalent to the `density` argument, but produces incorrect
+results for unequal bin widths. It should not be used.
+
+.. versionchanged:: 1.15.0
+    DeprecationWarnings are actually emitted.
+</code></pre>
+<p>weights : array_like, optional  An array of weights, of the same shape as <code>a</code>. Each value in  <code>a</code> only contributes its associated weight towards the bin count  (instead of 1). If <code>density</code> is True, the weights are  normalized, so that the integral of the density over the range  remains 1. density : bool, optional  If <code>False</code>, the result will contain the number of samples in  each bin. If <code>True</code>, the result is the value of the  probability <em>density</em> function at the bin, normalized such that  the <em>integral</em> over the range is 1. Note that the sum of the  histogram values will not be equal to 1 unless bins of unity  width are chosen; it is not a probability <em>mass</em> function.</p>
+<pre><code>Overrides the ``normed`` keyword if given.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>hist : array  The values of the histogram. See <code>density</code> and <code>weights</code> for a  description of the possible semantics. bin_edges : array of dtype float  Return the bin edges <code>(length(hist)+1)</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>histogramdd, bincount, searchsorted, digitize, histogram_bin_edges</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>All but the last (righthand-most) bin is half-open. In other words, if <code>bins</code> is::</p>
+<p>[1, 2, 3, 4]</p>
+<p>then the first bin is <code>[1, 2)</code> (including 1, but excluding 2) and the second <code>[2, 3)</code>. The last bin, however, is <code>[3, 4]</code>, which <em>includes</em> 4.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.histogram([1, 2, 1], bins=[0, 1, 2, 3]) (array([0, 2, 1]), array([0, 1, 2, 3])) np.histogram(np.arange(4), bins=np.arange(5), density=True) (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4])) np.histogram(<a href="null">1, 2, 1], [1, 0, 1</a>, bins=[0,1,2,3]) (array([1, 4, 1]), array([0, 1, 2, 3]))</p>
+      <p>a = np.arange(5) hist, bin_edges = np.histogram(a, density=True) hist array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5]) hist.sum() 2.4999999999999996 np.sum(hist * np.diff(bin_edges)) 1.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>.. versionadded:: 1.11.0</p>
+<p>Automated Bin Selection Methods example, using 2 peak random data with 2000 points:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt rng = np.random.RandomState(10) # deterministic random data a = np.hstack((rng.normal(size=1000), … rng.normal(loc=5, scale=2, size=1000))) _ = plt.hist(a, bins=‘auto’) # arguments are passed to np.histogram plt.title(“Histogram with ‘auto’ bins”) Text(0.5, 1.0, “Histogram with ‘auto’ bins”) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15624">view source</a></div></div><div class="public anchor" id="var-histogram2d"><h3>histogram2d</h3><div class="usage"><code>(histogram2d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the bi-dimensional histogram of two data samples.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like, shape (N,)  An array containing the x coordinates of the points to be  histogrammed. y : array_like, shape (N,)  An array containing the y coordinates of the points to be  histogrammed. bins : int or array_like or [int, int] or [array, array], optional  The bin specification:</p>
+<pre><code>  * If int, the number of bins for the two dimensions (nx=ny=bins).
+  * If array_like, the bin edges for the two dimensions
+    (x_edges=y_edges=bins).
+  * If [int, int], the number of bins in each dimension
+    (nx, ny = bins).
+  * If [array, array], the bin edges in each dimension
+    (x_edges, y_edges = bins).
+  * A combination [int, array] or [array, int], where int
+    is the number of bins and array is the bin edges.
+</code></pre>
+<p>range : array_like, shape(2,2), optional  The leftmost and rightmost edges of the bins along each dimension  (if not specified explicitly in the <code>bins</code> parameters):  <code>[[xmin, xmax], [ymin, ymax]]</code>. All values outside of this range  will be considered outliers and not tallied in the histogram. density : bool, optional  If False, the default, returns the number of samples in each bin.  If True, returns the probability <em>density</em> function at the bin,  <code>bin_count / sample_count / bin_area</code>. normed : bool, optional  An alias for the density argument that behaves identically. To avoid  confusion with the broken normed argument to <code>histogram</code>, <code>density</code>  should be preferred. weights : array_like, shape(N,), optional  An array of values <code>w_i</code> weighing each sample <code>(x_i, y_i)</code>.  Weights are normalized to 1 if <code>normed</code> is True. If <code>normed</code> is  False, the values of the returned histogram are equal to the sum of  the weights belonging to the samples falling into each bin.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>H : ndarray, shape(nx, ny)  The bi-dimensional histogram of samples <code>x</code> and <code>y</code>. Values in <code>x</code>  are histogrammed along the first dimension and values in <code>y</code> are  histogrammed along the second dimension. xedges : ndarray, shape(nx+1,)  The bin edges along the first dimension. yedges : ndarray, shape(ny+1,)  The bin edges along the second dimension.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>histogram : 1D histogram histogramdd : Multidimensional histogram</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>When <code>normed</code> is True, then the returned histogram is the sample density, defined such that the sum over bins of the product <code>bin_value * bin_area</code> is 1.</p>
+<p>Please note that the histogram does not follow the Cartesian convention where <code>x</code> values are on the abscissa and <code>y</code> values on the ordinate axis. Rather, <code>x</code> is histogrammed along the first dimension of the array (vertical), and <code>y</code> along the second dimension of the array (horizontal). This ensures compatibility with <code>histogramdd</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from matplotlib.image import NonUniformImage import matplotlib.pyplot as plt</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Construct a 2-D histogram with variable bin width. First define the bin edges:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>xedges = [0, 1, 3, 5] yedges = [0, 2, 3, 4, 6]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Next we create a histogram H with random bin content:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.random.normal(2, 1, 100) y = np.random.normal(1, 1, 100) H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges)) H = H.T # Let each row list bins with common y range.</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>:func:<code>imshow &lt;matplotlib.pyplot.imshow&gt;</code> can only display square bins:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>fig = plt.figure(figsize=(7, 3)) ax = fig.add_subplot(131, title=‘imshow: square bins’) plt.imshow(H, interpolation=‘nearest’, origin=‘low’, … extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]]) &lt;matplotlib.image.AxesImage object at 0x…&gt;</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>:func:<code>pcolormesh &lt;matplotlib.pyplot.pcolormesh&gt;</code> can display actual edges:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>ax = fig.add_subplot(132, title=‘pcolormesh: actual edges’, … aspect=‘equal’) X, Y = np.meshgrid(xedges, yedges) ax.pcolormesh(X, Y, H) &lt;matplotlib.collections.QuadMesh object at 0x…&gt;</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>:class:<code>NonUniformImage &lt;matplotlib.image.NonUniformImage&gt;</code> can be used to display actual bin edges with interpolation:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>ax = fig.add_subplot(133, title=‘NonUniformImage: interpolated’, … aspect=‘equal’, xlim=xedges<a href="null">0, -1</a>, ylim=yedges<a href="null">0, -1</a>) im = NonUniformImage(ax, interpolation=‘bilinear’) xcenters = (xedges[:-1] + xedges[1:]) / 2 ycenters = (yedges[:-1] + yedges[1:]) / 2 im.set_data(xcenters, ycenters, H) ax.images.append(im) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1916">view source</a></div></div><div class="public anchor" id="var-histogram_bin_edges"><h3>histogram_bin_edges</h3><div class="usage"><code>(histogram_bin_edges &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Function to calculate only the edges of the bins used by the <code>histogram</code> function.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. The histogram is computed over the flattened array. bins : int or sequence of scalars or str, optional  If <code>bins</code> is an int, it defines the number of equal-width  bins in the given range (10, by default). If <code>bins</code> is a  sequence, it defines the bin edges, including the rightmost  edge, allowing for non-uniform bin widths.</p>
+<pre><code>If `bins` is a string from the list below, `histogram_bin_edges` will use
+the method chosen to calculate the optimal bin width and
+consequently the number of bins (see `Notes` for more detail on
+the estimators) from the data that falls within the requested
+range. While the bin width will be optimal for the actual data
+in the range, the number of bins will be computed to fill the
+entire range, including the empty portions. For visualisation,
+using the 'auto' option is suggested. Weighted data is not
+supported for automated bin size selection.
+
+'auto'
+    Maximum of the 'sturges' and 'fd' estimators. Provides good
+    all around performance.
+
+'fd' (Freedman Diaconis Estimator)
+    Robust (resilient to outliers) estimator that takes into
+    account data variability and data size.
+
+'doane'
+    An improved version of Sturges' estimator that works better
+    with non-normal datasets.
+
+'scott'
+    Less robust estimator that that takes into account data
+    variability and data size.
+
+'stone'
+    Estimator based on leave-one-out cross-validation estimate of
+    the integrated squared error. Can be regarded as a generalization
+    of Scott's rule.
+
+'rice'
+    Estimator does not take variability into account, only data
+    size. Commonly overestimates number of bins required.
+
+'sturges'
+    R's default method, only accounts for data size. Only
+    optimal for gaussian data and underestimates number of bins
+    for large non-gaussian datasets.
+
+'sqrt'
+    Square root (of data size) estimator, used by Excel and
+    other programs for its speed and simplicity.
+</code></pre>
+<p>range : (float, float), optional  The lower and upper range of the bins. If not provided, range  is simply <code>(a.min(), a.max())</code>. Values outside the range are  ignored. The first element of the range must be less than or  equal to the second. <code>range</code> affects the automatic bin  computation as well. While bin width is computed to be optimal  based on the actual data within <code>range</code>, the bin count will fill  the entire range including portions containing no data.</p>
+<p>weights : array_like, optional  An array of weights, of the same shape as <code>a</code>. Each value in  <code>a</code> only contributes its associated weight towards the bin count  (instead of 1). This is currently not used by any of the bin estimators,  but may be in the future.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>bin_edges : array of dtype float  The edges to pass into <code>histogram</code></p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>histogram</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The methods to estimate the optimal number of bins are well founded in literature, and are inspired by the choices R provides for histogram visualisation. Note that having the number of bins proportional to :math:<code>n^{1/3}</code> is asymptotically optimal, which is why it appears in most estimators. These are simply plug-in methods that give good starting points for number of bins. In the equations below, :math:<code>h</code> is the binwidth and :math:<code>n_h</code> is the number of bins. All estimators that compute bin counts are recast to bin width using the <code>ptp</code> of the data. The final bin count is obtained from <code>np.round(np.ceil(range / h))</code>.</p>
+<p>‘auto’ (maximum of the ‘sturges’ and ‘fd’ estimators)  A compromise to get a good value. For small datasets the Sturges  value will usually be chosen, while larger datasets will usually  default to FD. Avoids the overly conservative behaviour of FD  and Sturges for small and large datasets respectively.  Switchover point is usually :math:<code>a.size \approx 1000</code>.</p>
+<p>‘fd’ (Freedman Diaconis Estimator)  .. math:: h = 2 \frac{IQR}{n^{1/3}}</p>
+<pre><code>The binwidth is proportional to the interquartile range (IQR)
+and inversely proportional to cube root of a.size. Can be too
+conservative for small datasets, but is quite good for large
+datasets. The IQR is very robust to outliers.
+</code></pre>
+<p>‘scott’  .. math:: h = \sigma \sqrt[3]{\frac{24 * \sqrt{\pi}}{n}}</p>
+<pre><code>The binwidth is proportional to the standard deviation of the
+data and inversely proportional to cube root of ``x.size``. Can
+be too conservative for small datasets, but is quite good for
+large datasets. The standard deviation is not very robust to
+outliers. Values are very similar to the Freedman-Diaconis
+estimator in the absence of outliers.
+</code></pre>
+<p>‘rice’  .. math:: n_h = 2n^{1/3}</p>
+<pre><code>The number of bins is only proportional to cube root of
+``a.size``. It tends to overestimate the number of bins and it
+does not take into account data variability.
+</code></pre>
+<p>‘sturges’  .. math:: n_h = \log _{2}n+1</p>
+<pre><code>The number of bins is the base 2 log of ``a.size``.  This
+estimator assumes normality of data and is too conservative for
+larger, non-normal datasets. This is the default method in R's
+``hist`` method.
+</code></pre>
+<p>‘doane’  .. math:: n_h = 1 + \log_{2}(n) +  \log_{2}(1 + \frac{|g_1|}{\sigma_{g_1}})</p>
+<pre><code>    g_1 = mean[(\frac{x - \mu}{\sigma})^3]
+
+    \sigma_{g_1} = \sqrt{\frac{6(n - 2)}{(n + 1)(n + 3)}}
+
+An improved version of Sturges' formula that produces better
+estimates for non-normal datasets. This estimator attempts to
+account for the skew of the data.
+</code></pre>
+<p>‘sqrt’  .. math:: n_h = \sqrt n</p>
+<pre><code>The simplest and fastest estimator. Only takes into account the
+data size.
+</code></pre>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]) np.histogram_bin_edges(arr, bins=‘auto’, range=(0, 1)) array([0. , 0.25, 0.5 , 0.75, 1. ]) np.histogram_bin_edges(arr, bins=2) array([0. , 2.5, 5. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>For consistency with histogram, an array of pre-computed bins is passed through unmodified:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.histogram_bin_edges(arr, [1, 2]) array([1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>This function allows one set of bins to be computed, and reused across multiple histograms:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>shared_bins = np.histogram_bin_edges(arr, bins=‘auto’) shared_bins array([0., 1., 2., 3., 4., 5.])</p>
+      <p>group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1]) hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins) hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins)</p>
+      <p>hist_0; hist_1 array([1, 1, 0, 1, 0]) array([2, 0, 1, 1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Which gives more easily comparable results than using separate bins for each histogram:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>hist_0, bins_0 = np.histogram(arr[group_id == 0], bins=‘auto’) hist_1, bins_1 = np.histogram(arr[group_id == 1], bins=‘auto’) hist_0; hist_1 array([1, 1, 1]) array([2, 1, 1, 2]) bins_0; bins_1 array([0., 1., 2., 3.]) array([0. , 1.25, 2.5 , 3.75, 5. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3186">view source</a></div></div><div class="public anchor" id="var-histogramdd"><h3>histogramdd</h3><div class="usage"><code>(histogramdd &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the multidimensional histogram of some data.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>sample : (N, D) array, or (D, N) array_like  The data to be histogrammed.</p>
+<pre><code>Note the unusual interpretation of sample when an array_like:
+
+* When an array, each row is a coordinate in a D-dimensional space -
+  such as ``histogramgramdd(np.array([p1, p2, p3]))``.
+* When an array_like, each element is the list of values for single
+  coordinate - such as ``histogramgramdd((X, Y, Z))``.
+
+The first form should be preferred.
+</code></pre>
+<p>bins : sequence or int, optional  The bin specification:</p>
+<pre><code>* A sequence of arrays describing the monotonically increasing bin
+  edges along each dimension.
+* The number of bins for each dimension (nx, ny, ... =bins)
+* The number of bins for all dimensions (nx=ny=...=bins).
+</code></pre>
+<p>range : sequence, optional  A sequence of length D, each an optional (lower, upper) tuple giving  the outer bin edges to be used if the edges are not given explicitly in  <code>bins</code>.  An entry of None in the sequence results in the minimum and maximum  values being used for the corresponding dimension.  The default, None, is equivalent to passing a tuple of D None values. density : bool, optional  If False, the default, returns the number of samples in each bin.  If True, returns the probability <em>density</em> function at the bin,  <code>bin_count / sample_count / bin_volume</code>. normed : bool, optional  An alias for the density argument that behaves identically. To avoid  confusion with the broken normed argument to <code>histogram</code>, <code>density</code>  should be preferred. weights : (N,) array_like, optional  An array of values <code>w_i</code> weighing each sample <code>(x_i, y_i, z_i, ...)</code>.  Weights are normalized to 1 if normed is True. If normed is False,  the values of the returned histogram are equal to the sum of the  weights belonging to the samples falling into each bin.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>H : ndarray  The multidimensional histogram of sample x. See normed and weights  for the different possible semantics. edges : list  A list of D arrays describing the bin edges for each dimension.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>histogram: 1-D histogram histogram2d: 2-D histogram</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>r = np.random.randn(100,3) H, edges = np.histogramdd(r, bins = (5, 8, 4)) H.shape, edges[0].size, edges[1].size, edges[2].size ((5, 8, 4), 6, 9, 5)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5110">view source</a></div></div><div class="public anchor" id="var-hsplit"><h3>hsplit</h3><div class="usage"><code>(hsplit &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Split an array into multiple sub-arrays horizontally (column-wise).</p>
+<p>Please refer to the <code>split</code> documentation. <code>hsplit</code> is equivalent to <code>split</code> with <code>axis=1</code>, the array is always split along the second axis regardless of the array dimension.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>split : Split an array into multiple sub-arrays of equal size.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(16.0).reshape(4, 4) x array(<a href="null"> 0.,   1.,   2.,   3.],
+       [ 4.,   5.,   6.,   7.],
+       [ 8.,   9.,  10.,  11.],
+       [12.,  13.,  14.,  15.</a>) np.hsplit(x, 2) [array([[ 0., 1.],  [ 4., 5.],  [ 8., 9.],  [12., 13.]]),  array([[ 2., 3.],  [ 6., 7.],  [10., 11.],  [14., 15.]])] np.hsplit(x, np.array([3, 6])) [array([[ 0., 1., 2.],  [ 4., 5., 6.],  [ 8., 9., 10.],  [12., 13., 14.]]),  array([[ 3.],  [ 7.],  [11.],  [15.]]),  array([], shape=(4, 0), dtype=float64)]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>With a higher dimensional array the split is still along the second axis.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(8.0).reshape(2, 2, 2) x array(<a href="null">[0.,  1.],
+        [2.,  3.</a>,  <a href="null">4.,  5.],
+        [6.,  7.</a>]) np.hsplit(x, 2) [array([[[0., 1.]],  [[4., 5.]]]),  array([[[2., 3.]],  [[6., 7.]]])]</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27302">view source</a></div></div><div class="public anchor" id="var-hstack"><h3>hstack</h3><div class="usage"><code>(hstack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Stack arrays in sequence horizontally (column wise).</p>
+<p>This is equivalent to concatenation along the second axis, except for 1-D arrays where it concatenates along the first axis. Rebuilds arrays divided by <code>hsplit</code>.</p>
+<p>This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions <code>concatenate</code>, <code>stack</code> and <code>block</code> provide more general stacking and concatenation operations.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>tup : sequence of ndarrays  The arrays must have the same shape along all but the second axis,  except 1-D arrays which can be any length.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>stacked : ndarray  The array formed by stacking the given arrays.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>stack : Join a sequence of arrays along a new axis. vstack : Stack arrays in sequence vertically (row wise). dstack : Stack arrays in sequence depth wise (along third axis). concatenate : Join a sequence of arrays along an existing axis. hsplit : Split array along second axis. block : Assemble arrays from blocks.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array((1,2,3)) b = np.array((2,3,4)) np.hstack((a,b)) array([1, 2, 3, 2, 3, 4]) a = np.array(<a href="null">1],[2],[3</a>) b = np.array(<a href="null">2],[3],[4</a>) np.hstack((a,b)) array(<a href="null">1, 2],
+       [2, 3],
+       [3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25776">view source</a></div></div><div class="public anchor" id="var-hypot"><h3>hypot</h3><div class="usage"><code>(hypot self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>hypot(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Given the “legs” of a right triangle, return its hypotenuse.</p>
+<p>Equivalent to <code>sqrt(x1**2 + x2**2)</code>, element-wise. If <code>x1</code> or <code>x2</code> is scalar_like (i.e., unambiguously cast-able to a scalar type), it is broadcast for use with each element of the other argument. (See Examples)</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Leg of the triangle(s). If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>z : ndarray  The hypotenuse of the triangle(s).  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) array(<a href="null"> 5.,  5.,  5.],
+       [ 5.,  5.,  5.],
+       [ 5.,  5.,  5.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Example showing broadcast of scalar_like argument:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.hypot(3*np.ones((3, 3)), [4]) array(<a href="null"> 5.,  5.,  5.],
+       [ 5.,  5.,  5.],
+       [ 5.,  5.,  5.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14943">view source</a></div></div><div class="public anchor" id="var-i0"><h3>i0</h3><div class="usage"><code>(i0 &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Modified Bessel function of the first kind, order 0.</p>
+<p>Usually denoted :math:<code>I_0</code>. This function does broadcast, but will <em>not</em> “up-cast” int dtype arguments unless accompanied by at least one float or complex dtype argument (see Raises below).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like, dtype float or complex  Argument of the Bessel function.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray, shape = x.shape, dtype = x.dtype  The modified Bessel function evaluated at each of the elements of <code>x</code>.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>TypeError: array cannot be safely cast to required type  If argument consists exclusively of int dtypes.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>scipy.special.i0, scipy.special.iv, scipy.special.ive</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The scipy implementation is recommended over this function: it is a proper ufunc written in C, and more than an order of magnitude faster.</p>
+<p>We use the algorithm published by Clenshaw [1]_ and referenced by Abramowitz and Stegun [2]_, for which the function domain is partitioned into the two intervals [0,8] and (8,inf), and Chebyshev polynomial expansions are employed in each interval. Relative error on the domain [0,30] using IEEE arithmetic is documented [3]_ as having a peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] C. W. Clenshaw, “Chebyshev series for mathematical functions”, in  <em>National Physical Laboratory Mathematical Tables</em>, vol. 5, London:  Her Majesty’s Stationery Office, 1962. .. [2] M. Abramowitz and I. A. Stegun, <em>Handbook of Mathematical  Functions</em>, 10th printing, New York: Dover, 1964, pp. 379.  <a href="http://www.math.sfu.ca/~cbm/aands/page_379.htm">http://www.math.sfu.ca/~cbm/aands/page_379.htm</a> .. [3] <a href="http://kobesearch.cpan.org/htdocs/Math-Cephes/Math/Cephes.html">http://kobesearch.cpan.org/htdocs/Math-Cephes/Math/Cephes.html</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.i0(0.) array(1.0) # may vary np.i0([0., 1. + 2j]) array([ 1.00000000+0.j , 0.18785373+0.64616944j]) # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13950">view source</a></div></div><div class="public anchor" id="var-identity"><h3>identity</h3><div class="usage"><code>(identity n &amp; [{dtype :dtype}])</code><code>(identity n)</code></div><div class="doc"><div class="markdown"><p>Return the identity array.</p>
+<p>The identity array is a square array with ones on the main diagonal.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>n : int  Number of rows (and columns) in <code>n</code> x <code>n</code> output. dtype : data-type, optional  Data-type of the output. Defaults to <code>float</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  <code>n</code> x <code>n</code> array with its main diagonal set to one,  and all other elements 0.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.identity(3) array(<a href="null">1.,  0.,  0.],
+       [0.,  1.,  0.],
+       [0.,  0.,  1.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16898">view source</a></div></div><div class="public anchor" id="var-iinfo"><h3>iinfo</h3><div class="usage"><code>(iinfo self int_type)</code></div><div class="doc"><div class="markdown"><p>iinfo(type)</p>
+<p>Machine limits for integer types.</p>
+<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
+<p>bits : int  The number of bits occupied by the type. min : int  The smallest integer expressible by the type. max : int  The largest integer expressible by the type.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>int_type : integer type, dtype, or instance  The kind of integer data type to get information about.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>finfo : The equivalent for floating point data types.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>With types:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>ii16 = np.iinfo(np.int16) ii16.min -32768 ii16.max 32767 ii32 = np.iinfo(np.int32) ii32.min -2147483648 ii32.max 2147483647</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>With instances:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>ii32 = np.iinfo(np.int32(10)) ii32.min -2147483648 ii32.max 2147483647</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21405">view source</a></div></div><div class="public anchor" id="var-imag"><h3>imag</h3><div class="usage"><code>(imag &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the imaginary part of the complex argument.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>val : array_like  Input array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  The imaginary component of the complex argument. If <code>val</code> is real,  the type of <code>val</code> is used for the output. If <code>val</code> has complex  elements, the returned type is float.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>real, angle, real_if_close</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1+2j, 3+4j, 5+6j]) a.imag array([2., 4., 6.]) a.imag = np.array([8, 10, 12]) a array([1. +8.j, 3.+10.j, 5.+12.j]) np.imag(1 + 1j) 1.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12504">view source</a></div></div><div class="public anchor" id="var-in1d"><h3>in1d</h3><div class="usage"><code>(in1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Test whether each element of a 1-D array is also present in a second array.</p>
+<p>Returns a boolean array the same length as <code>ar1</code> that is True where an element of <code>ar1</code> is in <code>ar2</code> and False otherwise.</p>
+<p>We recommend using :func:<code>isin</code> instead of <code>in1d</code> for new code.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>ar1 : (M,) array_like  Input array. ar2 : array_like  The values against which to test each value of <code>ar1</code>. assume_unique : bool, optional  If True, the input arrays are both assumed to be unique, which  can speed up the calculation. Default is False. invert : bool, optional  If True, the values in the returned array are inverted (that is,  False where an element of <code>ar1</code> is in <code>ar2</code> and True otherwise).  Default is False. <code>np.in1d(a, b, invert=True)</code> is equivalent  to (but is faster than) <code>np.invert(in1d(a, b))</code>.</p>
+<pre><code>.. versionadded:: 1.8.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>in1d : (M,) ndarray, bool  The values <code>ar1[in1d]</code> are in <code>ar2</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>isin : Version of this function that preserves the  shape of ar1. numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>in1d</code> can be considered as an element-wise function version of the python keyword <code>in</code>, for 1-D sequences. <code>in1d(a, b)</code> is roughly equivalent to <code>np.array([item in b for item in a])</code>. However, this idea fails if <code>ar2</code> is a set, or similar (non-sequence) container: As <code>ar2</code> is converted to an array, in those cases <code>asarray(ar2)</code> is an object array rather than the expected array of contained values.</p>
+<p>.. versionadded:: 1.4.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>test = np.array([0, 1, 2, 5, 0]) states = [0, 2] mask = np.in1d(test, states) mask array([ True, False, True, False, True]) test[mask] array([0, 2, 0]) mask = np.in1d(test, states, invert=True) mask array([False, True, False, True, False]) test[mask] array([1, 5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4898">view source</a></div></div><div class="public anchor" id="var-index_exp"><h3>index_exp</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A nicer way to build up index tuples for arrays.</p>
+<p>.. note::  Use one of the two predefined instances <code>index_exp</code> or <code>s_</code>  rather than directly using <code>IndexExpression</code>.</p>
+<p>For any index combination, including slicing and axis insertion, <code>a[indices]</code> is the same as <code>a[np.index_exp[indices]]</code> for any array <code>a</code>. However, <code>np.index_exp[indices]</code> can be used anywhere in Python code and returns a tuple of slice objects that can be used in the construction of complex index expressions.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>maketuple : bool  If True, always returns a tuple.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>index_exp : Predefined instance that always returns a tuple:  <code>index_exp = IndexExpression(maketuple=True)</code>. s_ : Predefined instance without tuple conversion:  <code>s_ = IndexExpression(maketuple=False)</code>.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>You can do all this with <code>slice()</code> plus a few special objects, but there’s a lot to remember and this version is simpler because it uses the standard array indexing syntax.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.s_[2::2] slice(2, None, 2) np.index_exp[2::2] (slice(2, None, 2),)</p>
+      <p>np.array([0, 1, 2, 3, 4])[np.s_[2::2]] array([2, 4])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18097">view source</a></div></div><div class="public anchor" id="var-indices"><h3>indices</h3><div class="usage"><code>(indices dimensions &amp; [{dtype :dtype, sparse :sparse}])</code><code>(indices dimensions &amp; [{dtype :dtype}])</code><code>(indices dimensions)</code></div><div class="doc"><div class="markdown"><p>Return an array representing the indices of a grid.</p>
+<p>Compute an array where the subarrays contain index values 0, 1, … varying only along the corresponding axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>dimensions : sequence of ints  The shape of the grid. dtype : dtype, optional  Data type of the result. sparse : boolean, optional  Return a sparse representation of the grid instead of a dense  representation. Default is False.</p>
+<pre><code>.. versionadded:: 1.17
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>grid : one ndarray or tuple of ndarrays  If sparse is False:  Returns one array of grid indices,  <code>grid.shape = (len(dimensions),) + tuple(dimensions)</code>.  If sparse is True:  Returns a tuple of arrays, with  <code>grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)</code> with  dimensions[i] in the ith place</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>mgrid, ogrid, meshgrid</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The output shape in the dense case is obtained by prepending the number of dimensions in front of the tuple of dimensions, i.e. if <code>dimensions</code> is a tuple <code>(r0, ..., rN-1)</code> of length <code>N</code>, the output shape is <code>(N, r0, ..., rN-1)</code>.</p>
+<p>The subarrays <code>grid[k]</code> contains the N-D array of indices along the <code>k-th</code> axis. Explicitly::</p>
+<pre><code>grid[k, i0, i1, ..., iN-1] = ik
+</code></pre>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>grid = np.indices((2, 3)) grid.shape (2, 2, 3) grid[0] # row indices array(<a href="null">0, 0, 0],
+       [1, 1, 1</a>) grid[1] # column indices array(<a href="null">0, 1, 2],
+       [0, 1, 2</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The indices can be used as an index into an array.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(20).reshape(5, 4) row, col = np.indices((2, 3)) x[row, col] array(<a href="null">0, 1, 2],
+       [4, 5, 6</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that it would be more straightforward in the above example to extract the required elements directly with <code>x[:2, :3]</code>.</p>
+<p>If sparse is set to true, the grid will be returned in a sparse representation.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>i, j = np.indices((2, 3), sparse=True) i.shape (2, 1) j.shape (1, 3) i # row indices array(<a href="null">0],
+       [1</a>) j # column indices array(<a href="null">0, 1, 2</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28529">view source</a></div></div><div class="public anchor" id="var-inexact"><h3>inexact</h3><div class="usage"><code>(inexact self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all numeric scalar types with a (potentially) inexact representation of the values in its range, such as floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L381">view source</a></div></div><div class="public anchor" id="var-Inf"><h3>Inf</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24060">view source</a></div></div><div class="public anchor" id="var-inf"><h3>inf</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4408">view source</a></div></div><div class="public anchor" id="var-Infinity"><h3>Infinity</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14129">view source</a></div></div><div class="public anchor" id="var-info"><h3>info</h3><div class="usage"><code>(info &amp; [{object :object, maxwidth :maxwidth, output :output, toplevel :toplevel}])</code><code>(info &amp; [{object :object, maxwidth :maxwidth, output :output}])</code><code>(info &amp; [{object :object, maxwidth :maxwidth}])</code><code>(info &amp; [{object :object}])</code><code>(info)</code></div><div class="doc"><div class="markdown"><p>Get help information for a function, class, or module.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>object : object or str, optional  Input object or name to get information about. If <code>object</code> is a  numpy object, its docstring is given. If it is a string, available  modules are searched for matching objects. If None, information  about <code>info</code> itself is returned. maxwidth : int, optional  Printing width. output : file like object, optional  File like object that the output is written to, default is  <code>stdout</code>. The object has to be opened in ‘w’ or ‘a’ mode. toplevel : str, optional  Start search at this level.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>source, lookfor</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>When used interactively with an object, <code>np.info(obj)</code> is equivalent to <code>help(obj)</code> on the Python prompt or <code>obj?</code> on the IPython prompt.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.info(np.polyval) # doctest: +SKIP  polyval(p, x)  Evaluate the polynomial p at x.  …</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>When using a string for <code>object</code> it is possible to get multiple results.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.info(‘fft’) # doctest: +SKIP  *** Found in numpy *** Core FFT routines …  *** Found in numpy.fft ***  fft(a, n=None, axis=-1) …  *** Repeat reference found in numpy.fft.fftpack ***  *** Total of 3 references found. ***</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9162">view source</a></div></div><div class="public anchor" id="var-infty"><h3>infty</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2739">view source</a></div></div><div class="public anchor" id="var-inner"><h3>inner</h3><div class="usage"><code>(inner &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>inner(a, b)</p>
+<p>Inner product of two arrays.</p>
+<p>Ordinary inner product of vectors for 1-D arrays (without complex conjugation), in higher dimensions a sum product over the last axes.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a, b : array_like  If <code>a</code> and <code>b</code> are nonscalar, their last dimensions must match.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  <code>out.shape = a.shape[:-1] + b.shape[:-1]</code></p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If the last dimension of <code>a</code> and <code>b</code> has different size.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>tensordot : Sum products over arbitrary axes. dot : Generalised matrix product, using second last dimension of <code>b</code>. einsum : Einstein summation convention.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>For vectors (1-D arrays) it computes the ordinary inner-product::</p>
+<pre><code>np.inner(a, b) = sum(a[:]*b[:])
+</code></pre>
+<p>More generally, if <code>ndim(a) = r &gt; 0</code> and <code>ndim(b) = s &gt; 0</code>::</p>
+<pre><code>np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))
+</code></pre>
+<p>or explicitly::</p>
+<pre><code>np.inner(a, b)[i0,...,ir-1,j0,...,js-1]
+     = sum(a[i0,...,ir-1,:]*b[j0,...,js-1,:])
+</code></pre>
+<p>In addition <code>a</code> or <code>b</code> may be scalars, in which case::</p>
+<p>np.inner(a,b) = a*b</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Ordinary inner product for vectors:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1,2,3]) b = np.array([0,1,0]) np.inner(a, b) 2</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>A multidimensional example:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(24).reshape((2,3,4)) b = np.arange(4) np.inner(a, b) array(<a href="null"> 14,  38,  62],
+       [ 86, 110, 134</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>An example where <code>b</code> is a scalar:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.inner(np.eye(2), 7) array(<a href="null">7., 0.],
+       [0., 7.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22990">view source</a></div></div><div class="public anchor" id="var-insert"><h3>insert</h3><div class="usage"><code>(insert &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Insert values along the given axis before the given indices.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr : array_like  Input array. obj : int, slice or sequence of ints  Object that defines the index or indices before which <code>values</code> is  inserted.</p>
+<pre><code>.. versionadded:: 1.8.0
+
+Support for multiple insertions when `obj` is a single scalar or a
+sequence with one element (similar to calling insert multiple
+times).
+</code></pre>
+<p>values : array_like  Values to insert into <code>arr</code>. If the type of <code>values</code> is different  from that of <code>arr</code>, <code>values</code> is converted to the type of <code>arr</code>.  <code>values</code> should be shaped so that <code>arr[...,obj,...] = values</code>  is legal. axis : int, optional  Axis along which to insert <code>values</code>. If <code>axis</code> is None then <code>arr</code>  is flattened first.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  A copy of <code>arr</code> with <code>values</code> inserted. Note that <code>insert</code>  does not occur in-place: a new array is returned. If  <code>axis</code> is None, <code>out</code> is a flattened array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>append : Append elements at the end of an array. concatenate : Join a sequence of arrays along an existing axis. delete : Delete elements from an array.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Note that for higher dimensional inserts <code>obj=0</code> behaves very different from <code>obj=[0]</code> just like <code>arr[:,0,:] = values</code> is different from <code>arr[:,[0],:] = values</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 1], [2, 2], [3, 3</a>) a array(<a href="null">1, 1],
+       [2, 2],
+       [3, 3</a>) np.insert(a, 1, 5) array([1, 5, 1, …, 2, 3, 3]) np.insert(a, 1, 5, axis=1) array(<a href="null">1, 5, 1],
+       [2, 5, 2],
+       [3, 5, 3</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Difference between sequence and scalars:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.insert(a, [1], <a href="null">1],[2],[3</a>, axis=1) array(<a href="null">1, 1, 1],
+       [2, 2, 2],
+       [3, 3, 3</a>) np.array_equal(np.insert(a, 1, [1, 2, 3], axis=1), … np.insert(a, [1], <a href="null">1],[2],[3</a>, axis=1)) True</p>
+      <p>b = a.flatten() b array([1, 1, 2, 2, 3, 3]) np.insert(b, [2, 2], [5, 6]) array([1, 1, 5, …, 2, 3, 3])</p>
+      <p>np.insert(b, slice(2, 4), [5, 6]) array([1, 1, 5, …, 2, 3, 3])</p>
+      <p>np.insert(b, [2, 2], [7.13, False]) # type casting array([1, 1, 7, …, 2, 3, 3])</p>
+      <p>x = np.arange(8).reshape(2, 4) idx = (1, 3) np.insert(x, idx, 999, axis=1) array(<a href="null">  0, 999,   1,   2, 999,   3],
+       [  4, 999,   5,   6, 999,   7</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21809">view source</a></div></div><div class="public anchor" id="var-int"><h3>int</h3><div class="usage"><code>(int self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>int([x]) -&gt; integer int(x, base=10) -&gt; integer</p>
+<p>Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.</p>
+<p>If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by ‘+’ or ‘-’ and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>int(‘0b100’, base=0) 4</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L710">view source</a></div></div><div class="public anchor" id="var-int0"><h3>int0</h3><div class="usage"><code>(int0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with Python <code>int</code> anc C <code>long</code>. Character code: <code>'l'</code>. Canonical name: <code>np.int_</code>. Alias <em>on this platform</em>: <code>np.int64</code>: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). Alias <em>on this platform</em>: <code>np.intp</code>: Signed integer large enough to fit pointer, compatible with C <code>intptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22529">view source</a></div></div><div class="public anchor" id="var-int16"><h3>int16</h3><div class="usage"><code>(int16 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>short</code>. Character code: <code>'h'</code>. Canonical name: <code>np.short</code>. Alias <em>on this platform</em>: <code>np.int16</code>: 16-bit signed integer (-32768 to 32767).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L195">view source</a></div></div><div class="public anchor" id="var-int32"><h3>int32</h3><div class="usage"><code>(int32 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>int</code>. Character code: <code>'i'</code>. Canonical name: <code>np.intc</code>. Alias <em>on this platform</em>: <code>np.int32</code>: 32-bit signed integer (-2147483648 to 2147483647).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5536">view source</a></div></div><div class="public anchor" id="var-int64"><h3>int64</h3><div class="usage"><code>(int64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with Python <code>int</code> anc C <code>long</code>. Character code: <code>'l'</code>. Canonical name: <code>np.int_</code>. Alias <em>on this platform</em>: <code>np.int64</code>: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). Alias <em>on this platform</em>: <code>np.intp</code>: Signed integer large enough to fit pointer, compatible with C <code>intptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7604">view source</a></div></div><div class="public anchor" id="var-int8"><h3>int8</h3><div class="usage"><code>(int8 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>char</code>. Character code: <code>'b'</code>. Canonical name: <code>np.byte</code>. Alias <em>on this platform</em>: <code>np.int8</code>: 8-bit signed integer (-128 to 127).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20131">view source</a></div></div><div class="public anchor" id="var-int_"><h3>int_</h3><div class="usage"><code>(int_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with Python <code>int</code> anc C <code>long</code>. Character code: <code>'l'</code>. Canonical name: <code>np.int_</code>. Alias <em>on this platform</em>: <code>np.int64</code>: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). Alias <em>on this platform</em>: <code>np.intp</code>: Signed integer large enough to fit pointer, compatible with C <code>intptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19065">view source</a></div></div><div class="public anchor" id="var-int_asbuffer"><h3>int_asbuffer</h3><div class="usage"><code>(int_asbuffer self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1593">view source</a></div></div><div class="public anchor" id="var-intc"><h3>intc</h3><div class="usage"><code>(intc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>int</code>. Character code: <code>'i'</code>. Canonical name: <code>np.intc</code>. Alias <em>on this platform</em>: <code>np.int32</code>: 32-bit signed integer (-2147483648 to 2147483647).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5530">view source</a></div></div><div class="public anchor" id="var-integer"><h3>integer</h3><div class="usage"><code>(integer self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all integer scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20041">view source</a></div></div><div class="public anchor" id="var-interp"><h3>interp</h3><div class="usage"><code>(interp &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>One-dimensional linear interpolation.</p>
+<p>Returns the one-dimensional piecewise linear interpolant to a function with given discrete data points (<code>xp</code>, <code>fp</code>), evaluated at <code>x</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  The x-coordinates at which to evaluate the interpolated values.</p>
+<p>xp : 1-D sequence of floats  The x-coordinates of the data points, must be increasing if argument  <code>period</code> is not specified. Otherwise, <code>xp</code> is internally sorted after  normalizing the periodic boundaries with <code>xp = xp % period</code>.</p>
+<p>fp : 1-D sequence of float or complex  The y-coordinates of the data points, same length as <code>xp</code>.</p>
+<p>left : optional float or complex corresponding to fp  Value to return for <code>x &lt; xp[0]</code>, default is <code>fp[0]</code>.</p>
+<p>right : optional float or complex corresponding to fp  Value to return for <code>x &gt; xp[-1]</code>, default is <code>fp[-1]</code>.</p>
+<p>period : None or float, optional  A period for the x-coordinates. This parameter allows the proper  interpolation of angular x-coordinates. Parameters <code>left</code> and <code>right</code>  are ignored if <code>period</code> is specified.</p>
+<pre><code>.. versionadded:: 1.10.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : float or complex (corresponding to fp) or ndarray  The interpolated values, same shape as <code>x</code>.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If <code>xp</code> and <code>fp</code> have different length  If <code>xp</code> or <code>fp</code> are not 1-D sequences  If <code>period == 0</code></p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The x-coordinate sequence is expected to be increasing, but this is not explicitly enforced. However, if the sequence <code>xp</code> is non-increasing, interpolation results are meaningless.</p>
+<p>Note that, since NaN is unsortable, <code>xp</code> also cannot contain NaNs.</p>
+<p>A simple check for <code>xp</code> being strictly increasing is::</p>
+<pre><code>np.all(np.diff(xp) &gt; 0)
+</code></pre>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>xp = [1, 2, 3] fp = [3, 2, 0] np.interp(2.5, xp, fp) 1.0 np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp) array([3. , 3. , 2.5 , 0.56, 0. ]) UNDEF = -99.0 np.interp(3.14, xp, fp, right=UNDEF) -99.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot an interpolant to the sine function:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.linspace(0, 2*np.pi, 10) y = np.sin(x) xvals = np.linspace(0, 2*np.pi, 50) yinterp = np.interp(xvals, x, y) import matplotlib.pyplot as plt plt.plot(x, y, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.plot(xvals, yinterp, ‘-x’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Interpolation with periodic x-coordinates:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = [-180, -170, -185, 185, -10, -5, 0, 365] xp = [190, -190, 350, -350] fp = [5, 10, 3, 4] np.interp(x, xp, fp, period=360) array([7.5 , 5. , 8.75, 6.25, 3. , 3.25, 3.5 , 3.75])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Complex interpolation:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = [1.5, 4.0] xp = [2,3,5] fp = [1.0j, 0, 2+3j] np.interp(x, xp, fp) array([0.+1.j , 1.+1.5j])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10582">view source</a></div></div><div class="public anchor" id="var-intersect1d"><h3>intersect1d</h3><div class="usage"><code>(intersect1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the intersection of two arrays.</p>
+<p>Return the sorted, unique values that are in both of the input arrays.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>ar1, ar2 : array_like  Input arrays. Will be flattened if not already 1D. assume_unique : bool  If True, the input arrays are both assumed to be unique, which  can speed up the calculation. Default is False. return_indices : bool  If True, the indices which correspond to the intersection of the two  arrays are returned. The first instance of a value is used if there are  multiple. Default is False.</p>
+<pre><code>.. versionadded:: 1.15.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>intersect1d : ndarray  Sorted 1D array of common and unique elements. comm1 : ndarray  The indices of the first occurrences of the common values in <code>ar1</code>.  Only provided if <code>return_indices</code> is True. comm2 : ndarray  The indices of the first occurrences of the common values in <code>ar2</code>.  Only provided if <code>return_indices</code> is True.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1]) array([1, 3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>To intersect more than two arrays, use functools.reduce:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from functools import reduce reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) array([3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>To return the indices of the values common to the input arrays along with the intersected values:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([1, 1, 2, 3, 4]) y = np.array([2, 1, 4, 6]) xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True) x_ind, y_ind (array([0, 2, 4]), array([1, 0, 2])) xy, x[x_ind], y[y_ind] (array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19570">view source</a></div></div><div class="public anchor" id="var-intp"><h3>intp</h3><div class="usage"><code>(intp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with Python <code>int</code> anc C <code>long</code>. Character code: <code>'l'</code>. Canonical name: <code>np.int_</code>. Alias <em>on this platform</em>: <code>np.int64</code>: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). Alias <em>on this platform</em>: <code>np.intp</code>: Signed integer large enough to fit pointer, compatible with C <code>intptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4070">view source</a></div></div><div class="public anchor" id="var-invert"><h3>invert</h3><div class="usage"><code>(invert self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>invert(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute bit-wise inversion, or bit-wise NOT, element-wise.</p>
+<p>Computes the bit-wise NOT of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>~</code>.</p>
+<p>For signed integer inputs, the two’s complement is returned. In a two’s-complement system negative numbers are represented by the two’s complement of the absolute value. This is the most common method of representing signed integers on computers [1]_. A N-bit two’s-complement system can represent every integer in the range :math:<code>-2^{N-1}</code> to :math:<code>+2^{N-1}-1</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Only integer and boolean types are handled. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Result.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>bitwise_and, bitwise_or, bitwise_xor logical_not binary_repr :  Return the binary representation of the input number as a string.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>bitwise_not</code> is an alias for <code>invert</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.bitwise_not is np.invert True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Wikipedia, “Two’s complement”,  <a href="https://en.wikipedia.org/wiki/Two's_complement">https://en.wikipedia.org/wiki/Two's_complement</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>We’ve seen that 13 is represented by <code>00001101</code>. The invert or bit-wise NOT of 13 is then:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.invert(np.array(13, dtype=np.uint8)) x 242 np.binary_repr(x, width=8) ‘11110010’</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The result depends on the bit-width:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.invert(np.array(13, dtype=np.uint16)) x 65522 np.binary_repr(x, width=16) ‘1111111111110010’</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>When using signed integer types the result is the two’s complement of the result for the unsigned type:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.invert(np.array([13], dtype=np.int8)) array([-14], dtype=int8) np.binary_repr(-14, width=8) ‘11110010’</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Booleans are accepted as well:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.invert(np.array([True, False])) array([False, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2133">view source</a></div></div><div class="public anchor" id="var-ipmt"><h3>ipmt</h3><div class="usage"><code>(ipmt &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the interest portion of a payment.</p>
+<p>.. deprecated:: 1.18</p>
+<p><code>ipmt</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>rate : scalar or array_like of shape(M, )  Rate of interest as decimal (not per cent) per period per : scalar or array_like of shape(M, )  Interest paid against the loan changes during the life or the loan.  The <code>per</code> is the payment period to calculate the interest amount. nper : scalar or array_like of shape(M, )  Number of compounding periods pv : scalar or array_like of shape(M, )  Present value fv : scalar or array_like of shape(M, ), optional  Future value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}, optional  When payments are due (‘begin’ (1) or ‘end’ (0)).  Defaults to {‘end’, 0}.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Interest portion of payment. If all input is scalar, returns a scalar  float. If any input is array_like, returns interest payment for each  input element. If multiple inputs are array_like, they all must have  the same shape.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ppmt, pmt, pv</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The total payment is made up of payment against principal plus interest.</p>
+<p><code>pmt = ppmt + ipmt</code></p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>What is the amortization schedule for a 1 year loan of $2500 at 8.24% interest per year compounded monthly?</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>principal = 2500.00</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The ‘per’ variable represents the periods of the loan. Remember that financial equations start the period count at 1!</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>per = np.arange(1*12) + 1 ipmt = np.ipmt(0.0824/12, per, 1*12, principal) ppmt = np.ppmt(0.0824/12, per, 1*12, principal)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Each element of the sum of the ‘ipmt’ and ‘ppmt’ arrays should equal ‘pmt’.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>pmt = np.pmt(0.0824/12, 1*12, principal) np.allclose(ipmt + ppmt, pmt) True</p>
+      <p>fmt = ‘{0:2d} {1:8.2f} {2:8.2f} {3:8.2f}’ for payment in per: … index = payment - 1 … principal = principal + ppmt[index] … print(fmt.format(payment, ppmt[index], ipmt[index], principal))  1 -200.58 -17.17 2299.42  2 -201.96 -15.79 2097.46  3 -203.35 -14.40 1894.11  4 -204.74 -13.01 1689.37  5 -206.15 -11.60 1483.22  6 -207.56 -10.18 1275.66  7 -208.99 -8.76 1066.67  8 -210.42 -7.32 856.25  9 -211.87 -5.88 644.38 10 -213.32 -4.42 431.05 11 -214.79 -2.96 216.26 12 -216.26 -1.49 -0.00</p>
+      <p>interestpd = np.sum(ipmt) np.round(interestpd, 2) -112.98</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9913">view source</a></div></div><div class="public anchor" id="var-irr"><h3>irr</h3><div class="usage"><code>(irr &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the Internal Rate of Return (IRR).</p>
+<p>.. deprecated:: 1.18</p>
+<p><code>irr</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
+<p>This is the “average” periodically compounded rate of return that gives a net present value of 0.0; for a more complete explanation, see Notes below.</p>
+<p>:class:<code>decimal.Decimal</code> type is not supported.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>values : array_like, shape(N,)  Input cash flows per time period. By convention, net “deposits”  are negative and net “withdrawals” are positive. Thus, for  example, at least the first element of <code>values</code>, which represents  the initial investment, will typically be negative.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : float  Internal Rate of Return for periodic input values.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The IRR is perhaps best understood through an example (illustrated using np.irr in the Examples section below). Suppose one invests 100 units and then makes the following withdrawals at regular (fixed) intervals: 39, 59, 55, 20. Assuming the ending value is 0, one’s 100 unit investment yields 173 units; however, due to the combination of compounding and the periodic withdrawals, the “average” rate of return is neither simply 0.73/4 nor (1.73)^0.25-1. Rather, it is the solution (for :math:<code>r</code>) of the equation:</p>
+<p>.. math:: -100 + \frac{39}{1+r} + \frac{59}{(1+r)^2}  + \frac{55}{(1+r)^3} + \frac{20}{(1+r)^4} = 0</p>
+<p>In general, for <code>values</code> :math:<code>= [v_0, v_1, ... v_M]</code>, irr is the solution of the equation: [2]_</p>
+<p>.. math:: \sum_{t=0}^M{\frac{v_t}{(1+irr)^{t}}} = 0</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] L. J. Gitman, “Principles of Managerial Finance, Brief,” 3rd ed.,  Addison-Wesley, 2003, pg. 348.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>round(np.irr([-100, 39, 59, 55, 20]), 5) 0.28095 round(np.irr([-100, 0, 0, 74]), 5) -0.0955 round(np.irr([-100, 100, 0, -7]), 5) -0.0833 round(np.irr([-100, 100, 0, 7]), 5) 0.06206 round(np.irr([-5, 10.5, 1, -8, 1]), 5) 0.0886</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18661">view source</a></div></div><div class="public anchor" id="var-is_busday"><h3>is_busday</h3><div class="usage"><code>(is_busday &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>is_busday(dates, weekmask=‘1111100’, holidays=None, busdaycal=None, out=None)</p>
+<p>Calculates which of the given dates are valid days, and which are not.</p>
+<p>.. versionadded:: 1.7.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>dates : array_like of datetime64[D]  The array of dates to process. weekmask : str or array_like of bool, optional  A seven-element array indicating which of Monday through Sunday are  valid days. May be specified as a length-seven list or array, like  [1,1,1,1,1,0,0]; a length-seven string, like ‘1111100’; or a string  like “Mon Tue Wed Thu Fri”, made up of 3-character abbreviations for  weekdays, optionally separated by white space. Valid abbreviations  are: Mon Tue Wed Thu Fri Sat Sun holidays : array_like of datetime64[D], optional  An array of dates to consider as invalid dates. They may be  specified in any order, and NaT (not-a-time) dates are ignored.  This list is saved in a normalized form that is suited for  fast calculations of valid days. busdaycal : busdaycalendar, optional  A <code>busdaycalendar</code> object which specifies the valid days. If this  parameter is provided, neither weekmask nor holidays may be  provided. out : array of bool, optional  If provided, this array is filled with the result.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : array of bool  An array with the same shape as <code>dates</code>, containing True for  each valid day, and False for each invalid day.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>busdaycalendar: An object that specifies a custom set of valid days. busday_offset : Applies an offset counted in valid days. busday_count : Counts how many valid days are in a half-open date range.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <h1><a href="#the-weekdays-are-friday-saturday-and-monday" name="the-weekdays-are-friday-saturday-and-monday"></a>The weekdays are Friday, Saturday, and Monday</h1>
+      <p>… np.is_busday([‘2011-07-01’, ‘2011-07-02’, ‘2011-07-18’], … holidays=[‘2011-07-01’, ‘2011-07-04’, ‘2011-07-17’]) array([False, False, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5768">view source</a></div></div><div class="public anchor" id="var-isclose"><h3>isclose</h3><div class="usage"><code>(isclose &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns a boolean array where two arrays are element-wise equal within a tolerance.</p>
+<p>The tolerance values are positive, typically very small numbers. The relative difference (<code>rtol</code> * abs(<code>b</code>)) and the absolute difference <code>atol</code> are added together to compare against the absolute difference between <code>a</code> and <code>b</code>.</p>
+<p>.. warning:: The default <code>atol</code> is not appropriate for comparing numbers  that are much smaller than one (see Notes).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a, b : array_like  Input arrays to compare. rtol : float  The relative tolerance parameter (see Notes). atol : float  The absolute tolerance parameter (see Notes). equal_nan : bool  Whether to compare NaN’s as equal. If True, NaN’s in <code>a</code> will be  considered equal to NaN’s in <code>b</code> in the output array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : array_like  Returns a boolean array of where <code>a</code> and <code>b</code> are equal within the  given tolerance. If both <code>a</code> and <code>b</code> are scalars, returns a single  boolean value.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>allclose</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.7.0</p>
+<p>For finite values, isclose uses the following equation to test whether two floating point values are equivalent.</p>
+<p>absolute(<code>a</code> - <code>b</code>) &lt;= (<code>atol</code> + <code>rtol</code> * absolute(<code>b</code>))</p>
+<p>Unlike the built-in <code>math.isclose</code>, the above equation is not symmetric in <code>a</code> and <code>b</code> – it assumes <code>b</code> is the reference value – so that <code>isclose(a, b)</code> might be different from <code>isclose(b, a)</code>. Furthermore, the default value of atol is not zero, and is used to determine what small values should be considered close to zero. The default value is appropriate for expected values of order unity: if the expected values are significantly smaller than one, it can result in false positives. <code>atol</code> should be carefully selected for the use case at hand. A zero value for <code>atol</code> will result in <code>False</code> if either <code>a</code> or <code>b</code> is zero.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isclose([1e10,1e-7], [1.00001e10,1e-8]) array([ True, False]) np.isclose([1e10,1e-8], [1.00001e10,1e-9]) array([ True, True]) np.isclose([1e10,1e-8], [1.0001e10,1e-9]) array([False, True]) np.isclose([1.0, np.nan], [1.0, np.nan]) array([ True, False]) np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) array([ True, True]) np.isclose([1e-8, 1e-7], [0.0, 0.0]) array([ True, False]) np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0) array([False, False]) np.isclose([1e-10, 1e-10], [1e-20, 0.0]) array([ True, True]) np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0) array([False, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22359">view source</a></div></div><div class="public anchor" id="var-iscomplex"><h3>iscomplex</h3><div class="usage"><code>(iscomplex &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns a bool array, where True if input element is complex.</p>
+<p>What is tested is whether the input has a non-zero imaginary part, not if the input type is complex.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray of bools  Output array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>isreal iscomplexobj : Return True if x is a complex type or an array of complex  numbers.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j]) array([ True, False, False, False, False, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12036">view source</a></div></div><div class="public anchor" id="var-iscomplexobj"><h3>iscomplexobj</h3><div class="usage"><code>(iscomplexobj &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Check for a complex type or an array of complex numbers.</p>
+<p>The type of the input is checked, not the value. Even if the input has an imaginary part equal to zero, <code>iscomplexobj</code> evaluates to True.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : any  The input can be of any type and shape.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>iscomplexobj : bool  The return value, True if <code>x</code> is of a complex type or has at least  one complex element.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>isrealobj, iscomplex</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.iscomplexobj(1) False np.iscomplexobj(1+0j) True np.iscomplexobj([3, 1+0j, True]) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5276">view source</a></div></div><div class="public anchor" id="var-isfinite"><h3>isfinite</h3><div class="usage"><code>(isfinite self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>isfinite(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Test element-wise for finiteness (not infinity or not Not a Number).</p>
+<p>The result is returned as a boolean array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray, bool  True where <code>x</code> is not positive infinity, negative infinity,  or NaN; false otherwise.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>isinf, isneginf, isposinf, isnan</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Not a Number, positive infinity and negative infinity are considered to be non-finite.</p>
+<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity. Also that positive infinity is not equivalent to negative infinity. But infinity is equivalent to positive infinity. Errors result if the second argument is also supplied when <code>x</code> is a scalar input, or if first and second arguments have different shapes.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isfinite(1) True np.isfinite(0) True np.isfinite(np.nan) False np.isfinite(np.inf) False np.isfinite(np.NINF) False np.isfinite([np.log(-1.),1.,np.log(0)]) array([False, True, False])</p>
+      <p>x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) np.isfinite(x, y) array([0, 1, 0]) y array([0, 1, 0])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12890">view source</a></div></div><div class="public anchor" id="var-isfortran"><h3>isfortran</h3><div class="usage"><code>(isfortran a)</code></div><div class="doc"><div class="markdown"><p>Check if the array is Fortran contiguous but <em>not</em> C contiguous.</p>
+<p>This function is obsolete and, because of changes due to relaxed stride checking, its return value for the same array may differ for versions of NumPy &gt;= 1.10.0 and previous versions. If you only want to check if an array is Fortran contiguous use <code>a.flags.f_contiguous</code> instead.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : ndarray  Input array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>isfortran : bool  Returns True if the array is Fortran contiguous but <em>not</em> C contiguous.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>np.array allows to specify whether the array is written in C-contiguous order (last index varies the fastest), or FORTRAN-contiguous order in memory (first index varies the fastest).</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 2, 3], [4, 5, 6</a>, order=‘C’) a array(<a href="null">1, 2, 3],
+       [4, 5, 6</a>) np.isfortran(a) False</p>
+      <p>b = np.array(<a href="null">1, 2, 3], [4, 5, 6</a>, order=‘F’) b array(<a href="null">1, 2, 3],
+       [4, 5, 6</a>) np.isfortran(b) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The transpose of a C-ordered array is a FORTRAN-ordered array.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 2, 3], [4, 5, 6</a>, order=‘C’) a array(<a href="null">1, 2, 3],
+       [4, 5, 6</a>) np.isfortran(a) False b = a.T b array(<a href="null">1, 4],
+       [2, 5],
+       [3, 6</a>) np.isfortran(b) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>C-ordered arrays evaluate as False even if they are also FORTRAN-ordered.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isfortran(np.array([1, 2], order=‘F’)) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15738">view source</a></div></div><div class="public anchor" id="var-isin"><h3>isin</h3><div class="usage"><code>(isin &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Calculates <code>element in test_elements</code>, broadcasting over <code>element</code> only. Returns a boolean array of the same shape as <code>element</code> that is True where an element of <code>element</code> is in <code>test_elements</code> and False otherwise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>element : array_like  Input array. test_elements : array_like  The values against which to test each value of <code>element</code>.  This argument is flattened if it is an array or array_like.  See notes for behavior with non-array-like parameters. assume_unique : bool, optional  If True, the input arrays are both assumed to be unique, which  can speed up the calculation. Default is False. invert : bool, optional  If True, the values in the returned array are inverted, as if  calculating <code>element not in test_elements</code>. Default is False.  <code>np.isin(a, b, invert=True)</code> is equivalent to (but faster  than) <code>np.invert(np.isin(a, b))</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>isin : ndarray, bool  Has the same shape as <code>element</code>. The values <code>element[isin]</code>  are in <code>test_elements</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>in1d : Flattened version of this function. numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>isin</code> is an element-wise function version of the python keyword <code>in</code>. <code>isin(a, b)</code> is roughly equivalent to <code>np.array([item in b for item in a])</code> if <code>a</code> and <code>b</code> are 1-D sequences.</p>
+<p><code>element</code> and <code>test_elements</code> are converted to arrays if they are not already. If <code>test_elements</code> is a set (or other non-sequence collection) it will be converted to an object array with one element, rather than an array of the values contained in <code>test_elements</code>. This is a consequence of the <code>array</code> constructor’s way of handling non-sequence collections. Converting the set to a list usually gives the desired behavior.</p>
+<p>.. versionadded:: 1.13.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>element = 2*np.arange(4).reshape((2, 2)) element array(<a href="null">0, 2],
+       [4, 6</a>) test_elements = [1, 2, 4, 8] mask = np.isin(element, test_elements) mask array(<a href="null">False,  True],
+       [ True, False</a>) element[mask] array([2, 4])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The indices of the matched values can be obtained with <code>nonzero</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.nonzero(mask) (array([0, 1]), array([1, 0]))</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The test can also be inverted:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>mask = np.isin(element, test_elements, invert=True) mask array(<a href="null"> True, False],
+       [False,  True</a>) element[mask] array([0, 6])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Because of how <code>array</code> handles sets, the following does not work as expected:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>test_set = {1, 2, 4, 8} np.isin(element, test_set) array(<a href="null">False, False],
+       [False, False</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Casting the set to a list gives the expected result:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isin(element, list(test_set)) array(<a href="null">False,  True],
+       [ True, False</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11101">view source</a></div></div><div class="public anchor" id="var-isinf"><h3>isinf</h3><div class="usage"><code>(isinf self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>isinf(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Test element-wise for positive or negative infinity.</p>
+<p>Returns a boolean array of the same shape as <code>x</code>, True where <code>x ==
++/-inf</code>, otherwise False.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input values out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : bool (scalar) or boolean ndarray  True where <code>x</code> is positive or negative infinity, false otherwise.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>isneginf, isposinf, isnan, isfinite</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754).</p>
+<p>Errors result if the second argument is supplied when the first argument is a scalar, or if the first and second arguments have different shapes.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isinf(np.inf) True np.isinf(np.nan) False np.isinf(np.NINF) True np.isinf([np.inf, -np.inf, 1.0, np.nan]) array([ True, True, False, False])</p>
+      <p>x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) np.isinf(x, y) array([1, 0, 1]) y array([1, 0, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2426">view source</a></div></div><div class="public anchor" id="var-isnan"><h3>isnan</h3><div class="usage"><code>(isnan self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>isnan(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Test element-wise for NaN and return result as a boolean array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or bool  True where <code>x</code> is NaN, false otherwise.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>isinf, isneginf, isposinf, isfinite, isnat</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isnan(np.nan) True np.isnan(np.inf) False np.isnan([np.log(-1.),1.,np.log(0)]) array([ True, False, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10259">view source</a></div></div><div class="public anchor" id="var-isnat"><h3>isnat</h3><div class="usage"><code>(isnat self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>isnat(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Test element-wise for NaT (not a time) and return result as a boolean array.</p>
+<p>.. versionadded:: 1.13.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array with datetime or timedelta data type. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or bool  True where <code>x</code> is NaT, false otherwise.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>isnan, isinf, isneginf, isposinf, isfinite</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isnat(np.datetime64(“NaT”)) True np.isnat(np.datetime64(“2016-01-01”)) False np.isnat(np.array([“NaT”, “2016-01-01”], dtype=“datetime64[ns]”)) array([ True, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8951">view source</a></div></div><div class="public anchor" id="var-isneginf"><h3>isneginf</h3><div class="usage"><code>(isneginf &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Test element-wise for negative infinity, return result as bool array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  The input array. out : array_like, optional  A boolean array with the same shape and type as <code>x</code> to store the  result.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  A boolean array with the same dimensions as the input.  If second argument is not supplied then a numpy boolean array is  returned with values True where the corresponding element of the  input is negative infinity and values False where the element of  the input is not negative infinity.</p>
+<pre><code>If a second argument is supplied the result is stored there. If the
+type of that array is a numeric type the result is represented as
+zeros and ones, if the type is boolean then as False and True. The
+return value `out` is then a reference to that array.
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>isinf, isposinf, isnan, isfinite</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754).</p>
+<p>Errors result if the second argument is also supplied when x is a scalar input, if first and second arguments have different shapes, or if the first argument has complex values.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isneginf(np.NINF) True np.isneginf(np.inf) False np.isneginf(np.PINF) False np.isneginf([-np.inf, 0., np.inf]) array([ True, False, False])</p>
+      <p>x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) np.isneginf(x, y) array([1, 0, 0]) y array([1, 0, 0])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3486">view source</a></div></div><div class="public anchor" id="var-isposinf"><h3>isposinf</h3><div class="usage"><code>(isposinf &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Test element-wise for positive infinity, return result as bool array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  The input array. y : array_like, optional  A boolean array with the same shape as <code>x</code> to store the result.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  A boolean array with the same dimensions as the input.  If second argument is not supplied then a boolean array is returned  with values True where the corresponding element of the input is  positive infinity and values False where the element of the input is  not positive infinity.</p>
+<pre><code>If a second argument is supplied the result is stored there. If the
+type of that array is a numeric type the result is represented as zeros
+and ones, if the type is boolean then as False and True.
+The return value `out` is then a reference to that array.
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>isinf, isneginf, isfinite, isnan</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754).</p>
+<p>Errors result if the second argument is also supplied when x is a scalar input, if first and second arguments have different shapes, or if the first argument has complex values</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isposinf(np.PINF) True np.isposinf(np.inf) True np.isposinf(np.NINF) False np.isposinf([-np.inf, 0., np.inf]) array([False, False, True])</p>
+      <p>x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) np.isposinf(x, y) array([0, 0, 1]) y array([0, 0, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22108">view source</a></div></div><div class="public anchor" id="var-isreal"><h3>isreal</h3><div class="usage"><code>(isreal &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns a bool array, where True if input element is real.</p>
+<p>If element has complex type with zero complex part, the return value for that element is True.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray, bool  Boolean array of same shape as <code>x</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>iscomplex isrealobj : Return True if x is not a complex type.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isreal([1+1j, 1+0j, 4.5, 3, 2, 2j]) array([False, True, True, True, True, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16806">view source</a></div></div><div class="public anchor" id="var-isrealobj"><h3>isrealobj</h3><div class="usage"><code>(isrealobj &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return True if x is a not complex type or an array of complex numbers.</p>
+<p>The type of the input is checked, not the value. So even if the input has an imaginary part equal to zero, <code>isrealobj</code> evaluates to False if the data type is complex.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : any  The input can be of any type and shape.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : bool  The return value, False if <code>x</code> is of a complex type.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>iscomplexobj, isreal</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isrealobj(1) True np.isrealobj(1+0j) False np.isrealobj([3, 1+0j, True]) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25694">view source</a></div></div><div class="public anchor" id="var-isscalar"><h3>isscalar</h3><div class="usage"><code>(isscalar element)</code></div><div class="doc"><div class="markdown"><p>Returns True if the type of <code>element</code> is a scalar type.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>element : any  Input argument, can be of any type and shape.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>val : bool  True if <code>element</code> is a scalar type, False if it is not.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndim : Get the number of dimensions of an array</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If you need a stricter way to identify a <em>numerical</em> scalar, use <code>isinstance(x, numbers.Number)</code>, as that returns <code>False</code> for most non-numerical elements such as strings.</p>
+<p>In most cases <code>np.ndim(x) == 0</code> should be used instead of this function, as that will also return true for 0d arrays. This is how numpy overloads functions in the style of the <code>dx</code> arguments to <code>gradient</code> and the <code>bins</code> argument to <code>histogram</code>. Some key differences:</p>
+<p>+————————————–+—————+——————-+ | x |<code>isscalar(x)</code>|<code>np.ndim(x) == 0</code>| +======================================+===============+===================+ | PEP 3141 numeric objects (including | <code>True</code> | <code>True</code> | | builtins) | | | +————————————–+—————+——————-+ | builtin string and buffer objects | <code>True</code> | <code>True</code> | +————————————–+—————+——————-+ | other builtin objects, like | <code>False</code> | <code>True</code> | | <code>pathlib.Path</code>, <code>Exception</code>, | | | | the result of <code>re.compile</code> | | | +————————————–+—————+——————-+ | third-party objects like | <code>False</code> | <code>True</code> | | <code>matplotlib.figure.Figure</code> | | | +————————————–+—————+——————-+ | zero-dimensional numpy arrays | <code>False</code> | <code>True</code> | +————————————–+—————+——————-+ | other numpy arrays | <code>False</code> | <code>False</code> | +————————————–+—————+——————-+ | <code>list</code>, <code>tuple</code>, and other sequence | <code>False</code> | <code>False</code> | | objects | | | +————————————–+—————+——————-+</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.isscalar(3.1) True np.isscalar(np.array(3.1)) False np.isscalar([3.1]) False np.isscalar(False) True np.isscalar(‘numpy’) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>NumPy supports PEP 3141 numbers:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from fractions import Fraction np.isscalar(Fraction(5, 17)) True from numbers import Number np.isscalar(Number()) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L857">view source</a></div></div><div class="public anchor" id="var-issctype"><h3>issctype</h3><div class="usage"><code>(issctype rep)</code></div><div class="doc"><div class="markdown"><p>Determines whether the given object represents a scalar data-type.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>rep : any  If <code>rep</code> is an instance of a scalar dtype, True is returned. If not,  False is returned.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : bool  Boolean result of check whether <code>rep</code> is a scalar dtype.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>issubsctype, issubdtype, obj2sctype, sctype2char</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.issctype(np.int32) True np.issctype(list) False np.issctype(1.1) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Strings are also a scalar type:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.issctype(np.dtype(‘str’)) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18149">view source</a></div></div><div class="public anchor" id="var-issubclass_"><h3>issubclass_</h3><div class="usage"><code>(issubclass_ arg1 arg2)</code></div><div class="doc"><div class="markdown"><p>Determine if a class is a subclass of a second class.</p>
+<p><code>issubclass_</code> is equivalent to the Python built-in <code>issubclass</code>, except that it returns False instead of raising a TypeError if one of the arguments is not a class.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arg1 : class  Input class. True is returned if <code>arg1</code> is a subclass of <code>arg2</code>. arg2 : class or tuple of classes.  Input class. If a tuple of classes, True is returned if <code>arg1</code> is a  subclass of any of the tuple elements.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : bool  Whether <code>arg1</code> is a subclass of <code>arg2</code> or not.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>issubsctype, issubdtype, issctype</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.issubclass_(np.int32, int) False # True on Python 2.7 np.issubclass_(np.int32, float) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7674">view source</a></div></div><div class="public anchor" id="var-issubdtype"><h3>issubdtype</h3><div class="usage"><code>(issubdtype arg1 arg2)</code></div><div class="doc"><div class="markdown"><p>Returns True if first argument is a typecode lower/equal in type hierarchy.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arg1, arg2 : dtype_like  dtype or string representing a typecode.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : bool</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>issubsctype, issubclass_ numpy.core.numerictypes : Overview of numpy type hierarchy.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.issubdtype(‘S1’, np.string_) True np.issubdtype(np.float64, np.float32) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26233">view source</a></div></div><div class="public anchor" id="var-issubsctype"><h3>issubsctype</h3><div class="usage"><code>(issubsctype arg1 arg2)</code></div><div class="doc"><div class="markdown"><p>Determine if the first argument is a subclass of the second argument.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arg1, arg2 : dtype or dtype specifier  Data-types.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : bool  The result.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>issctype, issubdtype, obj2sctype</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.issubsctype(‘S8’, str) False np.issubsctype(np.array([1]), int) True np.issubsctype(np.array([1]), float) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21981">view source</a></div></div><div class="public anchor" id="var-iterable"><h3>iterable</h3><div class="usage"><code>(iterable y)</code></div><div class="doc"><div class="markdown"><p>Check whether or not an object can be iterated over.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>y : object  Input object.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>b : bool  Return <code>True</code> if the object has an iterator method or is a  sequence and <code>False</code> otherwise.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.iterable([1, 2, 3]) True np.iterable(2) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21309">view source</a></div></div><div class="public anchor" id="var-ix_"><h3>ix_</h3><div class="usage"><code>(ix_ &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Construct an open mesh from multiple sequences.</p>
+<p>This function takes N 1-D sequences and returns N outputs with N dimensions each, such that the shape is 1 in all but one dimension and the dimension with the non-unit shape value cycles through all N dimensions.</p>
+<p>Using <code>ix_</code> one can quickly construct index arrays that will index the cross product. <code>a[np.ix_([1,3],[2,5])]</code> returns the array <code>[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>args : 1-D sequences  Each sequence should be of integer or boolean type.  Boolean sequences will be interpreted as boolean masks for the  corresponding dimension (equivalent to passing in  <code>np.nonzero(boolean_sequence)</code>).</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : tuple of ndarrays  N arrays with N dimensions each, with N the number of input  sequences. Together these arrays form an open mesh.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ogrid, mgrid, meshgrid</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(10).reshape(2, 5) a array(<a href="null">0, 1, 2, 3, 4],
+       [5, 6, 7, 8, 9</a>) ixgrid = np.ix_([0, 1], [2, 4]) ixgrid (array(<a href="null">0],
+       [1</a>), array(<a href="null">2, 4</a>)) ixgrid[0].shape, ixgrid[1].shape ((2, 1), (1, 2)) a[ixgrid] array(<a href="null">2, 4],
+       [7, 9</a>)</p>
+      <p>ixgrid = np.ix_([True, True], [2, 4]) a[ixgrid] array(<a href="null">2, 4],
+       [7, 9</a>) ixgrid = np.ix_([True, True], [False, False, True, False, True]) a[ixgrid] array(<a href="null">2, 4],
+       [7, 9</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1533">view source</a></div></div><div class="public anchor" id="var-kaiser"><h3>kaiser</h3><div class="usage"><code>(kaiser M beta)</code></div><div class="doc"><div class="markdown"><p>Return the Kaiser window.</p>
+<p>The Kaiser window is a taper formed by using a Bessel function.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>M : int  Number of points in the output window. If zero or less, an  empty array is returned. beta : float  Shape parameter for window.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : array  The window, with the maximum value normalized to one (the value  one appears only if the number of samples is odd).</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>bartlett, blackman, hamming, hanning</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The Kaiser window is defined as</p>
+<p>.. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}}  \right)/I_0(\beta)</p>
+<p>with</p>
+<p>.. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2},</p>
+<p>where :math:<code>I_0</code> is the modified zeroth-order Bessel function.</p>
+<p>The Kaiser was named for Jim Kaiser, who discovered a simple approximation to the DPSS window based on Bessel functions. The Kaiser window is a very good approximation to the Digital Prolate Spheroidal Sequence, or Slepian window, which is the transform which maximizes the energy in the main lobe of the window relative to total energy.</p>
+<p>The Kaiser can approximate many other windows by varying the beta parameter.</p>
+<p>==== ======================= beta Window shape ==== ======================= 0 Rectangular 5 Similar to a Hamming 6 Similar to a Hanning 8.6 Similar to a Blackman ==== =======================</p>
+<p>A beta value of 14 is probably a good starting point. Note that as beta gets large, the window narrows, and so the number of samples needs to be large enough to sample the increasingly narrow spike, otherwise NaNs will get returned.</p>
+<p>Most references to the Kaiser window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means “removing the foot”, i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] J. F. Kaiser, “Digital Filters” - Ch 7 in “Systems analysis by  digital computer”, Editors: F.F. Kuo and J.F. Kaiser, p 218-285.  John Wiley and Sons, New York, (1966). .. [2] E.R. Kanasewich, “Time Sequence Analysis in Geophysics”, The  University of Alberta Press, 1975, pp. 177-178. .. [3] Wikipedia, “Window function”,  <a href="https://en.wikipedia.org/wiki/Window_function">https://en.wikipedia.org/wiki/Window_function</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt np.kaiser(12, 14)  array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary  2.29737120e-01, 5.99885316e-01, 9.45674898e-01,  9.45674898e-01, 5.99885316e-01, 2.29737120e-01,  4.65200189e-02, 3.46009194e-03, 7.72686684e-06])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot the window and the frequency response:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from numpy.fft import fft, fftshift window = np.kaiser(51, 14) plt.plot(window) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Kaiser window”) Text(0.5, 1.0, ‘Kaiser window’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“Sample”) Text(0.5, 0, ‘Sample’) plt.show()</p>
+      <p>plt.figure() </p><figure size="" 640x480="" with="" 0="" axes=""> A = fft(window, 2048) / 25.5 mag = np.abs(fftshift(A)) freq = np.linspace(-0.5, 0.5, len(A)) response = 20 * np.log10(mag) response = np.clip(response, -100, 100) plt.plot(freq, response) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Frequency response of Kaiser window”) Text(0.5, 1.0, ‘Frequency response of Kaiser window’) plt.ylabel(“Magnitude [dB]”) Text(0, 0.5, ‘Magnitude [dB]’) plt.xlabel(“Normalized frequency [cycles per sample]”) Text(0.5, 0, ‘Normalized frequency [cycles per sample]’) plt.axis(‘tight’) (-0.5, 0.5, -100.0, …) # may vary plt.show()<p></p>
+    </figure></blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8447">view source</a></div></div><div class="public anchor" id="var-kron"><h3>kron</h3><div class="usage"><code>(kron &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Kronecker product of two arrays.</p>
+<p>Computes the Kronecker product, a composite array made of blocks of the second array scaled by the first.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a, b : array_like</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>outer : The outer product</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The function assumes that the number of dimensions of <code>a</code> and <code>b</code> are the same, if necessary prepending the smallest with ones. If <code>a.shape = (r0,r1,..,rN)</code> and <code>b.shape = (s0,s1,...,sN)</code>, the Kronecker product has shape <code>(r0*s0, r1*s1, ..., rN*SN)</code>. The elements are products of elements from <code>a</code> and <code>b</code>, organized explicitly by::</p>
+<pre><code>kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]
+</code></pre>
+<p>where::</p>
+<pre><code>kt = it * st + jt,  t = 0,...,N
+</code></pre>
+<p>In the common 2-D case (N=1), the block structure can be visualized::</p>
+<pre><code>[[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
+ [  ...                              ...   ],
+ [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]]
+</code></pre>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.kron([1,10,100], [5,6,7]) array([ 5, 6, 7, …, 500, 600, 700]) np.kron([5,6,7], [1,10,100]) array([ 5, 50, 500, …, 7, 70, 700])</p>
+      <p>np.kron(np.eye(2), np.ones((2,2))) array(<a href="null">1.,  1.,  0.,  0.],
+       [1.,  1.,  0.,  0.],
+       [0.,  0.,  1.,  1.],
+       [0.,  0.,  1.,  1.</a>)</p>
+      <p>a = np.arange(100).reshape((2,5,2,5)) b = np.arange(24).reshape((2,3,4)) c = np.kron(a,b) c.shape (2, 10, 6, 20) I = (1,3,0,2) J = (0,2,1) J1 = (0,) + J # extend to ndim=4 S1 = (1,) + b.shape K = tuple(np.array(I) * np.array(S1) + np.array(J1)) c[K] == a[I]*b[J] True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L284">view source</a></div></div><div class="public anchor" id="var-lcm"><h3>lcm</h3><div class="usage"><code>(lcm self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>lcm(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Returns the lowest common multiple of <code>|x1|</code> and <code>|x2|</code></p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like, int  Arrays of values. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output).</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  The lowest common multiple of the absolute value of the inputs  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>gcd : The greatest common divisor</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.lcm(12, 20) 60 np.lcm.reduce([3, 12, 20]) 60 np.lcm.reduce([40, 12, 20]) 120 np.lcm(np.arange(6), 20) array([ 0, 20, 20, 60, 20, 20])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5622">view source</a></div></div><div class="public anchor" id="var-ldexp"><h3>ldexp</h3><div class="usage"><code>(ldexp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>ldexp(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Returns x1 * 2**x2, element-wise.</p>
+<p>The mantissas <code>x1</code> and twos exponents <code>x2</code> are used to construct floating point numbers <code>x1 * 2**x2</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  Array of multipliers. x2 : array_like, int  Array of twos exponents. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  The result of <code>x1 * 2**x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>frexp : Return (y1, y2) from <code>x = y1 * 2**y2</code>, inverse to <code>ldexp</code>.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Complex dtypes are not supported, they will raise a TypeError.</p>
+<p><code>ldexp</code> is useful as the inverse of <code>frexp</code>, if used by itself it is more clear to simply use the expression <code>x1 * 2**x2</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.ldexp(5, np.arange(4)) array([ 5., 10., 20., 40.], dtype=float16)</p>
+      <p>x = np.arange(6) np.ldexp(*np.frexp(x)) array([ 0., 1., 2., 3., 4., 5.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22536">view source</a></div></div><div class="public anchor" id="var-left_shift"><h3>left_shift</h3><div class="usage"><code>(left_shift self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>left_shift(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Shift the bits of an integer to the left.</p>
+<p>Bits are shifted to the left by appending <code>x2</code> 0s at the right of <code>x1</code>. Since the internal representation of numbers is in binary format, this operation is equivalent to multiplying <code>x1</code> by <code>2**x2</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like of integer type  Input values. x2 : array_like of integer type  Number of zeros to append to <code>x1</code>. Has to be non-negative.  If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : array of integer type  Return <code>x1</code> with bits shifted <code>x2</code> times to the left.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>right_shift : Shift the bits of an integer to the right. binary_repr : Return the binary representation of the input number  as a string.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.binary_repr(5) ‘101’ np.left_shift(5, 2) 20 np.binary_repr(20) ‘10100’</p>
+      <p>np.left_shift(5, [1,2,3]) array([10, 20, 40])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27574">view source</a></div></div><div class="public anchor" id="var-less"><h3>less</h3><div class="usage"><code>(less self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>less(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the truth value of (x1 &lt; x2) element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>greater, less_equal, greater_equal, equal, not_equal</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.less([1, 2], [2, 2]) array([ True, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20461">view source</a></div></div><div class="public anchor" id="var-less_equal"><h3>less_equal</h3><div class="usage"><code>(less_equal self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>less_equal(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the truth value of (x1 =&lt; x2) element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>greater, less, greater_equal, equal, not_equal</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.less_equal([4, 2, 1], [2, 2, 2]) array([False, True, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8406">view source</a></div></div><div class="public anchor" id="var-lexsort"><h3>lexsort</h3><div class="usage"><code>(lexsort &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>lexsort(keys, axis=-1)</p>
+<p>Perform an indirect stable sort using a sequence of keys.</p>
+<p>Given multiple sorting keys, which can be interpreted as columns in a spreadsheet, lexsort returns an array of integer indices that describes the sort order by multiple columns. The last key in the sequence is used for the primary sort order, the second-to-last key for the secondary sort order, and so on. The keys argument must be a sequence of objects that can be converted to arrays of the same shape. If a 2D array is provided for the keys argument, it’s rows are interpreted as the sorting keys and sorting is according to the last row, second last row etc.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>keys : (k, N) array or tuple containing k (N,)-shaped sequences  The <code>k</code> different “columns” to be sorted. The last column (or row if  <code>keys</code> is a 2D array) is the primary sort key. axis : int, optional  Axis to be indirectly sorted. By default, sort over the last axis.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>indices : (N,) ndarray of ints  Array of indices that sort the keys along the specified axis.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>argsort : Indirect sort. ndarray.sort : In-place sort. sort : Return a sorted copy of an array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Sort names: first by surname, then by name.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>surnames = (‘Hertz’, ‘Galilei’, ‘Hertz’) first_names = (‘Heinrich’, ‘Galileo’, ‘Gustav’) ind = np.lexsort((first_names, surnames)) ind array([1, 2, 0])</p>
+      <p>[surnames[i] + “, ” + first_names[i] for i in ind]
+[‘Galilei, Galileo’, ‘Hertz, Gustav’, ‘Hertz, Heinrich’]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Sort two columns of numbers:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = [1,5,1,4,3,4,4] # First column b = [9,4,0,4,0,2,1] # Second column ind = np.lexsort((b,a)) # Sort by a, then by b ind array([2, 0, 4, 6, 5, 3, 1])</p>
+      <p>[(a[i],b[i]) for i in ind]
+[(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that sorting is first according to the elements of <code>a</code>. Secondary sorting is according to the elements of <code>b</code>.</p>
+<p>A normal <code>argsort</code> would have yielded:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>[(a[i],b[i]) for i in np.argsort(a)]
+[(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Structured arrays are sorted lexically by <code>argsort</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)], … dtype=np.dtype([(‘x’, int), (‘y’, int)]))</p>
+      <p>np.argsort(x) # or np.argsort(x, order=(‘x’, ‘y’)) array([2, 0, 4, 6, 5, 3, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16672">view source</a></div></div><div class="public anchor" id="var-lib"><h3>lib</h3><div class="usage"></div><div class="doc"><div class="markdown"><p><strong>Note:</strong> almost all functions in the <code>numpy.lib</code> namespace are also present in the main <code>numpy</code> namespace. Please use the functions as <code>np.&lt;funcname&gt;</code> where possible.</p>
+<p><code>numpy.lib</code> is mostly a space for implementing functions that don’t belong in core or in another NumPy submodule with a clear purpose (e.g. <code>random</code>, <code>fft</code>, <code>linalg</code>, <code>ma</code>).</p>
+<p>Most contains basic functions that are used by several submodules and are useful to have in the main name-space.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20181">view source</a></div></div><div class="public anchor" id="var-linalg"><h3>linalg</h3><div class="usage"></div><div class="doc"><div class="markdown"><h1><code>numpy.linalg</code></h1>
+<p>The NumPy linear algebra functions rely on BLAS and LAPACK to provide efficient low level implementations of standard linear algebra algorithms. Those libraries may be provided by NumPy itself using C versions of a subset of their reference implementations but, when possible, highly optimized libraries that take advantage of specialized processor functionality are preferred. Examples of such libraries are OpenBLAS, MKL (TM), and ATLAS. Because those libraries are multithreaded and processor dependent, environmental variables and external packages such as threadpoolctl may be needed to control the number of threads or specify the processor architecture.</p>
+<ul>
+  <li>OpenBLAS: <a href="https://www.openblas.net/">https://www.openblas.net/</a></li>
+  <li>threadpoolctl: <a href="https://github.com/joblib/threadpoolctl">https://github.com/joblib/threadpoolctl</a></li>
+</ul>
+<p>Please note that the most-used linear algebra functions in NumPy are present in the main <code>numpy</code> namespace rather than in <code>numpy.linalg</code>. There are: <code>dot</code>, <code>vdot</code>, <code>inner</code>, <code>outer</code>, <code>matmul</code>, <code>tensordot</code>, <code>einsum</code>, <code>einsum_path</code> and <code>kron</code>.</p>
+<p>Functions present in numpy.linalg are listed below.</p>
+<h2><a href="#matrix-and-vector-products" name="matrix-and-vector-products"></a>Matrix and vector products</h2>
+<p>multi_dot  matrix_power</p>
+<h2><a href="#decompositions" name="decompositions"></a>Decompositions</h2>
+<p>cholesky  qr  svd</p>
+<h2><a href="#matrix-eigenvalues" name="matrix-eigenvalues"></a>Matrix eigenvalues</h2>
+<p>eig  eigh  eigvals  eigvalsh</p>
+<h2><a href="#norms-and-other-numbers" name="norms-and-other-numbers"></a>Norms and other numbers</h2>
+<p>norm  cond  det  matrix_rank  slogdet</p>
+<h2><a href="#solving-equations-and-inverting-matrices" name="solving-equations-and-inverting-matrices"></a>Solving equations and inverting matrices</h2>
+<p>solve  tensorsolve  lstsq  inv  pinv  tensorinv</p>
+<h2><a href="#exceptions" name="exceptions"></a>Exceptions</h2>
+<p>LinAlgError</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19742">view source</a></div></div><div class="public anchor" id="var-linspace"><h3>linspace</h3><div class="usage"><code>(linspace &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return evenly spaced numbers over a specified interval.</p>
+<p>Returns <code>num</code> evenly spaced samples, calculated over the interval [<code>start</code>, <code>stop</code>].</p>
+<p>The endpoint of the interval can optionally be excluded.</p>
+<p>.. versionchanged:: 1.16.0  Non-scalar <code>start</code> and <code>stop</code> are now supported.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>start : array_like  The starting value of the sequence. stop : array_like  The end value of the sequence, unless <code>endpoint</code> is set to False.  In that case, the sequence consists of all but the last of <code>num + 1</code>  evenly spaced samples, so that <code>stop</code> is excluded. Note that the step  size changes when <code>endpoint</code> is False. num : int, optional  Number of samples to generate. Default is 50. Must be non-negative. endpoint : bool, optional  If True, <code>stop</code> is the last sample. Otherwise, it is not included.  Default is True. retstep : bool, optional  If True, return (<code>samples</code>, <code>step</code>), where <code>step</code> is the spacing  between samples. dtype : dtype, optional  The type of the output array. If <code>dtype</code> is not given, infer the data  type from the other input arguments.</p>
+<pre><code>.. versionadded:: 1.9.0
+</code></pre>
+<p>axis : int, optional  The axis in the result to store the samples. Relevant only if start  or stop are array-like. By default (0), the samples will be along a  new axis inserted at the beginning. Use -1 to get an axis at the end.</p>
+<pre><code>.. versionadded:: 1.16.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>samples : ndarray  There are <code>num</code> equally spaced samples in the closed interval  <code>[start, stop]</code> or the half-open interval <code>[start, stop)</code>  (depending on whether <code>endpoint</code> is True or False). step : float, optional  Only returned if <code>retstep</code> is True</p>
+<pre><code>Size of spacing between samples.
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>arange : Similar to <code>linspace</code>, but uses a step size (instead of the  number of samples). geomspace : Similar to <code>linspace</code>, but with numbers spaced evenly on a log  scale (a geometric progression). logspace : Similar to <code>geomspace</code>, but with the end points specified as  logarithms.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.linspace(2.0, 3.0, num=5) array([2. , 2.25, 2.5 , 2.75, 3. ]) np.linspace(2.0, 3.0, num=5, endpoint=False) array([2. , 2.2, 2.4, 2.6, 2.8]) np.linspace(2.0, 3.0, num=5, retstep=True) (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Graphical illustration:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt N = 8 y = np.zeros(N) x1 = np.linspace(0, 10, N, endpoint=True) x2 = np.linspace(0, 10, N, endpoint=False) plt.plot(x1, y, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.plot(x2, y + 0.5, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.ylim([-0.5, 1]) (-0.5, 1) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9332">view source</a></div></div><div class="public anchor" id="var-little_endian"><h3>little_endian</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25024">view source</a></div></div><div class="public anchor" id="var-load"><h3>load</h3><div class="usage"><code>(load file &amp; [{mmap_mode :mmap_mode, allow_pickle :allow_pickle, fix_imports :fix_imports, encoding :encoding}])</code><code>(load file &amp; [{mmap_mode :mmap_mode, allow_pickle :allow_pickle, fix_imports :fix_imports}])</code><code>(load file &amp; [{mmap_mode :mmap_mode, allow_pickle :allow_pickle}])</code><code>(load file &amp; [{mmap_mode :mmap_mode}])</code><code>(load file)</code></div><div class="doc"><div class="markdown"><p>Load arrays or pickled objects from <code>.npy</code>, <code>.npz</code> or pickled files.</p>
+<p>.. warning:: Loading files that contain object arrays uses the <code>pickle</code>  module, which is not secure against erroneous or maliciously  constructed data. Consider passing <code>allow_pickle=False</code> to  load data that is known not to contain object arrays for the  safer handling of untrusted sources.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>file : file-like object, string, or pathlib.Path  The file to read. File-like objects must support the  <code>seek()</code> and <code>read()</code> methods. Pickled files require that the  file-like object support the <code>readline()</code> method as well. mmap_mode : {None, ‘r+’, ‘r’, ‘w+’, ‘c’}, optional  If not None, then memory-map the file, using the given mode (see  <code>numpy.memmap</code> for a detailed description of the modes). A  memory-mapped array is kept on disk. However, it can be accessed  and sliced like any ndarray. Memory mapping is especially useful  for accessing small fragments of large files without reading the  entire file into memory. allow_pickle : bool, optional  Allow loading pickled object arrays stored in npy files. Reasons for  disallowing pickles include security, as loading pickled data can  execute arbitrary code. If pickles are disallowed, loading object  arrays will fail. Default: False</p>
+<pre><code>.. versionchanged:: 1.16.3
+    Made default False in response to CVE-2019-6446.
+</code></pre>
+<p>fix_imports : bool, optional  Only useful when loading Python 2 generated pickled files on Python 3,  which includes npy/npz files containing object arrays. If <code>fix_imports</code>  is True, pickle will try to map the old Python 2 names to the new names  used in Python 3. encoding : str, optional  What encoding to use when reading Python 2 strings. Only useful when  loading Python 2 generated pickled files in Python 3, which includes  npy/npz files containing object arrays. Values other than ‘latin1’,  ‘ASCII’, and ‘bytes’ are not allowed, as they can corrupt numerical  data. Default: ‘ASCII’</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>result : array, tuple, dict, etc.  Data stored in the file. For <code>.npz</code> files, the returned instance  of NpzFile class must be closed to avoid leaking file descriptors.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>IOError  If the input file does not exist or cannot be read. ValueError  The file contains an object array, but allow_pickle=False given.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>save, savez, savez_compressed, loadtxt memmap : Create a memory-map to an array stored in a file on disk. lib.format.open_memmap : Create or load a memory-mapped <code>.npy</code> file.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<ul>
+  <li>If the file contains pickle data, then whatever object is stored  in the pickle is returned.</li>
+  <li>If the file is a <code>.npy</code> file, then a single array is returned.</li>
+  <li>If the file is a <code>.npz</code> file, then a dictionary-like object is  returned, containing <code>{filename: array}</code> key-value pairs, one for  each file in the archive.</li>
+  <li>If the file is a <code>.npz</code> file, the returned value supports the  context manager protocol in a similar fashion to the open function::
+    <p>with load(‘foo.npz’) as data:  a = data[‘a’]</p>
+  </li>
+</ul>
+<p>The underlying file descriptor is closed when exiting the ‘with’  block.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Store data to disk, and load it again:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.save(‘/tmp/123’, np.array(<a href="null">1, 2, 3], [4, 5, 6</a>)) np.load(‘/tmp/123.npy’) array(<a href="null">1, 2, 3],
+       [4, 5, 6</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Store compressed data to disk, and load it again:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a=np.array(<a href="null">1, 2, 3], [4, 5, 6</a>) b=np.array([1, 2]) np.savez(‘/tmp/123.npz’, a=a, b=b) data = np.load(‘/tmp/123.npz’) data[‘a’] array(<a href="null">1, 2, 3],
+       [4, 5, 6</a>) data[‘b’] array([1, 2]) data.close()</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Mem-map the stored array, and then access the second row directly from disk:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>X = np.load(‘/tmp/123.npy’, mmap_mode=‘r’) X[1, :] memmap([4, 5, 6])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7359">view source</a></div></div><div class="public anchor" id="var-loads"><h3>loads</h3><div class="usage"><code>(loads &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18867">view source</a></div></div><div class="public anchor" id="var-loadtxt"><h3>loadtxt</h3><div class="usage"><code>(loadtxt fname &amp; [{max_rows :max_rows, encoding :encoding, ndmin :ndmin, dtype :dtype, comments :comments, unpack :unpack, converters :converters, delimiter :delimiter, skiprows :skiprows, usecols :usecols}])</code><code>(loadtxt fname &amp; [{encoding :encoding, ndmin :ndmin, dtype :dtype, comments :comments, unpack :unpack, converters :converters, delimiter :delimiter, skiprows :skiprows, usecols :usecols}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols, unpack :unpack, ndmin :ndmin}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols, unpack :unpack}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments}])</code><code>(loadtxt fname &amp; [{dtype :dtype}])</code><code>(loadtxt fname)</code></div><div class="doc"><div class="markdown"><p>Load data from a text file.</p>
+<p>Each row in the text file must have the same number of values.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>fname : file, str, or pathlib.Path  File, filename, or generator to read. If the filename extension is  <code>.gz</code> or <code>.bz2</code>, the file is first decompressed. Note that  generators should return byte strings. dtype : data-type, optional  Data-type of the resulting array; default: float. If this is a  structured data-type, the resulting array will be 1-dimensional, and  each row will be interpreted as an element of the array. In this  case, the number of columns used must match the number of fields in  the data-type. comments : str or sequence of str, optional  The characters or list of characters used to indicate the start of a  comment. None implies no comments. For backwards compatibility, byte  strings will be decoded as ‘latin1’. The default is ‘#’. delimiter : str, optional  The string used to separate values. For backwards compatibility, byte  strings will be decoded as ‘latin1’. The default is whitespace. converters : dict, optional  A dictionary mapping column number to a function that will parse the  column string into the desired value. E.g., if column 0 is a date  string: <code>converters = {0: datestr2num}</code>. Converters can also be  used to provide a default value for missing data (but see also  <code>genfromtxt</code>): <code>converters = {3: lambda s: float(s.strip() or 0)}</code>.  Default: None. skiprows : int, optional  Skip the first <code>skiprows</code> lines, including comments; default: 0. usecols : int or sequence, optional  Which columns to read, with 0 being the first. For example,  <code>usecols = (1,4,5)</code> will extract the 2nd, 5th and 6th columns.  The default, None, results in all columns being read.</p>
+<pre><code>.. versionchanged:: 1.11.0
+    When a single column has to be read it is possible to use
+    an integer instead of a tuple. E.g ``usecols = 3`` reads the
+    fourth column the same way as ``usecols = (3,)`` would.
+</code></pre>
+<p>unpack : bool, optional  If True, the returned array is transposed, so that arguments may be  unpacked using <code>x, y, z = loadtxt(...)</code>. When used with a structured  data-type, arrays are returned for each field. Default is False. ndmin : int, optional  The returned array will have at least <code>ndmin</code> dimensions.  Otherwise mono-dimensional axes will be squeezed.  Legal values: 0 (default), 1 or 2.</p>
+<pre><code>.. versionadded:: 1.6.0
+</code></pre>
+<p>encoding : str, optional  Encoding used to decode the inputfile. Does not apply to input streams.  The special value ‘bytes’ enables backward compatibility workarounds  that ensures you receive byte arrays as results if possible and passes  ‘latin1’ encoded strings to converters. Override this value to receive  unicode arrays and pass strings as input to converters. If set to None  the system default is used. The default value is ‘bytes’.</p>
+<pre><code>.. versionadded:: 1.14.0
+</code></pre>
+<p>max_rows : int, optional  Read <code>max_rows</code> lines of content after <code>skiprows</code> lines. The default  is to read all the lines.</p>
+<pre><code>.. versionadded:: 1.16.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Data read from the text file.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>load, fromstring, fromregex genfromtxt : Load data with missing values handled as specified. scipy.io.loadmat : reads MATLAB data files</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This function aims to be a fast reader for simply formatted files. The <code>genfromtxt</code> function provides more sophisticated handling of, e.g., lines with missing values.</p>
+<p>.. versionadded:: 1.10.0</p>
+<p>The strings produced by the Python float.hex method can be used as input for floats.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from io import StringIO # StringIO behaves like a file object c = StringIO(u“0 1\n2 3”) np.loadtxt(c) array(<a href="null">0., 1.],
+       [2., 3.</a>)</p>
+      <p>d = StringIO(u“M 21 72\nF 35 58”) np.loadtxt(d, dtype={‘names’: (‘gender’, ‘age’, ‘weight’), … ‘formats’: (‘S1’, ‘i4’, ‘f4’)}) array([(b’M’, 21, 72.), (b’F’, 35, 58.)],  dtype=[(‘gender’, ‘S1’), (‘age’, ‘&lt;i4’), (‘weight’, ‘&lt;f4’)])</p>
+      <p>c = StringIO(u“1,0,2\n3,0,4”) x, y = np.loadtxt(c, delimiter=‘,’, usecols=(0, 2), unpack=True) x array([1., 3.]) y array([2., 4.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6922">view source</a></div></div><div class="public anchor" id="var-log"><h3>log</h3><div class="usage"><code>(log self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>log(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Natural logarithm, element-wise.</p>
+<p>The natural logarithm <code>log</code> is the inverse of the exponential function, so that <code>log(exp(x)) = x</code>. The natural logarithm is logarithm in base <code>e</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input value. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The natural logarithm of <code>x</code>, element-wise.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>log10, log2, log1p, emath.log</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Logarithm is a multivalued function: for each <code>x</code> there is an infinite number of <code>z</code> such that <code>exp(z) = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi, pi]</code>.</p>
+<p>For real-valued input data types, <code>log</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
+<p>For complex-valued input, <code>log</code> is a complex analytical function that has a branch cut <code>[-inf, 0]</code> and is continuous from above on it. <code>log</code> handles the floating-point negative zero as an infinitesimal negative number, conforming to the C99 standard.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 67. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Logarithm”. <a href="https://en.wikipedia.org/wiki/Logarithm">https://en.wikipedia.org/wiki/Logarithm</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.log([1, np.e, np.e**2, 0]) array([ 0., 1., 2., -Inf])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12962">view source</a></div></div><div class="public anchor" id="var-log10"><h3>log10</h3><div class="usage"><code>(log10 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>log10(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the base 10 logarithm of the input array, element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The logarithm to the base 10 of <code>x</code>, element-wise. NaNs are  returned where x is negative.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>emath.log10</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Logarithm is a multivalued function: for each <code>x</code> there is an infinite number of <code>z</code> such that <code>10**z = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi, pi]</code>.</p>
+<p>For real-valued input data types, <code>log10</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
+<p>For complex-valued input, <code>log10</code> is a complex analytical function that has a branch cut <code>[-inf, 0]</code> and is continuous from above on it. <code>log10</code> handles the floating-point negative zero as an infinitesimal negative number, conforming to the C99 standard.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 67. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Logarithm”. <a href="https://en.wikipedia.org/wiki/Logarithm">https://en.wikipedia.org/wiki/Logarithm</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.log10([1e-15, -3.]) array([-15., nan])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17394">view source</a></div></div><div class="public anchor" id="var-log1p"><h3>log1p</h3><div class="usage"><code>(log1p self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>log1p(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the natural logarithm of one plus the input array, element-wise.</p>
+<p>Calculates <code>log(1 + x)</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  Natural logarithm of <code>1 + x</code>, element-wise.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>expm1 : <code>exp(x) - 1</code>, the inverse of <code>log1p</code>.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>For real-valued input, <code>log1p</code> is accurate also for <code>x</code> so small that <code>1 + x == 1</code> in floating-point accuracy.</p>
+<p>Logarithm is a multivalued function: for each <code>x</code> there is an infinite number of <code>z</code> such that <code>exp(z) = 1 + x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi, pi]</code>.</p>
+<p>For real-valued input data types, <code>log1p</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
+<p>For complex-valued input, <code>log1p</code> is a complex analytical function that has a branch cut <code>[-inf, -1]</code> and is continuous from above on it. <code>log1p</code> handles the floating-point negative zero as an infinitesimal negative number, conforming to the C99 standard.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 67. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Logarithm”. <a href="https://en.wikipedia.org/wiki/Logarithm">https://en.wikipedia.org/wiki/Logarithm</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.log1p(1e-99) 1e-99 np.log(1 + 1e-99) 0.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L507">view source</a></div></div><div class="public anchor" id="var-log2"><h3>log2</h3><div class="usage"><code>(log2 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>log2(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Base-2 logarithm of <code>x</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  Base-2 logarithm of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>log, log10, log1p, emath.log2</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.3.0</p>
+<p>Logarithm is a multivalued function: for each <code>x</code> there is an infinite number of <code>z</code> such that <code>2**z = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi, pi]</code>.</p>
+<p>For real-valued input data types, <code>log2</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
+<p>For complex-valued input, <code>log2</code> is a complex analytical function that has a branch cut <code>[-inf, 0]</code> and is continuous from above on it. <code>log2</code> handles the floating-point negative zero as an infinitesimal negative number, conforming to the C99 standard.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([0, 1, 2, 2**4]) np.log2(x) array([-Inf, 0., 1., 4.])</p>
+      <p>xi = np.array([0+1.j, 1, 2+0.j, 4.j]) np.log2(xi) array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27512">view source</a></div></div><div class="public anchor" id="var-logaddexp"><h3>logaddexp</h3><div class="usage"><code>(logaddexp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logaddexp(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Logarithm of the sum of exponentiations of the inputs.</p>
+<p>Calculates <code>log(exp(x1) + exp(x2))</code>. This function is useful in statistics where the calculated probabilities of events may be so small as to exceed the range of normal floating point numbers. In such cases the logarithm of the calculated probability is stored. This function allows adding probabilities stored in such a fashion.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Input values. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>result : ndarray  Logarithm of <code>exp(x1) + exp(x2)</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.3.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>prob1 = np.log(1e-50) prob2 = np.log(2.5e-50) prob12 = np.logaddexp(prob1, prob2) prob12 -113.87649168120691 np.exp(prob12) 3.5000000000000057e-50</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5309">view source</a></div></div><div class="public anchor" id="var-logaddexp2"><h3>logaddexp2</h3><div class="usage"><code>(logaddexp2 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logaddexp2(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Logarithm of the sum of exponentiations of the inputs in base-2.</p>
+<p>Calculates <code>log2(2**x1 + 2**x2)</code>. This function is useful in machine learning when the calculated probabilities of events may be so small as to exceed the range of normal floating point numbers. In such cases the base-2 logarithm of the calculated probability can be used instead. This function allows adding probabilities stored in such a fashion.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Input values. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>result : ndarray  Base-2 logarithm of <code>2**x1 + 2**x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>logaddexp: Logarithm of the sum of exponentiations of the inputs.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.3.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>prob1 = np.log2(1e-50) prob2 = np.log2(2.5e-50) prob12 = np.logaddexp2(prob1, prob2) prob1, prob2, prob12 (-166.09640474436813, -164.77447664948076, -164.28904982231052) 2**prob12 3.4999999999999914e-50</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26370">view source</a></div></div><div class="public anchor" id="var-logical_and"><h3>logical_and</h3><div class="usage"><code>(logical_and self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logical_and(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute the truth value of x1 AND x2 element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or bool  Boolean result of the logical AND operation applied to the elements  of <code>x1</code> and <code>x2</code>; the shape is determined by broadcasting.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>logical_or, logical_not, logical_xor bitwise_and</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.logical_and(True, False) False np.logical_and([True, False], [False, False]) array([False, False])</p>
+      <p>x = np.arange(5) np.logical_and(x&gt;1, x&lt;4) array([False, False, True, True, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L764">view source</a></div></div><div class="public anchor" id="var-logical_not"><h3>logical_not</h3><div class="usage"><code>(logical_not self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logical_not(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute the truth value of NOT x element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Logical NOT is applied to the elements of <code>x</code>. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : bool or ndarray of bool  Boolean result with the same shape as <code>x</code> of the NOT operation  on elements of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>logical_and, logical_or, logical_xor</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.logical_not(3) False np.logical_not([True, False, 0, 1]) array([False, True, True, False])</p>
+      <p>x = np.arange(5) np.logical_not(x&lt;3) array([False, False, False, True, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18820">view source</a></div></div><div class="public anchor" id="var-logical_or"><h3>logical_or</h3><div class="usage"><code>(logical_or self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logical_or(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute the truth value of x1 OR x2 element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Logical OR is applied to the elements of <code>x1</code> and <code>x2</code>.  If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or bool  Boolean result of the logical OR operation applied to the elements  of <code>x1</code> and <code>x2</code>; the shape is determined by broadcasting.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>logical_and, logical_not, logical_xor bitwise_or</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.logical_or(True, False) True np.logical_or([True, False], [False, False]) array([ True, False])</p>
+      <p>x = np.arange(5) np.logical_or(x &lt; 1, x &gt; 3) array([ True, False, False, False, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4331">view source</a></div></div><div class="public anchor" id="var-logical_xor"><h3>logical_xor</h3><div class="usage"><code>(logical_xor self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logical_xor(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute the truth value of x1 XOR x2, element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Logical XOR is applied to the elements of <code>x1</code> and <code>x2</code>. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : bool or ndarray of bool  Boolean result of the logical XOR operation applied to the elements  of <code>x1</code> and <code>x2</code>; the shape is determined by broadcasting.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>logical_and, logical_or, logical_not, bitwise_xor</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.logical_xor(True, False) True np.logical_xor([True, True, False, False], [True, False, True, False]) array([False, True, True, False])</p>
+      <p>x = np.arange(5) np.logical_xor(x &lt; 1, x &gt; 3) array([ True, False, False, False, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Simple example showing support of broadcasting</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.logical_xor(0, np.eye(2)) array(<a href="null"> True, False],
+       [False,  True</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23887">view source</a></div></div><div class="public anchor" id="var-logspace"><h3>logspace</h3><div class="usage"><code>(logspace &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return numbers spaced evenly on a log scale.</p>
+<p>In linear space, the sequence starts at <code>base ** start</code> (<code>base</code> to the power of <code>start</code>) and ends with <code>base ** stop</code> (see <code>endpoint</code> below).</p>
+<p>.. versionchanged:: 1.16.0  Non-scalar <code>start</code> and <code>stop</code> are now supported.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>start : array_like  <code>base ** start</code> is the starting value of the sequence. stop : array_like  <code>base ** stop</code> is the final value of the sequence, unless <code>endpoint</code>  is False. In that case, <code>num + 1</code> values are spaced over the  interval in log-space, of which all but the last (a sequence of  length <code>num</code>) are returned. num : integer, optional  Number of samples to generate. Default is 50. endpoint : boolean, optional  If true, <code>stop</code> is the last sample. Otherwise, it is not included.  Default is True. base : float, optional  The base of the log space. The step size between the elements in  <code>ln(samples) / ln(base)</code> (or <code>log_base(samples)</code>) is uniform.  Default is 10.0. dtype : dtype  The type of the output array. If <code>dtype</code> is not given, infer the data  type from the other input arguments. axis : int, optional  The axis in the result to store the samples. Relevant only if start  or stop are array-like. By default (0), the samples will be along a  new axis inserted at the beginning. Use -1 to get an axis at the end.</p>
+<pre><code>.. versionadded:: 1.16.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>samples : ndarray  <code>num</code> samples, equally spaced on a log scale.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>arange : Similar to linspace, with the step size specified instead of the  number of samples. Note that, when used with a float endpoint, the  endpoint may or may not be included. linspace : Similar to logspace, but with the samples uniformly distributed  in linear space, instead of log space. geomspace : Similar to logspace, but with endpoints specified directly.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Logspace is equivalent to the code</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>y = np.linspace(start, stop, num=num, endpoint=endpoint) … # doctest: +SKIP power(base, y).astype(dtype) … # doctest: +SKIP</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.logspace(2.0, 3.0, num=4) array([ 100. , 215.443469 , 464.15888336, 1000. ]) np.logspace(2.0, 3.0, num=4, endpoint=False) array([100. , 177.827941 , 316.22776602, 562.34132519]) np.logspace(2.0, 3.0, num=4, base=2.0) array([4. , 5.0396842 , 6.34960421, 8. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Graphical illustration:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt N = 10 x1 = np.logspace(0.1, 1, N, endpoint=True) x2 = np.logspace(0.1, 1, N, endpoint=False) y = np.zeros(N) plt.plot(x1, y, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.plot(x2, y + 0.5, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.ylim([-0.5, 1]) (-0.5, 1) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18731">view source</a></div></div><div class="public anchor" id="var-long"><h3>long</h3><div class="usage"><code>(long self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>int([x]) -&gt; integer int(x, base=10) -&gt; integer</p>
+<p>Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.</p>
+<p>If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by ‘+’ or ‘-’ and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>int(‘0b100’, base=0) 4</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7708">view source</a></div></div><div class="public anchor" id="var-longcomplex"><h3>longcomplex</h3><div class="usage"><code>(longcomplex self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two extended-precision floating-point numbers. Character code: <code>'G'</code>. Canonical name: <code>np.clongdouble</code>. Alias: <code>np.clongfloat</code>. Alias: <code>np.longcomplex</code>. Alias <em>on this platform</em>: <code>np.complex256</code>: Complex number type composed of 2 128-bit extended-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7724">view source</a></div></div><div class="public anchor" id="var-longdouble"><h3>longdouble</h3><div class="usage"><code>(longdouble self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Extended-precision floating-point number type, compatible with C <code>long double</code> but not necessarily with IEEE 754 quadruple-precision. Character code: <code>'g'</code>. Canonical name: <code>np.longdouble</code>. Alias: <code>np.longfloat</code>. Alias <em>on this platform</em>: <code>np.float128</code>: 128-bit extended-precision floating-point number type.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6487">view source</a></div></div><div class="public anchor" id="var-longfloat"><h3>longfloat</h3><div class="usage"><code>(longfloat self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Extended-precision floating-point number type, compatible with C <code>long double</code> but not necessarily with IEEE 754 quadruple-precision. Character code: <code>'g'</code>. Canonical name: <code>np.longdouble</code>. Alias: <code>np.longfloat</code>. Alias <em>on this platform</em>: <code>np.float128</code>: 128-bit extended-precision floating-point number type.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L499">view source</a></div></div><div class="public anchor" id="var-longlong"><h3>longlong</h3><div class="usage"><code>(longlong self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>long long</code>. Character code: <code>'q'</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28966">view source</a></div></div><div class="public anchor" id="var-lookfor"><h3>lookfor</h3><div class="usage"><code>(lookfor what &amp; [{module :module, import_modules :import_modules, regenerate :regenerate, output :output}])</code><code>(lookfor what &amp; [{module :module, import_modules :import_modules, regenerate :regenerate}])</code><code>(lookfor what &amp; [{module :module, import_modules :import_modules}])</code><code>(lookfor what &amp; [{module :module}])</code><code>(lookfor what)</code></div><div class="doc"><div class="markdown"><p>Do a keyword search on docstrings.</p>
+<p>A list of objects that matched the search is displayed, sorted by relevance. All given keywords need to be found in the docstring for it to be returned as a result, but the order does not matter.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>what : str  String containing words to look for. module : str or list, optional  Name of module(s) whose docstrings to go through. import_modules : bool, optional  Whether to import sub-modules in packages. Default is True. regenerate : bool, optional  Whether to re-generate the docstring cache. Default is False. output : file-like, optional  File-like object to write the output to. If omitted, use a pager.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>source, info</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Relevance is determined only roughly, by checking if the keywords occur in the function name, at the start of a docstring, etc.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.lookfor(‘binary representation’) # doctest: +SKIP</p>
+      <h2><a href="#search-results-for-binary-representation" name="search-results-for-binary-representation"></a>Search results for ‘binary representation’</h2>
+      <p>numpy.binary_repr  Return the binary representation of the input number as a string. numpy.core.setup_common.long_double_representation  Given a binary dump as given by GNU od -b, look for long double numpy.base_repr  Return a string representation of a number in the given base system. …</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21667">view source</a></div></div><div class="public anchor" id="var-ma"><h3>ma</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>=============</p>
+<h1><a href="#masked-arrays" name="masked-arrays"></a>Masked Arrays</h1>
+<p>Arrays sometimes contain invalid or missing data. When doing operations on such arrays, we wish to suppress invalid values, which is the purpose masked arrays fulfill (an example of typical use is given below).</p>
+<p>For example, examine the following array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([2, 1, 3, np.nan, 5, 2, 3, np.nan])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>When we try to calculate the mean of the data, the result is undetermined:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.mean(x) nan</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The mean is calculated using roughly <code>np.sum(x)/len(x)</code>, but since any number added to <code>NaN</code> [1]_ produces <code>NaN</code>, this doesn’t work. Enter masked arrays:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>m = np.ma.masked_array(x, np.isnan(x)) m masked_array(data = [2.0 1.0 3.0 – 5.0 2.0 3.0 –],  mask = [False False False True False False False True],  fill_value=1e+20)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Here, we construct a masked array that suppress all <code>NaN</code> values. We may now proceed to calculate the mean of the other values:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.mean(m) 2.6666666666666665</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>.. [1] Not-a-Number, a floating point value that is the result of an  invalid operation.</p>
+<p>.. moduleauthor:: Pierre Gerard-Marchant .. moduleauthor:: Jarrod Millman</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15056">view source</a></div></div><div class="public anchor" id="var-MachAr"><h3>MachAr</h3><div class="usage"><code>(MachAr self &amp; [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float, float_to_str :float_to_str, title :title}])</code><code>(MachAr self &amp; [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float, float_to_str :float_to_str}])</code><code>(MachAr self &amp; [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float}])</code><code>(MachAr self &amp; [{float_conv :float_conv, int_conv :int_conv}])</code><code>(MachAr self &amp; [{float_conv :float_conv}])</code><code>(MachAr self)</code></div><div class="doc"><div class="markdown"><p>Diagnosing machine parameters.</p>
+<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
+<p>ibeta : int  Radix in which numbers are represented. it : int  Number of base-<code>ibeta</code> digits in the floating point mantissa M. machep : int  Exponent of the smallest (most negative) power of <code>ibeta</code> that,  added to 1.0, gives something different from 1.0 eps : float  Floating-point number <code>beta**machep</code> (floating point precision) negep : int  Exponent of the smallest power of <code>ibeta</code> that, subtracted  from 1.0, gives something different from 1.0. epsneg : float  Floating-point number <code>beta**negep</code>. iexp : int  Number of bits in the exponent (including its sign and bias). minexp : int  Smallest (most negative) power of <code>ibeta</code> consistent with there  being no leading zeros in the mantissa. xmin : float  Floating point number <code>beta**minexp</code> (the smallest [in  magnitude] usable floating value). maxexp : int  Smallest (positive) power of <code>ibeta</code> that causes overflow. xmax : float  <code>(1-epsneg) * beta**maxexp</code> (the largest [in magnitude]  usable floating value). irnd : int  In <code>range(6)</code>, information on what kind of rounding is done  in addition, and on how underflow is handled. ngrd : int  Number of ‘guard digits’ used when truncating the product  of two mantissas to fit the representation. epsilon : float  Same as <code>eps</code>. tiny : float  Same as <code>xmin</code>. huge : float  Same as <code>xmax</code>. precision : float  <code>- int(-log10(eps))</code> resolution : float  <code>- 10**(-precision)</code></p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>float_conv : function, optional  Function that converts an integer or integer array to a float  or float array. Default is <code>float</code>. int_conv : function, optional  Function that converts a float or float array to an integer or  integer array. Default is <code>int</code>. float_to_float : function, optional  Function that converts a float array to float. Default is <code>float</code>.  Note that this does not seem to do anything useful in the current  implementation. float_to_str : function, optional  Function that converts a single float to a string. Default is  <code>lambda v:'%24.16e' %v</code>. title : str, optional  Title that is printed in the string representation of <code>MachAr</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>finfo : Machine limits for floating point types. iinfo : Machine limits for integer types.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Press, Teukolsky, Vetterling and Flannery,  “Numerical Recipes in C++,” 2nd ed,  Cambridge University Press, 2002, p. 31.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L203">view source</a></div></div><div class="public anchor" id="var-mafromtxt"><h3>mafromtxt</h3><div class="usage"><code>(mafromtxt fname &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Load ASCII data stored in a text file and return a masked array.</p>
+<p>.. deprecated:: 1.17  np.mafromtxt is a deprecated alias of <code>genfromtxt</code> which  overwrites the <code>usemask</code> argument with <code>True</code> even when  explicitly called as <code>mafromtxt(..., usemask=False)</code>.  Use <code>genfromtxt</code> instead.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>fname, kwargs : For a description of input parameters, see <code>genfromtxt</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.genfromtxt : generic function to load ASCII data.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22869">view source</a></div></div><div class="public anchor" id="var-mask_indices"><h3>mask_indices</h3><div class="usage"><code>(mask_indices n mask_func &amp; [{k :k}])</code><code>(mask_indices n mask_func)</code></div><div class="doc"><div class="markdown"><p>Return the indices to access (n, n) arrays, given a masking function.</p>
+<p>Assume <code>mask_func</code> is a function that, for a square array a of size <code>(n, n)</code> with a possible offset argument <code>k</code>, when called as <code>mask_func(a, k)</code> returns a new array with zeros in certain locations (functions like <code>triu</code> or <code>tril</code> do precisely this). Then this function returns the indices where the non-zero values would be located.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>n : int  The returned indices will be valid to access arrays of shape (n, n). mask_func : callable  A function whose call signature is similar to that of <code>triu</code>, <code>tril</code>.  That is, <code>mask_func(x, k)</code> returns a boolean array, shaped like <code>x</code>.  <code>k</code> is an optional argument to the function. k : scalar  An optional argument which is passed through to <code>mask_func</code>. Functions  like <code>triu</code>, <code>tril</code> take a second argument that is interpreted as an  offset.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>indices : tuple of arrays.  The <code>n</code> arrays of indices corresponding to the locations where  <code>mask_func(np.ones((n, n)), k)</code> is True.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>triu, tril, triu_indices, tril_indices</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.4.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>These are the indices that would allow you to access the upper triangular part of any 3x3 array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>iu = np.mask_indices(3, np.triu)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>For example, if <code>a</code> is a 3x3 array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(9).reshape(3, 3) a array(<a href="null">0, 1, 2],
+       [3, 4, 5],
+       [6, 7, 8</a>) a[iu] array([0, 1, 2, 4, 5, 8])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>An offset can be passed also to the masking function. This gets us the indices starting on the first diagonal right of the main one:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>iu1 = np.mask_indices(3, np.triu, 1)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>with which we now extract only three elements:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a[iu1] array([1, 2, 5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17456">view source</a></div></div><div class="public anchor" id="var-mat"><h3>mat</h3><div class="usage"><code>(mat data &amp; [{dtype :dtype}])</code><code>(mat data)</code></div><div class="doc"><div class="markdown"><p>Interpret the input as a matrix.</p>
+<p>Unlike <code>matrix</code>, <code>asmatrix</code> does not make a copy if the input is already a matrix or an ndarray. Equivalent to <code>matrix(data, copy=False)</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>data : array_like  Input data. dtype : data-type  Data-type of the output matrix.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>mat : matrix  <code>data</code> interpreted as a matrix.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">1, 2], [3, 4</a>)</p>
+      <p>m = np.asmatrix(x)</p>
+      <p>x[0,0] = 5</p>
+      <p>m matrix(<a href="null">5, 2],
+        [3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9421">view source</a></div></div><div class="public anchor" id="var-math"><h3>math</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>This module provides access to the mathematical functions defined by the C standard.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15053">view source</a></div></div><div class="public anchor" id="var-matmul"><h3>matmul</h3><div class="usage"><code>(matmul self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>matmul(x1, x2, /, out=None, *, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Matrix product of two arrays.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Input arrays, scalars not allowed. out : ndarray, optional  A location into which the result is stored. If provided, it must have  a shape that matches the signature <code>(n,k),(k,m)-&gt;(n,m)</code>. If not  provided or None, a freshly-allocated array is returned. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<pre><code>.. versionadded:: 1.16
+   Now handles ufunc kwargs
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The matrix product of the inputs.  This is a scalar only when both x1, x2 are 1-d vectors.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If the last dimension of <code>a</code> is not the same size as  the second-to-last dimension of <code>b</code>.</p>
+<pre><code>If a scalar value is passed in.
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>vdot : Complex-conjugating dot product. tensordot : Sum products over arbitrary axes. einsum : Einstein summation convention. dot : alternative matrix product with different broadcasting rules.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The behavior depends on the arguments in the following way.</p>
+<ul>
+  <li>If both arguments are 2-D they are multiplied like conventional  matrices.</li>
+  <li>If either argument is N-D, N &gt; 2, it is treated as a stack of  matrices residing in the last two indexes and broadcast accordingly.</li>
+  <li>If the first argument is 1-D, it is promoted to a matrix by  prepending a 1 to its dimensions. After matrix multiplication  the prepended 1 is removed.</li>
+  <li>If the second argument is 1-D, it is promoted to a matrix by  appending a 1 to its dimensions. After matrix multiplication  the appended 1 is removed.</li>
+</ul>
+<p><code>matmul</code> differs from <code>dot</code> in two important ways:</p>
+<ul>
+  <li>Multiplication by scalars is not allowed, use <code>*</code> instead.</li>
+  <li>Stacks of matrices are broadcast together as if the matrices  were elements, respecting the signature <code>(n,k),(k,m)-&gt;(n,m)</code>:</li>
+</ul>
+<p>&gt;&gt;&gt; a = np.ones([9, 5, 7, 4])  &gt;&gt;&gt; c = np.ones([9, 5, 4, 3])  &gt;&gt;&gt; np.dot(a, c).shape  (9, 5, 7, 9, 5, 3)  &gt;&gt;&gt; np.matmul(a, c).shape  (9, 5, 7, 3)  &gt;&gt;&gt; # n is 7, k is 4, m is 3</p>
+<p>The matmul function implements the semantics of the <code>@</code> operator introduced in Python 3.5 following PEP465.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>For 2-D arrays it is the matrix product:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 0],
+...               [0, 1</a>) b = np.array(<a href="null">4, 1],
+...               [2, 2</a>) np.matmul(a, b) array(<a href="null">4, 1],
+       [2, 2</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>For 2-D mixed with 1-D, the result is the usual.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 0],
+...               [0, 1</a>) b = np.array([1, 2]) np.matmul(a, b) array([1, 2]) np.matmul(b, a) array([1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Broadcasting is conventional for stacks of arrays</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) np.matmul(a,b).shape (2, 2, 2) np.matmul(a, b)[0, 1, 1] 98 sum(a[0, 1, :] * b[0 , :, 1]) 98</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Vector, vector returns the scalar inner product, but neither argument is complex-conjugated:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.matmul([2j, 3j], [2j, 3j]) (-13+0j)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Scalar multiplication raises an error.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.matmul([1,2], 3) Traceback (most recent call last): … ValueError: matmul: Input operand 1 does not have enough dimensions …</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>.. versionadded:: 1.10.0</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6668">view source</a></div></div><div class="public anchor" id="var-matrix"><h3>matrix</h3><div class="usage"><code>(matrix self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>matrix(data, dtype=None, copy=True)</p>
+<p>.. note:: It is no longer recommended to use this class, even for linear  algebra. Instead use regular arrays. The class may be removed  in the future.</p>
+<p>Returns a matrix from an array-like object, or from a string of data. A matrix is a specialized 2-D array that retains its 2-D nature through operations. It has certain special operators, such as <code>*</code> (matrix multiplication) and <code>**</code> (matrix power).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>data : array_like or string  If <code>data</code> is a string, it is interpreted as a matrix with commas  or spaces separating columns, and semicolons separating rows. dtype : data-type  Data-type of the output matrix. copy : bool  If <code>data</code> is already an <code>ndarray</code>, then this flag determines  whether the data is copied (the default), or whether a view is  constructed.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>array</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.matrix(‘1 2; 3 4’) a matrix(<a href="null">1, 2],
+        [3, 4</a>)</p>
+      <p>np.matrix(<a href="null">1, 2], [3, 4</a>) matrix(<a href="null">1, 2],
+        [3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8364">view source</a></div></div><div class="public anchor" id="var-matrixlib"><h3>matrixlib</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Sub-package containing the matrix class and related functions.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5618">view source</a></div></div><div class="public anchor" id="var-max"><h3>max</h3><div class="usage"><code>(max &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the maximum of an array or maximum along an axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  Axis or axes along which to operate. By default, flattened input is  used.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If this is a tuple of ints, the maximum is selected over multiple axes,
+instead of a single axis or all the axes as before.
+</code></pre>
+<p>out : ndarray, optional  Alternative output array in which to place the result. Must  be of the same shape and buffer length as the expected output.  See <code>ufuncs-output-type</code> for more details.</p>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `amax` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<p>initial : scalar, optional  The minimum value of an output element. Must be present to allow  computation on empty slice. See <code>~numpy.ufunc.reduce</code> for details.</p>
+<pre><code>.. versionadded:: 1.15.0
+</code></pre>
+<p>where : array_like of bool, optional  Elements to compare for the maximum. See <code>~numpy.ufunc.reduce</code>  for details.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>amax : ndarray or scalar  Maximum of <code>a</code>. If <code>axis</code> is None, the result is a scalar value.  If <code>axis</code> is given, the result is an array of dimension  <code>a.ndim - 1</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>amin :  The minimum value of an array along a given axis, propagating any NaNs. nanmax :  The maximum value of an array along a given axis, ignoring any NaNs. maximum :  Element-wise maximum of two arrays, propagating any NaNs. fmax :  Element-wise maximum of two arrays, ignoring any NaNs. argmax :  Return the indices of the maximum values.</p>
+<p>nanmin, minimum, fmin</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>NaN values are propagated, that is if at least one item is NaN, the corresponding max value will be NaN as well. To ignore NaN values (MATLAB behavior), please use nanmax.</p>
+<p>Don’t use <code>amax</code> for element-wise comparison of 2 arrays; when <code>a.shape[0]</code> is 2, <code>maximum(a[0], a[1])</code> is faster than <code>amax(a, axis=0)</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(4).reshape((2,2)) a array(<a href="null">0, 1],
+       [2, 3</a>) np.amax(a) # Maximum of the flattened array 3 np.amax(a, axis=0) # Maxima along the first axis array([2, 3]) np.amax(a, axis=1) # Maxima along the second axis array([1, 3]) np.amax(a, where=[False, True], initial=-1, axis=0) array([-1, 3]) b = np.arange(5, dtype=float) b[2] = np.NaN np.amax(b) nan np.amax(b, where=~np.isnan(b), initial=-1) 4.0 np.nanmax(b) 4.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>You can use an initial value to compute the maximum of an empty slice, or to initialize it to a different value:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.max(<a href="null">-50], [10</a>, axis=-1, initial=0) array([ 0, 10])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Notice that the initial value is used as one of the elements for which the maximum is determined, unlike for the default argument Python’s max function, which is only used for empty iterables.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.max([5], initial=6) 6 max([5], default=6) 5</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9047">view source</a></div></div><div class="public anchor" id="var-MAXDIMS"><h3>MAXDIMS</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26989">view source</a></div></div><div class="public anchor" id="var-maximum"><h3>maximum</h3><div class="usage"><code>(maximum self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>maximum(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Element-wise maximum of array elements.</p>
+<p>Compare two arrays and returns a new array containing the element-wise maxima. If one of the elements being compared is a NaN, then that element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are propagated.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  The arrays holding the elements to be compared. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  The maximum of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>minimum :  Element-wise minimum of two arrays, propagates NaNs. fmax :  Element-wise maximum of two arrays, ignores NaNs. amax :  The maximum value of an array along a given axis, propagates NaNs. nanmax :  The maximum value of an array along a given axis, ignores NaNs.</p>
+<p>fmin, amin, nanmin</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The maximum is equivalent to <code>np.where(x1 &gt;= x2, x1, x2)</code> when neither x1 nor x2 are nans, but it is faster and does proper broadcasting.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.maximum([2, 3, 4], [1, 5, 2]) array([2, 5, 4])</p>
+      <p>np.maximum(np.eye(2), [0.5, 2]) # broadcasting array(<a href="null"> 1. ,  2. ],
+       [ 0.5,  2. </a>)</p>
+      <p>np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) array([nan, nan, nan]) np.maximum(np.Inf, 1) inf</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9683">view source</a></div></div><div class="public anchor" id="var-maximum_sctype"><h3>maximum_sctype</h3><div class="usage"><code>(maximum_sctype t)</code></div><div class="doc"><div class="markdown"><p>Return the scalar type of highest precision of the same kind as the input.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>t : dtype or dtype specifier  The input data type. This can be a <code>dtype</code> object or an object that  is convertible to a <code>dtype</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : dtype  The highest precision data type of the same kind (<code>dtype.kind</code>) as <code>t</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>obj2sctype, mintypecode, sctype2char dtype</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.maximum_sctype(int) &lt;class ‘numpy.int64’&gt; np.maximum_sctype(np.uint8) &lt;class ‘numpy.uint64’&gt; np.maximum_sctype(complex) &lt;class ‘numpy.complex256’&gt; # may vary</p>
+      <p>np.maximum_sctype(str) &lt;class ‘numpy.str_’&gt;</p>
+      <p>np.maximum_sctype(‘i2’) &lt;class ‘numpy.int64’&gt; np.maximum_sctype(‘f4’) &lt;class ‘numpy.float128’&gt; # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4165">view source</a></div></div><div class="public anchor" id="var-MAY_SHARE_BOUNDS"><h3>MAY_SHARE_BOUNDS</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1393">view source</a></div></div><div class="public anchor" id="var-MAY_SHARE_EXACT"><h3>MAY_SHARE_EXACT</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14131">view source</a></div></div><div class="public anchor" id="var-may_share_memory"><h3>may_share_memory</h3><div class="usage"><code>(may_share_memory &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>may_share_memory(a, b, max_work=None)</p>
+<p>Determine if two arrays might share memory</p>
+<p>A return of True does not necessarily mean that the two arrays share any element. It just means that they <em>might</em>.</p>
+<p>Only the memory bounds of a and b are checked by default.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a, b : ndarray  Input arrays max_work : int, optional  Effort to spend on solving the overlap problem. See  <code>shares_memory</code> for details. Default for <code>may_share_memory</code>  is to do a bounds check.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : bool</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>shares_memory</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.may_share_memory(np.array([1,2]), np.array([5,8,9])) False x = np.zeros([3, 4]) np.may_share_memory(x[:,0], x[:,1]) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20304">view source</a></div></div><div class="public anchor" id="var-mean"><h3>mean</h3><div class="usage"><code>(mean &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the arithmetic mean along the specified axis.</p>
+<p>Returns the average of the array elements. The average is taken over the flattened array by default, otherwise over the specified axis. <code>float64</code> intermediate and return values are used for integer inputs.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array containing numbers whose mean is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : None or int or tuple of ints, optional  Axis or axes along which the means are computed. The default is to  compute the mean of the flattened array.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If this is a tuple of ints, a mean is performed over multiple axes,
+instead of a single axis or all the axes as before.
+</code></pre>
+<p>dtype : data-type, optional  Type to use in computing the mean. For integer inputs, the default  is <code>float64</code>; for floating point inputs, it is the same as the  input dtype. out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>; if provided, it must have the same shape as the  expected output, but the type will be cast if necessary.  See <code>ufuncs-output-type</code> for more details.</p>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `mean` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>m : ndarray, see dtype parameter above  If <code>out=None</code>, returns a new array containing the mean values,  otherwise a reference to the output array is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>average : Weighted average std, var, nanmean, nanstd, nanvar</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The arithmetic mean is the sum of the elements along the axis divided by the number of elements.</p>
+<p>Note that for floating-point input, the mean is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for <code>float32</code> (see example below). Specifying a higher-precision accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
+<p>By default, <code>float16</code> results are computed using <code>float32</code> intermediates for extra precision.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 2], [3, 4</a>) np.mean(a) 2.5 np.mean(a, axis=0) array([2., 3.]) np.mean(a, axis=1) array([1.5, 3.5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>In single precision, <code>mean</code> can be inaccurate:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.zeros((2, 512*512), dtype=np.float32) a[0, :] = 1.0 a[1, :] = 0.1 np.mean(a) 0.54999924</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Computing the mean in float64 is more accurate:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.mean(a, dtype=np.float64) 0.55000000074505806 # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6809">view source</a></div></div><div class="public anchor" id="var-median"><h3>median</h3><div class="usage"><code>(median &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the median along the specified axis.</p>
+<p>Returns the median of the array elements.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array or object that can be converted to an array. axis : {int, sequence of int, None}, optional  Axis or axes along which the medians are computed. The default  is to compute the median along a flattened version of the array.  A sequence of axes is supported since version 1.9.0. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow use of memory of input array <code>a</code> for  calculations. The input array will be modified by the call to  <code>median</code>. This will save memory when you do not need to preserve  the contents of the input array. Treat the input as undefined,  but it will probably be fully or partially sorted. Default is  False. If <code>overwrite_input</code> is <code>True</code> and <code>a</code> is not already an  <code>ndarray</code>, an error will be raised. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>arr</code>.</p>
+<pre><code>.. versionadded:: 1.9.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>median : ndarray  A new array holding the result. If the input contains integers  or floats smaller than <code>float64</code>, then the output data-type is  <code>np.float64</code>. Otherwise, the data-type of the output is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>mean, percentile</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Given a vector <code>V</code> of length <code>N</code>, the median of <code>V</code> is the middle value of a sorted copy of <code>V</code>, <code>V_sorted</code> - i e., <code>V_sorted[(N-1)/2]</code>, when <code>N</code> is odd, and the average of the two middle values of <code>V_sorted</code> when <code>N</code> is even.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">10, 7, 4], [3, 2, 1</a>) a array(<a href="null">10,  7,  4],
+       [ 3,  2,  1</a>) np.median(a) 3.5 np.median(a, axis=0) array([6.5, 4.5, 2.5]) np.median(a, axis=1) array([7., 2.]) m = np.median(a, axis=0) out = np.zeros_like(m) np.median(a, axis=0, out=m) array([6.5, 4.5, 2.5]) m array([6.5, 4.5, 2.5]) b = a.copy() np.median(b, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a==b) b = a.copy() np.median(b, axis=None, overwrite_input=True) 3.5 assert not np.all(a==b)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28989">view source</a></div></div><div class="public anchor" id="var-memmap"><h3>memmap</h3><div class="usage"><code>(memmap self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create a memory-map to an array stored in a <em>binary</em> file on disk.</p>
+<p>Memory-mapped files are used for accessing small segments of large files on disk, without reading the entire file into memory. NumPy’s memmap’s are array-like objects. This differs from Python’s <code>mmap</code> module, which uses file-like objects.</p>
+<p>This subclass of ndarray has some unpleasant interactions with some operations, because it doesn’t quite fit properly as a subclass. An alternative to using this subclass is to create the <code>mmap</code> object yourself, then create an ndarray with ndarray.__new__ directly, passing the object created in its ‘buffer=’ parameter.</p>
+<p>This class may at some point be turned into a factory function which returns a view into an mmap buffer.</p>
+<p>Delete the memmap instance to close the memmap file.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>filename : str, file-like object, or pathlib.Path instance  The file name or file object to be used as the array data buffer. dtype : data-type, optional  The data-type used to interpret the file contents.  Default is <code>uint8</code>. mode : {‘r+’, ‘r’, ‘w+’, ‘c’}, optional  The file is opened in this mode:</p>
+<pre><code>+------+-------------------------------------------------------------+
+| 'r'  | Open existing file for reading only.                        |
++------+-------------------------------------------------------------+
+| 'r+' | Open existing file for reading and writing.                 |
++------+-------------------------------------------------------------+
+| 'w+' | Create or overwrite existing file for reading and writing.  |
++------+-------------------------------------------------------------+
+| 'c'  | Copy-on-write: assignments affect data in memory, but       |
+|      | changes are not saved to disk.  The file on disk is         |
+|      | read-only.                                                  |
++------+-------------------------------------------------------------+
+
+Default is 'r+'.
+</code></pre>
+<p>offset : int, optional  In the file, array data starts at this offset. Since <code>offset</code> is  measured in bytes, it should normally be a multiple of the byte-size  of <code>dtype</code>. When <code>mode != 'r'</code>, even positive offsets beyond end of  file are valid; The file will be extended to accommodate the  additional data. By default, <code>memmap</code> will start at the beginning of  the file, even if <code>filename</code> is a file pointer <code>fp</code> and  <code>fp.tell() != 0</code>. shape : tuple, optional  The desired shape of the array. If <code>mode == 'r'</code> and the number  of remaining bytes after <code>offset</code> is not a multiple of the byte-size  of <code>dtype</code>, you must specify <code>shape</code>. By default, the returned array  will be 1-D with the number of elements determined by file size  and data-type. order : {‘C’, ‘F’}, optional  Specify the order of the ndarray memory layout:  :term:<code>row-major</code>, C-style or :term:<code>column-major</code>,  Fortran-style. This only has an effect if the shape is  greater than 1-D. The default order is ‘C’.</p>
+<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
+<p>filename : str or pathlib.Path instance  Path to the mapped file. offset : int  Offset position in the file. mode : str  File mode.</p>
+<h2><a href="#methods" name="methods"></a>Methods</h2>
+<p>flush  Flush any changes in memory to file on disk.  When you delete a memmap object, flush is called first to write  changes to disk before removing the object.</p>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>lib.format.open_memmap : Create or load a memory-mapped <code>.npy</code> file.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The memmap object can be used anywhere an ndarray is accepted. Given a memmap <code>fp</code>, <code>isinstance(fp, numpy.ndarray)</code> returns <code>True</code>.</p>
+<p>Memory-mapped files cannot be larger than 2GB on 32-bit systems.</p>
+<p>When a memmap causes a file to be created or extended beyond its current size in the filesystem, the contents of the new part are unspecified. On systems with POSIX filesystem semantics, the extended part will be filled with zero bytes.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>data = np.arange(12, dtype=‘float32’) data.resize((3,4))</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>This example uses a temporary file so that doctest doesn’t write files to your directory. You would use a ‘normal’ filename.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from tempfile import mkdtemp import os.path as path filename = path.join(mkdtemp(), ‘newfile.dat’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Create a memmap with dtype and shape that matches our data:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>fp = np.memmap(filename, dtype=‘float32’, mode=‘w+’, shape=(3,4)) fp memmap(<a href="null">0., 0., 0., 0.],
+        [0., 0., 0., 0.],
+        [0., 0., 0., 0.</a>, dtype=float32)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Write data to memmap array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>fp[:] = data[:] fp memmap(<a href="null">  0.,   1.,   2.,   3.],
+        [  4.,   5.,   6.,   7.],
+        [  8.,   9.,  10.,  11.</a>, dtype=float32)</p>
+      <p>fp.filename == path.abspath(filename) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Deletion flushes memory changes to disk before removing the object:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>del fp</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Load the memmap and verify data was stored:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>newfp = np.memmap(filename, dtype=‘float32’, mode=‘r’, shape=(3,4)) newfp memmap(<a href="null">  0.,   1.,   2.,   3.],
+        [  4.,   5.,   6.,   7.],
+        [  8.,   9.,  10.,  11.</a>, dtype=float32)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Read-only memmap:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>fpr = np.memmap(filename, dtype=‘float32’, mode=‘r’, shape=(3,4)) fpr.flags.writeable False</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Copy-on-write memmap:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>fpc = np.memmap(filename, dtype=‘float32’, mode=‘c’, shape=(3,4)) fpc.flags.writeable True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>It’s possible to assign to copy-on-write array, but values are only written into the memory copy of the array, and not written to disk:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>fpc memmap(<a href="null">  0.,   1.,   2.,   3.],
+        [  4.,   5.,   6.,   7.],
+        [  8.,   9.,  10.,  11.</a>, dtype=float32) fpc[0,:] = 0 fpc memmap(<a href="null">  0.,   0.,   0.,   0.],
+        [  4.,   5.,   6.,   7.],
+        [  8.,   9.,  10.,  11.</a>, dtype=float32)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>File on disk is unchanged:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>fpr memmap(<a href="null">  0.,   1.,   2.,   3.],
+        [  4.,   5.,   6.,   7.],
+        [  8.,   9.,  10.,  11.</a>, dtype=float32)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Offset into a memmap:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>fpo = np.memmap(filename, dtype=‘float32’, mode=‘r’, offset=16) fpo memmap([ 4., 5., 6., 7., 8., 9., 10., 11.], dtype=float32)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8592">view source</a></div></div><div class="public anchor" id="var-meshgrid"><h3>meshgrid</h3><div class="usage"><code>(meshgrid &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return coordinate matrices from coordinate vectors.</p>
+<p>Make N-D coordinate arrays for vectorized evaluations of N-D scalar/vector fields over N-D grids, given one-dimensional coordinate arrays x1, x2,…, xn.</p>
+<p>.. versionchanged:: 1.9  1-D and 0-D cases are allowed.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2,…, xn : array_like  1-D arrays representing the coordinates of a grid. indexing : {‘xy’, ‘ij’}, optional  Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output.  See Notes for more details.</p>
+<pre><code>.. versionadded:: 1.7.0
+</code></pre>
+<p>sparse : bool, optional  If True a sparse grid is returned in order to conserve memory.  Default is False.</p>
+<pre><code>.. versionadded:: 1.7.0
+</code></pre>
+<p>copy : bool, optional  If False, a view into the original arrays are returned in order to  conserve memory. Default is True. Please note that  <code>sparse=False, copy=False</code> will likely return non-contiguous  arrays. Furthermore, more than one element of a broadcast array  may refer to a single memory location. If you need to write to the  arrays, make copies first.</p>
+<pre><code>.. versionadded:: 1.7.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>X1, X2,…, XN : ndarray  For vectors <code>x1</code>, <code>x2</code>,…, ‘xn’ with lengths <code>Ni=len(xi)</code> ,  return <code>(N1, N2, N3,...Nn)</code> shaped arrays if indexing=‘ij’  or <code>(N2, N1, N3,...Nn)</code> shaped arrays if indexing=‘xy’  with the elements of <code>xi</code> repeated to fill the matrix along  the first dimension for <code>x1</code>, the second for <code>x2</code> and so on.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This function supports both indexing conventions through the indexing keyword argument. Giving the string ‘ij’ returns a meshgrid with matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing. In the 2-D case with inputs of length M and N, the outputs are of shape (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing. In the 3-D case with inputs of length M, N and P, outputs are of shape (N, M, P) for ‘xy’ indexing and (M, N, P) for ‘ij’ indexing. The difference is illustrated by the following code snippet::</p>
+<pre><code>xv, yv = np.meshgrid(x, y, sparse=False, indexing='ij')
+for i in range(nx):
+    for j in range(ny):
+        # treat xv[i,j], yv[i,j]
+
+xv, yv = np.meshgrid(x, y, sparse=False, indexing='xy')
+for i in range(nx):
+    for j in range(ny):
+        # treat xv[j,i], yv[j,i]
+</code></pre>
+<p>In the 1-D and 0-D case, the indexing and sparse keywords have no effect.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>index_tricks.mgrid : Construct a multi-dimensional “meshgrid”  using indexing notation. index_tricks.ogrid : Construct an open multi-dimensional “meshgrid”  using indexing notation.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>nx, ny = (3, 2) x = np.linspace(0, 1, nx) y = np.linspace(0, 1, ny) xv, yv = np.meshgrid(x, y) xv array(<a href="null">0. , 0.5, 1. ],
+       [0. , 0.5, 1. </a>) yv array(<a href="null">0.,  0.,  0.],
+       [1.,  1.,  1.</a>) xv, yv = np.meshgrid(x, y, sparse=True) # make sparse output arrays xv array(<a href="null">0. ,  0.5,  1. </a>) yv array(<a href="null">0.],
+       [1.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p><code>meshgrid</code> is very useful to evaluate functions on a grid.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt x = np.arange(-5, 5, 0.1) y = np.arange(-5, 5, 0.1) xx, yy = np.meshgrid(x, y, sparse=True) z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2) h = plt.contourf(x,y,z) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28614">view source</a></div></div><div class="public anchor" id="var-mgrid"><h3>mgrid</h3><div class="usage"></div><div class="doc"><div class="markdown"><p><code>nd_grid</code> instance which returns a dense multi-dimensional “meshgrid”.</p>
+<p>An instance of <code>numpy.lib.index_tricks.nd_grid</code> which returns an dense (or fleshed out) mesh-grid when indexed, so that each returned argument has the same shape. The dimensions and number of the output arrays are equal to the number of indexing dimensions. If the step length is not a complex number, then the stop is not inclusive.</p>
+<p>However, if the step length is a <strong>complex number</strong> (e.g. 5j), then the integer part of its magnitude is interpreted as specifying the number of points to create between the start and stop values, where the stop value <strong>is inclusive</strong>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>mesh-grid <code>ndarrays</code> all of the same dimensions</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.lib.index_tricks.nd_grid : class of <code>ogrid</code> and <code>mgrid</code> objects ogrid : like mgrid but returns open (not fleshed out) mesh grids r_ : array concatenator</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.mgrid[0:5,0:5] array(<a href="null">[0, 0, 0, 0, 0],
+        [1, 1, 1, 1, 1],
+        [2, 2, 2, 2, 2],
+        [3, 3, 3, 3, 3],
+        [4, 4, 4, 4, 4</a>,  <a href="null">0, 1, 2, 3, 4],
+        [0, 1, 2, 3, 4],
+        [0, 1, 2, 3, 4],
+        [0, 1, 2, 3, 4],
+        [0, 1, 2, 3, 4</a>]) np.mgrid[-1:1:5j] array([-1. , -0.5, 0. , 0.5, 1. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4997">view source</a></div></div><div class="public anchor" id="var-min"><h3>min</h3><div class="usage"><code>(min &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the minimum of an array or minimum along an axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  Axis or axes along which to operate. By default, flattened input is  used.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If this is a tuple of ints, the minimum is selected over multiple axes,
+instead of a single axis or all the axes as before.
+</code></pre>
+<p>out : ndarray, optional  Alternative output array in which to place the result. Must  be of the same shape and buffer length as the expected output.  See <code>ufuncs-output-type</code> for more details.</p>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `amin` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<p>initial : scalar, optional  The maximum value of an output element. Must be present to allow  computation on empty slice. See <code>~numpy.ufunc.reduce</code> for details.</p>
+<pre><code>.. versionadded:: 1.15.0
+</code></pre>
+<p>where : array_like of bool, optional  Elements to compare for the minimum. See <code>~numpy.ufunc.reduce</code>  for details.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>amin : ndarray or scalar  Minimum of <code>a</code>. If <code>axis</code> is None, the result is a scalar value.  If <code>axis</code> is given, the result is an array of dimension  <code>a.ndim - 1</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>amax :  The maximum value of an array along a given axis, propagating any NaNs. nanmin :  The minimum value of an array along a given axis, ignoring any NaNs. minimum :  Element-wise minimum of two arrays, propagating any NaNs. fmin :  Element-wise minimum of two arrays, ignoring any NaNs. argmin :  Return the indices of the minimum values.</p>
+<p>nanmax, maximum, fmax</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>NaN values are propagated, that is if at least one item is NaN, the corresponding min value will be NaN as well. To ignore NaN values (MATLAB behavior), please use nanmin.</p>
+<p>Don’t use <code>amin</code> for element-wise comparison of 2 arrays; when <code>a.shape[0]</code> is 2, <code>minimum(a[0], a[1])</code> is faster than <code>amin(a, axis=0)</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(4).reshape((2,2)) a array(<a href="null">0, 1],
+       [2, 3</a>) np.amin(a) # Minimum of the flattened array 0 np.amin(a, axis=0) # Minima along the first axis array([0, 1]) np.amin(a, axis=1) # Minima along the second axis array([0, 2]) np.amin(a, where=[False, True], initial=10, axis=0) array([10, 1])</p>
+      <p>b = np.arange(5, dtype=float) b[2] = np.NaN np.amin(b) nan np.amin(b, where=~np.isnan(b), initial=10) 0.0 np.nanmin(b) 0.0</p>
+      <p>np.min(<a href="null">-50], [10</a>, axis=-1, initial=0) array([-50, 0])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Notice that the initial value is used as one of the elements for which the minimum is determined, unlike for the default argument Python’s max function, which is only used for empty iterables.</p>
+<p>Notice that this isn’t the same as Python’s <code>default</code> argument.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.min([6], initial=5) 5 min([6], default=5) 6</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1801">view source</a></div></div><div class="public anchor" id="var-min_scalar_type"><h3>min_scalar_type</h3><div class="usage"><code>(min_scalar_type &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>min_scalar_type(a)</p>
+<p>For scalar <code>a</code>, returns the data type with the smallest size and smallest scalar kind which can hold its value. For non-scalar array <code>a</code>, returns the vector’s dtype unmodified.</p>
+<p>Floating point values are not demoted to integers, and complex values are not demoted to floats.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : scalar or array_like  The value whose minimal data type is to be found.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : dtype  The minimal data type.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.6.0</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>result_type, promote_types, dtype, can_cast</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.min_scalar_type(10) dtype(‘uint8’)</p>
+      <p>np.min_scalar_type(-260) dtype(‘int16’)</p>
+      <p>np.min_scalar_type(3.1) dtype(‘float16’)</p>
+      <p>np.min_scalar_type(1e50) dtype(‘float64’)</p>
+      <p>np.min_scalar_type(np.arange(4,dtype=‘f8’)) dtype(‘float64’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8045">view source</a></div></div><div class="public anchor" id="var-minimum"><h3>minimum</h3><div class="usage"><code>(minimum self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>minimum(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Element-wise minimum of array elements.</p>
+<p>Compare two arrays and returns a new array containing the element-wise minima. If one of the elements being compared is a NaN, then that element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are propagated.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  The arrays holding the elements to be compared. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  The minimum of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>maximum :  Element-wise maximum of two arrays, propagates NaNs. fmin :  Element-wise minimum of two arrays, ignores NaNs. amin :  The minimum value of an array along a given axis, propagates NaNs. nanmin :  The minimum value of an array along a given axis, ignores NaNs.</p>
+<p>fmax, amax, nanmax</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The minimum is equivalent to <code>np.where(x1 &lt;= x2, x1, x2)</code> when neither x1 nor x2 are NaNs, but it is faster and does proper broadcasting.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.minimum([2, 3, 4], [1, 5, 2]) array([1, 3, 2])</p>
+      <p>np.minimum(np.eye(2), [0.5, 2]) # broadcasting array(<a href="null"> 0.5,  0. ],
+       [ 0. ,  1. </a>)</p>
+      <p>np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) array([nan, nan, nan]) np.minimum(-np.Inf, 1) -inf</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10511">view source</a></div></div><div class="public anchor" id="var-mintypecode"><h3>mintypecode</h3><div class="usage"><code>(mintypecode typechars &amp; [{typeset :typeset, default :default}])</code><code>(mintypecode typechars &amp; [{typeset :typeset}])</code><code>(mintypecode typechars)</code></div><div class="doc"><div class="markdown"><p>Return the character for the minimum-size type to which given types can be safely cast.</p>
+<p>The returned type character must represent the smallest size dtype such that an array of the returned type can handle the data from an array of all types in <code>typechars</code> (or if <code>typechars</code> is an array, then its dtype.char).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>typechars : list of str or array_like  If a list of strings, each string should represent a dtype.  If array_like, the character representation of the array dtype is used. typeset : str or list of str, optional  The set of characters that the returned character is chosen from.  The default set is ‘GDFgdf’. default : str, optional  The default character, this is returned if none of the characters in  <code>typechars</code> matches a character in <code>typeset</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>typechar : str  The character representing the minimum-size type that was found.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>dtype, sctype2char, maximum_sctype</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.mintypecode([‘d’, ‘f’, ‘S’]) ‘d’ x = np.array([1.1, 2-3.j]) np.mintypecode(x) ‘D’</p>
+      <p>np.mintypecode(‘abceh’, default=‘G’) ‘G’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8217">view source</a></div></div><div class="public anchor" id="var-mirr"><h3>mirr</h3><div class="usage"><code>(mirr &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Modified internal rate of return.</p>
+<p>.. deprecated:: 1.18</p>
+<p><code>mirr</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>values : array_like  Cash flows (must contain at least one positive and one negative  value) or nan is returned. The first value is considered a sunk  cost at time zero. finance_rate : scalar  Interest rate paid on the cash flows reinvest_rate : scalar  Interest rate received on the cash flows upon reinvestment</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : float  Modified internal rate of return</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19962">view source</a></div></div><div class="public anchor" id="var-mod"><h3>mod</h3><div class="usage"><code>(mod self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>remainder(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return element-wise remainder of division.</p>
+<p>Computes the remainder complementary to the <code>floor_divide</code> function. It is equivalent to the Python modulus operator<code>x1 % x2</code> and has the same sign as the divisor <code>x2</code>. The MATLAB function equivalent to <code>np.remainder</code> is <code>mod</code>.</p>
+<p>.. warning::</p>
+<pre><code>This should not be confused with:
+
+* Python 3.7's `math.remainder` and C's ``remainder``, which
+  computes the IEEE remainder, which are the complement to
+  ``round(x1 / x2)``.
+* The MATLAB ``rem`` function and or the C ``%`` operator which is the
+  complement to ``int(x1 / x2)``.
+</code></pre>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  Dividend array. x2 : array_like  Divisor array. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The element-wise remainder of the quotient <code>floor_divide(x1, x2)</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>floor_divide : Equivalent of Python <code>//</code> operator. divmod : Simultaneous floor division and remainder. fmod : Equivalent of the MATLAB <code>rem</code> function. divide, floor</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Returns 0 when <code>x2</code> is 0 and both <code>x1</code> and <code>x2</code> are (arrays of) integers. <code>mod</code> is an alias of <code>remainder</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.remainder([4, 7], [2, 3]) array([0, 1]) np.remainder(np.arange(7), 5) array([0, 1, 2, 3, 4, 0, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19894">view source</a></div></div><div class="public anchor" id="var-modf"><h3>modf</h3><div class="usage"><code>(modf self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the fractional and integral parts of an array, element-wise.</p>
+<p>The fractional and integral parts are negative if the given number is negative.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y1 : ndarray  Fractional part of <code>x</code>.  This is a scalar if <code>x</code> is a scalar. y2 : ndarray  Integral part of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>For integer input the return values are floats.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>divmod : <code>divmod(x, 1)</code> is equivalent to <code>modf</code> with the return values  switched, except it always has a positive remainder.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.modf([0, 3.5]) (array([ 0. , 0.5]), array([ 0., 3.])) np.modf(-0.5) (-0.5, -0)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28802">view source</a></div></div><div class="public anchor" id="var-ModuleDeprecationWarning"><h3>ModuleDeprecationWarning</h3><div class="usage"><code>(ModuleDeprecationWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Module deprecation warning.</p>
+<p>The nose tester turns ordinary Deprecation warnings into test failures. That makes it hard to deprecate whole modules, because they get imported by default. So this is a special Deprecation warning that the nose tester will let pass without making tests fail.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20294">view source</a></div></div><div class="public anchor" id="var-moveaxis"><h3>moveaxis</h3><div class="usage"><code>(moveaxis &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Move axes of an array to new positions.</p>
+<p>Other axes remain in their original order.</p>
+<p>.. versionadded:: 1.11.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : np.ndarray  The array whose axes should be reordered. source : int or sequence of int  Original positions of the axes to move. These must be unique. destination : int or sequence of int  Destination positions for each of the original axes. These must also be  unique.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>result : np.ndarray  Array with moved axes. This array is a view of the input array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>transpose: Permute the dimensions of an array. swapaxes: Interchange two axes of an array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.zeros((3, 4, 5)) np.moveaxis(x, 0, -1).shape (4, 5, 3) np.moveaxis(x, -1, 0).shape (5, 3, 4)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>These all achieve the same result:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.transpose(x).shape (5, 4, 3) np.swapaxes(x, 0, -1).shape (5, 4, 3) np.moveaxis(x, [0, 1], [-1, -2]).shape (5, 4, 3) np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape (5, 4, 3)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28193">view source</a></div></div><div class="public anchor" id="var-msort"><h3>msort</h3><div class="usage"><code>(msort &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a copy of an array sorted along the first axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array to be sorted.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>sorted_array : ndarray  Array of the same type and shape as <code>a</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>sort</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>np.msort(a)</code> is equivalent to <code>np.sort(a, axis=0)</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6165">view source</a></div></div><div class="public anchor" id="var-multiply"><h3>multiply</h3><div class="usage"><code>(multiply self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>multiply(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Multiply arguments element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Input arrays to be multiplied. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The product of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Equivalent to <code>x1</code> * <code>x2</code> in terms of array broadcasting.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.multiply(2.0, 4.0) 8.0</p>
+      <p>x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.multiply(x1, x2) array(<a href="null">  0.,   1.,   4.],
+       [  0.,   4.,  10.],
+       [  0.,   7.,  16.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5364">view source</a></div></div><div class="public anchor" id="var-NAN"><h3>NAN</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14127">view source</a></div></div><div class="public anchor" id="var-NaN"><h3>NaN</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L201">view source</a></div></div><div class="public anchor" id="var-nan"><h3>nan</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12502">view source</a></div></div><div class="public anchor" id="var-nan_to_num"><h3>nan_to_num</h3><div class="usage"><code>(nan_to_num &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Replace NaN with zero and infinity with large finite numbers (default behaviour) or with the numbers defined by the user using the <code>nan</code>, <code>posinf</code> and/or <code>neginf</code> keywords.</p>
+<p>If <code>x</code> is inexact, NaN is replaced by zero or by the user defined value in <code>nan</code> keyword, infinity is replaced by the largest finite floating point values representable by <code>x.dtype</code> or by the user defined value in <code>posinf</code> keyword and -infinity is replaced by the most negative finite floating point values representable by <code>x.dtype</code> or by the user defined value in <code>neginf</code> keyword.</p>
+<p>For complex dtypes, the above is applied to each of the real and imaginary components of <code>x</code> separately.</p>
+<p>If <code>x</code> is not inexact, then no replacements are made.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : scalar or array_like  Input data. copy : bool, optional  Whether to create a copy of <code>x</code> (True) or to replace values  in-place (False). The in-place operation only occurs if  casting to an array does not require a copy.  Default is True.</p>
+<pre><code>.. versionadded:: 1.13
+</code></pre>
+<p>nan : int, float, optional  Value to be used to fill NaN values. If no value is passed  then NaN values will be replaced with 0.0.</p>
+<pre><code>.. versionadded:: 1.17
+</code></pre>
+<p>posinf : int, float, optional  Value to be used to fill positive infinity values. If no value is  passed then positive infinity values will be replaced with a very  large number.</p>
+<pre><code>.. versionadded:: 1.17
+</code></pre>
+<p>neginf : int, float, optional  Value to be used to fill negative infinity values. If no value is  passed then negative infinity values will be replaced with a very  small (or negative) number.</p>
+<pre><code>.. versionadded:: 1.17
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  <code>x</code>, with the non-finite values replaced. If <code>copy</code> is False, this may  be <code>x</code> itself.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>isinf : Shows which elements are positive or negative infinity. isneginf : Shows which elements are negative infinity. isposinf : Shows which elements are positive infinity. isnan : Shows which elements are Not a Number (NaN). isfinite : Shows which elements are finite (not NaN, not infinity)</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.nan_to_num(np.inf) 1.7976931348623157e+308 np.nan_to_num(-np.inf) -1.7976931348623157e+308 np.nan_to_num(np.nan) 0.0 x = np.array([np.inf, -np.inf, np.nan, -128, 128]) np.nan_to_num(x) array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary  -1.28000000e+002, 1.28000000e+002]) np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333) array([ 3.3333333e+07, 3.3333333e+07, -9.9990000e+03,  -1.2800000e+02, 1.2800000e+02]) y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)]) array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary  -1.28000000e+002, 1.28000000e+002]) np.nan_to_num(y) array([ 1.79769313e+308 +0.00000000e+000j, # may vary  0.00000000e+000 +0.00000000e+000j,  0.00000000e+000 +1.79769313e+308j]) np.nan_to_num(y, nan=111111, posinf=222222) array([222222.+111111.j, 111111. +0.j, 111111.+222222.j])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24186">view source</a></div></div><div class="public anchor" id="var-nanargmax"><h3>nanargmax</h3><div class="usage"><code>(nanargmax &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices of the maximum values in the specified axis ignoring NaNs. For all-NaN slices <code>ValueError</code> is raised. Warning: the results cannot be trusted if a slice contains only NaNs and -Infs.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. axis : int, optional  Axis along which to operate. By default flattened input is used.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>index_array : ndarray  An array of indices or a single index value.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>argmax, nanargmin</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">np.nan, 4], [2, 3</a>) np.argmax(a) 0 np.nanargmax(a) 1 np.nanargmax(a, axis=0) array([1, 0]) np.nanargmax(a, axis=1) array([1, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17528">view source</a></div></div><div class="public anchor" id="var-nanargmin"><h3>nanargmin</h3><div class="usage"><code>(nanargmin &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices of the minimum values in the specified axis ignoring NaNs. For all-NaN slices <code>ValueError</code> is raised. Warning: the results cannot be trusted if a slice contains only NaNs and Infs.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. axis : int, optional  Axis along which to operate. By default flattened input is used.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>index_array : ndarray  An array of indices or a single index value.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>argmin, nanargmax</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">np.nan, 4], [2, 3</a>) np.argmin(a) 0 np.nanargmin(a) 2 np.nanargmin(a, axis=0) array([1, 1]) np.nanargmin(a, axis=1) array([1, 0])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7968">view source</a></div></div><div class="public anchor" id="var-nancumprod"><h3>nancumprod</h3><div class="usage"><code>(nancumprod &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cumulative product of array elements over a given axis treating Not a Numbers (NaNs) as one. The cumulative product does not change when NaNs are encountered and leading NaNs are replaced by ones.</p>
+<p>Ones are returned for slices that are all-NaN or empty.</p>
+<p>.. versionadded:: 1.12.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. axis : int, optional  Axis along which the cumulative product is computed. By default  the input is flattened. dtype : dtype, optional  Type of the returned array, as well as of the accumulator in which  the elements are multiplied. If <em>dtype</em> is not specified, it  defaults to the dtype of <code>a</code>, unless <code>a</code> has an integer dtype with  a precision less than that of the default platform integer. In  that case, the default platform integer is used instead. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output  but the type of the resulting values will be cast if necessary.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>nancumprod : ndarray  A new array holding the result is returned unless <code>out</code> is  specified, in which case it is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.cumprod : Cumulative product across array propagating NaNs. isnan : Show which elements are NaN.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.nancumprod(1) array([1]) np.nancumprod([1]) array([1]) np.nancumprod([1, np.nan]) array([1., 1.]) a = np.array(<a href="null">1, 2], [3, np.nan</a>) np.nancumprod(a) array([1., 2., 6., 6.]) np.nancumprod(a, axis=0) array(<a href="null">1.,  2.],
+       [3.,  2.</a>) np.nancumprod(a, axis=1) array(<a href="null">1.,  2.],
+       [3.,  3.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13088">view source</a></div></div><div class="public anchor" id="var-nancumsum"><h3>nancumsum</h3><div class="usage"><code>(nancumsum &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cumulative sum of array elements over a given axis treating Not a Numbers (NaNs) as zero. The cumulative sum does not change when NaNs are encountered and leading NaNs are replaced by zeros.</p>
+<p>Zeros are returned for slices that are all-NaN or empty.</p>
+<p>.. versionadded:: 1.12.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. axis : int, optional  Axis along which the cumulative sum is computed. The default  (None) is to compute the cumsum over the flattened array. dtype : dtype, optional  Type of the returned array and of the accumulator in which the  elements are summed. If <code>dtype</code> is not specified, it defaults  to the dtype of <code>a</code>, unless <code>a</code> has an integer dtype with a  precision less than that of the default platform integer. In  that case, the default platform integer is used. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output  but the type will be cast if necessary. See <code>ufuncs-output-type</code> for  more details.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>nancumsum : ndarray.  A new array holding the result is returned unless <code>out</code> is  specified, in which it is returned. The result has the same  size as <code>a</code>, and the same shape as <code>a</code> if <code>axis</code> is not None  or <code>a</code> is a 1-d array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.cumsum : Cumulative sum across array propagating NaNs. isnan : Show which elements are NaN.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.nancumsum(1) array([1]) np.nancumsum([1]) array([1]) np.nancumsum([1, np.nan]) array([1., 1.]) a = np.array(<a href="null">1, 2], [3, np.nan</a>) np.nancumsum(a) array([1., 3., 6., 6.]) np.nancumsum(a, axis=0) array(<a href="null">1.,  2.],
+       [4.,  2.</a>) np.nancumsum(a, axis=1) array(<a href="null">1.,  3.],
+       [3.,  3.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10188">view source</a></div></div><div class="public anchor" id="var-nanmax"><h3>nanmax</h3><div class="usage"><code>(nanmax &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the maximum of an array or maximum along an axis, ignoring any NaNs. When all-NaN slices are encountered a <code>RuntimeWarning</code> is raised and NaN is returned for that slice.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array containing numbers whose maximum is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the maximum is computed. The default is to compute  the maximum of the flattened array. out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>; if provided, it must have the same shape as the  expected output, but the type will be cast if necessary. See  <code>ufuncs-output-type</code> for more details.</p>
+<pre><code>.. versionadded:: 1.8.0
+</code></pre>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
+<pre><code>If the value is anything but the default, then
+`keepdims` will be passed through to the `max` method
+of sub-classes of `ndarray`.  If the sub-classes methods
+does not implement `keepdims` any exceptions will be raised.
+
+.. versionadded:: 1.8.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>nanmax : ndarray  An array with the same shape as <code>a</code>, with the specified axis removed.  If <code>a</code> is a 0-d array, or if axis is None, an ndarray scalar is  returned. The same dtype as <code>a</code> is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>nanmin :  The minimum value of an array along a given axis, ignoring any NaNs. amax :  The maximum value of an array along a given axis, propagating any NaNs. fmax :  Element-wise maximum of two arrays, ignoring any NaNs. maximum :  Element-wise maximum of two arrays, propagating any NaNs. isnan :  Shows which elements are Not a Number (NaN). isfinite:  Shows which elements are neither NaN nor infinity.</p>
+<p>amin, fmin, minimum</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity. Positive infinity is treated as a very large number and negative infinity is treated as a very small (i.e. negative) number.</p>
+<p>If the input has a integer type the function is equivalent to np.max.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 2], [3, np.nan</a>) np.nanmax(a) 3.0 np.nanmax(a, axis=0) array([3., 2.]) np.nanmax(a, axis=1) array([2., 3.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>When positive infinity and negative infinity are present:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.nanmax([1, 2, np.nan, np.NINF]) 2.0 np.nanmax([1, 2, np.nan, np.inf]) inf</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1034">view source</a></div></div><div class="public anchor" id="var-nanmean"><h3>nanmean</h3><div class="usage"><code>(nanmean &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the arithmetic mean along the specified axis, ignoring NaNs.</p>
+<p>Returns the average of the array elements. The average is taken over the flattened array by default, otherwise over the specified axis. <code>float64</code> intermediate and return values are used for integer inputs.</p>
+<p>For all-NaN slices, NaN is returned and a <code>RuntimeWarning</code> is raised.</p>
+<p>.. versionadded:: 1.8.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array containing numbers whose mean is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the means are computed. The default is to compute  the mean of the flattened array. dtype : data-type, optional  Type to use in computing the mean. For integer inputs, the default  is <code>float64</code>; for inexact inputs, it is the same as the input  dtype. out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>; if provided, it must have the same shape as the  expected output, but the type will be cast if necessary. See  <code>ufuncs-output-type</code> for more details. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
+<pre><code>If the value is anything but the default, then
+`keepdims` will be passed through to the `mean` or `sum` methods
+of sub-classes of `ndarray`.  If the sub-classes methods
+does not implement `keepdims` any exceptions will be raised.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>m : ndarray, see dtype parameter above  If <code>out=None</code>, returns a new array containing the mean values,  otherwise a reference to the output array is returned. Nan is  returned for slices that contain only NaNs.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>average : Weighted average mean : Arithmetic mean taken while not ignoring NaNs var, nanvar</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The arithmetic mean is the sum of the non-NaN elements along the axis divided by the number of non-NaN elements.</p>
+<p>Note that for floating-point input, the mean is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for <code>float32</code>. Specifying a higher-precision accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, np.nan], [3, 4</a>) np.nanmean(a) 2.6666666666666665 np.nanmean(a, axis=0) array([2., 4.]) np.nanmean(a, axis=1) array([1., 3.5]) # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25342">view source</a></div></div><div class="public anchor" id="var-nanmedian"><h3>nanmedian</h3><div class="usage"><code>(nanmedian &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the median along the specified axis, while ignoring NaNs.</p>
+<p>Returns the median of the array elements.</p>
+<p>.. versionadded:: 1.9.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array or object that can be converted to an array. axis : {int, sequence of int, None}, optional  Axis or axes along which the medians are computed. The default  is to compute the median along a flattened version of the array.  A sequence of axes is supported since version 1.9.0. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow use of memory of input array <code>a</code> for  calculations. The input array will be modified by the call to  <code>median</code>. This will save memory when you do not need to preserve  the contents of the input array. Treat the input as undefined,  but it will probably be fully or partially sorted. Default is  False. If <code>overwrite_input</code> is <code>True</code> and <code>a</code> is not already an  <code>ndarray</code>, an error will be raised. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
+<pre><code>If this is anything but the default value it will be passed
+through (in the special case of an empty array) to the
+`mean` function of the underlying array.  If the array is
+a sub-class and `mean` does not have the kwarg `keepdims` this
+will raise a RuntimeError.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>median : ndarray  A new array holding the result. If the input contains integers  or floats smaller than <code>float64</code>, then the output data-type is  <code>np.float64</code>. Otherwise, the data-type of the output is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>mean, median, percentile</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Given a vector <code>V</code> of length <code>N</code>, the median of <code>V</code> is the middle value of a sorted copy of <code>V</code>, <code>V_sorted</code> - i.e., <code>V_sorted[(N-1)/2]</code>, when <code>N</code> is odd and the average of the two middle values of <code>V_sorted</code> when <code>N</code> is even.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">10.0, 7, 4], [3, 2, 1</a>) a[0, 1] = np.nan a array(<a href="null">10., nan,  4.],
+       [ 3.,  2.,  1.</a>) np.median(a) nan np.nanmedian(a) 3.0 np.nanmedian(a, axis=0) array([6.5, 2. , 2.5]) np.median(a, axis=1) array([nan, 2.]) b = a.copy() np.nanmedian(b, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a==b) b = a.copy() np.nanmedian(b, axis=None, overwrite_input=True) 3.0 assert not np.all(a==b)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25832">view source</a></div></div><div class="public anchor" id="var-nanmin"><h3>nanmin</h3><div class="usage"><code>(nanmin &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return minimum of an array or minimum along an axis, ignoring any NaNs. When all-NaN slices are encountered a <code>RuntimeWarning</code> is raised and Nan is returned for that slice.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array containing numbers whose minimum is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the minimum is computed. The default is to compute  the minimum of the flattened array. out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>; if provided, it must have the same shape as the  expected output, but the type will be cast if necessary. See  <code>ufuncs-output-type</code> for more details.</p>
+<pre><code>.. versionadded:: 1.8.0
+</code></pre>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
+<pre><code>If the value is anything but the default, then
+`keepdims` will be passed through to the `min` method
+of sub-classes of `ndarray`.  If the sub-classes methods
+does not implement `keepdims` any exceptions will be raised.
+
+.. versionadded:: 1.8.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>nanmin : ndarray  An array with the same shape as <code>a</code>, with the specified axis  removed. If <code>a</code> is a 0-d array, or if axis is None, an ndarray  scalar is returned. The same dtype as <code>a</code> is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>nanmax :  The maximum value of an array along a given axis, ignoring any NaNs. amin :  The minimum value of an array along a given axis, propagating any NaNs. fmin :  Element-wise minimum of two arrays, ignoring any NaNs. minimum :  Element-wise minimum of two arrays, propagating any NaNs. isnan :  Shows which elements are Not a Number (NaN). isfinite:  Shows which elements are neither NaN nor infinity.</p>
+<p>amax, fmax, maximum</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity. Positive infinity is treated as a very large number and negative infinity is treated as a very small (i.e. negative) number.</p>
+<p>If the input has a integer type the function is equivalent to np.min.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 2], [3, np.nan</a>) np.nanmin(a) 1.0 np.nanmin(a, axis=0) array([1., 2.]) np.nanmin(a, axis=1) array([1., 3.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>When positive infinity and negative infinity are present:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.nanmin([1, 2, np.nan, np.inf]) 1.0 np.nanmin([1, 2, np.nan, np.NINF]) -inf</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17870">view source</a></div></div><div class="public anchor" id="var-nanpercentile"><h3>nanpercentile</h3><div class="usage"><code>(nanpercentile &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the qth percentile of the data along the specified axis, while ignoring nan values.</p>
+<p>Returns the qth percentile(s) of the array elements.</p>
+<p>.. versionadded:: 1.9.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array or object that can be converted to an array, containing  nan values to be ignored. q : array_like of float  Percentile or sequence of percentiles to compute, which must be between  0 and 100 inclusive. axis : {int, tuple of int, None}, optional  Axis or axes along which the percentiles are computed. The  default is to compute the percentile(s) along a flattened  version of the array. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow the input array <code>a</code> to be modified by intermediate  calculations, to save memory. In this case, the contents of the input  <code>a</code> after this function completes is undefined. interpolation : {‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}  This optional parameter specifies the interpolation method to  use when the desired percentile lies between two data points  <code>i &lt; j</code>:</p>
+<pre><code>* 'linear': ``i + (j - i) * fraction``, where ``fraction``
+  is the fractional part of the index surrounded by ``i``
+  and ``j``.
+* 'lower': ``i``.
+* 'higher': ``j``.
+* 'nearest': ``i`` or ``j``, whichever is nearest.
+* 'midpoint': ``(i + j) / 2``.
+</code></pre>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left in  the result as dimensions with size one. With this option, the  result will broadcast correctly against the original array <code>a</code>.</p>
+<pre><code>If this is anything but the default value it will be passed
+through (in the special case of an empty array) to the
+`mean` function of the underlying array.  If the array is
+a sub-class and `mean` does not have the kwarg `keepdims` this
+will raise a RuntimeError.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>percentile : scalar or ndarray  If <code>q</code> is a single percentile and <code>axis=None</code>, then the result  is a scalar. If multiple percentiles are given, first axis of  the result corresponds to the percentiles. The other axes are  the axes that remain after the reduction of <code>a</code>. If the input  contains integers or floats smaller than <code>float64</code>, the output  data-type is <code>float64</code>. Otherwise, the output data-type is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>nanmean nanmedian : equivalent to <code>nanpercentile(..., 50)</code> percentile, median, mean nanquantile : equivalent to nanpercentile, but with q in the range [0, 1].</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Given a vector <code>V</code> of length <code>N</code>, the <code>q</code>-th percentile of <code>V</code> is the value <code>q/100</code> of the way from the minimum to the maximum in a sorted copy of <code>V</code>. The values and distances of the two nearest neighbors as well as the <code>interpolation</code> parameter will determine the percentile if the normalized ranking does not match the location of <code>q</code> exactly. This function is the same as the median if <code>q=50</code>, the same as the minimum if <code>q=0</code> and the same as the maximum if <code>q=100</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">10., 7., 4.], [3., 2., 1.</a>) a[0][1] = np.nan a array(<a href="null">10.,  nan,   4.],
+      [ 3.,   2.,   1.</a>) np.percentile(a, 50) nan np.nanpercentile(a, 50) 3.0 np.nanpercentile(a, 50, axis=0) array([6.5, 2. , 2.5]) np.nanpercentile(a, 50, axis=1, keepdims=True) array(<a href="null">7.],
+       [2.</a>) m = np.nanpercentile(a, 50, axis=0) out = np.zeros_like(m) np.nanpercentile(a, 50, axis=0, out=out) array([6.5, 2. , 2.5]) m array([6.5, 2. , 2.5])</p>
+      <p>b = a.copy() np.nanpercentile(b, 50, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a==b)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5418">view source</a></div></div><div class="public anchor" id="var-nanprod"><h3>nanprod</h3><div class="usage"><code>(nanprod &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.</p>
+<p>One is returned for slices that are all-NaN or empty.</p>
+<p>.. versionadded:: 1.10.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array containing numbers whose product is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the product is computed. The default is to compute  the product of the flattened array. dtype : data-type, optional  The type of the returned array and of the accumulator in which the  elements are summed. By default, the dtype of <code>a</code> is used. An  exception is when <code>a</code> has an integer type with less precision than  the platform (u)intp. In that case, the default will be either  (u)int32 or (u)int64 depending on whether the platform is 32 or 64  bits. For inexact inputs, dtype must be inexact. out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>. If provided, it must have the same shape as the  expected output, but the type will be cast if necessary. See  <code>ufuncs-output-type</code> for more details. The casting of NaN to integer  can yield unexpected results. keepdims : bool, optional  If True, the axes which are reduced are left in the result as  dimensions with size one. With this option, the result will  broadcast correctly against the original <code>arr</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>nanprod : ndarray  A new array holding the result is returned unless <code>out</code> is  specified, in which case it is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.prod : Product across array propagating NaNs. isnan : Show which elements are NaN.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.nanprod(1) 1 np.nanprod([1]) 1 np.nanprod([1, np.nan]) 1.0 a = np.array(<a href="null">1, 2], [3, np.nan</a>) np.nanprod(a) 6.0 np.nanprod(a, axis=0) array([3., 2.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4761">view source</a></div></div><div class="public anchor" id="var-nanquantile"><h3>nanquantile</h3><div class="usage"><code>(nanquantile &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the qth quantile of the data along the specified axis, while ignoring nan values. Returns the qth quantile(s) of the array elements.</p>
+<p>.. versionadded:: 1.15.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array or object that can be converted to an array, containing  nan values to be ignored q : array_like of float  Quantile or sequence of quantiles to compute, which must be between  0 and 1 inclusive. axis : {int, tuple of int, None}, optional  Axis or axes along which the quantiles are computed. The  default is to compute the quantile(s) along a flattened  version of the array. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow the input array <code>a</code> to be modified by intermediate  calculations, to save memory. In this case, the contents of the input  <code>a</code> after this function completes is undefined. interpolation : {‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}  This optional parameter specifies the interpolation method to  use when the desired quantile lies between two data points  <code>i &lt; j</code>:</p>
+<pre><code>* linear: ``i + (j - i) * fraction``, where ``fraction``
+  is the fractional part of the index surrounded by ``i``
+  and ``j``.
+* lower: ``i``.
+* higher: ``j``.
+* nearest: ``i`` or ``j``, whichever is nearest.
+* midpoint: ``(i + j) / 2``.
+</code></pre>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left in  the result as dimensions with size one. With this option, the  result will broadcast correctly against the original array <code>a</code>.</p>
+<pre><code>If this is anything but the default value it will be passed
+through (in the special case of an empty array) to the
+`mean` function of the underlying array.  If the array is
+a sub-class and `mean` does not have the kwarg `keepdims` this
+will raise a RuntimeError.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>quantile : scalar or ndarray  If <code>q</code> is a single percentile and <code>axis=None</code>, then the result  is a scalar. If multiple quantiles are given, first axis of  the result corresponds to the quantiles. The other axes are  the axes that remain after the reduction of <code>a</code>. If the input  contains integers or floats smaller than <code>float64</code>, the output  data-type is <code>float64</code>. Otherwise, the output data-type is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>quantile nanmean, nanmedian nanmedian : equivalent to <code>nanquantile(..., 0.5)</code> nanpercentile : same as nanquantile, but with q in the range [0, 100].</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">10., 7., 4.], [3., 2., 1.</a>) a[0][1] = np.nan a array(<a href="null">10.,  nan,   4.],
+      [ 3.,   2.,   1.</a>) np.quantile(a, 0.5) nan np.nanquantile(a, 0.5) 3.0 np.nanquantile(a, 0.5, axis=0) array([6.5, 2. , 2.5]) np.nanquantile(a, 0.5, axis=1, keepdims=True) array(<a href="null">7.],
+       [2.</a>) m = np.nanquantile(a, 0.5, axis=0) out = np.zeros_like(m) np.nanquantile(a, 0.5, axis=0, out=out) array([6.5, 2. , 2.5]) m array([6.5, 2. , 2.5]) b = a.copy() np.nanquantile(b, 0.5, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a==b)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14507">view source</a></div></div><div class="public anchor" id="var-nanstd"><h3>nanstd</h3><div class="usage"><code>(nanstd &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the standard deviation along the specified axis, while ignoring NaNs.</p>
+<p>Returns the standard deviation, a measure of the spread of a distribution, of the non-NaN array elements. The standard deviation is computed for the flattened array by default, otherwise over the specified axis.</p>
+<p>For all-NaN slices or slices with zero degrees of freedom, NaN is returned and a <code>RuntimeWarning</code> is raised.</p>
+<p>.. versionadded:: 1.8.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Calculate the standard deviation of the non-NaN values. axis : {int, tuple of int, None}, optional  Axis or axes along which the standard deviation is computed. The default is  to compute the standard deviation of the flattened array. dtype : dtype, optional  Type to use in computing the standard deviation. For arrays of  integer type the default is float64, for arrays of float types it  is the same as the array type. out : ndarray, optional  Alternative output array in which to place the result. It must have  the same shape as the expected output but the type (of the  calculated values) will be cast if necessary. ddof : int, optional  Means Delta Degrees of Freedom. The divisor used in calculations  is <code>N - ddof</code>, where <code>N</code> represents the number of non-NaN  elements. By default <code>ddof</code> is zero.</p>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
+<pre><code>If this value is anything but the default it is passed through
+as-is to the relevant functions of the sub-classes.  If these
+functions do not have a `keepdims` kwarg, a RuntimeError will
+be raised.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>standard_deviation : ndarray, see dtype parameter above.  If <code>out</code> is None, return a new array containing the standard  deviation, otherwise return a reference to the output array. If  ddof is &gt;= the number of non-NaN elements in a slice or the slice  contains only NaNs, then the result for that slice is NaN.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>var, mean, std nanvar, nanmean ufuncs-output-type</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The standard deviation is the square root of the average of the squared deviations from the mean: <code>std = sqrt(mean(abs(x - x.mean())**2))</code>.</p>
+<p>The average squared deviation is normally calculated as <code>x.sum() / N</code>, where <code>N = len(x)</code>. If, however, <code>ddof</code> is specified, the divisor <code>N - ddof</code> is used instead. In standard statistical practice, <code>ddof=1</code> provides an unbiased estimator of the variance of the infinite population. <code>ddof=0</code> provides a maximum likelihood estimate of the variance for normally distributed variables. The standard deviation computed in this function is the square root of the estimated variance, so even with <code>ddof=1</code>, it will not be an unbiased estimate of the standard deviation per se.</p>
+<p>Note that, for complex numbers, <code>std</code> takes the absolute value before squaring, so that the result is always real and nonnegative.</p>
+<p>For floating-point input, the <em>std</em> is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for float32 (see example below). Specifying a higher-accuracy accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, np.nan], [3, 4</a>) np.nanstd(a) 1.247219128924647 np.nanstd(a, axis=0) array([1., 0.]) np.nanstd(a, axis=1) array([0., 0.5]) # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22889">view source</a></div></div><div class="public anchor" id="var-nansum"><h3>nansum</h3><div class="usage"><code>(nansum &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.</p>
+<p>In NumPy versions &lt;= 1.9.0 Nan is returned for slices that are all-NaN or empty. In later versions zero is returned.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array containing numbers whose sum is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the sum is computed. The default is to compute the  sum of the flattened array. dtype : data-type, optional  The type of the returned array and of the accumulator in which the  elements are summed. By default, the dtype of <code>a</code> is used. An  exception is when <code>a</code> has an integer type with less precision than  the platform (u)intp. In that case, the default will be either  (u)int32 or (u)int64 depending on whether the platform is 32 or 64  bits. For inexact inputs, dtype must be inexact.</p>
+<pre><code>.. versionadded:: 1.8.0
+</code></pre>
+<p>out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>. If provided, it must have the same shape as the  expected output, but the type will be cast if necessary. See  <code>ufuncs-output-type</code> for more details. The casting of NaN to integer  can yield unexpected results.</p>
+<pre><code>.. versionadded:: 1.8.0
+</code></pre>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
+<pre><code>If the value is anything but the default, then
+`keepdims` will be passed through to the `mean` or `sum` methods
+of sub-classes of `ndarray`.  If the sub-classes methods
+does not implement `keepdims` any exceptions will be raised.
+
+.. versionadded:: 1.8.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>nansum : ndarray.  A new array holding the result is returned unless <code>out</code> is  specified, in which it is returned. The result has the same  size as <code>a</code>, and the same shape as <code>a</code> if <code>axis</code> is not None  or <code>a</code> is a 1-d array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.sum : Sum across array propagating NaNs. isnan : Show which elements are NaN. isfinite: Show which elements are not NaN or +/-inf.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If both positive and negative infinity are present, the sum will be Not A Number (NaN).</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.nansum(1) 1 np.nansum([1]) 1 np.nansum([1, np.nan]) 1.0 a = np.array(<a href="null">1, 1], [1, np.nan</a>) np.nansum(a) 3.0 np.nansum(a, axis=0) array([2., 1.]) np.nansum([1, np.nan, np.inf]) inf np.nansum([1, np.nan, np.NINF]) -inf from numpy.testing import suppress_warnings with suppress_warnings() as sup: … sup.filter(RuntimeWarning) … np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present nan</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4671">view source</a></div></div><div class="public anchor" id="var-nanvar"><h3>nanvar</h3><div class="usage"><code>(nanvar &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the variance along the specified axis, while ignoring NaNs.</p>
+<p>Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis.</p>
+<p>For all-NaN slices or slices with zero degrees of freedom, NaN is returned and a <code>RuntimeWarning</code> is raised.</p>
+<p>.. versionadded:: 1.8.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array containing numbers whose variance is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the variance is computed. The default is to compute  the variance of the flattened array. dtype : data-type, optional  Type to use in computing the variance. For arrays of integer type  the default is <code>float64</code>; for arrays of float types it is the same as  the array type. out : ndarray, optional  Alternate output array in which to place the result. It must have  the same shape as the expected output, but the type is cast if  necessary. ddof : int, optional  “Delta Degrees of Freedom”: the divisor used in the calculation is  <code>N - ddof</code>, where <code>N</code> represents the number of non-NaN  elements. By default <code>ddof</code> is zero. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>variance : ndarray, see dtype parameter above  If <code>out</code> is None, return a new array containing the variance,  otherwise return a reference to the output array. If ddof is &gt;= the  number of non-NaN elements in a slice or the slice contains only  NaNs, then the result for that slice is NaN.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>std : Standard deviation mean : Average var : Variance while not ignoring NaNs nanstd, nanmean ufuncs-output-type</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The variance is the average of the squared deviations from the mean, i.e., <code>var = mean(abs(x - x.mean())**2)</code>.</p>
+<p>The mean is normally calculated as <code>x.sum() / N</code>, where <code>N = len(x)</code>. If, however, <code>ddof</code> is specified, the divisor <code>N - ddof</code> is used instead. In standard statistical practice, <code>ddof=1</code> provides an unbiased estimator of the variance of a hypothetical infinite population. <code>ddof=0</code> provides a maximum likelihood estimate of the variance for normally distributed variables.</p>
+<p>Note that for complex numbers, the absolute value is taken before squaring, so that the result is always real and nonnegative.</p>
+<p>For floating-point input, the variance is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for <code>float32</code> (see example below). Specifying a higher-accuracy accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
+<p>For this function to work on sub-classes of ndarray, they must define <code>sum</code> with the kwarg <code>keepdims</code></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, np.nan], [3, 4</a>) np.nanvar(a) 1.5555555555555554 np.nanvar(a, axis=0) array([1., 0.]) np.nanvar(a, axis=1) array([0., 0.25]) # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28033">view source</a></div></div><div class="public anchor" id="var-nbytes"><h3>nbytes</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Base object for a dictionary for look-up with any alias for an array dtype.</p>
+<p>Instances of <code>_typedict</code> can not be used as dictionaries directly, first they have to be populated.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25824">view source</a></div></div><div class="public anchor" id="var-ndarray"><h3>ndarray</h3><div class="usage"><code>(ndarray self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>ndarray(shape, dtype=float, buffer=None, offset=0,  strides=None, order=None)</p>
+<p>An array object represents a multidimensional, homogeneous array of fixed-size items. An associated data-type object describes the format of each element in the array (its byte-order, how many bytes it occupies in memory, whether it is an integer, a floating point number, or something else, etc.)</p>
+<p>Arrays should be constructed using <code>array</code>, <code>zeros</code> or <code>empty</code> (refer to the See Also section below). The parameters given here refer to a low-level method (<code>ndarray(...)</code>) for instantiating an array.</p>
+<p>For more information, refer to the <code>numpy</code> module and examine the methods and attributes of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>(for the <strong>new</strong> method; see Notes below)</p>
+<p>shape : tuple of ints  Shape of created array. dtype : data-type, optional  Any object that can be interpreted as a numpy data type. buffer : object exposing buffer interface, optional  Used to fill the array with data. offset : int, optional  Offset of array data in buffer. strides : tuple of ints, optional  Strides of data in memory. order : {‘C’, ‘F’}, optional  Row-major (C-style) or column-major (Fortran-style) order.</p>
+<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
+<p>T : ndarray  Transpose of the array. data : buffer  The array’s elements, in memory. dtype : dtype object  Describes the format of the elements in the array. flags : dict  Dictionary containing information related to memory use, e.g.,  ‘C_CONTIGUOUS’, ‘OWNDATA’, ‘WRITEABLE’, etc. flat : numpy.flatiter object  Flattened version of the array as an iterator. The iterator  allows assignments, e.g., <code>x.flat = 3</code> (See <code>ndarray.flat</code> for  assignment examples; TODO). imag : ndarray  Imaginary part of the array. real : ndarray  Real part of the array. size : int  Number of elements in the array. itemsize : int  The memory use of each array element in bytes. nbytes : int  The total number of bytes required to store the array data,  i.e., <code>itemsize * size</code>. ndim : int  The array’s number of dimensions. shape : tuple of ints  Shape of the array. strides : tuple of ints  The step-size required to move from one element to the next in  memory. For example, a contiguous <code>(3, 4)</code> array of type  <code>int16</code> in C-order has strides <code>(8, 2)</code>. This implies that  to move from element to element in memory requires jumps of 2 bytes.  To move from row-to-row, one needs to jump 8 bytes at a time  (<code>2 * 4</code>). ctypes : ctypes object  Class containing properties of the array needed for interaction  with ctypes. base : ndarray  If the array is a view into another array, that array is its <code>base</code>  (unless that array is also a view). The <code>base</code> array is where the  array data is actually stored.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>array : Construct an array. zeros : Create an array, each element of which is zero. empty : Create an array, but leave its allocated memory unchanged (i.e.,  it contains “garbage”). dtype : Create a data-type.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>There are two modes of creating an array using <code>__new__</code>:</p>
+<ol>
+  <li>If <code>buffer</code> is None, then only <code>shape</code>, <code>dtype</code>, and <code>order</code>  are used.</li>
+  <li>If <code>buffer</code> is an object exposing the buffer interface, then  all keywords are interpreted.</li>
+</ol>
+<p>No <code>__init__</code> method is needed because the array is fully initialized after the <code>__new__</code> method.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>These examples illustrate the low-level <code>ndarray</code> constructor. Refer to the <code>See Also</code> section above for easier ways of constructing an ndarray.</p>
+<p>First mode, <code>buffer</code> is None:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.ndarray(shape=(2,2), dtype=float, order=‘F’) array(<a href="null">0.0e+000, 0.0e+000], # random
+       [     nan, 2.5e-323</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Second mode:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.ndarray((2,), buffer=np.array([1,2,3]), … offset=np.int_().itemsize, … dtype=int) # offset = 1*itemsize, i.e. skip first element array([2, 3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13399">view source</a></div></div><div class="public anchor" id="var-ndenumerate"><h3>ndenumerate</h3><div class="usage"><code>(ndenumerate self arr)</code></div><div class="doc"><div class="markdown"><p>Multidimensional index iterator.</p>
+<p>Return an iterator yielding pairs of array coordinates and values.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr : ndarray  Input array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndindex, flatiter</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 2], [3, 4</a>) for index, x in np.ndenumerate(a): … print(index, x) (0, 0) 1 (0, 1) 2 (1, 0) 3 (1, 1) 4</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14008">view source</a></div></div><div class="public anchor" id="var-ndfromtxt"><h3>ndfromtxt</h3><div class="usage"><code>(ndfromtxt fname &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Load ASCII data stored in a file and return it as a single array.</p>
+<p>.. deprecated:: 1.17  ndfromtxt<code>is a deprecated alias of</code>genfromtxt<code>which
+    overwrites the ``usemask`` argument with</code>False<code>even when
+    explicitly called as ``ndfromtxt(..., usemask=True)``.
+    Use</code>genfromtxt` instead.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>fname, kwargs : For a description of input parameters, see <code>genfromtxt</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.genfromtxt : generic function.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15151">view source</a></div></div><div class="public anchor" id="var-ndim"><h3>ndim</h3><div class="usage"><code>(ndim &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the number of dimensions of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. If it is not already an ndarray, a conversion is  attempted.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>number_of_dimensions : int  The number of dimensions in <code>a</code>. Scalars are zero-dimensional.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.ndim : equivalent method shape : dimensions of array ndarray.shape : dimensions of array</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.ndim(<a href="null">1,2,3],[4,5,6</a>) 2 np.ndim(np.array(<a href="null">1,2,3],[4,5,6</a>)) 2 np.ndim(1) 0</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18344">view source</a></div></div><div class="public anchor" id="var-ndindex"><h3>ndindex</h3><div class="usage"><code>(ndindex self &amp; [shape])</code></div><div class="doc"><div class="markdown"><p>An N-dimensional iterator object to index arrays.</p>
+<p>Given the shape of an array, an <code>ndindex</code> instance iterates over the N-dimensional index of the array. At each iteration a tuple of indices is returned, the last dimension is iterated over first.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p><code>*args</code> : ints  The size of each dimension of the array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndenumerate, flatiter</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>for index in np.ndindex(3, 2, 1): … print(index) (0, 0, 0) (0, 1, 0) (1, 0, 0) (1, 1, 0) (2, 0, 0) (2, 1, 0)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2709">view source</a></div></div><div class="public anchor" id="var-nditer"><h3>nditer</h3><div class="usage"><code>(nditer self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Efficient multi-dimensional iterator object to iterate over arrays. To get started using this object, see the :ref:<code>introductory guide to array iteration &lt;arrays.nditer&gt;</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>op : ndarray or sequence of array_like  The array(s) to iterate over.</p>
+<p>flags : sequence of str, optional  Flags to control the behavior of the iterator.</p>
+<pre><code>  * ``buffered`` enables buffering when required.
+  * ``c_index`` causes a C-order index to be tracked.
+  * ``f_index`` causes a Fortran-order index to be tracked.
+  * ``multi_index`` causes a multi-index, or a tuple of indices
+    with one per iteration dimension, to be tracked.
+  * ``common_dtype`` causes all the operands to be converted to
+    a common data type, with copying or buffering as necessary.
+  * ``copy_if_overlap`` causes the iterator to determine if read
+    operands have overlap with write operands, and make temporary
+    copies as necessary to avoid overlap. False positives (needless
+    copying) are possible in some cases.
+  * ``delay_bufalloc`` delays allocation of the buffers until
+    a reset() call is made. Allows ``allocate`` operands to
+    be initialized before their values are copied into the buffers.
+  * ``external_loop`` causes the ``values`` given to be
+    one-dimensional arrays with multiple values instead of
+    zero-dimensional arrays.
+  * ``grow_inner`` allows the ``value`` array sizes to be made
+    larger than the buffer size when both ``buffered`` and
+    ``external_loop`` is used.
+  * ``ranged`` allows the iterator to be restricted to a sub-range
+    of the iterindex values.
+  * ``refs_ok`` enables iteration of reference types, such as
+    object arrays.
+  * ``reduce_ok`` enables iteration of ``readwrite`` operands
+    which are broadcasted, also known as reduction operands.
+  * ``zerosize_ok`` allows `itersize` to be zero.
+</code></pre>
+<p>op_flags : list of list of str, optional  This is a list of flags for each operand. At minimum, one of  <code>readonly</code>, <code>readwrite</code>, or <code>writeonly</code> must be specified.</p>
+<pre><code>  * ``readonly`` indicates the operand will only be read from.
+  * ``readwrite`` indicates the operand will be read from and written to.
+  * ``writeonly`` indicates the operand will only be written to.
+  * ``no_broadcast`` prevents the operand from being broadcasted.
+  * ``contig`` forces the operand data to be contiguous.
+  * ``aligned`` forces the operand data to be aligned.
+  * ``nbo`` forces the operand data to be in native byte order.
+  * ``copy`` allows a temporary read-only copy if required.
+  * ``updateifcopy`` allows a temporary read-write copy if required.
+  * ``allocate`` causes the array to be allocated if it is None
+    in the ``op`` parameter.
+  * ``no_subtype`` prevents an ``allocate`` operand from using a subtype.
+  * ``arraymask`` indicates that this operand is the mask to use
+    for selecting elements when writing to operands with the
+    'writemasked' flag set. The iterator does not enforce this,
+    but when writing from a buffer back to the array, it only
+    copies those elements indicated by this mask.
+  * ``writemasked`` indicates that only elements where the chosen
+    ``arraymask`` operand is True will be written to.
+  * ``overlap_assume_elementwise`` can be used to mark operands that are
+    accessed only in the iterator order, to allow less conservative
+    copying when ``copy_if_overlap`` is present.
+</code></pre>
+<p>op_dtypes : dtype or tuple of dtype(s), optional  The required data type(s) of the operands. If copying or buffering  is enabled, the data will be converted to/from their original types. order : {‘C’, ‘F’, ‘A’, ‘K’}, optional  Controls the iteration order. ‘C’ means C order, ‘F’ means  Fortran order, ‘A’ means ‘F’ order if all the arrays are Fortran  contiguous, ‘C’ order otherwise, and ‘K’ means as close to the  order the array elements appear in memory as possible. This also  affects the element memory order of <code>allocate</code> operands, as they  are allocated to be compatible with iteration order.  Default is ‘K’. casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional  Controls what kind of data casting may occur when making a copy  or buffering. Setting this to ‘unsafe’ is not recommended,  as it can adversely affect accumulations.</p>
+<pre><code>* 'no' means the data types should not be cast at all.
+* 'equiv' means only byte-order changes are allowed.
+* 'safe' means only casts which can preserve values are allowed.
+* 'same_kind' means only safe casts or casts within a kind,
+  like float64 to float32, are allowed.
+* 'unsafe' means any data conversions may be done.
+</code></pre>
+<p>op_axes : list of list of ints, optional  If provided, is a list of ints or None for each operands.  The list of axes for an operand is a mapping from the dimensions  of the iterator to the dimensions of the operand. A value of  -1 can be placed for entries, causing that dimension to be  treated as <code>newaxis</code>. itershape : tuple of ints, optional  The desired shape of the iterator. This allows <code>allocate</code> operands  with a dimension mapped by op_axes not corresponding to a dimension  of a different operand to get a value not equal to 1 for that  dimension. buffersize : int, optional  When buffering is enabled, controls the size of the temporary  buffers. Set to 0 for the default value.</p>
+<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
+<p>dtypes : tuple of dtype(s)  The data types of the values provided in <code>value</code>. This may be  different from the operand data types if buffering is enabled.  Valid only before the iterator is closed. finished : bool  Whether the iteration over the operands is finished or not. has_delayed_bufalloc : bool  If True, the iterator was created with the <code>delay_bufalloc</code> flag,  and no reset() function was called on it yet. has_index : bool  If True, the iterator was created with either the <code>c_index</code> or  the <code>f_index</code> flag, and the property <code>index</code> can be used to  retrieve it. has_multi_index : bool  If True, the iterator was created with the <code>multi_index</code> flag,  and the property <code>multi_index</code> can be used to retrieve it. index  When the <code>c_index</code> or <code>f_index</code> flag was used, this property  provides access to the index. Raises a ValueError if accessed  and <code>has_index</code> is False. iterationneedsapi : bool  Whether iteration requires access to the Python API, for example  if one of the operands is an object array. iterindex : int  An index which matches the order of iteration. itersize : int  Size of the iterator. itviews  Structured view(s) of <code>operands</code> in memory, matching the reordered  and optimized iterator access pattern. Valid only before the iterator  is closed. multi_index  When the <code>multi_index</code> flag was used, this property  provides access to the index. Raises a ValueError if accessed  accessed and <code>has_multi_index</code> is False. ndim : int  The dimensions of the iterator. nop : int  The number of iterator operands. operands : tuple of operand(s)  The array(s) to be iterated over. Valid only before the iterator is  closed. shape : tuple of ints  Shape tuple, the shape of the iterator. value  Value of <code>operands</code> at current iteration. Normally, this is a  tuple of array scalars, but if the flag <code>external_loop</code> is used,  it is a tuple of one dimensional arrays.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>nditer</code> supersedes <code>flatiter</code>. The iterator implementation behind <code>nditer</code> is also exposed by the NumPy C API.</p>
+<p>The Python exposure supplies two iteration interfaces, one which follows the Python iterator protocol, and another which mirrors the C-style do-while pattern. The native Python approach is better in most cases, but if you need the coordinates or index of an iterator, use the C-style pattern.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Here is how we might write an <code>iter_add</code> function, using the Python iterator protocol:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>def iter_add_py(x, y, out=None): … addop = np.add … it = np.nditer([x, y, out], [], … <a href="null">'readonly'], ['readonly'], ['writeonly','allocate'</a>) … with it: … for (a, b, c) in it: … addop(a, b, out=c) … return it.operands[2]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Here is the same function, but following the C-style pattern:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>def iter_add(x, y, out=None): … addop = np.add … it = np.nditer([x, y, out], [], … <a href="null">'readonly'], ['readonly'], ['writeonly','allocate'</a>) … with it: … while not it.finished: … addop(it[0], it[1], out=it[2]) … it.iternext() … return it.operands[2]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Here is an example outer product function:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>def outer_it(x, y, out=None): … mulop = np.multiply … it = np.nditer([x, y, out], [‘external_loop’], … <a href="null">'readonly'], ['readonly'], ['writeonly', 'allocate'</a>, … op_axes=[list(range(x.ndim)) + [-1] * y.ndim, … [-1] * x.ndim + list(range(y.ndim)), … None]) … with it: … for (a, b, c) in it: … mulop(a, b, out=c) … return it.operands[2]</p>
+      <p>a = np.arange(2)+1 b = np.arange(3)+1 outer_it(a,b) array(<a href="null">1, 2, 3],
+       [2, 4, 6</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Here is an example function which operates like a “lambda” ufunc:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>def luf(lamdaexpr, *args, **kwargs): … ’‘‘luf(lambdaexpr, op1, …, opn, out=None, order=‘K’, casting=‘safe’, buffersize=0)’’’ … nargs = len(args) … op = (kwargs.get(‘out’,None),) + args … it = np.nditer(op, [‘buffered’,‘external_loop’], … <a href="null">'writeonly','allocate','no_broadcast'</a> + … <a href="null">'readonly','nbo','aligned'</a>*nargs, … order=kwargs.get(‘order’,‘K’), … casting=kwargs.get(‘casting’,‘safe’), … buffersize=kwargs.get(‘buffersize’,0)) … while not it.finished: … it[0] = lamdaexpr(*it[1:]) … it.iternext() … return it.operands[0]</p>
+      <p>a = np.arange(5) b = np.ones(5) luf(lambda i,j:i*i + j/2, a, b) array([ 0.5, 1.5, 4.5, 9.5, 16.5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>If operand flags <code>"writeonly"</code> or <code>"readwrite"</code> are used the operands may be views into the original data with the <code>WRITEBACKIFCOPY</code> flag. In this case <code>nditer</code> must be used as a context manager or the <code>nditer.close</code> method must be called before using the result. The temporary data will be written back to the original data when the <code>__exit__</code> function is called but not before:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(6, dtype=‘i4’)[::-2] with np.nditer(a, [], … <a href="null">'writeonly', 'updateifcopy'</a>, … casting=‘unsafe’, … op_dtypes=[np.dtype(‘f4’)]) as i: … x = i.operands[0] … x[:] = [-1, -2, -3] … # a still unchanged here a, x (array([-1, -2, -3], dtype=int32), array([-1., -2., -3.], dtype=float32))</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>It is important to note that once the iterator is exited, dangling references (like <code>x</code> in the example) may or may not share data with the original data <code>a</code>. If writeback semantics were active, i.e. if <code>x.base.flags.writebackifcopy</code> is <code>True</code>, then exiting the iterator will sever the connection between <code>x</code> and <code>a</code>, writing to <code>x</code> will no longer write to <code>a</code>. If writeback semantics are not active, then <code>x.data</code> will still point at some part of <code>a.data</code>, and writing to one will affect the other.</p>
+<p>Context management and the <code>close</code> method appeared in version 1.15.0.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4410">view source</a></div></div><div class="public anchor" id="var-negative"><h3>negative</h3><div class="usage"><code>(negative self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>negative(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Numerical negative, element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like or scalar  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  Returned array or scalar: <code>y = -x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.negative([1.,-1.]) array([-1., 1.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9754">view source</a></div></div><div class="public anchor" id="var-nested_iters"><h3>nested_iters</h3><div class="usage"><code>(nested_iters self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create nditers for use in nested loops</p>
+<p>Create a tuple of <code>nditer</code> objects which iterate in nested loops over different axes of the op argument. The first iterator is used in the outermost loop, the last in the innermost loop. Advancing one will change the subsequent iterators to point at its new element.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>op : ndarray or sequence of array_like  The array(s) to iterate over.</p>
+<p>axes : list of list of int  Each item is used as an “op_axes” argument to an nditer</p>
+<p>flags, op_flags, op_dtypes, order, casting, buffersize (optional)  See <code>nditer</code> parameters of the same name</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>iters : tuple of nditer  An nditer for each item in <code>axes</code>, outermost first</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>nditer</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Basic usage. Note how y is the “flattened” version of [a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified the first iter’s axes as [1]</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(12).reshape(2, 3, 2) i, j = np.nested_iters(a, <a href="null">1], [0, 2</a>, flags=[“multi_index”]) for x in i: … print(i.multi_index) … for y in j: … print(’’, j.multi_index, y) (0,)  (0, 0) 0  (0, 1) 1  (1, 0) 6  (1, 1) 7 (1,)  (0, 0) 2  (0, 1) 3  (1, 0) 8  (1, 1) 9 (2,)  (0, 0) 4  (0, 1) 5  (1, 0) 10  (1, 1) 11</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14996">view source</a></div></div><div class="public anchor" id="var-nextafter"><h3>nextafter</h3><div class="usage"><code>(nextafter self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>nextafter(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the next floating-point value after x1 towards x2, element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  Values to find the next representable value of. x2 : array_like  The direction where to look for the next representable value of <code>x1</code>.  If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  The next representable values of <code>x1</code> in the direction of <code>x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>eps = np.finfo(np.float64).eps np.nextafter(1, 2) == eps + 1 True np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] array([ True, True])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25129">view source</a></div></div><div class="public anchor" id="var-NINF"><h3>NINF</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1591">view source</a></div></div><div class="public anchor" id="var-nonzero"><h3>nonzero</h3><div class="usage"><code>(nonzero &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices of the elements that are non-zero.</p>
+<p>Returns a tuple of arrays, one for each dimension of <code>a</code>, containing the indices of the non-zero elements in that dimension. The values in <code>a</code> are always tested and returned in row-major, C-style order.</p>
+<p>To group the indices by element, rather than dimension, use <code>argwhere</code>, which returns a row for each non-zero element.</p>
+<p>.. note::</p>
+<p>When called on a zero-d array or scalar, <code>nonzero(a)</code> is treated  as <code>nonzero(atleast1d(a))</code>.</p>
+<p>.. deprecated:: 1.17.0</p>
+<pre><code>  Use `atleast1d` explicitly if this behavior is deliberate.
+</code></pre>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>tuple_of_arrays : tuple  Indices of elements that are non-zero.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>flatnonzero :  Return indices that are non-zero in the flattened version of the input  array. ndarray.nonzero :  Equivalent ndarray method. count_nonzero :  Counts the number of non-zero elements in the input array.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>While the nonzero values can be obtained with <code>a[nonzero(a)]</code>, it is recommended to use <code>x[x.astype(bool)]</code> or <code>x[x != 0]</code> instead, which will correctly handle 0-d arrays.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">3, 0, 0], [0, 4, 0], [5, 6, 0</a>) x array(<a href="null">3, 0, 0],
+       [0, 4, 0],
+       [5, 6, 0</a>) np.nonzero(x) (array([0, 1, 2, 2]), array([0, 1, 0, 1]))</p>
+      <p>x[np.nonzero(x)] array([3, 4, 5, 6]) np.transpose(np.nonzero(x)) array(<a href="null">0, 0],
+       [1, 1],
+       [2, 0],
+       [2, 1</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>A common use for <code>nonzero</code> is to find the indices of an array, where a condition is True. Given an array <code>a</code>, the condition <code>a</code> &gt; 3 is a boolean array and since False is interpreted as 0, np.nonzero(a &gt; 3) yields the indices of the <code>a</code> where the condition is true.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 2, 3], [4, 5, 6], [7, 8, 9</a>) a &gt; 3 array(<a href="null">False, False, False],
+       [ True,  True,  True],
+       [ True,  True,  True</a>) np.nonzero(a &gt; 3) (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using this result to index <code>a</code> is equivalent to using the mask directly:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a[np.nonzero(a &gt; 3)] array([4, 5, 6, 7, 8, 9]) a[a &gt; 3] # prefer this spelling array([4, 5, 6, 7, 8, 9])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p><code>nonzero</code> can also be called as a method of the array.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>(a &gt; 3).nonzero() (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8774">view source</a></div></div><div class="public anchor" id="var-not_equal"><h3>not_equal</h3><div class="usage"><code>(not_equal self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>not_equal(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return (x1 != x2) element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>equal, greater, greater_equal, less, less_equal</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.not_equal([1.,2.], [1., 3.]) array([False, True]) np.not_equal([1, 2], <a href="null">1, 3],[1, 4</a>) array(<a href="null">False,  True],
+       [False,  True</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6062">view source</a></div></div><div class="public anchor" id="var-nper"><h3>nper</h3><div class="usage"><code>(nper &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the number of periodic payments.</p>
+<p>.. deprecated:: 1.18</p>
+<p><code>nper</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
+<p>:class:<code>decimal.Decimal</code> type is not supported.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>rate : array_like  Rate of interest (per period) pmt : array_like  Payment pv : array_like  Present value fv : array_like, optional  Future value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}, optional  When payments are due (‘begin’ (1) or ‘end’ (0))</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The number of periods <code>nper</code> is computed by solving the equation::</p>
+<p>fv + pv*(1+rate)**nper + pmt*(1+rate*when)/rate*((1+rate)**nper-1) = 0</p>
+<p>but if <code>rate = 0</code> then::</p>
+<p>fv + pv + pmt*nper = 0</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>If you only had $150/month to pay towards the loan, how long would it take to pay-off a loan of $8,000 at 7% annual interest?</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>print(np.round(np.nper(0.07/12, -150, 8000), 5)) 64.07335</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>So, over 64 months would be required to pay off the loan.</p>
+<p>The same analysis could be done with several different interest rates and/or payments and/or total amounts to produce an entire table.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.nper(*(np.ogrid[0.07/12: 0.08/12: 0.01/12, … -150 : -99 : 50 , … 8000 : 9001 : 1000])) array(<a href="null">[ 64.07334877,  74.06368256],
+        [108.07548412, 127.99022654</a>,  <a href="null"> 66.12443902,  76.87897353],
+        [114.70165583, 137.90124779</a>])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7611">view source</a></div></div><div class="public anchor" id="var-npv"><h3>npv</h3><div class="usage"><code>(npv &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the NPV (Net Present Value) of a cash flow series.</p>
+<p>.. deprecated:: 1.18</p>
+<p><code>npv</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>rate : scalar  The discount rate. values : array_like, shape(M, )  The values of the time series of cash flows. The (fixed) time  interval between cash flow “events” must be the same as that for  which <code>rate</code> is given (i.e., if <code>rate</code> is per year, then precisely  a year is understood to elapse between each cash flow event). By  convention, investments or “deposits” are negative, income or  “withdrawals” are positive; <code>values</code> must begin with the initial  investment, thus <code>values[0]</code> will typically be negative.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : float  The NPV of the input cash flow series <code>values</code> at the discount  <code>rate</code>.</p>
+<h2><a href="#warnings" name="warnings"></a>Warnings</h2>
+<p><code>npv</code> considers a series of cashflows starting in the present (t = 0). NPV can also be defined with a series of future cashflows, paid at the end, rather than the start, of each period. If future cashflows are used, the first cashflow <code>values[0]</code> must be zeroed and added to the net present value of the future cashflows. This is demonstrated in the examples.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Returns the result of: [2]_</p>
+<p>.. math :: \sum_{t=0}^{M-1}{\frac{values_t}{(1+rate)^{t}}}</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] L. J. Gitman, “Principles of Managerial Finance, Brief,” 3rd ed.,  Addison-Wesley, 2003, pg. 346.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Consider a potential project with an initial investment of $40 000 and projected cashflows of $5 000, $8 000, $12 000 and $30 000 at the end of each period discounted at a rate of 8% per period. To find the project’s net present value:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>rate, cashflows = 0.08, [-40_000, 5_000, 8_000, 12_000, 30_000] np.npv(rate, cashflows).round(5) 3065.22267</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>It may be preferable to split the projected cashflow into an initial investment and expected future cashflows. In this case, the value of the initial cashflow is zero and the initial investment is later added to the future cashflows net present value:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>initial_cashflow = cashflows[0] cashflows[0] = 0 np.round(np.npv(rate, cashflows) + initial_cashflow, 5) 3065.22267</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16324">view source</a></div></div><div class="public anchor" id="var-numarray"><h3>numarray</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25019">view source</a></div></div><div class="public anchor" id="var-number"><h3>number</h3><div class="usage"><code>(number self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all numeric scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17525">view source</a></div></div><div class="public anchor" id="var-NZERO"><h3>NZERO</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23617">view source</a></div></div><div class="public anchor" id="var-obj2sctype"><h3>obj2sctype</h3><div class="usage"><code>(obj2sctype rep &amp; [{default :default}])</code><code>(obj2sctype rep)</code></div><div class="doc"><div class="markdown"><p>Return the scalar dtype or NumPy equivalent of Python type of an object.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>rep : any  The object of which the type is returned. default : any, optional  If given, this is returned for objects whose types can not be  determined. If not given, None is returned for those objects.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>dtype : dtype or Python type  The data type of <code>rep</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>sctype2char, issctype, issubsctype, issubdtype, maximum_sctype</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.obj2sctype(np.int32) &lt;class ‘numpy.int32’&gt; np.obj2sctype(np.array([1., 2.])) &lt;class ‘numpy.float64’&gt; np.obj2sctype(np.array([1.j])) &lt;class ‘numpy.complex128’&gt;</p>
+      <p>np.obj2sctype(dict) &lt;class ‘numpy.object_’&gt; np.obj2sctype(‘string’)</p>
+      <p>np.obj2sctype(1, default=list) &lt;class ‘list’&gt;</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3971">view source</a></div></div><div class="public anchor" id="var-object"><h3>object</h3><div class="usage"><code>(object self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>The base class of the class hierarchy.</p>
+<p>When called, it accepts no arguments and returns a new featureless instance that has no instance attributes and cannot be given any.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L812">view source</a></div></div><div class="public anchor" id="var-object0"><h3>object0</h3><div class="usage"><code>(object0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Any Python object. Character code: <code>'O'</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18340">view source</a></div></div><div class="public anchor" id="var-object_"><h3>object_</h3><div class="usage"><code>(object_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Any Python object. Character code: <code>'O'</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25690">view source</a></div></div><div class="public anchor" id="var-ogrid"><h3>ogrid</h3><div class="usage"></div><div class="doc"><div class="markdown"><p><code>nd_grid</code> instance which returns an open multi-dimensional “meshgrid”.</p>
+<p>An instance of <code>numpy.lib.index_tricks.nd_grid</code> which returns an open (i.e. not fleshed out) mesh-grid when indexed, so that only one dimension of each returned array is greater than 1. The dimension and number of the output arrays are equal to the number of indexing dimensions. If the step length is not a complex number, then the stop is not inclusive.</p>
+<p>However, if the step length is a <strong>complex number</strong> (e.g. 5j), then the integer part of its magnitude is interpreted as specifying the number of points to create between the start and stop values, where the stop value <strong>is inclusive</strong>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>mesh-grid  <code>ndarrays</code> with only one dimension not equal to 1</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>np.lib.index_tricks.nd_grid : class of <code>ogrid</code> and <code>mgrid</code> objects mgrid : like <code>ogrid</code> but returns dense (or fleshed out) mesh grids r_ : array concatenator</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from numpy import ogrid ogrid[-1:1:5j] array([-1. , -0.5, 0. , 0.5, 1. ]) ogrid[0:5,0:5]
+[array([[0],  [1],  [2],  [3],  [4]]), array([[0, 1, 2, 3, 4]])]</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22069">view source</a></div></div><div class="public anchor" id="var-oldnumeric"><h3>oldnumeric</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22357">view source</a></div></div><div class="public anchor" id="var-ones"><h3>ones</h3><div class="usage"><code>(ones shape &amp; [{dtype :dtype, order :order}])</code><code>(ones shape &amp; [{dtype :dtype}])</code><code>(ones shape)</code></div><div class="doc"><div class="markdown"><p>Return a new array of given shape and type, filled with ones.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>shape : int or sequence of ints  Shape of the new array, e.g., <code>(2, 3)</code> or <code>2</code>. dtype : data-type, optional  The desired data-type for the array, e.g., <code>numpy.int8</code>. Default is  <code>numpy.float64</code>. order : {‘C’, ‘F’}, optional, default: C  Whether to store multi-dimensional data in row-major  (C-style) or column-major (Fortran-style) order in  memory.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Array of ones with the given shape, dtype, and order.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ones_like : Return an array of ones with shape and type of input. empty : Return a new uninitialized array. zeros : Return a new array setting values to zero. full : Return a new array of given shape filled with value.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.ones(5) array([1., 1., 1., 1., 1.])</p>
+      <p>np.ones((5,), dtype=int) array([1, 1, 1, 1, 1])</p>
+      <p>np.ones((2, 1)) array(<a href="null">1.],
+       [1.</a>)</p>
+      <p>s = (2,2) np.ones(s) array(<a href="null">1.,  1.],
+       [1.,  1.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3580">view source</a></div></div><div class="public anchor" id="var-ones_like"><h3>ones_like</h3><div class="usage"><code>(ones_like &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an array of ones with the same shape and type as a given array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  The shape and data-type of <code>a</code> define these same attributes of  the returned array. dtype : data-type, optional  Overrides the data type of the result.</p>
+<pre><code>.. versionadded:: 1.6.0
+</code></pre>
+<p>order : {‘C’, ‘F’, ‘A’, or ‘K’}, optional  Overrides the memory layout of the result. ‘C’ means C-order,  ‘F’ means F-order, ‘A’ means ‘F’ if <code>a</code> is Fortran contiguous,  ‘C’ otherwise. ‘K’ means match the layout of <code>a</code> as closely  as possible.</p>
+<pre><code>.. versionadded:: 1.6.0
+</code></pre>
+<p>subok : bool, optional.  If True, then the newly created array will use the sub-class  type of ‘a’, otherwise it will be a base-class array. Defaults  to True. shape : int or sequence of ints, optional.  Overrides the shape of the result. If order=‘K’ and the number of  dimensions is unchanged, will try to keep order, otherwise,  order=‘C’ is implied.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Array of ones with the same shape and type as <code>a</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>empty_like : Return an empty array with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. full_like : Return a new array with shape of input filled with value. ones : Return a new array setting values to one.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(6) x = x.reshape((2, 3)) x array(<a href="null">0, 1, 2],
+       [3, 4, 5</a>) np.ones_like(x) array(<a href="null">1, 1, 1],
+       [1, 1, 1</a>)</p>
+      <p>y = np.arange(3, dtype=float) y array([0., 1., 2.]) np.ones_like(y) array([1., 1., 1.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21454">view source</a></div></div><div class="public anchor" id="var-outer"><h3>outer</h3><div class="usage"><code>(outer &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the outer product of two vectors.</p>
+<p>Given two vectors, <code>a = [a0, a1, ..., aM]</code> and <code>b = [b0, b1, ..., bN]</code>, the outer product [1]_ is::</p>
+<p><a href="null">a0*b0  a0*b1 ... a0*bN ]
+   [a1*b0    .
+   [ ...          .
+   [aM*b0            aM*bN </a></p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : (M,) array_like  First input vector. Input is flattened if  not already 1-dimensional. b : (N,) array_like  Second input vector. Input is flattened if  not already 1-dimensional. out : (M, N) ndarray, optional  A location where the result is stored</p>
+<pre><code>.. versionadded:: 1.9.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : (M, N) ndarray  <code>out[i, j] = a[i] * b[j]</code></p>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>inner einsum : <code>einsum('i,j-&gt;ij', a.ravel(), b.ravel())</code> is the equivalent. ufunc.outer : A generalization to N dimensions and other operations.  <code>np.multiply.outer(a.ravel(), b.ravel())</code> is the equivalent.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] : G. H. Golub and C. F. Van Loan, <em>Matrix Computations</em>, 3rd  ed., Baltimore, MD, Johns Hopkins University Press, 1996,  pg. 8.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Make a (*very* coarse) grid for computing a Mandelbrot set:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5)) rl array(<a href="null">-2., -1.,  0.,  1.,  2.],
+       [-2., -1.,  0.,  1.,  2.],
+       [-2., -1.,  0.,  1.,  2.],
+       [-2., -1.,  0.,  1.,  2.],
+       [-2., -1.,  0.,  1.,  2.</a>) im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,))) im array(<a href="null">0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
+       [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
+       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
+       [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
+       [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j</a>) grid = rl + im grid array(<a href="null">-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
+       [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
+       [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
+       [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
+       [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>An example using a “vector” of letters:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([‘a’, ‘b’, ‘c’], dtype=object) np.outer(x, [1, 2, 3]) array(<a href="null">'a', 'aa', 'aaa'],
+       ['b', 'bb', 'bbb'],
+       ['c', 'cc', 'ccc'</a>, dtype=object)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16546">view source</a></div></div><div class="public anchor" id="var-packbits"><h3>packbits</h3><div class="usage"><code>(packbits &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>packbits(a, axis=None, bitorder=‘big’)</p>
+<p>Packs the elements of a binary-valued array into bits in a uint8 array.</p>
+<p>The result is padded to full bytes by inserting zero bits at the end.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  An array of integers or booleans whose elements should be packed to  bits. axis : int, optional  The dimension over which bit-packing is done.  <code>None</code> implies packing the flattened array. bitorder : {‘big’, ‘little’}, optional  The order of the input bits. ‘big’ will mimic bin(val),  <code>[0, 0, 0, 0, 0, 0, 1, 1] =&gt; 3 = 0b00000011 =&gt;</code>, ‘little’ will  reverse the order so <code>[1, 1, 0, 0, 0, 0, 0, 0] =&gt; 3</code>.  Defaults to ‘big’.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>packed : ndarray  Array of type uint8 whose elements represent bits corresponding to the  logical (0 or nonzero) value of the input elements. The shape of  <code>packed</code> has the same number of dimensions as the input (unless <code>axis</code>  is None, in which case the output is 1-D).</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>unpackbits: Unpacks elements of a uint8 array into a binary-valued output  array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">[1,0,1],
+...                [0,1,0</a>, … <a href="null">1,1,0],
+...                [0,0,1</a>]) b = np.packbits(a, axis=-1) b array(<a href="null">[160],
+        [ 64</a>,  <a href="null">192],
+        [ 32</a>], dtype=uint8)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000, and 32 = 0010 0000.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14312">view source</a></div></div><div class="public anchor" id="var-pad"><h3>pad</h3><div class="usage"><code>(pad &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Pad an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>array : array_like of rank N  The array to pad. pad_width : {sequence, array_like, int}  Number of values padded to the edges of each axis.  ((before_1, after_1), … (before_N, after_N)) unique pad widths  for each axis.  ((before, after),) yields same before and after pad for each axis.  (pad,) or int is a shortcut for before = after = pad width for all  axes. mode : str or function, optional  One of the following string values or a user supplied function.</p>
+<pre><code>'constant' (default)
+    Pads with a constant value.
+'edge'
+    Pads with the edge values of array.
+'linear_ramp'
+    Pads with the linear ramp between end_value and the
+    array edge value.
+'maximum'
+    Pads with the maximum value of all or part of the
+    vector along each axis.
+'mean'
+    Pads with the mean value of all or part of the
+    vector along each axis.
+'median'
+    Pads with the median value of all or part of the
+    vector along each axis.
+'minimum'
+    Pads with the minimum value of all or part of the
+    vector along each axis.
+'reflect'
+    Pads with the reflection of the vector mirrored on
+    the first and last values of the vector along each
+    axis.
+'symmetric'
+    Pads with the reflection of the vector mirrored
+    along the edge of the array.
+'wrap'
+    Pads with the wrap of the vector along the axis.
+    The first values are used to pad the end and the
+    end values are used to pad the beginning.
+'empty'
+    Pads with undefined values.
+
+    .. versionadded:: 1.17
+
+&lt;function&gt;
+    Padding function, see Notes.
+</code></pre>
+<p>stat_length : sequence or int, optional  Used in ‘maximum’, ‘mean’, ‘median’, and ‘minimum’. Number of  values at edge of each axis used to calculate the statistic value.</p>
+<pre><code>((before_1, after_1), ... (before_N, after_N)) unique statistic
+lengths for each axis.
+
+((before, after),) yields same before and after statistic lengths
+for each axis.
+
+(stat_length,) or int is a shortcut for before = after = statistic
+length for all axes.
+
+Default is ``None``, to use the entire axis.
+</code></pre>
+<p>constant_values : sequence or scalar, optional  Used in ‘constant’. The values to set the padded values for each  axis.</p>
+<pre><code>``((before_1, after_1), ... (before_N, after_N))`` unique pad constants
+for each axis.
+
+``((before, after),)`` yields same before and after constants for each
+axis.
+
+``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
+all axes.
+
+Default is 0.
+</code></pre>
+<p>end_values : sequence or scalar, optional  Used in ‘linear_ramp’. The values used for the ending value of the  linear_ramp and that will form the edge of the padded array.</p>
+<pre><code>``((before_1, after_1), ... (before_N, after_N))`` unique end values
+for each axis.
+
+``((before, after),)`` yields same before and after end values for each
+axis.
+
+``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
+all axes.
+
+Default is 0.
+</code></pre>
+<p>reflect_type : {‘even’, ‘odd’}, optional  Used in ‘reflect’, and ‘symmetric’. The ‘even’ style is the  default with an unaltered reflection around the edge value. For  the ‘odd’ style, the extended part of the array is created by  subtracting the reflected values from two times the edge value.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>pad : ndarray  Padded array of rank equal to <code>array</code> with shape increased  according to <code>pad_width</code>.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.7.0</p>
+<p>For an array with rank greater than 1, some of the padding of later axes is calculated from padding of previous axes. This is easiest to think about with a rank 2 array where the corners of the padded array are calculated by using padded values from the first axis.</p>
+<p>The padding function, if used, should modify a rank 1 array in-place. It has the following signature::</p>
+<pre><code>padding_func(vector, iaxis_pad_width, iaxis, kwargs)
+</code></pre>
+<p>where</p>
+<pre><code>vector : ndarray
+    A rank 1 array already padded with zeros.  Padded values are
+    vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:].
+iaxis_pad_width : tuple
+    A 2-tuple of ints, iaxis_pad_width[0] represents the number of
+    values padded at the beginning of vector where
+    iaxis_pad_width[1] represents the number of values padded at
+    the end of vector.
+iaxis : int
+    The axis currently being calculated.
+kwargs : dict
+    Any keyword arguments the function requires.
+</code></pre>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = [1, 2, 3, 4, 5] np.pad(a, (2, 3), ‘constant’, constant_values=(4, 6)) array([4, 4, 1, …, 6, 6, 6])</p>
+      <p>np.pad(a, (2, 3), ‘edge’) array([1, 1, 1, …, 5, 5, 5])</p>
+      <p>np.pad(a, (2, 3), ‘linear_ramp’, end_values=(5, -4)) array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4])</p>
+      <p>np.pad(a, (2,), ‘maximum’) array([5, 5, 1, 2, 3, 4, 5, 5, 5])</p>
+      <p>np.pad(a, (2,), ‘mean’) array([3, 3, 1, 2, 3, 4, 5, 3, 3])</p>
+      <p>np.pad(a, (2,), ‘median’) array([3, 3, 1, 2, 3, 4, 5, 3, 3])</p>
+      <p>a = <a href="null">1, 2], [3, 4</a> np.pad(a, ((3, 2), (2, 3)), ‘minimum’) array(<a href="null">1, 1, 1, 2, 1, 1, 1],
+       [1, 1, 1, 2, 1, 1, 1],
+       [1, 1, 1, 2, 1, 1, 1],
+       [1, 1, 1, 2, 1, 1, 1],
+       [3, 3, 3, 4, 3, 3, 3],
+       [1, 1, 1, 2, 1, 1, 1],
+       [1, 1, 1, 2, 1, 1, 1</a>)</p>
+      <p>a = [1, 2, 3, 4, 5] np.pad(a, (2, 3), ‘reflect’) array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])</p>
+      <p>np.pad(a, (2, 3), ‘reflect’, reflect_type=‘odd’) array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8])</p>
+      <p>np.pad(a, (2, 3), ‘symmetric’) array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])</p>
+      <p>np.pad(a, (2, 3), ‘symmetric’, reflect_type=‘odd’) array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])</p>
+      <p>np.pad(a, (2, 3), ‘wrap’) array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])</p>
+      <p>def pad_with(vector, pad_width, iaxis, kwargs): … pad_value = kwargs.get(‘padder’, 10) … vector[:pad_width[0]] = pad_value … vector[-pad_width[1]:] = pad_value a = np.arange(6) a = a.reshape((2, 3)) np.pad(a, 2, pad_with) array(<a href="null">10, 10, 10, 10, 10, 10, 10],
+       [10, 10, 10, 10, 10, 10, 10],
+       [10, 10,  0,  1,  2, 10, 10],
+       [10, 10,  3,  4,  5, 10, 10],
+       [10, 10, 10, 10, 10, 10, 10],
+       [10, 10, 10, 10, 10, 10, 10</a>) np.pad(a, 2, pad_with, padder=100) array(<a href="null">100, 100, 100, 100, 100, 100, 100],
+       [100, 100, 100, 100, 100, 100, 100],
+       [100, 100,   0,   1,   2, 100, 100],
+       [100, 100,   3,   4,   5, 100, 100],
+       [100, 100, 100, 100, 100, 100, 100],
+       [100, 100, 100, 100, 100, 100, 100</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2932">view source</a></div></div><div class="public anchor" id="var-partition"><h3>partition</h3><div class="usage"><code>(partition &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a partitioned copy of an array.</p>
+<p>Creates a copy of the array with its elements rearranged in such a way that the value of the element in k-th position is in the position it would be in a sorted array. All elements smaller than the k-th element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undefined.</p>
+<p>.. versionadded:: 1.8.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array to be sorted. kth : int or sequence of ints  Element index to partition by. The k-th value of the element  will be in its final sorted position and all smaller elements  will be moved before it and all equal or greater elements behind  it. The order of all elements in the partitions is undefined. If  provided with a sequence of k-th it will partition all elements  indexed by k-th of them into their sorted position at once. axis : int or None, optional  Axis along which to sort. If None, the array is flattened before  sorting. The default is -1, which sorts along the last axis. kind : {‘introselect’}, optional  Selection algorithm. Default is ‘introselect’. order : str or list of str, optional  When <code>a</code> is an array with fields defined, this argument  specifies which fields to compare first, second, etc. A single  field can be specified as a string. Not all fields need be  specified, but unspecified fields will still be used, in the  order in which they come up in the dtype, to break ties.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>partitioned_array : ndarray  Array of the same type and shape as <code>a</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.partition : Method to sort an array in-place. argpartition : Indirect partition. sort : Full sorting</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The various selection algorithms are characterized by their average speed, worst case performance, work space size, and whether they are stable. A stable sort keeps items with the same key in the same relative order. The available algorithms have the following properties:</p>
+<p>================= ======= ============= ============ =======  kind speed worst case work space stable ================= ======= ============= ============ ======= ‘introselect’ 1 O(n) 0 no ================= ======= ============= ============ =======</p>
+<p>All the partition algorithms make temporary copies of the data when partitioning along any but the last axis. Consequently, partitioning along the last axis is faster and uses less space than partitioning along any other axis.</p>
+<p>The sort order for complex numbers is lexicographic. If both the real and imaginary parts are non-nan then the order is determined by the real parts except when they are equal, in which case the order is determined by the imaginary parts.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([3, 4, 2, 1]) np.partition(a, 3) array([2, 1, 3, 4])</p>
+      <p>np.partition(a, (1, 3)) array([1, 2, 3, 4])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10357">view source</a></div></div><div class="public anchor" id="var-percentile"><h3>percentile</h3><div class="usage"><code>(percentile &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the q-th percentile of the data along the specified axis.</p>
+<p>Returns the q-th percentile(s) of the array elements.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array or object that can be converted to an array. q : array_like of float  Percentile or sequence of percentiles to compute, which must be between  0 and 100 inclusive. axis : {int, tuple of int, None}, optional  Axis or axes along which the percentiles are computed. The  default is to compute the percentile(s) along a flattened  version of the array.</p>
+<pre><code>.. versionchanged:: 1.9.0
+    A tuple of axes is supported
+</code></pre>
+<p>out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow the input array <code>a</code> to be modified by intermediate  calculations, to save memory. In this case, the contents of the input  <code>a</code> after this function completes is undefined.</p>
+<p>interpolation : {‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}  This optional parameter specifies the interpolation method to  use when the desired percentile lies between two data points  <code>i &lt; j</code>:</p>
+<pre><code>* 'linear': ``i + (j - i) * fraction``, where ``fraction``
+  is the fractional part of the index surrounded by ``i``
+  and ``j``.
+* 'lower': ``i``.
+* 'higher': ``j``.
+* 'nearest': ``i`` or ``j``, whichever is nearest.
+* 'midpoint': ``(i + j) / 2``.
+
+.. versionadded:: 1.9.0
+</code></pre>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left in  the result as dimensions with size one. With this option, the  result will broadcast correctly against the original array <code>a</code>.</p>
+<pre><code>.. versionadded:: 1.9.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>percentile : scalar or ndarray  If <code>q</code> is a single percentile and <code>axis=None</code>, then the result  is a scalar. If multiple percentiles are given, first axis of  the result corresponds to the percentiles. The other axes are  the axes that remain after the reduction of <code>a</code>. If the input  contains integers or floats smaller than <code>float64</code>, the output  data-type is <code>float64</code>. Otherwise, the output data-type is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>mean median : equivalent to <code>percentile(..., 50)</code> nanpercentile quantile : equivalent to percentile, except with q in the range [0, 1].</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Given a vector <code>V</code> of length <code>N</code>, the q-th percentile of <code>V</code> is the value <code>q/100</code> of the way from the minimum to the maximum in a sorted copy of <code>V</code>. The values and distances of the two nearest neighbors as well as the <code>interpolation</code> parameter will determine the percentile if the normalized ranking does not match the location of <code>q</code> exactly. This function is the same as the median if <code>q=50</code>, the same as the minimum if <code>q=0</code> and the same as the maximum if <code>q=100</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">10, 7, 4], [3, 2, 1</a>) a array(<a href="null">10,  7,  4],
+       [ 3,  2,  1</a>) np.percentile(a, 50) 3.5 np.percentile(a, 50, axis=0) array([6.5, 4.5, 2.5]) np.percentile(a, 50, axis=1) array([7., 2.]) np.percentile(a, 50, axis=1, keepdims=True) array(<a href="null">7.],
+       [2.</a>)</p>
+      <p>m = np.percentile(a, 50, axis=0) out = np.zeros_like(m) np.percentile(a, 50, axis=0, out=out) array([6.5, 4.5, 2.5]) m array([6.5, 4.5, 2.5])</p>
+      <p>b = a.copy() np.percentile(b, 50, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a == b)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The different types of interpolation can be visualized graphically:</p>
+<p>.. plot::</p>
+<pre><code>import matplotlib.pyplot as plt
+
+a = np.arange(4)
+p = np.linspace(0, 100, 6001)
+ax = plt.gca()
+lines = [
+    ('linear', None),
+    ('higher', '--'),
+    ('lower', '--'),
+    ('nearest', '-.'),
+    ('midpoint', '-.'),
+]
+for interpolation, style in lines:
+    ax.plot(
+        p, np.percentile(a, p, interpolation=interpolation),
+        label=interpolation, linestyle=style)
+ax.set(
+    title='Interpolation methods for list: ' + str(a),
+    xlabel='Percentile',
+    ylabel='List item returned',
+    yticks=a)
+ax.legend()
+plt.show()
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14369">view source</a></div></div><div class="public anchor" id="var-pi"><h3>pi</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14835">view source</a></div></div><div class="public anchor" id="var-piecewise"><h3>piecewise</h3><div class="usage"><code>(piecewise &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Evaluate a piecewise-defined function.</p>
+<p>Given a set of conditions and corresponding functions, evaluate each function on the input data wherever its condition is true.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : ndarray or scalar  The input domain. condlist : list of bool arrays or bool scalars  Each boolean array corresponds to a function in <code>funclist</code>. Wherever  <code>condlist[i]</code> is True, <code>funclist[i](x)</code> is used as the output value.</p>
+<pre><code>Each boolean array in `condlist` selects a piece of `x`,
+and should therefore be of the same shape as `x`.
+
+The length of `condlist` must correspond to that of `funclist`.
+If one extra function is given, i.e. if
+``len(funclist) == len(condlist) + 1``, then that extra function
+is the default value, used wherever all conditions are false.
+</code></pre>
+<p>funclist : list of callables, f(x,*args,**kw), or scalars  Each function is evaluated over <code>x</code> wherever its corresponding  condition is True. It should take a 1d array as input and give an 1d  array or a scalar value as output. If, instead of a callable,  a scalar is provided then a constant function (<code>lambda x: scalar</code>) is  assumed. args : tuple, optional  Any further arguments given to <code>piecewise</code> are passed to the functions  upon execution, i.e., if called <code>piecewise(..., ..., 1, 'a')</code>, then  each function is called as <code>f(x, 1, 'a')</code>. kw : dict, optional  Keyword arguments used in calling <code>piecewise</code> are passed to the  functions upon execution, i.e., if called  <code>piecewise(..., ..., alpha=1)</code>, then each function is called as  <code>f(x, alpha=1)</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  The output is the same shape and type as x and is found by  calling the functions in <code>funclist</code> on the appropriate portions of <code>x</code>,  as defined by the boolean arrays in <code>condlist</code>. Portions not covered  by any condition have a default value of 0.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>choose, select, where</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This is similar to choose or select, except that functions are evaluated on elements of <code>x</code> that satisfy the corresponding condition from <code>condlist</code>.</p>
+<p>The result is::</p>
+<pre><code>    |--
+    |funclist[0](x[condlist[0]])
+</code></pre>
+<p>out = |funclist<a href="x[condlist[1]]">1</a>  |…  |funclist<a href="x[condlist[n2]]">n2</a>  |–</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Define the sigma function, which is -1 for <code>x &lt; 0</code> and +1 for <code>x &gt;= 0</code>.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.linspace(-2.5, 2.5, 6) np.piecewise(x, [x &lt; 0, x &gt;= 0], [-1, 1]) array([-1., -1., -1., 1., 1., 1.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Define the absolute value, which is <code>-x</code> for <code>x &lt;0</code> and <code>x</code> for <code>x &gt;= 0</code>.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.piecewise(x, [x &lt; 0, x &gt;= 0], [lambda x: -x, lambda x: x]) array([2.5, 1.5, 0.5, 0.5, 1.5, 2.5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Apply the same function to a scalar value.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>y = -2 np.piecewise(y, [y &lt; 0, y &gt;= 0], [lambda x: -x, lambda x: x]) array(2)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20621">view source</a></div></div><div class="public anchor" id="var-PINF"><h3>PINF</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22010">view source</a></div></div><div class="public anchor" id="var-place"><h3>place</h3><div class="usage"><code>(place &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Change elements of an array based on conditional and input values.</p>
+<p>Similar to <code>np.copyto(arr, vals, where=mask)</code>, the difference is that <code>place</code> uses the first N elements of <code>vals</code>, where N is the number of True values in <code>mask</code>, while <code>copyto</code> uses the elements where <code>mask</code> is True.</p>
+<p>Note that <code>extract</code> does the exact opposite of <code>place</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr : ndarray  Array to put data into. mask : array_like  Boolean mask array. Must have the same size as <code>a</code>. vals : 1-D sequence  Values to put into <code>a</code>. Only the first N elements are used, where  N is the number of True values in <code>mask</code>. If <code>vals</code> is smaller  than N, it will be repeated, and if elements of <code>a</code> are to be masked,  this sequence must be non-empty.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>copyto, put, take, extract</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>arr = np.arange(6).reshape(2, 3) np.place(arr, arr&gt;2, [44, 55]) arr array(<a href="null"> 0,  1,  2],
+       [44, 55, 44</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5542">view source</a></div></div><div class="public anchor" id="var-pmt"><h3>pmt</h3><div class="usage"><code>(pmt &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the payment against loan principal plus interest.</p>
+<p>.. deprecated:: 1.18</p>
+<p><code>pmt</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
+<p>Given:  * a present value, <code>pv</code> (e.g., an amount borrowed)  * a future value, <code>fv</code> (e.g., 0)  * an interest <code>rate</code> compounded once per period, of which  there are  * <code>nper</code> total  * and (optional) specification of whether payment is made  at the beginning (<code>when</code> = {‘begin’, 1}) or the end  (<code>when</code> = {‘end’, 0}) of each period</p>
+<p>Return:  the (fixed) periodic payment.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>rate : array_like  Rate of interest (per period) nper : array_like  Number of compounding periods pv : array_like  Present value fv : array_like, optional  Future value (default = 0) when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}  When payments are due (‘begin’ (1) or ‘end’ (0))</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Payment against loan plus interest. If all input is scalar, returns a  scalar float. If any input is array_like, returns payment for each  input element. If multiple inputs are array_like, they all must have  the same shape.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The payment is computed by solving the equation::</p>
+<p>fv +  pv*(1 + rate)**nper +  pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) == 0</p>
+<p>or, when <code>rate == 0</code>::</p>
+<p>fv + pv + pmt * nper == 0</p>
+<p>for <code>pmt</code>.</p>
+<p>Note that computing a monthly mortgage payment is only one use for this function. For example, pmt returns the periodic deposit one must make to achieve a specified future balance given an initial deposit, a fixed, periodically compounded interest rate, and the total number of periods.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).  Open Document Format for Office Applications (OpenDocument)v1.2,  Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,  Pre-Draft 12. Organization for the Advancement of Structured Information  Standards (OASIS). Billerica, MA, USA. [ODT Document].  Available:  <a href="http://www.oasis-open.org/committees/documents.php">http://www.oasis-open.org/committees/documents.php</a>  ?wg_abbrev=office-formulaOpenDocument-formula-20090508.odt</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>What is the monthly payment needed to pay off a $200,000 loan in 15 years at an annual interest rate of 7.5%?</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.pmt(0.075/12, 12*15, 200000) -1854.0247200054619</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>In order to pay-off (i.e., have a future-value of 0) the $200,000 obtained today, a monthly payment of $1,854.02 would be required. Note that this example illustrates usage of <code>fv</code> having a default value of 0.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27358">view source</a></div></div><div class="public anchor" id="var-poly"><h3>poly</h3><div class="usage"><code>(poly &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the coefficients of a polynomial with the given sequence of roots.</p>
+<p>Returns the coefficients of the polynomial whose leading coefficient is one for the given sequence of zeros (multiple roots must be included in the sequence as many times as their multiplicity; see Examples). A square matrix (or array, which will be treated as a matrix) can also be given, in which case the coefficients of the characteristic polynomial of the matrix are returned.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>seq_of_zeros : array_like, shape (N,) or (N, N)  A sequence of polynomial roots, or a square array or matrix object.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>c : ndarray  1D array of polynomial coefficients from highest to lowest degree:</p>
+<pre><code>``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]``
+where c[0] always equals 1.
+</code></pre>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If input is the wrong shape (the input must be a 1-D or square  2-D array).</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>polyval : Compute polynomial values. roots : Return the roots of a polynomial. polyfit : Least squares polynomial fit. poly1d : A one-dimensional polynomial class.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Specifying the roots of a polynomial still leaves one degree of freedom, typically represented by an undetermined leading coefficient. [1]_ In the case of this function, that coefficient - the first one in the returned array - is always taken as one. (If for some reason you have one other point, the only automatic way presently to leverage that information is to use <code>polyfit</code>.)</p>
+<p>The characteristic polynomial, :math:<code>p_a(t)</code>, of an <code>n</code>-by-<code>n</code> matrix <strong>A</strong> is given by</p>
+<pre><code>:math:`p_a(t) = \mathrm{det}(t\, \mathbf{I} - \mathbf{A})`,
+</code></pre>
+<p>where <strong>I</strong> is the <code>n</code>-by-<code>n</code> identity matrix. [2]_</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] M. Sullivan and M. Sullivan, III, “Algebra and Trignometry,  Enhanced With Graphing Utilities,” Prentice-Hall, pg. 318, 1996.</p>
+<p>.. [2] G. Strang, “Linear Algebra and Its Applications, 2nd Edition,”  Academic Press, pg. 182, 1980.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Given a sequence of a polynomial’s zeros:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.poly((0, 0, 0)) # Multiple root example array([1., 0., 0., 0.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The line above represents z**3 + 0*z**2 + 0*z + 0.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.poly((-1./2, 0, 1./2)) array([ 1. , 0. , -0.25, 0. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The line above represents z**3 - z/4</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.poly((np.random.random(1)[0], 0, np.random.random(1)[0])) array([ 1. , -0.77086955, 0.08618131, 0. ]) # random</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Given a square array object:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>P = np.array(<a href="null">0, 1./3], [-1./2, 0</a>) np.poly(P) array([1. , 0. , 0.16666667])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note how in all cases the leading coefficient is always 1.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4077">view source</a></div></div><div class="public anchor" id="var-poly1d"><h3>poly1d</h3><div class="usage"><code>(poly1d self c_or_r &amp; [{r :r, variable :variable}])</code><code>(poly1d self c_or_r &amp; [{r :r}])</code><code>(poly1d self c_or_r)</code></div><div class="doc"><div class="markdown"><p>A one-dimensional polynomial class.</p>
+<p>A convenience class, used to encapsulate “natural” operations on polynomials so that said operations may take on their customary form in code (see Examples).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>c_or_r : array_like  The polynomial’s coefficients, in decreasing powers, or if  the value of the second parameter is True, the polynomial’s  roots (values where the polynomial evaluates to 0). For example,  <code>poly1d([1, 2, 3])</code> returns an object that represents  :math:<code>x^2 + 2x + 3</code>, whereas <code>poly1d([1, 2, 3], True)</code> returns  one that represents :math:<code>(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6</code>. r : bool, optional  If True, <code>c_or_r</code> specifies the polynomial’s roots; the default  is False. variable : str, optional  Changes the variable used when printing <code>p</code> from <code>x</code> to <code>variable</code>  (see Examples).</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Construct the polynomial :math:<code>x^2 + 2x + 3</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p = np.poly1d([1, 2, 3]) print(np.poly1d(p))  2 1 x + 2 x + 3</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Evaluate the polynomial at :math:<code>x = 0.5</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p(0.5) 4.25</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Find the roots:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p.r array([-1.+1.41421356j, -1.-1.41421356j]) p(p.r) array([ -4.44089210e-16+0.j, -4.44089210e-16+0.j]) # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>These numbers in the previous line represent (0, 0) to machine precision</p>
+<p>Show the coefficients:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p.c array([1, 2, 3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Display the order (the leading zero-coefficients are removed):</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p.order 2</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Show the coefficient of the k-th power in the polynomial (which is equivalent to <code>p.c[-(i+1)]</code>):</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p[1] 2</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Polynomials can be added, subtracted, multiplied, and divided (returns quotient and remainder):</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p * p poly1d([ 1, 4, 10, 12, 9])</p>
+      <p>(p**3 + 4) / p (poly1d([ 1., 4., 10., 12., 9.]), poly1d([4.]))</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p><code>asarray(p)</code> gives the coefficient array, so polynomials can be used in all functions that accept arrays:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p**2 # square of polynomial poly1d([ 1, 4, 10, 12, 9])</p>
+      <p>np.square(p) # square of individual coefficients array([1, 4, 9])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The variable used in the string representation of <code>p</code> can be modified, using the <code>variable</code> parameter:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p = np.poly1d([1,2,3], variable=‘z’) print(p)  2 1 z + 2 z + 3</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Construct a polynomial from its roots:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.poly1d([1, 2], True) poly1d([ 1., -3., 2.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>This is the same polynomial as obtained by:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.poly1d([1, -1]) * np.poly1d([1, -2]) poly1d([ 1, -3, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12789">view source</a></div></div><div class="public anchor" id="var-polyadd"><h3>polyadd</h3><div class="usage"><code>(polyadd &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the sum of two polynomials.</p>
+<p>Returns the polynomial resulting from the sum of two input polynomials. Each input must be either a poly1d object or a 1D sequence of polynomial coefficients, from highest to lowest degree.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a1, a2 : array_like or poly1d object  Input polynomials.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or poly1d object  The sum of the inputs. If either input is a poly1d object, then the  output is also a poly1d object. Otherwise, it is a 1D array of  polynomial coefficients from highest to lowest degree.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>poly1d : A one-dimensional polynomial class. poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.polyadd([1, 2], [9, 5, 4]) array([9, 6, 6])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using poly1d objects:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p1 = np.poly1d([1, 2]) p2 = np.poly1d([9, 5, 4]) print(p1) 1 x + 2 print(p2)  2 9 x + 5 x + 4 print(np.polyadd(p1, p2))  2 9 x + 6 x + 6</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17955">view source</a></div></div><div class="public anchor" id="var-polyder"><h3>polyder</h3><div class="usage"><code>(polyder &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the derivative of the specified order of a polynomial.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>p : poly1d or sequence  Polynomial to differentiate.  A sequence is interpreted as polynomial coefficients, see <code>poly1d</code>. m : int, optional  Order of differentiation (default: 1)</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>der : poly1d  A new polynomial representing the derivative.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>polyint : Anti-derivative of a polynomial. poly1d : Class for one-dimensional polynomials.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>The derivative of the polynomial :math:<code>x^3 + x^2 + x^1 + 1</code> is:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p = np.poly1d([1,1,1,1]) p2 = np.polyder(p) p2 poly1d([3, 2, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>which evaluates to:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p2(2.) 17.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>We can verify this, approximating the derivative with <code>(f(x + h) - f(x))/h</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>(p(2. + 0.001) - p(2.)) / 0.001 17.007000999997857</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The fourth-order derivative of a 3rd-order polynomial is zero:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.polyder(p, 2) poly1d([6, 2]) np.polyder(p, 3) poly1d([6]) np.polyder(p, 4) poly1d([0.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28140">view source</a></div></div><div class="public anchor" id="var-polydiv"><h3>polydiv</h3><div class="usage"><code>(polydiv &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the quotient and remainder of polynomial division.</p>
+<p>The input arrays are the coefficients (including any coefficients equal to zero) of the “numerator” (dividend) and “denominator” (divisor) polynomials, respectively.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>u : array_like or poly1d  Dividend polynomial’s coefficients.</p>
+<p>v : array_like or poly1d  Divisor polynomial’s coefficients.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>q : ndarray  Coefficients, including those equal to zero, of the quotient. r : ndarray  Coefficients, including those equal to zero, of the remainder.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub polyval</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Both <code>u</code> and <code>v</code> must be 0-d or 1-d (ndim = 0 or 1), but <code>u.ndim</code> need not equal <code>v.ndim</code>. In other words, all four possible combinations - <code>u.ndim = v.ndim = 0</code>, <code>u.ndim = v.ndim = 1</code>, <code>u.ndim = 1, v.ndim = 0</code>, and <code>u.ndim = 0, v.ndim = 1</code> - work.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>.. math:: \frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([3.0, 5.0, 2.0]) y = np.array([2.0, 1.0]) np.polydiv(x, y) (array([1.5 , 1.75]), array([0.25]))</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28754">view source</a></div></div><div class="public anchor" id="var-polyfit"><h3>polyfit</h3><div class="usage"><code>(polyfit &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Least squares polynomial fit.</p>
+<p>Fit a polynomial <code>p(x) = p[0] * x**deg + ... + p[deg]</code> of degree <code>deg</code> to points <code>(x, y)</code>. Returns a vector of coefficients <code>p</code> that minimises the squared error in the order <code>deg</code>, <code>deg-1</code>, … <code>0</code>.</p>
+<p>The <code>Polynomial.fit &lt;numpy.polynomial.polynomial.Polynomial.fit&gt;</code> class method is recommended for new code as it is more stable numerically. See the documentation of the method for more information.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like, shape (M,)  x-coordinates of the M sample points <code>(x[i], y[i])</code>. y : array_like, shape (M,) or (M, K)  y-coordinates of the sample points. Several data sets of sample  points sharing the same x-coordinates can be fitted at once by  passing in a 2D-array that contains one dataset per column. deg : int  Degree of the fitting polynomial rcond : float, optional  Relative condition number of the fit. Singular values smaller than  this relative to the largest singular value will be ignored. The  default value is len(x)*eps, where eps is the relative precision of  the float type, about 2e-16 in most cases. full : bool, optional  Switch determining nature of return value. When it is False (the  default) just the coefficients are returned, when True diagnostic  information from the singular value decomposition is also returned. w : array_like, shape (M,), optional  Weights to apply to the y-coordinates of the sample points. For  gaussian uncertainties, use 1/sigma (not 1/sigma**2). cov : bool or str, optional  If given and not <code>False</code>, return not just the estimate but also its  covariance matrix. By default, the covariance are scaled by  chi2/sqrt(N-dof), i.e., the weights are presumed to be unreliable  except in a relative sense and everything is scaled such that the  reduced chi2 is unity. This scaling is omitted if <code>cov='unscaled'</code>,  as is relevant for the case that the weights are 1/sigma**2, with  sigma known to be a reliable estimate of the uncertainty.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>p : ndarray, shape (deg + 1,) or (deg + 1, K)  Polynomial coefficients, highest power first. If <code>y</code> was 2-D, the  coefficients for <code>k</code>-th data set are in <code>p[:,k]</code>.</p>
+<p>residuals, rank, singular_values, rcond  Present only if <code>full</code> = True. Residuals is sum of squared residuals  of the least-squares fit, the effective rank of the scaled Vandermonde  coefficient matrix, its singular values, and the specified value of  <code>rcond</code>. For more details, see <code>linalg.lstsq</code>.</p>
+<p>V : ndarray, shape (M,M) or (M,M,K)  Present only if <code>full</code> = False and <code>cov</code>=True. The covariance  matrix of the polynomial coefficient estimates. The diagonal of  this matrix are the variance estimates for each coefficient. If y  is a 2-D array, then the covariance matrix for the <code>k</code>-th data set  are in <code>V[:,:,k]</code></p>
+<h2><a href="#warns" name="warns"></a>Warns</h2>
+<p>RankWarning  The rank of the coefficient matrix in the least-squares fit is  deficient. The warning is only raised if <code>full</code> = False.</p>
+<pre><code>The warnings can be turned off by
+
+&gt;&gt;&gt; import warnings
+&gt;&gt;&gt; warnings.simplefilter('ignore', np.RankWarning)
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>polyval : Compute polynomial values. linalg.lstsq : Computes a least-squares fit. scipy.interpolate.UnivariateSpline : Computes spline fits.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The solution minimizes the squared error</p>
+<p>.. math ::  E = \sum_{j=0}^k |p(x_j) - y_j|^2</p>
+<p>in the equations::</p>
+<pre><code>x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]
+x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]
+...
+x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]
+</code></pre>
+<p>The coefficient matrix of the coefficients <code>p</code> is a Vandermonde matrix.</p>
+<p><code>polyfit</code> issues a <code>RankWarning</code> when the least-squares fit is badly conditioned. This implies that the best fit is not well-defined due to numerical error. The results may be improved by lowering the polynomial degree or by replacing <code>x</code> by <code>x</code> - <code>x</code>.mean(). The <code>rcond</code> parameter can also be set to a value smaller than its default, but the resulting fit may be spurious: including contributions from the small singular values can add numerical noise to the result.</p>
+<p>Note that fitting polynomial coefficients is inherently badly conditioned when the degree of the polynomial is large or the interval of sample points is badly centered. The quality of the fit should always be checked in these cases. When polynomial fits are not satisfactory, splines may be a good alternative.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Wikipedia, “Curve fitting”,  <a href="https://en.wikipedia.org/wiki/Curve_fitting">https://en.wikipedia.org/wiki/Curve_fitting</a> .. [2] Wikipedia, “Polynomial interpolation”,  <a href="https://en.wikipedia.org/wiki/Polynomial_interpolation">https://en.wikipedia.org/wiki/Polynomial_interpolation</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import warnings x = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0]) y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0]) z = np.polyfit(x, y, 3) z array([ 0.08703704, -0.81349206, 1.69312169, -0.03968254]) # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>It is convenient to use <code>poly1d</code> objects for dealing with polynomials:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p = np.poly1d(z) p(0.5) 0.6143849206349179 # may vary p(3.5) -0.34732142857143039 # may vary p(10) 22.579365079365115 # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>High-order polynomials may oscillate wildly:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>with warnings.catch_warnings(): … warnings.simplefilter(‘ignore’, np.RankWarning) … p30 = np.poly1d(np.polyfit(x, y, 30)) … p30(4) -0.80000000000000204 # may vary p30(5) -0.99999999999999445 # may vary p30(4.5) -0.10547061179440398 # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Illustration:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt xp = np.linspace(-2, 6, 100) _ = plt.plot(x, y, ‘.’, xp, p(xp), ‘-’, xp, p30(xp), ‘–’) plt.ylim(-2,2) (-2, 2) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18376">view source</a></div></div><div class="public anchor" id="var-polyint"><h3>polyint</h3><div class="usage"><code>(polyint &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an antiderivative (indefinite integral) of a polynomial.</p>
+<p>The returned order <code>m</code> antiderivative <code>P</code> of polynomial <code>p</code> satisfies :math:<code>\frac{d^m}{dx^m}P(x) = p(x)</code> and is defined up to <code>m - 1</code> integration constants <code>k</code>. The constants determine the low-order polynomial part</p>
+<p>.. math:: \frac{k_{m-1}}{0!} x^0 + \ldots + \frac{k_0}{(m-1)!}x^{m-1}</p>
+<p>of <code>P</code> so that :math:<code>P^{(j)}(0) = k_{m-j-1}</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>p : array_like or poly1d  Polynomial to integrate.  A sequence is interpreted as polynomial coefficients, see <code>poly1d</code>. m : int, optional  Order of the antiderivative. (Default: 1) k : list of <code>m</code> scalars or scalar, optional  Integration constants. They are given in the order of integration:  those corresponding to highest-order terms come first.</p>
+<pre><code>If ``None`` (default), all constants are assumed to be zero.
+If `m = 1`, a single scalar can be given instead of a list.
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>polyder : derivative of a polynomial poly1d.integ : equivalent method</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>The defining property of the antiderivative:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p = np.poly1d([1,1,1]) P = np.polyint(p) P  poly1d([ 0.33333333, 0.5 , 1. , 0. ]) # may vary np.polyder(P) == p True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The integration constants default to zero, but can be specified:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>P = np.polyint(p, 3) P(0) 0.0 np.polyder(P)(0) 0.0 np.polyder(P, 2)(0) 0.0 P = np.polyint(p, 3, k=[6,5,3]) P poly1d([ 0.01666667, 0.04166667, 0.16666667, 3. , 5. , 3. ]) # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that 3 = 6 / 2!, and that the constants are given in the order of integrations. Constant of the highest-order polynomial term comes first:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.polyder(P, 2)(0) 6.0 np.polyder(P, 1)(0) 5.0 P(0) 3.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9615">view source</a></div></div><div class="public anchor" id="var-polymul"><h3>polymul</h3><div class="usage"><code>(polymul &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the product of two polynomials.</p>
+<p>Finds the polynomial resulting from the multiplication of the two input polynomials. Each input must be either a poly1d object or a 1D sequence of polynomial coefficients, from highest to lowest degree.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a1, a2 : array_like or poly1d object  Input polynomials.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or poly1d object  The polynomial resulting from the multiplication of the inputs. If  either inputs is a poly1d object, then the output is also a poly1d  object. Otherwise, it is a 1D array of polynomial coefficients from  highest to lowest degree.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>poly1d : A one-dimensional polynomial class. poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval convolve : Array convolution. Same output as polymul, but has parameter  for overlap mode.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.polymul([1, 2, 3], [9, 5, 1]) array([ 9, 23, 38, 17, 3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using poly1d objects:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p1 = np.poly1d([1, 2, 3]) p2 = np.poly1d([9, 5, 1]) print(p1)  2 1 x + 2 x + 3 print(p2)  2 9 x + 5 x + 1 print(np.polymul(p1, p2))  4 3 2 9 x + 23 x + 38 x + 17 x + 3</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18243">view source</a></div></div><div class="public anchor" id="var-polynomial"><h3>polynomial</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A sub-package for efficiently dealing with polynomials.</p>
+<p>Within the documentation for this sub-package, a “finite power series,” i.e., a polynomial (also referred to simply as a “series”) is represented by a 1-D numpy array of the polynomial’s coefficients, ordered from lowest order term to highest. For example, array([1,2,3]) represents <code>P_0 + 2*P_1 + 3*P_2</code>, where P_n is the n-th order basis polynomial applicable to the specific module in question, e.g., <code>polynomial</code> (which “wraps” the “standard” basis) or <code>chebyshev</code>. For optimal performance, all operations on polynomials, including evaluation at an argument, are implemented as operations on the coefficients. Additional (module-specific) information can be found in the docstring for the module of interest.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28124">view source</a></div></div><div class="public anchor" id="var-polysub"><h3>polysub</h3><div class="usage"><code>(polysub &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Difference (subtraction) of two polynomials.</p>
+<p>Given two polynomials <code>a1</code> and <code>a2</code>, returns <code>a1 - a2</code>. <code>a1</code> and <code>a2</code> can be either array_like sequences of the polynomials’ coefficients (including coefficients equal to zero), or <code>poly1d</code> objects.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a1, a2 : array_like or poly1d  Minuend and subtrahend polynomials, respectively.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or poly1d  Array or <code>poly1d</code> object of the difference polynomial’s coefficients.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>polyval, polydiv, polymul, polyadd</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>.. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2)</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.polysub([2, 10, -2], [3, 10, -4]) array([-1, 0, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9267">view source</a></div></div><div class="public anchor" id="var-polyval"><h3>polyval</h3><div class="usage"><code>(polyval &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Evaluate a polynomial at specific values.</p>
+<p>If <code>p</code> is of length N, this function returns the value:</p>
+<pre><code>``p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]``
+</code></pre>
+<p>If <code>x</code> is a sequence, then <code>p(x)</code> is returned for each element of <code>x</code>. If <code>x</code> is another polynomial then the composite polynomial <code>p(x(t))</code> is returned.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>p : array_like or poly1d object  1D array of polynomial coefficients (including coefficients equal  to zero) from highest degree to the constant term, or an  instance of poly1d. x : array_like or poly1d object  A number, an array of numbers, or an instance of poly1d, at  which to evaluate <code>p</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>values : ndarray or poly1d  If <code>x</code> is a poly1d instance, the result is the composition of the two  polynomials, i.e., <code>x</code> is “substituted” in <code>p</code> and the simplified  result is returned. In addition, the type of <code>x</code> - array_like or  poly1d - governs the type of the output: <code>x</code> array_like =&gt; <code>values</code>  array_like, <code>x</code> a poly1d object =&gt; <code>values</code> is also.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>poly1d: A polynomial class.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Horner’s scheme [1]_ is used to evaluate the polynomial. Even so, for polynomials of high degree the values may be inaccurate due to rounding errors. Use carefully.</p>
+<p>If <code>x</code> is a subtype of <code>ndarray</code> the return value will be of the same type.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng.  trans. Ed.), <em>Handbook of Mathematics</em>, New York, Van Nostrand  Reinhold Co., 1985, pg. 720.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.polyval([3,0,1], 5) # 3 * 5**2 + 0 * 5**1 + 1 76 np.polyval([3,0,1], np.poly1d(5)) poly1d([76.]) np.polyval(np.poly1d([3,0,1]), 5) 76 np.polyval(np.poly1d([3,0,1]), np.poly1d(5)) poly1d([76.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2553">view source</a></div></div><div class="public anchor" id="var-positive"><h3>positive</h3><div class="usage"><code>(positive self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>positive(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Numerical positive, element-wise.</p>
+<p>.. versionadded:: 1.13.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like or scalar  Input array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  Returned array or scalar: <code>y = +x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Equivalent to <code>x.copy()</code>, but only defined for types that support arithmetic.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4385">view source</a></div></div><div class="public anchor" id="var-power"><h3>power</h3><div class="usage"><code>(power self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>power(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>First array elements raised to powers from second array, element-wise.</p>
+<p>Raise each base in <code>x1</code> to the positionally-corresponding power in <code>x2</code>. <code>x1</code> and <code>x2</code> must be broadcastable to the same shape. Note that an integer type raised to a negative integer power will raise a ValueError.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  The bases. x2 : array_like  The exponents. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The bases in <code>x1</code> raised to the exponents in <code>x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>float_power : power function that promotes integers to float</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Cube each element in a list.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x1 = range(6) x1 [0, 1, 2, 3, 4, 5] np.power(x1, 3) array([ 0, 1, 8, 27, 64, 125])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Raise the bases to different exponents.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] np.power(x1, x2) array([ 0., 1., 8., 27., 16., 5.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The effect of broadcasting.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x2 = np.array(<a href="null">1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1</a>) x2 array(<a href="null">1, 2, 3, 3, 2, 1],
+       [1, 2, 3, 3, 2, 1</a>) np.power(x1, x2) array(<a href="null"> 0,  1,  8, 27, 16,  5],
+       [ 0,  1,  8, 27, 16,  5</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14768">view source</a></div></div><div class="public anchor" id="var-ppmt"><h3>ppmt</h3><div class="usage"><code>(ppmt &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the payment against loan principal.</p>
+<p>.. deprecated:: 1.18</p>
+<p><code>ppmt</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>rate : array_like  Rate of interest (per period) per : array_like, int  Amount paid against the loan changes. The <code>per</code> is the period of  interest. nper : array_like  Number of compounding periods pv : array_like  Present value fv : array_like, optional  Future value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}  When payments are due (‘begin’ (1) or ‘end’ (0))</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>pmt, pv, ipmt</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8912">view source</a></div></div><div class="public anchor" id="var-print_function"><h3>print_function</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18036">view source</a></div></div><div class="public anchor" id="var-printoptions"><h3>printoptions</h3><div class="usage"><code>(printoptions &amp; [args {:as kwds}])</code></div><div class="doc"><div class="markdown"><p>Context manager for setting print options.</p>
+<p>Set print options for the scope of the <code>with</code> block, and restore the old options at the end. See <code>set_printoptions</code> for the full description of available options.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from numpy.testing import assert_equal with np.printoptions(precision=2): … np.array([2.0]) / 3 array([0.67])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The <code>as</code>-clause of the <code>with</code>-statement gives the current print options:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>with np.printoptions(precision=2) as opts: … assert_equal(opts, np.get_printoptions())</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>set_printoptions, get_printoptions</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20105">view source</a></div></div><div class="public anchor" id="var-prod"><h3>prod</h3><div class="usage"><code>(prod &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the product of array elements over a given axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  Axis or axes along which a product is performed. The default,  axis=None, will calculate the product of all the elements in the  input array. If axis is negative it counts from the last to the  first axis.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If axis is a tuple of ints, a product is performed on all of the
+axes specified in the tuple instead of a single axis or all the
+axes as before.
+</code></pre>
+<p>dtype : dtype, optional  The type of the returned array, as well as of the accumulator in  which the elements are multiplied. The dtype of <code>a</code> is used by  default unless <code>a</code> has an integer dtype of less precision than the  default platform integer. In that case, if <code>a</code> is signed then the  platform integer is used while if <code>a</code> is unsigned then an unsigned  integer of the same precision as the platform integer is used. out : ndarray, optional  Alternative output array in which to place the result. It must have  the same shape as the expected output, but the type of the output  values will be cast if necessary. keepdims : bool, optional  If this is set to True, the axes which are reduced are left in the  result as dimensions with size one. With this option, the result  will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `prod` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<p>initial : scalar, optional  The starting value for this product. See <code>~numpy.ufunc.reduce</code> for details.</p>
+<pre><code>.. versionadded:: 1.15.0
+</code></pre>
+<p>where : array_like of bool, optional  Elements to include in the product. See <code>~numpy.ufunc.reduce</code> for details.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>product_along_axis : ndarray, see <code>dtype</code> parameter above.  An array shaped as <code>a</code> but with the specified axis removed.  Returns a reference to <code>out</code> if specified.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.prod : equivalent method ufuncs-output-type</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Arithmetic is modular when using integer types, and no error is raised on overflow. That means that, on a 32-bit platform:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([536870910, 536870910, 536870910, 536870910]) np.prod(x) 16 # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The product of an empty array is the neutral element 1:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.prod([]) 1.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>By default, calculate the product of all elements:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.prod([1.,2.]) 2.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Even when the input array is two-dimensional:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.prod(<a href="null">1.,2.],[3.,4.</a>) 24.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>But we can also specify the axis over which to multiply:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.prod(<a href="null">1.,2.],[3.,4.</a>, axis=1) array([ 2., 12.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Or select specific elements to include:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.prod([1., np.nan, 3.], where=[True, False, True]) 3.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>If the type of <code>x</code> is unsigned, then the output type is the unsigned platform integer:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([1, 2, 3], dtype=np.uint8) np.prod(x).dtype == np.uint True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>If <code>x</code> is of a signed integer type, then the output type is the default platform integer:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([1, 2, 3], dtype=np.int8) np.prod(x).dtype == int True</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>You can also start the product with a value other than one:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.prod([1, 2], initial=5) 10</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7242">view source</a></div></div><div class="public anchor" id="var-product"><h3>product</h3><div class="usage"><code>(product &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the product of array elements over a given axis.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>prod : equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13517">view source</a></div></div><div class="public anchor" id="var-promote_types"><h3>promote_types</h3><div class="usage"><code>(promote_types self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>promote_types(type1, type2)</p>
+<p>Returns the data type with the smallest size and smallest scalar kind to which both <code>type1</code> and <code>type2</code> may be safely cast. The returned data type is always in native byte order.</p>
+<p>This function is symmetric, but rarely associative.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>type1 : dtype or dtype specifier  First data type. type2 : dtype or dtype specifier  Second data type.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : dtype  The promoted data type.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.6.0</p>
+<p>Starting in NumPy 1.9, promote_types function now returns a valid string length when given an integer or float dtype as one argument and a string dtype as another argument. Previously it always returned the input string dtype, even if it wasn’t long enough to store the max integer/float value converted to a string.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>result_type, dtype, can_cast</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.promote_types(‘f4’, ‘f8’) dtype(‘float64’)</p>
+      <p>np.promote_types(‘i8’, ‘f4’) dtype(‘float64’)</p>
+      <p>np.promote_types(‘&gt;i8’, ‘&lt;c8’) dtype(‘complex128’)</p>
+      <p>np.promote_types(‘i4’, ‘S8’) dtype(‘S11’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>An example of a non-associative case:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>p = np.promote_types p(‘S’, p(‘i1’, ‘u1’)) dtype(‘S6’) p(p(‘S’, ‘i1’), ‘u1’) dtype(‘S4’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20195">view source</a></div></div><div class="public anchor" id="var-ptp"><h3>ptp</h3><div class="usage"><code>(ptp &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Range of values (maximum - minimum) along an axis.</p>
+<p>The name of the function comes from the acronym for ‘peak to peak’.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input values. axis : None or int or tuple of ints, optional  Axis along which to find the peaks. By default, flatten the  array. <code>axis</code> may be negative, in  which case it counts from the last to the first axis.</p>
+<pre><code>.. versionadded:: 1.15.0
+
+If this is a tuple of ints, a reduction is performed on multiple
+axes, instead of a single axis or all the axes as before.
+</code></pre>
+<p>out : array_like  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type of the output values will be cast if necessary.</p>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `ptp` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>ptp : ndarray  A new array holding the result, unless <code>out</code> was  specified, in which case a reference to <code>out</code> is returned.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(4).reshape((2,2)) x array(<a href="null">0, 1],
+       [2, 3</a>)</p>
+      <p>np.ptp(x, axis=0) array([2, 2])</p>
+      <p>np.ptp(x, axis=1) array([1, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13531">view source</a></div></div><div class="public anchor" id="var-put"><h3>put</h3><div class="usage"><code>(put &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Replaces specified elements of an array with given values.</p>
+<p>The indexing works on the flattened target array. <code>put</code> is roughly equivalent to:</p>
+<p>::</p>
+<pre><code>a.flat[ind] = v
+</code></pre>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : ndarray  Target array. ind : array_like  Target indices, interpreted as integers. v : array_like  Values to place in <code>a</code> at target indices. If <code>v</code> is shorter than  <code>ind</code> it will be repeated as necessary. mode : {‘raise’, ‘wrap’, ‘clip’}, optional  Specifies how out-of-bounds indices will behave.</p>
+<pre><code>* 'raise' -- raise an error (default)
+* 'wrap' -- wrap around
+* 'clip' -- clip to the range
+
+'clip' mode means that all indices that are too large are replaced
+by the index that addresses the last element along that axis. Note
+that this disables indexing with negative numbers. In 'raise' mode,
+if an exception occurs the target array may still be modified.
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>putmask, place put_along_axis : Put elements by matching the array and the index arrays</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(5) np.put(a, [0, 2], [-44, -55]) a array([-44, 1, -55, 3, 4])</p>
+      <p>a = np.arange(5) np.put(a, 22, -5, mode=‘clip’) a array([ 0, 1, 2, 3, -5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6011">view source</a></div></div><div class="public anchor" id="var-put_along_axis"><h3>put_along_axis</h3><div class="usage"><code>(put_along_axis &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Put values into the destination array by matching 1d index and data slices.</p>
+<p>This iterates over matching 1d slices oriented along the specified axis in the index and data arrays, and uses the former to place values into the latter. These slices can be different lengths.</p>
+<p>Functions returning an index along an axis, like <code>argsort</code> and <code>argpartition</code>, produce suitable indices for this function.</p>
+<p>.. versionadded:: 1.15.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr: ndarray (Ni…, M, Nk…)  Destination array. indices: ndarray (Ni…, J, Nk…)  Indices to change along each 1d slice of <code>arr</code>. This must match the  dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast  against <code>arr</code>. values: array_like (Ni…, J, Nk…)  values to insert at those indices. Its shape and dimension are  broadcast to match that of <code>indices</code>. axis: int  The axis to take 1d slices along. If axis is None, the destination  array is treated as if a flattened 1d view had been created of it.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This is equivalent to (but faster than) the following use of <code>ndindex</code> and <code>s_</code>, which sets each of <code>ii</code> and <code>kk</code> to a tuple of indices::</p>
+<pre><code>Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
+J = indices.shape[axis]  # Need not equal M
+
+for ii in ndindex(Ni):
+    for kk in ndindex(Nk):
+        a_1d       = a      [ii + s_[:,] + kk]
+        indices_1d = indices[ii + s_[:,] + kk]
+        values_1d  = values [ii + s_[:,] + kk]
+        for j in range(J):
+            a_1d[indices_1d[j]] = values_1d[j]
+</code></pre>
+<p>Equivalently, eliminating the inner loop, the last two lines would be::</p>
+<pre><code>        a_1d[indices_1d] = values_1d
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>take_along_axis :  Take values from the input array by matching 1d index and data slices</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>For this sample array</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">10, 30, 20], [60, 40, 50</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>We can replace the maximum values with:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>ai = np.expand_dims(np.argmax(a, axis=1), axis=1) ai array(<a href="null">1],
+       [0</a>) np.put_along_axis(a, ai, 99, axis=1) a array(<a href="null">10, 99, 20],
+       [99, 40, 50</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4258">view source</a></div></div><div class="public anchor" id="var-putmask"><h3>putmask</h3><div class="usage"><code>(putmask &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>putmask(a, mask, values)</p>
+<p>Changes elements of an array based on conditional and input values.</p>
+<p>Sets <code>a.flat[n] = values[n]</code> for each n where <code>mask.flat[n]==True</code>.</p>
+<p>If <code>values</code> is not the same size as <code>a</code> and <code>mask</code> then it will repeat. This gives behavior different from <code>a[mask] = values</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Target array. mask : array_like  Boolean mask array. It has to be the same shape as <code>a</code>. values : array_like  Values to put into <code>a</code> where <code>mask</code> is True. If <code>values</code> is smaller  than <code>a</code> it will be repeated.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>place, put, take, copyto</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(6).reshape(2, 3) np.putmask(x, x&gt;2, x**2) x array(<a href="null"> 0,  1,  2],
+       [ 9, 16, 25</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>If <code>values</code> is smaller than <code>a</code> it is repeated:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(5) np.putmask(x, x&gt;1, [-33, -44]) x array([ 0, 1, -33, -44, -33])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11683">view source</a></div></div><div class="public anchor" id="var-pv"><h3>pv</h3><div class="usage"><code>(pv &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the present value.</p>
+<p>.. deprecated:: 1.18</p>
+<p><code>pv</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
+<p>Given:  * a future value, <code>fv</code>  * an interest <code>rate</code> compounded once per period, of which  there are  * <code>nper</code> total  * a (fixed) payment, <code>pmt</code>, paid either  * at the beginning (<code>when</code> = {‘begin’, 1}) or the end  (<code>when</code> = {‘end’, 0}) of each period</p>
+<p>Return:  the value now</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>rate : array_like  Rate of interest (per period) nper : array_like  Number of compounding periods pmt : array_like  Payment fv : array_like, optional  Future value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}, optional  When payments are due (‘begin’ (1) or ‘end’ (0))</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray, float  Present value of a series of payments or investments.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The present value is computed by solving the equation::</p>
+<p>fv +  pv*(1 + rate)**nper +  pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) = 0</p>
+<p>or, when <code>rate = 0</code>::</p>
+<p>fv + pv + pmt * nper = 0</p>
+<p>for <code>pv</code>, which is then returned.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).  Open Document Format for Office Applications (OpenDocument)v1.2,  Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,  Pre-Draft 12. Organization for the Advancement of Structured Information  Standards (OASIS). Billerica, MA, USA. [ODT Document].  Available:  <a href="http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula">http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula</a>  OpenDocument-formula-20090508.odt</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>What is the present value (e.g., the initial investment) of an investment that needs to total $15692.93 after 10 years of saving $100 every month? Assume the interest rate is 5% (annually) compounded monthly.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.pv(0.05/12, 10*12, -100, 15692.93) -100.00067131625819</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>By convention, the negative sign represents cash flow out (i.e., money not available today). Thus, to end up with $15,692.93 in 10 years saving $100 a month at 5% annual interest, one’s initial deposit should also be $100.</p>
+<p>If any input is array_like, <code>pv</code> returns an array of equal shape. Let’s compare different interest rates in the example above:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array((0.05, 0.04, 0.03))/12 np.pv(a, 10*12, -100, 15692.93) array([ -100.00067132, -649.26771385, -1273.78633713]) # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>So, to end up with the same $15692.93 under the same $100 per month “savings plan,” for annual interest rates of 4% and 3%, one would need initial investments of $649.27 and $1273.79, respectively.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27207">view source</a></div></div><div class="public anchor" id="var-PZERO"><h3>PZERO</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9544">view source</a></div></div><div class="public anchor" id="var-quantile"><h3>quantile</h3><div class="usage"><code>(quantile &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the q-th quantile of the data along the specified axis.</p>
+<p>.. versionadded:: 1.15.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array or object that can be converted to an array. q : array_like of float  Quantile or sequence of quantiles to compute, which must be between  0 and 1 inclusive. axis : {int, tuple of int, None}, optional  Axis or axes along which the quantiles are computed. The  default is to compute the quantile(s) along a flattened  version of the array. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow the input array <code>a</code> to be modified by intermediate  calculations, to save memory. In this case, the contents of the input  <code>a</code> after this function completes is undefined. interpolation : {‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}  This optional parameter specifies the interpolation method to  use when the desired quantile lies between two data points  <code>i &lt; j</code>:</p>
+<pre><code>    * linear: ``i + (j - i) * fraction``, where ``fraction``
+      is the fractional part of the index surrounded by ``i``
+      and ``j``.
+    * lower: ``i``.
+    * higher: ``j``.
+    * nearest: ``i`` or ``j``, whichever is nearest.
+    * midpoint: ``(i + j) / 2``.
+</code></pre>
+<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left in  the result as dimensions with size one. With this option, the  result will broadcast correctly against the original array <code>a</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>quantile : scalar or ndarray  If <code>q</code> is a single quantile and <code>axis=None</code>, then the result  is a scalar. If multiple quantiles are given, first axis of  the result corresponds to the quantiles. The other axes are  the axes that remain after the reduction of <code>a</code>. If the input  contains integers or floats smaller than <code>float64</code>, the output  data-type is <code>float64</code>. Otherwise, the output data-type is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>mean percentile : equivalent to quantile, but with q in the range [0, 100]. median : equivalent to <code>quantile(..., 0.5)</code> nanquantile</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Given a vector <code>V</code> of length <code>N</code>, the q-th quantile of <code>V</code> is the value <code>q</code> of the way from the minimum to the maximum in a sorted copy of <code>V</code>. The values and distances of the two nearest neighbors as well as the <code>interpolation</code> parameter will determine the quantile if the normalized ranking does not match the location of <code>q</code> exactly. This function is the same as the median if <code>q=0.5</code>, the same as the minimum if <code>q=0.0</code> and the same as the maximum if <code>q=1.0</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">10, 7, 4], [3, 2, 1</a>) a array(<a href="null">10,  7,  4],
+       [ 3,  2,  1</a>) np.quantile(a, 0.5) 3.5 np.quantile(a, 0.5, axis=0) array([6.5, 4.5, 2.5]) np.quantile(a, 0.5, axis=1) array([7., 2.]) np.quantile(a, 0.5, axis=1, keepdims=True) array(<a href="null">7.],
+       [2.</a>) m = np.quantile(a, 0.5, axis=0) out = np.zeros_like(m) np.quantile(a, 0.5, axis=0, out=out) array([6.5, 4.5, 2.5]) m array([6.5, 4.5, 2.5]) b = a.copy() np.quantile(b, 0.5, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a == b)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12254">view source</a></div></div><div class="public anchor" id="var-r_"><h3>r_</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Translates slice objects to concatenation along the first axis.</p>
+<p>This is a simple way to build up arrays quickly. There are two use cases.</p>
+<ol>
+  <li>If the index expression contains comma separated arrays, then stack  them along their first axis.</li>
+  <li>If the index expression contains slice notation or scalars then create  a 1-D array with a range indicated by the slice notation.</li>
+</ol>
+<p>If slice notation is used, the syntax <code>start:stop:step</code> is equivalent to <code>np.arange(start, stop, step)</code> inside of the brackets. However, if <code>step</code> is an imaginary number (i.e. 100j) then its integer portion is interpreted as a number-of-points desired and the start and stop are inclusive. In other words <code>start:stop:stepj</code> is interpreted as <code>np.linspace(start, stop, step, endpoint=1)</code> inside of the brackets. After expansion of slice notation, all comma separated sequences are concatenated together.</p>
+<p>Optional character strings placed as the first element of the index expression can be used to change the output. The strings ‘r’ or ‘c’ result in matrix output. If the result is 1-D and ‘r’ is specified a 1 x N (row) matrix is produced. If the result is 1-D and ‘c’ is specified, then a N x 1 (column) matrix is produced. If the result is 2-D then both provide the same matrix result.</p>
+<p>A string integer specifies which axis to stack multiple comma separated arrays along. A string of two comma-separated integers allows indication of the minimum number of dimensions to force each entry into as the second integer (the axis to concatenate along is still the first integer).</p>
+<p>A string with three comma-separated integers allows specification of the axis to concatenate along, the minimum number of dimensions to force the entries to, and which axis should contain the start of the arrays which are less than the specified number of dimensions. In other words the third integer allows you to specify where the 1‘s should be placed in the shape of the arrays that have their shapes upgraded. By default, they are placed in the front of the shape tuple. The third argument allows you to specify where the start of the array should be instead. Thus, a third argument of ‘0’ would place the 1‘s at the end of the array shape. Negative integers specify where in the new shape tuple the last dimension of upgraded arrays should be placed, so the default is ’-1’.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>Not a function, so takes no parameters</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>A concatenated ndarray or matrix.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>concatenate : Join a sequence of arrays along an existing axis. c_ : Translates slice objects to concatenation along the second axis.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.r_[np.array([1,2,3]), 0, 0, np.array([4,5,6])] array([1, 2, 3, …, 4, 5, 6]) np.r_[-1:1:6j, [0]*3, 5, 6] array([-1. , -0.6, -0.2, 0.2, 0.6, 1. , 0. , 0. , 0. , 5. , 6. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>String integers specify the axis to concatenate along or the minimum number of dimensions to force entries into.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">0, 1, 2], [3, 4, 5</a>) np.r_[‘-1’, a, a] # concatenate along last axis array(<a href="null">0, 1, 2, 0, 1, 2],
+       [3, 4, 5, 3, 4, 5</a>) np.r_[‘0,2’, [1,2,3], [4,5,6]] # concatenate along first axis, dim&gt;=2 array(<a href="null">1, 2, 3],
+       [4, 5, 6</a>)</p>
+      <p>np.r_[‘0,2,0’, [1,2,3], [4,5,6]] array(<a href="null">1],
+       [2],
+       [3],
+       [4],
+       [5],
+       [6</a>) np.r_[‘1,2,0’, [1,2,3], [4,5,6]] array(<a href="null">1, 4],
+       [2, 5],
+       [3, 6</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using ‘r’ or ‘c’ as a first string argument creates a matrix.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.r_[‘r’,[1,2,3], [4,5,6]] matrix(<a href="null">1, 2, 3, 4, 5, 6</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2615">view source</a></div></div><div class="public anchor" id="var-rad2deg"><h3>rad2deg</h3><div class="usage"><code>(rad2deg self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>rad2deg(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Convert angles from radians to degrees.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Angle in radians. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The corresponding angle in degrees.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>deg2rad : Convert angles from degrees to radians. unwrap : Remove large jumps in angle by wrapping.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.3.0</p>
+<p>rad2deg(x) is <code>180 * x / pi</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.rad2deg(np.pi/2) 90.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6268">view source</a></div></div><div class="public anchor" id="var-radians"><h3>radians</h3><div class="usage"><code>(radians self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>radians(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Convert angles from degrees to radians.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array in degrees. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The corresponding radian values.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>deg2rad : equivalent function</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Convert a degree array to radians</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>deg = np.arange(12.) * 30. np.radians(deg) array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 ,  2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898,  5.23598776, 5.75958653])</p>
+      <p>out = np.zeros((deg.shape)) ret = np.radians(deg, out) ret is out True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15574">view source</a></div></div><div class="public anchor" id="var-RAISE"><h3>RAISE</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8772">view source</a></div></div><div class="public anchor" id="var-random"><h3>random</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>========================</p>
+<h1><a href="#random-number-generation" name="random-number-generation"></a>Random Number Generation</h1>
+<p>Use <code>default_rng()</code> to create a <code>Generator</code> and call its methods.</p>
+<p>=============== ========================================================= Generator ————— ——————————————————— Generator Class implementing all of the random number distributions default_rng Default constructor for <code>Generator</code> =============== =========================================================</p>
+<p>============================================= === BitGenerator Streams that work with Generator ——————————————— — MT19937 PCG64 Philox SFC64 ============================================= ===</p>
+<p>============================================= === Getting entropy to initialize a BitGenerator ——————————————— — SeedSequence ============================================= ===</p>
+<h2><a href="#legacy" name="legacy"></a>Legacy</h2>
+<p>For backwards compatibility with previous versions of numpy before 1.17, the various aliases to the global <code>RandomState</code> methods are left alone and do not use the new <code>Generator</code> API.</p>
+<p>==================== ========================================================= Utility functions ——————– ——————————————————— random Uniformly distributed floats over <code>[0, 1)</code> bytes Uniformly distributed random bytes. permutation Randomly permute a sequence / generate a random sequence. shuffle Randomly permute a sequence in place. choice Random sample from 1-D array. ==================== =========================================================</p>
+<p>==================== ========================================================= Compatibility functions - removed in the new API ——————– ——————————————————— rand Uniformly distributed values. randn Normally distributed values. ranf Uniformly distributed floating point numbers. random_integers Uniformly distributed integers in a given range.  (deprecated, use <code>integers(..., closed=True)</code> instead) random_sample Alias for <code>random_sample</code> randint Uniformly distributed integers in a given range seed Seed the legacy random number generator. ==================== =========================================================</p>
+<p>==================== ========================================================= Univariate distributions ——————– ——————————————————— beta Beta distribution over <code>[0, 1]</code>. binomial Binomial distribution. chisquare :math:<code>\chi^2</code> distribution. exponential Exponential distribution. f F (Fisher-Snedecor) distribution. gamma Gamma distribution. geometric Geometric distribution. gumbel Gumbel distribution. hypergeometric Hypergeometric distribution. laplace Laplace distribution. logistic Logistic distribution. lognormal Log-normal distribution. logseries Logarithmic series distribution. negative_binomial Negative binomial distribution. noncentral_chisquare Non-central chi-square distribution. noncentral_f Non-central F distribution. normal Normal / Gaussian distribution. pareto Pareto distribution. poisson Poisson distribution. power Power distribution. rayleigh Rayleigh distribution. triangular Triangular distribution. uniform Uniform distribution. vonmises Von Mises circular distribution. wald Wald (inverse Gaussian) distribution. weibull Weibull distribution. zipf Zipf’s distribution over ranked data. ==================== =========================================================</p>
+<p>==================== ========================================================== Multivariate distributions ——————– ———————————————————- dirichlet Multivariate generalization of Beta distribution. multinomial Multivariate generalization of the binomial distribution. multivariate_normal Multivariate generalization of the normal distribution. ==================== ==========================================================</p>
+<p>==================== ========================================================= Standard distributions ——————– ——————————————————— standard_cauchy Standard Cauchy-Lorentz distribution. standard_exponential Standard exponential distribution. standard_gamma Standard Gamma distribution. standard_normal Standard normal distribution. standard_t Standard Student’s t-distribution. ==================== =========================================================</p>
+<p>==================== ========================================================= Internal functions ——————– ——————————————————— get_state Get tuple representing internal state of generator. set_state Set state of generator. ==================== =========================================================</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1248">view source</a></div></div><div class="public anchor" id="var-RankWarning"><h3>RankWarning</h3><div class="usage"><code>(RankWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Issued by <code>polyfit</code> when the Vandermonde matrix is rank deficient.</p>
+<p>For more information, a way to suppress the warning, and an example of <code>RankWarning</code> being issued, see <code>polyfit</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2544">view source</a></div></div><div class="public anchor" id="var-rate"><h3>rate</h3><div class="usage"><code>(rate &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the rate of interest per period.</p>
+<p>.. deprecated:: 1.18</p>
+<p><code>rate</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>nper : array_like  Number of compounding periods pmt : array_like  Payment pv : array_like  Present value fv : array_like  Future value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}, optional  When payments are due (‘begin’ (1) or ‘end’ (0)) guess : Number, optional  Starting guess for solving the rate of interest, default 0.1 tol : Number, optional  Required tolerance for the solution, default 1e-6 maxiter : int, optional  Maximum iterations in finding the solution</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The rate of interest is computed by iteratively solving the (non-linear) equation::</p>
+<p>fv + pv*(1+rate)**nper + pmt*(1+rate*when)/rate * ((1+rate)**nper - 1) = 0</p>
+<p>for <code>rate</code>.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).  Open Document Format for Office Applications (OpenDocument)v1.2,  Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,  Pre-Draft 12. Organization for the Advancement of Structured Information  Standards (OASIS). Billerica, MA, USA. [ODT Document].  Available:  <a href="http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula">http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula</a>  OpenDocument-formula-20090508.odt</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15098">view source</a></div></div><div class="public anchor" id="var-ravel"><h3>ravel</h3><div class="usage"><code>(ravel &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a contiguous flattened array.</p>
+<p>A 1-D array, containing the elements of the input, is returned. A copy is made only if needed.</p>
+<p>As of NumPy 1.10, the returned array will have the same type as the input array. (for example, a masked array will be returned for a masked array input)</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. The elements in <code>a</code> are read in the order specified by  <code>order</code>, and packed as a 1-D array. order : {‘C’,‘F’, ‘A’, ‘K’}, optional</p>
+<pre><code>The elements of `a` are read using this index order. 'C' means
+to index the elements in row-major, C-style order,
+with the last axis index changing fastest, back to the first
+axis index changing slowest.  'F' means to index the elements
+in column-major, Fortran-style order, with the
+first index changing fastest, and the last index changing
+slowest. Note that the 'C' and 'F' options take no account of
+the memory layout of the underlying array, and only refer to
+the order of axis indexing.  'A' means to read the elements in
+Fortran-like index order if `a` is Fortran *contiguous* in
+memory, C-like order otherwise.  'K' means to read the
+elements in the order they occur in memory, except for
+reversing the data when strides are negative.  By default, 'C'
+index order is used.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : array_like  y is an array of the same subtype as <code>a</code>, with shape <code>(a.size,)</code>.  Note that matrices are special cased for backward compatibility, if <code>a</code>  is a matrix, then y is a 1-D ndarray.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.flat : 1-D iterator over an array. ndarray.flatten : 1-D array copy of the elements of an array  in row-major order. ndarray.reshape : Change the shape of an array without changing its data.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>In row-major, C-style order, in two dimensions, the row index varies the slowest, and the column index the quickest. This can be generalized to multiple dimensions, where row-major order implies that the index along the first axis varies slowest, and the index along the last quickest. The opposite holds for column-major, Fortran-style index ordering.</p>
+<p>When a view is desired in as many cases as possible, <code>arr.reshape(-1)</code> may be preferable.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>It is equivalent to <code>reshape(-1, order=order)</code>.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">1, 2, 3], [4, 5, 6</a>) np.ravel(x) array([1, 2, 3, 4, 5, 6])</p>
+      <p>x.reshape(-1) array([1, 2, 3, 4, 5, 6])</p>
+      <p>np.ravel(x, order=‘F’) array([1, 4, 2, 5, 3, 6])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>When <code>order</code> is ‘A’, it will preserve the array’s ‘C’ or ‘F’ ordering:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.ravel(x.T) array([1, 4, 2, 5, 3, 6]) np.ravel(x.T, order=‘A’) array([1, 2, 3, 4, 5, 6])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>When <code>order</code> is ‘K’, it will preserve orderings that are neither ‘C’ nor ‘F’, but won’t reverse axes:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(3)[::-1]; a array([2, 1, 0]) a.ravel(order=‘C’) array([2, 1, 0]) a.ravel(order=‘K’) array([2, 1, 0])</p>
+      <p>a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a array(<a href="null">[ 0,  2,  4],
+        [ 1,  3,  5</a>,  <a href="null"> 6,  8, 10],
+        [ 7,  9, 11</a>]) a.ravel(order=‘C’) array([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11]) a.ravel(order=‘K’) array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17704">view source</a></div></div><div class="public anchor" id="var-ravel_multi_index"><h3>ravel_multi_index</h3><div class="usage"><code>(ravel_multi_index &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>ravel_multi_index(multi_index, dims, mode=‘raise’, order=‘C’)</p>
+<p>Converts a tuple of index arrays into an array of flat indices, applying boundary modes to the multi-index.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>multi_index : tuple of array_like  A tuple of integer arrays, one array for each dimension. dims : tuple of ints  The shape of array into which the indices from <code>multi_index</code> apply. mode : {‘raise’, ‘wrap’, ‘clip’}, optional  Specifies how out-of-bounds indices are handled. Can specify  either one mode or a tuple of modes, one mode per index.</p>
+<pre><code>* 'raise' -- raise an error (default)
+* 'wrap' -- wrap around
+* 'clip' -- clip to the range
+
+In 'clip' mode, a negative index which would normally
+wrap will clip to 0 instead.
+</code></pre>
+<p>order : {‘C’, ‘F’}, optional  Determines whether the multi-index should be viewed as  indexing in row-major (C-style) or column-major  (Fortran-style) order.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>raveled_indices : ndarray  An array of indices into the flattened version of an array  of dimensions <code>dims</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>unravel_index</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.6.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>arr = np.array(<a href="null">3,6,6],[4,5,1</a>) np.ravel_multi_index(arr, (7,6)) array([22, 41, 37]) np.ravel_multi_index(arr, (7,6), order=‘F’) array([31, 41, 13]) np.ravel_multi_index(arr, (4,6), mode=‘clip’) array([22, 23, 19]) np.ravel_multi_index(arr, (4,4), mode=(‘clip’,‘wrap’)) array([12, 13, 13])</p>
+      <p>np.ravel_multi_index((3,1,4,1), (6,7,8,9)) 1621</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L82">view source</a></div></div><div class="public anchor" id="var-real"><h3>real</h3><div class="usage"><code>(real &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the real part of the complex argument.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>val : array_like  Input array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  The real component of the complex argument. If <code>val</code> is real, the type  of <code>val</code> is used for the output. If <code>val</code> has complex elements, the  returned type is float.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>real_if_close, imag, angle</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1+2j, 3+4j, 5+6j]) a.real array([1., 3., 5.]) a.real = 9 a array([9.+2.j, 9.+4.j, 9.+6.j]) a.real = np.array([9, 8, 7]) a array([9.+2.j, 8.+4.j, 7.+6.j]) np.real(1 + 1j) 1.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15246">view source</a></div></div><div class="public anchor" id="var-real_if_close"><h3>real_if_close</h3><div class="usage"><code>(real_if_close &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>If complex input returns a real array if complex parts are close to zero.</p>
+<p>“Close to zero” is defined as <code>tol</code> * (machine epsilon of the type for <code>a</code>).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. tol : float  Tolerance in machine epsilons for the complex part of the elements  in the array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  If <code>a</code> is real, the type of <code>a</code> is used for the output. If <code>a</code>  has complex elements, the returned type is float.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>real, imag, angle</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Machine epsilon varies from machine to machine and between data types but Python floats on most platforms have a machine epsilon equal to 2.2204460492503131e-16. You can use ‘np.finfo(float).eps’ to print out the machine epsilon for floats.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.finfo(float).eps 2.2204460492503131e-16 # may vary</p>
+      <p>np.real_if_close([2.1 + 4e-14j], tol=1000) array([2.1]) np.real_if_close([2.1 + 4e-13j], tol=1000) array([2.1+4.e-13j])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6318">view source</a></div></div><div class="public anchor" id="var-rec"><h3>rec</h3><div class="usage"></div><div class="doc"><div class="markdown"><h1><a href="#record-arrays" name="record-arrays"></a>Record Arrays</h1>
+<p>Record arrays expose the fields of structured arrays as properties.</p>
+<p>Most commonly, ndarrays contain elements of a single type, e.g. floats, integers, bools etc. However, it is possible for elements to be combinations of these using structured types, such as::</p>
+<p>&gt;&gt;&gt; a = np.array([(1, 2.0), (1, 2.0)], dtype=[(‘x’, np.int64), (‘y’, np.float64)])  &gt;&gt;&gt; a  array([(1, 2.), (1, 2.)], dtype=[(‘x’, ‘&lt;i8’), (‘y’, ‘&lt;f8’)])</p>
+<p>Here, each element consists of two fields: x (and int), and y (a float). This is known as a structured array. The different fields are analogous to columns in a spread-sheet. The different fields can be accessed as one would a dictionary::</p>
+<p>&gt;&gt;&gt; a[‘x’]  array([1, 1])</p>
+<p>&gt;&gt;&gt; a[‘y’]  array([2., 2.])</p>
+<p>Record arrays allow us to access fields as properties::</p>
+<p>&gt;&gt;&gt; ar = np.rec.array(a)</p>
+<p>&gt;&gt;&gt; ar.x  array([1, 1])</p>
+<p>&gt;&gt;&gt; ar.y  array([2., 2.])</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25729">view source</a></div></div><div class="public anchor" id="var-recarray"><h3>recarray</h3><div class="usage"><code>(recarray self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Construct an ndarray that allows field access using attributes.</p>
+<p>Arrays may have a data-types containing fields, analogous to columns in a spread sheet. An example is <code>[(x, int), (y, float)]</code>, where each entry in the array is a pair of <code>(int, float)</code>. Normally, these attributes are accessed using dictionary lookups such as <code>arr['x']</code> and <code>arr['y']</code>. Record arrays allow the fields to be accessed as members of the array, using <code>arr.x</code> and <code>arr.y</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>shape : tuple  Shape of output array. dtype : data-type, optional  The desired data-type. By default, the data-type is determined  from <code>formats</code>, <code>names</code>, <code>titles</code>, <code>aligned</code> and <code>byteorder</code>. formats : list of data-types, optional  A list containing the data-types for the different columns, e.g.  <code>['i4', 'f8', 'i4']</code>. <code>formats</code> does <em>not</em> support the new  convention of using types directly, i.e. <code>(int, float, int)</code>.  Note that <code>formats</code> must be a list, not a tuple.  Given that <code>formats</code> is somewhat limited, we recommend specifying  <code>dtype</code> instead. names : tuple of str, optional  The name of each column, e.g. <code>('x', 'y', 'z')</code>. buf : buffer, optional  By default, a new array is created of the given shape and data-type.  If <code>buf</code> is specified and is an object exposing the buffer interface,  the array will use the memory from the existing buffer. In this case,  the <code>offset</code> and <code>strides</code> keywords are available.</p>
+<h2><a href="#other-parameters" name="other-parameters"></a>Other Parameters</h2>
+<p>titles : tuple of str, optional  Aliases for column names. For example, if <code>names</code> were  <code>('x', 'y', 'z')</code> and <code>titles</code> is  <code>('x_coordinate', 'y_coordinate', 'z_coordinate')</code>, then  <code>arr['x']</code> is equivalent to both <code>arr.x</code> and <code>arr.x_coordinate</code>. byteorder : {‘&lt;’, ‘&gt;’, ‘=’}, optional  Byte-order for all fields. aligned : bool, optional  Align the fields in memory as the C-compiler would. strides : tuple of ints, optional  Buffer (<code>buf</code>) is interpreted according to these strides (strides  define how many bytes each array element, row, column, etc.  occupy in memory). offset : int, optional  Start reading buffer (<code>buf</code>) from this offset onwards. order : {‘C’, ‘F’}, optional  Row-major (C-style) or column-major (Fortran-style) order.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>rec : recarray  Empty array of the given shape and type.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>rec.fromrecords : Construct a record array from data. record : fundamental data-type for <code>recarray</code>. format_parser : determine a data-type from formats, names, titles.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This constructor can be compared to <code>empty</code>: it creates a new record array but does not fill it with data. To create a record array from data, use one of the following methods:</p>
+<ol>
+  <li>Create a standard ndarray and convert it to a record array,  using <code>arr.view(np.recarray)</code></li>
+  <li>Use the <code>buf</code> keyword.</li>
+  <li>Use <code>np.rec.fromrecords</code>.</li>
+</ol>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Create an array with two fields, <code>x</code> and <code>y</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([(1.0, 2), (3.0, 4)], dtype=[(‘x’, ‘&lt;f8’), (‘y’, ‘&lt;i8’)]) x array([(1., 2), (3., 4)], dtype=[(‘x’, ‘&lt;f8’), (‘y’, ‘&lt;i8’)])</p>
+      <p>x[‘x’] array([1., 3.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>View the array as a record array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = x.view(np.recarray)</p>
+      <p>x.x array([1., 3.])</p>
+      <p>x.y array([2, 4])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Create a new, empty record array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.recarray((2,), … dtype=[(‘x’, int), (‘y’, float), (‘z’, int)]) #doctest: +SKIP rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),  (3471280, 1.2134086255804012e-316, 0)],  dtype=[(‘x’, ‘&lt;i4’), (‘y’, ‘&lt;f8’), (‘z’, ‘&lt;i4’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19072">view source</a></div></div><div class="public anchor" id="var-recfromcsv"><h3>recfromcsv</h3><div class="usage"><code>(recfromcsv fname &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Load ASCII data stored in a comma-separated file.</p>
+<p>The returned array is a record array (if <code>usemask=False</code>, see <code>recarray</code>) or a masked record array (if <code>usemask=True</code>, see <code>ma.mrecords.MaskedRecords</code>).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>fname, kwargs : For a description of input parameters, see <code>genfromtxt</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.genfromtxt : generic function to load ASCII data.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>By default, <code>dtype</code> is None, which means that the data-type of the output array will be determined from the data.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L358">view source</a></div></div><div class="public anchor" id="var-recfromtxt"><h3>recfromtxt</h3><div class="usage"><code>(recfromtxt fname &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Load ASCII data from a file and return it in a record array.</p>
+<p>If <code>usemask=False</code> a standard <code>recarray</code> is returned, if <code>usemask=True</code> a MaskedRecords array is returned.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>fname, kwargs : For a description of input parameters, see <code>genfromtxt</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.genfromtxt : generic function</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>By default, <code>dtype</code> is None, which means that the data-type of the output array will be determined from the data.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17307">view source</a></div></div><div class="public anchor" id="var-reciprocal"><h3>reciprocal</h3><div class="usage"><code>(reciprocal self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>reciprocal(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the reciprocal of the argument, element-wise.</p>
+<p>Calculates <code>1/x</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  Return array.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. note::  This function is not designed to work with integers.</p>
+<p>For integer arguments with absolute value larger than 1 the result is always zero because of the way Python handles integer division. For integer zero the result is an overflow.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.reciprocal(2.) 0.5 np.reciprocal([1, 2., 3.33]) array([ 1. , 0.5 , 0.3003003])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10308">view source</a></div></div><div class="public anchor" id="var-record"><h3>record</h3><div class="usage"><code>(record self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>A data-type scalar that allows field access as attribute lookup.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6495">view source</a></div></div><div class="public anchor" id="var-remainder"><h3>remainder</h3><div class="usage"><code>(remainder self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>remainder(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return element-wise remainder of division.</p>
+<p>Computes the remainder complementary to the <code>floor_divide</code> function. It is equivalent to the Python modulus operator<code>x1 % x2</code> and has the same sign as the divisor <code>x2</code>. The MATLAB function equivalent to <code>np.remainder</code> is <code>mod</code>.</p>
+<p>.. warning::</p>
+<pre><code>This should not be confused with:
+
+* Python 3.7's `math.remainder` and C's ``remainder``, which
+  computes the IEEE remainder, which are the complement to
+  ``round(x1 / x2)``.
+* The MATLAB ``rem`` function and or the C ``%`` operator which is the
+  complement to ``int(x1 / x2)``.
+</code></pre>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  Dividend array. x2 : array_like  Divisor array. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The element-wise remainder of the quotient <code>floor_divide(x1, x2)</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>floor_divide : Equivalent of Python <code>//</code> operator. divmod : Simultaneous floor division and remainder. fmod : Equivalent of the MATLAB <code>rem</code> function. divide, floor</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Returns 0 when <code>x2</code> is 0 and both <code>x1</code> and <code>x2</code> are (arrays of) integers. <code>mod</code> is an alias of <code>remainder</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.remainder([4, 7], [2, 3]) array([0, 1]) np.remainder(np.arange(7), 5) array([0, 1, 2, 3, 4, 0, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16398">view source</a></div></div><div class="public anchor" id="var-repeat"><h3>repeat</h3><div class="usage"><code>(repeat &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Repeat elements of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. repeats : int or array of ints  The number of repetitions for each element. <code>repeats</code> is broadcasted  to fit the shape of the given axis. axis : int, optional  The axis along which to repeat values. By default, use the  flattened input array, and return a flat output array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>repeated_array : ndarray  Output array which has the same shape as <code>a</code>, except along  the given axis.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>tile : Tile an array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.repeat(3, 4) array([3, 3, 3, 3]) x = np.array(<a href="null">1,2],[3,4</a>) np.repeat(x, 2) array([1, 1, 2, 2, 3, 3, 4, 4]) np.repeat(x, 3, axis=1) array(<a href="null">1, 1, 1, 2, 2, 2],
+       [3, 3, 3, 4, 4, 4</a>) np.repeat(x, [1, 2], axis=0) array(<a href="null">1, 2],
+       [3, 4],
+       [3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8322">view source</a></div></div><div class="public anchor" id="var-require"><h3>require</h3><div class="usage"><code>(require a &amp; [{dtype :dtype, requirements :requirements}])</code><code>(require a &amp; [{dtype :dtype}])</code><code>(require a)</code></div><div class="doc"><div class="markdown"><p>Return an ndarray of the provided type that satisfies requirements.</p>
+<p>This function is useful to be sure that an array with the correct flags is returned for passing to compiled code (perhaps through ctypes).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  The object to be converted to a type-and-requirement-satisfying array. dtype : data-type  The required data-type. If None preserve the current dtype. If your  application requires the data to be in native byteorder, include  a byteorder specification as a part of the dtype specification. requirements : str or list of str  The requirements list can be any of the following</p>
+<ul>
+  <li>‘F_CONTIGUOUS’ (‘F’) - ensure a Fortran-contiguous array</li>
+  <li>‘C_CONTIGUOUS’ (‘C’) - ensure a C-contiguous array</li>
+  <li>‘ALIGNED’ (‘A’) - ensure a data-type aligned array</li>
+  <li>‘WRITEABLE’ (‘W’) - ensure a writable array</li>
+  <li>‘OWNDATA’ (‘O’) - ensure an array that owns its own data</li>
+  <li>‘ENSUREARRAY’, (‘E’) - ensure a base array, instead of a subclass</li>
+</ul>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Array with specified requirements and type if given.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>asarray : Convert input to an ndarray. asanyarray : Convert to an ndarray, but pass through ndarray subclasses. ascontiguousarray : Convert input to a contiguous array. asfortranarray : Convert input to an ndarray with column-major  memory order. ndarray.flags : Information about the memory layout of the array.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The returned array will be guaranteed to have the listed requirements by making a copy if needed.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(6).reshape(2,3) x.flags  C_CONTIGUOUS : True  F_CONTIGUOUS : False  OWNDATA : False  WRITEABLE : True  ALIGNED : True  WRITEBACKIFCOPY : False  UPDATEIFCOPY : False</p>
+      <p>y = np.require(x, dtype=np.float32, requirements=[‘A’, ‘O’, ‘W’, ‘F’]) y.flags  C_CONTIGUOUS : False  F_CONTIGUOUS : True  OWNDATA : True  WRITEABLE : True  ALIGNED : True  WRITEBACKIFCOPY : False  UPDATEIFCOPY : False</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10120">view source</a></div></div><div class="public anchor" id="var-reshape"><h3>reshape</h3><div class="usage"><code>(reshape &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Gives a new shape to an array without changing its data.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array to be reshaped. newshape : int or tuple of ints  The new shape should be compatible with the original shape. If  an integer, then the result will be a 1-D array of that length.  One shape dimension can be -1. In this case, the value is  inferred from the length of the array and remaining dimensions. order : {‘C’, ‘F’, ‘A’}, optional  Read the elements of <code>a</code> using this index order, and place the  elements into the reshaped array using this index order. ‘C’  means to read / write the elements using C-like index order,  with the last axis index changing fastest, back to the first  axis index changing slowest. ‘F’ means to read / write the  elements using Fortran-like index order, with the first index  changing fastest, and the last index changing slowest. Note that  the ‘C’ and ‘F’ options take no account of the memory layout of  the underlying array, and only refer to the order of indexing.  ‘A’ means to read / write the elements in Fortran-like index  order if <code>a</code> is Fortran <em>contiguous</em> in memory, C-like order  otherwise.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>reshaped_array : ndarray  This will be a new view object if possible; otherwise, it will  be a copy. Note there is no guarantee of the <em>memory layout</em> (C- or  Fortran- contiguous) of the returned array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.reshape : Equivalent method.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>It is not always possible to change the shape of an array without copying the data. If you want an error to be raised when the data is copied, you should assign the new shape to the shape attribute of the array::</p>
+<p>&gt;&gt;&gt; a = np.zeros((10, 2))</p>
+<p># A transpose makes the array non-contiguous  &gt;&gt;&gt; b = a.T</p>
+<p># Taking a view makes it possible to modify the shape without modifying  # the initial object.  &gt;&gt;&gt; c = b.view()  &gt;&gt;&gt; c.shape = (20)  Traceback (most recent call last):  …  AttributeError: incompatible shape for a non-contiguous array</p>
+<p>The <code>order</code> keyword gives the index ordering both for <em>fetching</em> the values from <code>a</code>, and then <em>placing</em> the values into the output array. For example, let’s say you have an array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(6).reshape((3, 2)) a array(<a href="null">0, 1],
+       [2, 3],
+       [4, 5</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>You can think of reshaping as first raveling the array (using the given index order), then inserting the elements from the raveled array into the new array using the same kind of index ordering as was used for the raveling.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.reshape(a, (2, 3)) # C-like index ordering array(<a href="null">0, 1, 2],
+       [3, 4, 5</a>) np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape array(<a href="null">0, 1, 2],
+       [3, 4, 5</a>) np.reshape(a, (2, 3), order=‘F’) # Fortran-like index ordering array(<a href="null">0, 4, 3],
+       [2, 1, 5</a>) np.reshape(np.ravel(a, order=‘F’), (2, 3), order=‘F’) array(<a href="null">0, 4, 3],
+       [2, 1, 5</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1,2,3], [4,5,6</a>) np.reshape(a, 6) array([1, 2, 3, 4, 5, 6]) np.reshape(a, 6, order=‘F’) array([1, 4, 2, 5, 3, 6])</p>
+      <p>np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2 array(<a href="null">1, 2],
+       [3, 4],
+       [5, 6</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13851">view source</a></div></div><div class="public anchor" id="var-resize"><h3>resize</h3><div class="usage"><code>(resize &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a new array with the specified shape.</p>
+<p>If the new array is larger than the original array, then the new array is filled with repeated copies of <code>a</code>. Note that this behavior is different from a.resize(new_shape) which fills with zeros instead of repeated copies of <code>a</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array to be resized.</p>
+<p>new_shape : int or tuple of int  Shape of resized array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>reshaped_array : ndarray  The new array is formed from the data in the old array, repeated  if necessary to fill out the required number of elements. The  data are repeated in the order that they are stored in memory.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.resize : resize an array in-place.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Warning: This functionality does <strong>not</strong> consider axes separately, i.e. it does not apply interpolation/extrapolation. It fills the return array with the required number of elements, taken from <code>a</code> as they are laid out in memory, disregarding strides and axes. (This is in case the new shape is smaller. For larger, see above.) This functionality is therefore not suitable to resize images, or data where each axis represents a separate and distinct entity.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a=np.array(<a href="null">0,1],[2,3</a>) np.resize(a,(2,3)) array(<a href="null">0, 1, 2],
+       [3, 0, 1</a>) np.resize(a,(1,4)) array(<a href="null">0, 1, 2, 3</a>) np.resize(a,(2,4)) array(<a href="null">0, 1, 2, 3],
+       [0, 1, 2, 3</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23725">view source</a></div></div><div class="public anchor" id="var-result_type"><h3>result_type</h3><div class="usage"><code>(result_type &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>result_type(*arrays_and_dtypes)</p>
+<p>Returns the type that results from applying the NumPy type promotion rules to the arguments.</p>
+<p>Type promotion in NumPy works similarly to the rules in languages like C++, with some slight differences. When both scalars and arrays are used, the array’s type takes precedence and the actual value of the scalar is taken into account.</p>
+<p>For example, calculating 3*a, where a is an array of 32-bit floats, intuitively should result in a 32-bit float output. If the 3 is a 32-bit integer, the NumPy rules indicate it can’t convert losslessly into a 32-bit float, so a 64-bit float should be the result type. By examining the value of the constant, ‘3’, we see that it fits in an 8-bit integer, which can be cast losslessly into the 32-bit float.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arrays_and_dtypes : list of arrays and dtypes  The operands of some operation whose result type is needed.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : dtype  The result type.</p>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>dtype, promote_types, min_scalar_type, can_cast</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.6.0</p>
+<p>The specific algorithm used is as follows.</p>
+<p>Categories are determined by first checking which of boolean, integer (int/uint), or floating point (float/complex) the maximum kind of all the arrays and the scalars are.</p>
+<p>If there are only scalars or the maximum category of the scalars is higher than the maximum category of the arrays, the data types are combined with :func:<code>promote_types</code> to produce the return value.</p>
+<p>Otherwise, <code>min_scalar_type</code> is called on each array, and the resulting data types are all combined with :func:<code>promote_types</code> to produce the return value.</p>
+<p>The set of int values is not a subset of the uint values for types with the same number of bits, something not reflected in :func:<code>min_scalar_type</code>, but handled as a special case in <code>result_type</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.result_type(3, np.arange(7, dtype=‘i1’)) dtype(‘int8’)</p>
+      <p>np.result_type(‘i4’, ‘c8’) dtype(‘complex128’)</p>
+      <p>np.result_type(3.0, -2) dtype(‘float64’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10">view source</a></div></div><div class="public anchor" id="var-right_shift"><h3>right_shift</h3><div class="usage"><code>(right_shift self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>right_shift(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Shift the bits of an integer to the right.</p>
+<p>Bits are shifted to the right <code>x2</code>. Because the internal representation of numbers is in binary format, this operation is equivalent to dividing <code>x1</code> by <code>2**x2</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like, int  Input values. x2 : array_like, int  Number of bits to remove at the right of <code>x1</code>. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray, int  Return <code>x1</code> with bits shifted <code>x2</code> times to the right.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>left_shift : Shift the bits of an integer to the left. binary_repr : Return the binary representation of the input number  as a string.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.binary_repr(10) ‘1010’ np.right_shift(10, 1) 5 np.binary_repr(5) ‘101’</p>
+      <p>np.right_shift(10, [1,2,3]) array([5, 2, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27978">view source</a></div></div><div class="public anchor" id="var-rint"><h3>rint</h3><div class="usage"><code>(rint self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>rint(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Round elements of the array to the nearest integer.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Output array is same shape and type as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ceil, floor, trunc</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.rint(a) array([-2., -2., -0., 0., 2., 2., 2.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28388">view source</a></div></div><div class="public anchor" id="var-roll"><h3>roll</h3><div class="usage"><code>(roll &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Roll array elements along a given axis.</p>
+<p>Elements that roll beyond the last position are re-introduced at the first.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. shift : int or tuple of ints  The number of places by which elements are shifted. If a tuple,  then <code>axis</code> must be a tuple of the same size, and each of the  given axes is shifted by the corresponding number. If an int  while <code>axis</code> is a tuple of ints, then the same value is used for  all given axes. axis : int or tuple of ints, optional  Axis or axes along which elements are shifted. By default, the  array is flattened before shifting, after which the original  shape is restored.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>res : ndarray  Output array, with the same shape as <code>a</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>rollaxis : Roll the specified axis backwards, until it lies in a  given position.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.12.0</p>
+<p>Supports rolling over multiple dimensions simultaneously.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(10) np.roll(x, 2) array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]) np.roll(x, -2) array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])</p>
+      <p>x2 = np.reshape(x, (2,5)) x2 array(<a href="null">0, 1, 2, 3, 4],
+       [5, 6, 7, 8, 9</a>) np.roll(x2, 1) array(<a href="null">9, 0, 1, 2, 3],
+       [4, 5, 6, 7, 8</a>) np.roll(x2, -1) array(<a href="null">1, 2, 3, 4, 5],
+       [6, 7, 8, 9, 0</a>) np.roll(x2, 1, axis=0) array(<a href="null">5, 6, 7, 8, 9],
+       [0, 1, 2, 3, 4</a>) np.roll(x2, -1, axis=0) array(<a href="null">5, 6, 7, 8, 9],
+       [0, 1, 2, 3, 4</a>) np.roll(x2, 1, axis=1) array(<a href="null">4, 0, 1, 2, 3],
+       [9, 5, 6, 7, 8</a>) np.roll(x2, -1, axis=1) array(<a href="null">1, 2, 3, 4, 0],
+       [6, 7, 8, 9, 5</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22212">view source</a></div></div><div class="public anchor" id="var-rollaxis"><h3>rollaxis</h3><div class="usage"><code>(rollaxis &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Roll the specified axis backwards, until it lies in a given position.</p>
+<p>This function continues to be supported for backward compatibility, but you should prefer <code>moveaxis</code>. The <code>moveaxis</code> function was added in NumPy 1.11.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : ndarray  Input array. axis : int  The axis to roll backwards. The positions of the other axes do not  change relative to one another. start : int, optional  The axis is rolled until it lies before this position. The default,  0, results in a “complete” roll.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>res : ndarray  For NumPy &gt;= 1.10.0 a view of <code>a</code> is always returned. For earlier  NumPy versions a view of <code>a</code> is returned only if the order of the  axes is changed, otherwise the input array is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>moveaxis : Move array axes to new positions. roll : Roll the elements of an array by a number of positions along a  given axis.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.ones((3,4,5,6)) np.rollaxis(a, 3, 1).shape (3, 6, 4, 5) np.rollaxis(a, 2).shape (5, 3, 4, 6) np.rollaxis(a, 1, 4).shape (3, 5, 6, 4)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8868">view source</a></div></div><div class="public anchor" id="var-roots"><h3>roots</h3><div class="usage"><code>(roots &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the roots of a polynomial with coefficients given in p.</p>
+<p>The values in the rank-1 array <code>p</code> are coefficients of a polynomial. If the length of <code>p</code> is n+1 then the polynomial is described by::</p>
+<p>p[0] * x**n + p[1] * x**(n-1) + … + p[n-1]*x + p[n]</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>p : array_like  Rank-1 array of polynomial coefficients.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  An array containing the roots of the polynomial.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  When <code>p</code> cannot be converted to a rank-1 array.</p>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>poly : Find the coefficients of a polynomial with a given sequence  of roots. polyval : Compute polynomial values. polyfit : Least squares polynomial fit. poly1d : A one-dimensional polynomial class.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The algorithm relies on computing the eigenvalues of the companion matrix [1]_.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] R. A. Horn &amp; C. R. Johnson, <em>Matrix Analysis</em>. Cambridge, UK:  Cambridge University Press, 1999, pp. 146-7.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>coeff = [3.2, 2, 1] np.roots(coeff) array([-0.3125+0.46351241j, -0.3125-0.46351241j])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8997">view source</a></div></div><div class="public anchor" id="var-rot90"><h3>rot90</h3><div class="usage"><code>(rot90 &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Rotate an array by 90 degrees in the plane specified by axes.</p>
+<p>Rotation direction is from the first towards the second axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>m : array_like  Array of two or more dimensions. k : integer  Number of times the array is rotated by 90 degrees. axes: (2,) array_like  The array is rotated in the plane defined by the axes.  Axes must be different.</p>
+<pre><code>.. versionadded:: 1.12.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  A rotated view of <code>m</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>flip : Reverse the order of elements in an array along the given axis. fliplr : Flip an array horizontally. flipud : Flip an array vertically.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>rot90(m, k=1, axes=(1,0)) is the reverse of rot90(m, k=1, axes=(0,1)) rot90(m, k=1, axes=(1,0)) is equivalent to rot90(m, k=-1, axes=(0,1))</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>m = np.array(<a href="null">1,2],[3,4</a>, int) m array(<a href="null">1, 2],
+       [3, 4</a>) np.rot90(m) array(<a href="null">2, 4],
+       [1, 3</a>) np.rot90(m, 2) array(<a href="null">4, 3],
+       [2, 1</a>) m = np.arange(8).reshape((2,2,2)) np.rot90(m, 1, (1,2)) array(<a href="null">[1, 3],
+        [0, 2</a>,  <a href="null">5, 7],
+        [4, 6</a>])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24490">view source</a></div></div><div class="public anchor" id="var-round"><h3>round</h3><div class="usage"><code>(round &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Round an array to the given number of decimals.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>around : equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25600">view source</a></div></div><div class="public anchor" id="var-round_"><h3>round_</h3><div class="usage"><code>(round_ &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Round an array to the given number of decimals.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>around : equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22775">view source</a></div></div><div class="public anchor" id="var-row_stack"><h3>row_stack</h3><div class="usage"><code>(row_stack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Stack arrays in sequence vertically (row wise).</p>
+<p>This is equivalent to concatenation along the first axis after 1-D arrays of shape <code>(N,)</code> have been reshaped to <code>(1,N)</code>. Rebuilds arrays divided by <code>vsplit</code>.</p>
+<p>This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions <code>concatenate</code>, <code>stack</code> and <code>block</code> provide more general stacking and concatenation operations.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>tup : sequence of ndarrays  The arrays must have the same shape along all but the first axis.  1-D arrays must have the same length.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>stacked : ndarray  The array formed by stacking the given arrays, will be at least 2-D.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>stack : Join a sequence of arrays along a new axis. hstack : Stack arrays in sequence horizontally (column wise). dstack : Stack arrays in sequence depth wise (along third dimension). concatenate : Join a sequence of arrays along an existing axis. vsplit : Split array into a list of multiple sub-arrays vertically. block : Assemble arrays from blocks.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1, 2, 3]) b = np.array([2, 3, 4]) np.vstack((a,b)) array(<a href="null">1, 2, 3],
+       [2, 3, 4</a>)</p>
+      <p>a = np.array(<a href="null">1], [2], [3</a>) b = np.array(<a href="null">2], [3], [4</a>) np.vstack((a,b)) array(<a href="null">1],
+       [2],
+       [3],
+       [2],
+       [3],
+       [4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27668">view source</a></div></div><div class="public anchor" id="var-s_"><h3>s_</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A nicer way to build up index tuples for arrays.</p>
+<p>.. note::  Use one of the two predefined instances <code>index_exp</code> or <code>s_</code>  rather than directly using <code>IndexExpression</code>.</p>
+<p>For any index combination, including slicing and axis insertion, <code>a[indices]</code> is the same as <code>a[np.index_exp[indices]]</code> for any array <code>a</code>. However, <code>np.index_exp[indices]</code> can be used anywhere in Python code and returns a tuple of slice objects that can be used in the construction of complex index expressions.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>maketuple : bool  If True, always returns a tuple.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>index_exp : Predefined instance that always returns a tuple:  <code>index_exp = IndexExpression(maketuple=True)</code>. s_ : Predefined instance without tuple conversion:  <code>s_ = IndexExpression(maketuple=False)</code>.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>You can do all this with <code>slice()</code> plus a few special objects, but there’s a lot to remember and this version is simpler because it uses the standard array indexing syntax.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.s_[2::2] slice(2, None, 2) np.index_exp[2::2] (slice(2, None, 2),)</p>
+      <p>np.array([0, 1, 2, 3, 4])[np.s_[2::2]] array([2, 4])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26686">view source</a></div></div><div class="public anchor" id="var-safe_eval"><h3>safe_eval</h3><div class="usage"><code>(safe_eval source)</code></div><div class="doc"><div class="markdown"><p>Protected string evaluation.</p>
+<p>Evaluate a string containing a Python literal expression without allowing the execution of arbitrary non-literal code.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>source : str  The string to evaluate.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>obj : object  The result of evaluating <code>source</code>.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>SyntaxError  If the code has invalid Python syntax, or if it contains  non-literal code.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.safe_eval(‘1’) 1 np.safe_eval(‘[1, 2, 3]’) [1, 2, 3] np.safe_eval(‘{“foo”: (“bar”, 10.0)}’) {‘foo’: (‘bar’, 10.0)}</p>
+      <p>np.safe_eval(‘import os’) Traceback (most recent call last):  … SyntaxError: invalid syntax</p>
+      <p>np.safe_eval(‘open(“/home/user/.ssh/id_dsa”).read()’) Traceback (most recent call last):  … ValueError: malformed node or string: &lt;_ast.Call object at 0x…&gt;</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20137">view source</a></div></div><div class="public anchor" id="var-save"><h3>save</h3><div class="usage"><code>(save &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Save an array to a binary file in NumPy <code>.npy</code> format.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>file : file, str, or pathlib.Path  File or filename to which the data is saved. If file is a file-object,  then the filename is unchanged. If file is a string or Path, a <code>.npy</code>  extension will be appended to the filename if it does not already  have one. arr : array_like  Array data to be saved. allow_pickle : bool, optional  Allow saving object arrays using Python pickles. Reasons for disallowing  pickles include security (loading pickled data can execute arbitrary  code) and portability (pickled objects may not be loadable on different  Python installations, for example if the stored objects require libraries  that are not available, and not all pickled data is compatible between  Python 2 and Python 3).  Default: True fix_imports : bool, optional  Only useful in forcing objects in object arrays on Python 3 to be  pickled in a Python 2 compatible way. If <code>fix_imports</code> is True, pickle  will try to map the new Python 3 names to the old module names used in  Python 2, so that the pickle data stream is readable with Python 2.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>savez : Save several arrays into a <code>.npz</code> archive savetxt, load</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>For a description of the <code>.npy</code> format, see :py:mod:<code>numpy.lib.format</code>.</p>
+<p>Any data saved to the file is appended to the end of the file.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from tempfile import TemporaryFile outfile = TemporaryFile()</p>
+      <p>x = np.arange(10) np.save(outfile, x)</p>
+      <p>_ = outfile.seek(0) # Only needed here to simulate closing &amp; reopening file np.load(outfile) array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])</p>
+      <p>with open(‘test.npy’, ‘wb’) as f: … np.save(f, np.array([1, 2])) … np.save(f, np.array([1, 3])) with open(‘test.npy’, ‘rb’) as f: … a = np.load(f) … b = np.load(f) print(a, b)</p>
+      <h1><a href="#1-2" name="1-2"></a>[1 2] [1 3]</h1>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1427">view source</a></div></div><div class="public anchor" id="var-savetxt"><h3>savetxt</h3><div class="usage"><code>(savetxt &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Save an array to a text file.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>fname : filename or file handle  If the filename ends in <code>.gz</code>, the file is automatically saved in  compressed gzip format. <code>loadtxt</code> understands gzipped files  transparently. X : 1D or 2D array_like  Data to be saved to a text file. fmt : str or sequence of strs, optional  A single format (%10.5f), a sequence of formats, or a  multi-format string, e.g. ‘Iteration %d – %10.5f’, in which  case <code>delimiter</code> is ignored. For complex <code>X</code>, the legal options  for <code>fmt</code> are:</p>
+<pre><code>* a single specifier, `fmt='%.4e'`, resulting in numbers formatted
+  like `' (%s+%sj)' % (fmt, fmt)`
+* a full string specifying every real and imaginary part, e.g.
+  `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns
+* a list of specifiers, one per column - in this case, the real
+  and imaginary part must have separate specifiers,
+  e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns
+</code></pre>
+<p>delimiter : str, optional  String or character separating columns. newline : str, optional  String or character separating lines.</p>
+<pre><code>.. versionadded:: 1.5.0
+</code></pre>
+<p>header : str, optional  String that will be written at the beginning of the file.</p>
+<pre><code>.. versionadded:: 1.7.0
+</code></pre>
+<p>footer : str, optional  String that will be written at the end of the file.</p>
+<pre><code>.. versionadded:: 1.7.0
+</code></pre>
+<p>comments : str, optional  String that will be prepended to the <code>header</code> and <code>footer</code> strings,  to mark them as comments. Default: ‘# ’, as expected by e.g.  <code>numpy.loadtxt</code>.</p>
+<pre><code>.. versionadded:: 1.7.0
+</code></pre>
+<p>encoding : {None, str}, optional  Encoding used to encode the outputfile. Does not apply to output  streams. If the encoding is something other than ‘bytes’ or ‘latin1’  you will not be able to load the file in NumPy versions &lt; 1.14. Default  is ‘latin1’.</p>
+<pre><code>.. versionadded:: 1.14.0
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>save : Save an array to a binary file in NumPy <code>.npy</code> format savez : Save several arrays into an uncompressed <code>.npz</code> archive savez_compressed : Save several arrays into a compressed <code>.npz</code> archive</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Further explanation of the <code>fmt</code> parameter (<code>%[flag]width[.precision]specifier</code>):</p>
+<p>flags:  <code>-</code> : left justify</p>
+<pre><code>``+`` : Forces to precede result with + or -.
+
+``0`` : Left pad the number with zeros instead of space (see width).
+</code></pre>
+<p>width:  Minimum number of characters to be printed. The value is not truncated  if it has more characters.</p>
+<p>precision:  - For integer specifiers (eg. <code>d,i,o,x</code>), the minimum number of  digits.  - For <code>e, E</code> and <code>f</code> specifiers, the number of digits to print  after the decimal point.  - For <code>g</code> and <code>G</code>, the maximum number of significant digits.  - For <code>s</code>, the maximum number of characters.</p>
+<p>specifiers:  <code>c</code> : character</p>
+<pre><code>``d`` or ``i`` : signed decimal integer
+
+``e`` or ``E`` : scientific notation with ``e`` or ``E``.
+
+``f`` : decimal floating point
+
+``g,G`` : use the shorter of ``e,E`` or ``f``
+
+``o`` : signed octal
+
+``s`` : string of characters
+
+``u`` : unsigned decimal integer
+
+``x,X`` : unsigned hexadecimal integer
+</code></pre>
+<p>This explanation of <code>fmt</code> is not complete, for an exhaustive specification see [1]_.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] <code>Format Specification Mini-Language
+       &lt;https://docs.python.org/library/string.html#format-specification-mini-language&gt;</code>_,  Python Documentation.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = y = z = np.arange(0.0,5.0,1.0) np.savetxt(‘test.out’, x, delimiter=‘,’) # X is an array np.savetxt(‘test.out’, (x,y,z)) # x,y,z equal sized 1D arrays np.savetxt(‘test.out’, x, fmt=‘%1.4e’) # use exponential notation</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13223">view source</a></div></div><div class="public anchor" id="var-savez"><h3>savez</h3><div class="usage"><code>(savez &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Save several arrays into a single file in uncompressed <code>.npz</code> format.</p>
+<p>If arguments are passed in with no keywords, the corresponding variable names, in the <code>.npz</code> file, are ‘arr_0’, ‘arr_1’, etc. If keyword arguments are given, the corresponding variable names, in the <code>.npz</code> file will match the keyword names.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>file : str or file  Either the filename (string) or an open file (file-like object)  where the data will be saved. If file is a string or a Path, the  <code>.npz</code> extension will be appended to the filename if it is not  already there. args : Arguments, optional  Arrays to save to the file. Since it is not possible for Python to  know the names of the arrays outside <code>savez</code>, the arrays will be saved  with names “arr_0”, “arr_1”, and so on. These arguments can be any  expression. kwds : Keyword arguments, optional  Arrays to save to the file. Arrays will be saved in the file with the  keyword names.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>None</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>save : Save a single array to a binary file in NumPy format. savetxt : Save an array to a file as plain text. savez_compressed : Save several arrays into a compressed <code>.npz</code> archive</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The <code>.npz</code> file format is a zipped archive of files named after the variables they contain. The archive is not compressed and each file in the archive contains one variable in <code>.npy</code> format. For a description of the <code>.npy</code> format, see :py:mod:<code>numpy.lib.format</code>.</p>
+<p>When opening the saved <code>.npz</code> file with <code>load</code> a <code>NpzFile</code> object is returned. This is a dictionary-like object which can be queried for its list of arrays (with the <code>.files</code> attribute), and for the arrays themselves.</p>
+<p>When saving dictionaries, the dictionary keys become filenames inside the ZIP archive. Therefore, keys should be valid filenames. E.g., avoid keys that begin with <code>/</code> or contain <code>.</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from tempfile import TemporaryFile outfile = TemporaryFile() x = np.arange(10) y = np.sin(x)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using <code>savez</code> with *args, the arrays are saved with default names.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.savez(outfile, x, y) _ = outfile.seek(0) # Only needed here to simulate closing &amp; reopening file npzfile = np.load(outfile) npzfile.files [‘arr_0’, ‘arr_1’] npzfile[‘arr_0’] array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Using <code>savez</code> with **kwds, the arrays are saved with the keyword names.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>outfile = TemporaryFile() np.savez(outfile, x=x, y=y) _ = outfile.seek(0) npzfile = np.load(outfile) sorted(npzfile.files) [‘x’, ‘y’] npzfile[‘x’] array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27721">view source</a></div></div><div class="public anchor" id="var-savez_compressed"><h3>savez_compressed</h3><div class="usage"><code>(savez_compressed &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Save several arrays into a single file in compressed <code>.npz</code> format.</p>
+<p>If keyword arguments are given, then filenames are taken from the keywords. If arguments are passed in with no keywords, then stored filenames are arr_0, arr_1, etc.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>file : str or file  Either the filename (string) or an open file (file-like object)  where the data will be saved. If file is a string or a Path, the  <code>.npz</code> extension will be appended to the filename if it is not  already there. args : Arguments, optional  Arrays to save to the file. Since it is not possible for Python to  know the names of the arrays outside <code>savez</code>, the arrays will be saved  with names “arr_0”, “arr_1”, and so on. These arguments can be any  expression. kwds : Keyword arguments, optional  Arrays to save to the file. Arrays will be saved in the file with the  keyword names.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>None</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.save : Save a single array to a binary file in NumPy format. numpy.savetxt : Save an array to a file as plain text. numpy.savez : Save several arrays into an uncompressed <code>.npz</code> file format numpy.load : Load the files created by savez_compressed.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The <code>.npz</code> file format is a zipped archive of files named after the variables they contain. The archive is compressed with <code>zipfile.ZIP_DEFLATED</code> and each file in the archive contains one variable in <code>.npy</code> format. For a description of the <code>.npy</code> format, see :py:mod:<code>numpy.lib.format</code>.</p>
+<p>When opening the saved <code>.npz</code> file with <code>load</code> a <code>NpzFile</code> object is returned. This is a dictionary-like object which can be queried for its list of arrays (with the <code>.files</code> attribute), and for the arrays themselves.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>test_array = np.random.rand(3, 2) test_vector = np.random.rand(4) np.savez_compressed(‘/tmp/123’, a=test_array, b=test_vector) loaded = np.load(‘/tmp/123.npz’) print(np.array_equal(test_array, loaded[‘a’])) True print(np.array_equal(test_vector, loaded[‘b’])) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5819">view source</a></div></div><div class="public anchor" id="var-ScalarType"><h3>ScalarType</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in immutable sequence.</p>
+<p>If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.</p>
+<p>If the argument is a tuple, the return value is the same object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22011">view source</a></div></div><div class="public anchor" id="var-sctype2char"><h3>sctype2char</h3><div class="usage"><code>(sctype2char sctype)</code></div><div class="doc"><div class="markdown"><p>Return the string representation of a scalar dtype.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>sctype : scalar dtype or object  If a scalar dtype, the corresponding string character is  returned. If an object, <code>sctype2char</code> tries to infer its scalar type  and then return the corresponding string character.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>typechar : str  The string character corresponding to the scalar type.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If <code>sctype</code> is an object for which the type can not be inferred.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>obj2sctype, issctype, issubsctype, mintypecode</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]: … print(np.sctype2char(sctype)) l # may vary d D S O</p>
+      <p>x = np.array([1., 2-1.j]) np.sctype2char(x) ‘D’ np.sctype2char(list) ‘O’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1649">view source</a></div></div><div class="public anchor" id="var-sctypeDict"><h3>sctypeDict</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16794">view source</a></div></div><div class="public anchor" id="var-sctypeNA"><h3>sctypeNA</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11195">view source</a></div></div><div class="public anchor" id="var-sctypes"><h3>sctypes</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2123">view source</a></div></div><div class="public anchor" id="var-searchsorted"><h3>searchsorted</h3><div class="usage"><code>(searchsorted &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find indices where elements should be inserted to maintain order.</p>
+<p>Find the indices into a sorted array <code>a</code> such that, if the corresponding elements in <code>v</code> were inserted before the indices, the order of <code>a</code> would be preserved.</p>
+<p>Assuming that <code>a</code> is sorted:</p>
+<p>====== ============================ <code>side</code> returned index <code>i</code> satisfies ====== ============================ left <code>a[i-1] &lt; v &lt;= a[i]</code> right <code>a[i-1] &lt;= v &lt; a[i]</code> ====== ============================</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : 1-D array_like  Input array. If <code>sorter</code> is None, then it must be sorted in  ascending order, otherwise <code>sorter</code> must be an array of indices  that sort it. v : array_like  Values to insert into <code>a</code>. side : {‘left’, ‘right’}, optional  If ‘left’, the index of the first suitable location found is given.  If ‘right’, return the last such index. If there is no suitable  index, return either 0 or N (where N is the length of <code>a</code>). sorter : 1-D array_like, optional  Optional array of integer indices that sort array a into ascending  order. They are typically the result of argsort.</p>
+<pre><code>.. versionadded:: 1.7.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>indices : array of ints  Array of insertion points with the same shape as <code>v</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>sort : Return a sorted copy of an array. histogram : Produce histogram from 1-D data.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Binary search is used to find the required insertion points.</p>
+<p>As of NumPy 1.4.0 <code>searchsorted</code> works with real/complex arrays containing <code>nan</code> values. The enhanced sort order is documented in <code>sort</code>.</p>
+<p>This function uses the same algorithm as the builtin python <code>bisect.bisect_left</code> (<code>side='left'</code>) and <code>bisect.bisect_right</code> (<code>side='right'</code>) functions, which is also vectorized in the <code>v</code> argument.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.searchsorted([1,2,3,4,5], 3) 2 np.searchsorted([1,2,3,4,5], 3, side=‘right’) 3 np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3]) array([0, 5, 1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15809">view source</a></div></div><div class="public anchor" id="var-select"><h3>select</h3><div class="usage"><code>(select &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an array drawn from elements in choicelist, depending on conditions.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>condlist : list of bool ndarrays  The list of conditions which determine from which array in <code>choicelist</code>  the output elements are taken. When multiple conditions are satisfied,  the first one encountered in <code>condlist</code> is used. choicelist : list of ndarrays  The list of arrays from which the output elements are taken. It has  to be of the same length as <code>condlist</code>. default : scalar, optional  The element inserted in <code>output</code> when all conditions evaluate to False.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>output : ndarray  The output at position m is the m-th element of the array in  <code>choicelist</code> where the m-th element of the corresponding array in  <code>condlist</code> is True.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>where : Return elements from one of two arrays depending on condition. take, choose, compress, diag, diagonal</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(10) condlist = [x&lt;3, x&gt;5] choicelist = [x, x**2] np.select(condlist, choicelist) array([ 0, 1, 2, …, 49, 64, 81])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16860">view source</a></div></div><div class="public anchor" id="var-set_numeric_ops"><h3>set_numeric_ops</h3><div class="usage"><code>(set_numeric_ops self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>set_numeric_ops(op1=func1, op2=func2, …)</p>
+<p>Set numerical operators for array objects.</p>
+<p>.. deprecated:: 1.16</p>
+<pre><code>For the general case, use :c:func:`PyUFunc_ReplaceLoopBySignature`.
+For ndarray subclasses, define the ``__array_ufunc__`` method and
+override the relevant ufunc.
+</code></pre>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>op1, op2, … : callable  Each <code>op = func</code> pair describes an operator to be replaced.  For example, <code>add = lambda x, y: np.add(x, y) % 5</code> would replace  addition by modulus 5 addition.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>saved_ops : list of callables  A list of all operators, stored before making replacements.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. WARNING::  Use with care! Incorrect usage may lead to memory errors.</p>
+<p>A function replacing an operator cannot make use of that operator. For example, when replacing add, you may not use <code>+</code>. Instead, directly call ufuncs.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>def add_mod5(x, y): … return np.add(x, y) % 5 … old_funcs = np.set_numeric_ops(add=add_mod5)</p>
+      <p>x = np.arange(12).reshape((3, 4)) x + x array(<a href="null">0, 2, 4, 1],
+       [3, 0, 2, 4],
+       [1, 3, 0, 2</a>)</p>
+      <p>ignore = np.set_numeric_ops(**old_funcs) # restore operators</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10917">view source</a></div></div><div class="public anchor" id="var-set_printoptions"><h3>set_printoptions</h3><div class="usage"><code>(set_printoptions &amp; [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, sign :sign, formatter :formatter, precision :precision, floatmode :floatmode, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}])</code><code>(set_printoptions &amp; [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, sign :sign, formatter :formatter, precision :precision, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}])</code><code>(set_printoptions &amp; [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, formatter :formatter, precision :precision, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, nanstr :nanstr, infstr :infstr, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, nanstr :nanstr, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, edgeitems :edgeitems, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, :as kwarg}])</code><code>(set_printoptions &amp; [{:as kwarg}])</code></div><div class="doc"><div class="markdown"><p>Set printing options.</p>
+<p>These options determine the way floating point numbers, arrays and other NumPy objects are displayed.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>precision : int or None, optional  Number of digits of precision for floating point output (default 8).  May be None if <code>floatmode</code> is not <code>fixed</code>, to print as many digits as  necessary to uniquely specify the value. threshold : int, optional  Total number of array elements which trigger summarization  rather than full repr (default 1000).  To always use the full repr without summarization, pass <code>sys.maxsize</code>. edgeitems : int, optional  Number of array items in summary at beginning and end of  each dimension (default 3). linewidth : int, optional  The number of characters per line for the purpose of inserting  line breaks (default 75). suppress : bool, optional  If True, always print floating point numbers using fixed point  notation, in which case numbers equal to zero in the current precision  will print as zero. If False, then scientific notation is used when  absolute value of the smallest number is &lt; 1e-4 or the ratio of the
+    maximum absolute value to the minimum is &gt; 1e3. The default is False. nanstr : str, optional  String representation of floating point not-a-number (default nan). infstr : str, optional  String representation of floating point infinity (default inf). sign : string, either ‘-’, ‘+’, or ‘ ’, optional  Controls printing of the sign of floating-point types. If ‘+’, always  print the sign of positive values. If ‘ ’, always prints a space  (whitespace character) in the sign position of positive values. If  ‘-’, omit the sign character of positive values. (default ‘-’) formatter : dict of callables, optional  If not None, the keys should indicate the type(s) that the respective  formatting function applies to. Callables should return a string.  Types that are not specified (by their corresponding keys) are handled  by the default formatters. Individual types for which a formatter  can be set are:</p>
+<pre><code>- 'bool'
+- 'int'
+- 'timedelta' : a `numpy.timedelta64`
+- 'datetime' : a `numpy.datetime64`
+- 'float'
+- 'longfloat' : 128-bit floats
+- 'complexfloat'
+- 'longcomplexfloat' : composed of two 128-bit floats
+- 'numpystr' : types `numpy.string_` and `numpy.unicode_`
+- 'object' : `np.object_` arrays
+- 'str' : all other strings
+
+Other keys that can be used to set a group of types at once are:
+
+- 'all' : sets all types
+- 'int_kind' : sets 'int'
+- 'float_kind' : sets 'float' and 'longfloat'
+- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
+- 'str_kind' : sets 'str' and 'numpystr'
+</code></pre>
+<p>floatmode : str, optional  Controls the interpretation of the <code>precision</code> option for  floating-point types. Can take the following values  (default maxprec_equal):</p>
+<pre><code>* 'fixed': Always print exactly `precision` fractional digits,
+        even if this would print more or fewer digits than
+        necessary to specify the value uniquely.
+* 'unique': Print the minimum number of fractional digits necessary
+        to represent each value uniquely. Different elements may
+        have a different number of digits. The value of the
+        `precision` option is ignored.
+* 'maxprec': Print at most `precision` fractional digits, but if
+        an element can be uniquely represented with fewer digits
+        only print it with that many.
+* 'maxprec_equal': Print at most `precision` fractional digits,
+        but if every element in the array can be uniquely
+        represented with an equal number of fewer digits, use that
+        many digits for all elements.
+</code></pre>
+<p>legacy : string or <code>False</code>, optional  If set to the string <code>'1.13'</code> enables 1.13 legacy printing mode. This  approximates numpy 1.13 print output by including a space in the sign  position of floats and different behavior for 0d arrays. If set to  <code>False</code>, disables legacy mode. Unrecognized strings will be ignored  with a warning for forward compatibility.</p>
+<pre><code>.. versionadded:: 1.14.0
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>get_printoptions, printoptions, set_string_function, array2string</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>formatter</code> is always reset with a call to <code>set_printoptions</code>.</p>
+<p>Use <code>printoptions</code> as a context manager to set the values temporarily.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Floating point precision can be set:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.set_printoptions(precision=4) np.array([1.123456789]) [1.1235]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Long arrays can be summarised:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.set_printoptions(threshold=5) np.arange(10) array([0, 1, 2, …, 7, 8, 9])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Small results can be suppressed:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>eps = np.finfo(float).eps x = np.arange(4.) x**2 - (x + eps)**2 array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) np.set_printoptions(suppress=True) x**2 - (x + eps)**2 array([-0., -0., 0., 0.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>A custom formatter can be used to display array elements as desired:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.set_printoptions(formatter={‘all’:lambda x: ‘int: ’+str(-x)}) x = np.arange(3) x array([int: 0, int: -1, int: -2]) np.set_printoptions() # formatter gets reset x array([0, 1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>To put back the default options, you can use:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.set_printoptions(edgeitems=3, infstr=‘inf’, … linewidth=75, nanstr=‘nan’, precision=8, … suppress=False, threshold=1000, formatter=None)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Also to temporarily override options, use <code>printoptions</code> as a context manager:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>with np.printoptions(precision=2, suppress=True, threshold=5): … np.linspace(0, 10, 10) array([ 0. , 1.11, 2.22, …, 7.78, 8.89, 10. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2782">view source</a></div></div><div class="public anchor" id="var-set_string_function"><h3>set_string_function</h3><div class="usage"><code>(set_string_function f &amp; [{repr :repr}])</code><code>(set_string_function f)</code></div><div class="doc"><div class="markdown"><p>Set a Python function to be used when pretty printing arrays.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>f : function or None  Function to be used to pretty print arrays. The function should expect  a single array argument and return a string of the representation of  the array. If None, the function is reset to the default NumPy function  to print arrays. repr : bool, optional  If True (default), the function for pretty printing (<code>__repr__</code>)  is set, if False the function that returns the default string  representation (<code>__str__</code>) is set.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>set_printoptions, get_printoptions</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>def pprint(arr): … return ‘HA! - What are you going to do now?’ … np.set_string_function(pprint) a = np.arange(10) a HA! - What are you going to do now? _ = a</p>
+      <h1><a href="#0-1-2-3-4-5-6-7-8-9" name="0-1-2-3-4-5-6-7-8-9"></a>[0 1 2 3 4 5 6 7 8 9]</h1>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>We can reset the function to the default:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.set_string_function(None) a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p><code>repr</code> affects either pretty printing or normal string representation. Note that <code>__repr__</code> is still affected by setting <code>__str__</code> because the width of each array element in the returned string becomes equal to the length of the result of <code>__str__()</code>.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(4) np.set_string_function(lambda x:‘random’, repr=False) x.__str__() ‘random’ x.__repr__() ‘array([0, 1, 2, 3])’</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23940">view source</a></div></div><div class="public anchor" id="var-setbufsize"><h3>setbufsize</h3><div class="usage"><code>(setbufsize size)</code></div><div class="doc"><div class="markdown"><p>Set the size of the buffer used in ufuncs.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>size : int  Size of buffer.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9533">view source</a></div></div><div class="public anchor" id="var-setdiff1d"><h3>setdiff1d</h3><div class="usage"><code>(setdiff1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the set difference of two arrays.</p>
+<p>Return the unique values in <code>ar1</code> that are not in <code>ar2</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>ar1 : array_like  Input array. ar2 : array_like  Input comparison array. assume_unique : bool  If True, the input arrays are both assumed to be unique, which  can speed up the calculation. Default is False.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>setdiff1d : ndarray  1D array of values in <code>ar1</code> that are not in <code>ar2</code>. The result  is sorted when <code>assume_unique=False</code>, but otherwise only sorted  if the input is sorted.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1, 2, 3, 2, 4, 1]) b = np.array([3, 4, 5, 6]) np.setdiff1d(a, b) array([1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16287">view source</a></div></div><div class="public anchor" id="var-seterr"><h3>seterr</h3><div class="usage"><code>(seterr &amp; [{all :all, divide :divide, over :over, under :under, invalid :invalid}])</code><code>(seterr &amp; [{all :all, divide :divide, over :over, under :under}])</code><code>(seterr &amp; [{all :all, divide :divide, over :over}])</code><code>(seterr &amp; [{all :all, divide :divide}])</code><code>(seterr &amp; [{all :all}])</code><code>(seterr)</code></div><div class="doc"><div class="markdown"><p>Set how floating-point errors are handled.</p>
+<p>Note that operations on integer scalar types (such as <code>int16</code>) are handled like floating point, and are affected by these settings.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>all : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional  Set treatment for all types of floating-point errors at once:</p>
+<pre><code>- ignore: Take no action when the exception occurs.
+- warn: Print a `RuntimeWarning` (via the Python `warnings` module).
+- raise: Raise a `FloatingPointError`.
+- call: Call a function specified using the `seterrcall` function.
+- print: Print a warning directly to ``stdout``.
+- log: Record error in a Log object specified by `seterrcall`.
+
+The default is not to change the current behavior.
+</code></pre>
+<p>divide : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional  Treatment for division by zero. over : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional  Treatment for floating-point overflow. under : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional  Treatment for floating-point underflow. invalid : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional  Treatment for invalid floating-point operation.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>old_settings : dict  Dictionary containing the old settings.</p>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>seterrcall : Set a callback function for the ‘call’ mode. geterr, geterrcall, errstate</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The floating-point exceptions are defined in the IEEE 754 standard [1]_:</p>
+<ul>
+  <li>Division by zero: infinite result obtained from finite numbers.</li>
+  <li>Overflow: result too large to be expressed.</li>
+  <li>Underflow: result so close to zero that some precision  was lost.</li>
+  <li>Invalid operation: result is not an expressible number, typically  indicates that a NaN was produced.</li>
+</ul>
+<p>.. [1] <a href="https://en.wikipedia.org/wiki/IEEE_754">https://en.wikipedia.org/wiki/IEEE_754</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>old_settings = np.seterr(all=‘ignore’) #seterr to known value np.seterr(over=‘raise’) {‘divide’: ‘ignore’, ‘over’: ‘ignore’, ‘under’: ‘ignore’, ‘invalid’: ‘ignore’} np.seterr(**old_settings) # reset to default {‘divide’: ‘ignore’, ‘over’: ‘raise’, ‘under’: ‘ignore’, ‘invalid’: ‘ignore’}</p>
+      <p>np.int16(32000) * np.int16(3) 30464 old_settings = np.seterr(all=‘warn’, over=‘raise’) np.int16(32000) * np.int16(3) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> FloatingPointError: overflow encountered in short_scalars</module></stdin></p>
+      <p>from collections import OrderedDict old_settings = np.seterr(all=‘print’) OrderedDict(np.geterr()) OrderedDict([(‘divide’, ‘print’), (‘over’, ‘print’), (‘under’, ‘print’), (‘invalid’, ‘print’)]) np.int16(32000) * np.int16(3) 30464</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2347">view source</a></div></div><div class="public anchor" id="var-seterrcall"><h3>seterrcall</h3><div class="usage"><code>(seterrcall func)</code></div><div class="doc"><div class="markdown"><p>Set the floating-point error callback function or log object.</p>
+<p>There are two ways to capture floating-point error messages. The first is to set the error-handler to ‘call’, using <code>seterr</code>. Then, set the function to call using this function.</p>
+<p>The second is to set the error-handler to ‘log’, using <code>seterr</code>. Floating-point errors then trigger a call to the ‘write’ method of the provided object.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>func : callable f(err, flag) or object with write method  Function to call upon floating-point errors (‘call’-mode) or  object whose ‘write’ method is used to log such message (‘log’-mode).</p>
+<pre><code>The call function takes two arguments. The first is a string describing
+the type of error (such as "divide by zero", "overflow", "underflow",
+or "invalid value"), and the second is the status flag.  The flag is a
+byte, whose four least-significant bits indicate the type of error, one
+of "divide", "over", "under", "invalid"::
+
+  [0 0 0 0 divide over under invalid]
+
+In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.
+
+If an object is provided, its write method should take one argument,
+a string.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>h : callable, log instance or None  The old error handler.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>seterr, geterr, geterrcall</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Callback upon error:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>def err_handler(type, flag): … print(“Floating point error (%s), with flag %s” % (type, flag)) …</p>
+      <p>saved_handler = np.seterrcall(err_handler) save_err = np.seterr(all=‘call’) from collections import OrderedDict</p>
+      <p>np.array([1, 2, 3]) / 0.0 Floating point error (divide by zero), with flag 1 array([inf, inf, inf])</p>
+      <p>np.seterrcall(saved_handler) &lt;function err_handler at 0x…&gt; OrderedDict(sorted(np.seterr(**save_err).items())) OrderedDict([(‘divide’, ‘call’), (‘invalid’, ‘call’), (‘over’, ‘call’), (‘under’, ‘call’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Log error message:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>class Log(object): … def write(self, msg): … print(“LOG: %s” % msg) …</p>
+      <p>log = Log() saved_handler = np.seterrcall(log) save_err = np.seterr(all=‘log’)</p>
+      <p>np.array([1, 2, 3]) / 0.0 LOG: Warning: divide by zero encountered in true_divide array([inf, inf, inf])</p>
+      <p>np.seterrcall(saved_handler) &lt;numpy.core.numeric.Log object at 0x…&gt; OrderedDict(sorted(np.seterr(**save_err).items())) OrderedDict([(‘divide’, ‘log’), (‘invalid’, ‘log’), (‘over’, ‘log’), (‘under’, ‘log’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11939">view source</a></div></div><div class="public anchor" id="var-seterrobj"><h3>seterrobj</h3><div class="usage"><code>(seterrobj self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>seterrobj(errobj)</p>
+<p>Set the object that defines floating-point error handling.</p>
+<p>The error object contains all information that defines the error handling behavior in NumPy. <code>seterrobj</code> is used internally by the other functions that set error handling behavior (<code>seterr</code>, <code>seterrcall</code>).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>errobj : list  The error object, a list containing three elements:  [internal numpy buffer size, error mask, error callback function].</p>
+<pre><code>The error mask is a single integer that holds the treatment information
+on all four floating point errors. The information for each error type
+is contained in three bits of the integer. If we print it in base 8, we
+can see what treatment is set for "invalid", "under", "over", and
+"divide" (in that order). The printed string can be interpreted with
+
+* 0 : 'ignore'
+* 1 : 'warn'
+* 2 : 'raise'
+* 3 : 'call'
+* 4 : 'print'
+* 5 : 'log'
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>geterrobj, seterr, geterr, seterrcall, geterrcall getbufsize, setbufsize</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>For complete documentation of the types of floating-point exceptions and treatment options, see <code>seterr</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>old_errobj = np.geterrobj() # first get the defaults old_errobj [8192, 521, None]</p>
+      <p>def err_handler(type, flag): … print(“Floating point error (%s), with flag %s” % (type, flag)) … new_errobj = [20000, 12, err_handler] np.seterrobj(new_errobj) np.base_repr(12, 8) # int for divide=4 (‘print’) and over=1 (‘warn’) ‘14’ np.geterr() {‘over’: ‘warn’, ‘divide’: ‘print’, ‘invalid’: ‘ignore’, ‘under’: ‘ignore’} np.geterrcall() is err_handler True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27456">view source</a></div></div><div class="public anchor" id="var-setxor1d"><h3>setxor1d</h3><div class="usage"><code>(setxor1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the set exclusive-or of two arrays.</p>
+<p>Return the sorted, unique values that are in only one (not both) of the input arrays.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>ar1, ar2 : array_like  Input arrays. assume_unique : bool  If True, the input arrays are both assumed to be unique, which  can speed up the calculation. Default is False.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>setxor1d : ndarray  Sorted 1D array of unique values that are in only one of the input  arrays.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1, 2, 3, 2, 4]) b = np.array([2, 3, 5, 7, 5]) np.setxor1d(a,b) array([1, 4, 5, 7])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4823">view source</a></div></div><div class="public anchor" id="var-shape"><h3>shape</h3><div class="usage"><code>(shape &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the shape of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>shape : tuple of ints  The elements of the shape tuple give the lengths of the  corresponding array dimensions.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>alen ndarray.shape : Equivalent array method.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.shape(np.eye(3)) (3, 3) np.shape(<a href="null">1, 2</a>) (1, 2) np.shape([0]) (1,) np.shape(0) ()</p>
+      <p>a = np.array([(1, 2), (3, 4)], dtype=[(‘x’, ‘i4’), (‘y’, ‘i4’)]) np.shape(a) (2,) a.shape (2,)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5579">view source</a></div></div><div class="public anchor" id="var-shares_memory"><h3>shares_memory</h3><div class="usage"><code>(shares_memory &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>shares_memory(a, b, max_work=None)</p>
+<p>Determine if two arrays share memory</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a, b : ndarray  Input arrays max_work : int, optional  Effort to spend on solving the overlap problem (maximum number  of candidate solutions to consider). The following special  values are recognized:</p>
+<pre><code>max_work=MAY_SHARE_EXACT  (default)
+    The problem is solved exactly. In this case, the function returns
+    True only if there is an element shared between the arrays.
+max_work=MAY_SHARE_BOUNDS
+    Only the memory bounds of a and b are checked.
+</code></pre>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>numpy.TooHardError  Exceeded max_work.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : bool</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>may_share_memory</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.may_share_memory(np.array([1,2]), np.array([5,8,9])) False</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11412">view source</a></div></div><div class="public anchor" id="var-SHIFT_DIVIDEBYZERO"><h3>SHIFT_DIVIDEBYZERO</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16670">view source</a></div></div><div class="public anchor" id="var-SHIFT_INVALID"><h3>SHIFT_INVALID</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2072">view source</a></div></div><div class="public anchor" id="var-SHIFT_OVERFLOW"><h3>SHIFT_OVERFLOW</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12034">view source</a></div></div><div class="public anchor" id="var-SHIFT_UNDERFLOW"><h3>SHIFT_UNDERFLOW</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21615">view source</a></div></div><div class="public anchor" id="var-short"><h3>short</h3><div class="usage"><code>(short self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>short</code>. Character code: <code>'h'</code>. Canonical name: <code>np.short</code>. Alias <em>on this platform</em>: <code>np.int16</code>: 16-bit signed integer (-32768 to 32767).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12397">view source</a></div></div><div class="public anchor" id="var-show_config"><h3>show_config</h3><div class="usage"><code>(show_config)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20946">view source</a></div></div><div class="public anchor" id="var-sign"><h3>sign</h3><div class="usage"><code>(sign self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>sign(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Returns an element-wise indication of the sign of a number.</p>
+<p>The <code>sign</code> function returns <code>-1 if x &lt; 0, 0 if x==0, 1 if x &gt; 0</code>. nan is returned for nan inputs.</p>
+<p>For complex inputs, the <code>sign</code> function returns <code>sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j</code>.</p>
+<p>complex(nan, 0) is returned for complex nan inputs.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The sign of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>There is more than one definition of sign in common use for complex numbers. The definition used here is equivalent to :math:<code>x/\sqrt{x*x}</code> which is different from a common alternative, :math:<code>x/|x|</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sign([-5., 4.5]) array([-1., 1.]) np.sign(0) 0 np.sign(5-2j) (1+0j)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25917">view source</a></div></div><div class="public anchor" id="var-signbit"><h3>signbit</h3><div class="usage"><code>(signbit self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>signbit(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Returns element-wise True where signbit is set (less than zero).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  The input value(s). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>result : ndarray of bool  Output array, or reference to <code>out</code> if that was supplied.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.signbit(-1.2) True np.signbit(np.array([1, -2.3, 2.1])) array([False, True, False])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23258">view source</a></div></div><div class="public anchor" id="var-signedinteger"><h3>signedinteger</h3><div class="usage"><code>(signedinteger self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all signed integer scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13733">view source</a></div></div><div class="public anchor" id="var-sin"><h3>sin</h3><div class="usage"><code>(sin self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>sin(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Trigonometric sine, element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Angle, in radians (:math:<code>2 \pi</code> rad equals 360 degrees). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : array_like  The sine of each element of x.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>arcsin, sinh, cos</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The sine is one of the fundamental functions of trigonometry (the mathematical study of triangles). Consider a circle of radius 1 centered on the origin. A ray comes in from the :math:<code>+x</code> axis, makes an angle at the origin (measured counter-clockwise from that axis), and departs from the origin. The :math:<code>y</code> coordinate of the outgoing ray’s intersection with the unit circle is the sine of that angle. It ranges from -1 for :math:<code>x=3\pi / 2</code> to +1 for :math:<code>\pi / 2.</code> The function has zeroes where the angle is a multiple of :math:<code>\pi</code>. Sines of angles between :math:<code>\pi</code> and :math:<code>2\pi</code> are negative. The numerous properties of the sine and related functions are included in any standard trigonometry text.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Print sine of one angle:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sin(np.pi/2.) 1.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Print sines of an array of angles given in degrees:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Plot the sine function:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pylab as plt x = np.linspace(-np.pi, np.pi, 201) plt.plot(x, np.sin(x)) plt.xlabel(‘Angle [rad]’) plt.ylabel(‘sin(x)’) plt.axis(‘tight’) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14648">view source</a></div></div><div class="public anchor" id="var-sinc"><h3>sinc</h3><div class="usage"><code>(sinc &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the sinc function.</p>
+<p>The sinc function is :math:<code>\sin(\pi x)/(\pi x)</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : ndarray  Array (possibly multi-dimensional) of values for which to to  calculate <code>sinc(x)</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  <code>sinc(x)</code>, which has the same shape as the input.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><code>sinc(0)</code> is the limit value 1.</p>
+<p>The name sinc is short for “sine cardinal” or “sinus cardinalis”.</p>
+<p>The sinc function is used in various signal processing applications, including in anti-aliasing, in the construction of a Lanczos resampling filter, and in interpolation.</p>
+<p>For bandlimited interpolation of discrete-time signals, the ideal interpolation kernel is proportional to the sinc function.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Weisstein, Eric W. “Sinc Function.” From MathWorld–A Wolfram Web  Resource. <a href="http://mathworld.wolfram.com/SincFunction.html">http://mathworld.wolfram.com/SincFunction.html</a> .. [2] Wikipedia, “Sinc function”,  <a href="https://en.wikipedia.org/wiki/Sinc_function">https://en.wikipedia.org/wiki/Sinc_function</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import matplotlib.pyplot as plt x = np.linspace(-4, 4, 41) np.sinc(x)  array([-3.89804309e-17, -4.92362781e-02, -8.40918587e-02, # may vary  -8.90384387e-02, -5.84680802e-02, 3.89804309e-17,  6.68206631e-02, 1.16434881e-01, 1.26137788e-01,  8.50444803e-02, -3.89804309e-17, -1.03943254e-01,  -1.89206682e-01, -2.16236208e-01, -1.55914881e-01,  3.89804309e-17, 2.33872321e-01, 5.04551152e-01,  7.56826729e-01, 9.35489284e-01, 1.00000000e+00,  9.35489284e-01, 7.56826729e-01, 5.04551152e-01,  2.33872321e-01, 3.89804309e-17, -1.55914881e-01,  -2.16236208e-01, -1.89206682e-01, -1.03943254e-01,  -3.89804309e-17, 8.50444803e-02, 1.26137788e-01,  1.16434881e-01, 6.68206631e-02, 3.89804309e-17,  -5.84680802e-02, -8.90384387e-02, -8.40918587e-02,  -4.92362781e-02, -3.89804309e-17])</p>
+      <p>plt.plot(x, np.sinc(x)) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Sinc Function”) Text(0.5, 1.0, ‘Sinc Function’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“X”) Text(0.5, 0, ‘X’) plt.show()</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17565">view source</a></div></div><div class="public anchor" id="var-single"><h3>single</h3><div class="usage"><code>(single self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Single-precision floating-point number type, compatible with C <code>float</code>. Character code: <code>'f'</code>. Canonical name: <code>np.single</code>. Alias <em>on this platform</em>: <code>np.float32</code>: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22984">view source</a></div></div><div class="public anchor" id="var-singlecomplex"><h3>singlecomplex</h3><div class="usage"><code>(singlecomplex self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two single-precision floating-point numbers. Character code: <code>'F'</code>. Canonical name: <code>np.csingle</code>. Alias: <code>np.singlecomplex</code>. Alias <em>on this platform</em>: <code>np.complex64</code>: Complex number type composed of 2 32-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24359">view source</a></div></div><div class="public anchor" id="var-sinh"><h3>sinh</h3><div class="usage"><code>(sinh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>sinh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Hyperbolic sine, element-wise.</p>
+<p>Equivalent to <code>1/2 * (np.exp(x) - np.exp(-x))</code> or <code>-1j * np.sin(1j*x)</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The corresponding hyperbolic sine values.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If <code>out</code> is provided, the function writes the result into it, and returns a reference to <code>out</code>. (See Examples)</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. New York, NY: Dover, 1972, pg. 83.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sinh(0) 0.0 np.sinh(np.pi*1j/2) 1j np.sinh(np.pi*1j) # (exact value is 0) 1.2246063538223773e-016j</p>
+      <h1><a href="#discrepancy-due-to-vagaries-of-floating-point-arithmetic-" name="discrepancy-due-to-vagaries-of-floating-point-arithmetic-"></a>Discrepancy due to vagaries of floating point arithmetic.</h1>
+      <h1><a href="#example-of-providing-the-optional-output-parameter" name="example-of-providing-the-optional-output-parameter"></a>Example of providing the optional output parameter</h1>
+      <p>out1 = np.array([0], dtype=‘d’) out2 = np.sinh([0.1], out1) out2 is out1 True</p>
+      <h1><a href="#example-of-valueerror-due-to-provision-of-shape-mis-matched" name="example-of-valueerror-due-to-provision-of-shape-mis-matched"></a>Example of ValueError due to provision of shape mis-matched <code>out</code></h1>
+      <p>np.sinh(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> ValueError: operands could not be broadcast together with shapes (3,3) (2,2)</module></stdin></p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24394">view source</a></div></div><div class="public anchor" id="var-size"><h3>size</h3><div class="usage"><code>(size &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the number of elements along a given axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. axis : int, optional  Axis along which the elements are counted. By default, give  the total number of elements.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>element_count : int  Number of elements along the specified axis.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>shape : dimensions of array ndarray.shape : dimensions of array ndarray.size : number of elements in array</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1,2,3],[4,5,6</a>) np.size(a) 6 np.size(a,1) 3 np.size(a,0) 2</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23777">view source</a></div></div><div class="public anchor" id="var-sometrue"><h3>sometrue</h3><div class="usage"><code>(sometrue &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Check whether some values are true.</p>
+<p>Refer to <code>any</code> for full documentation.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>any : equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24345">view source</a></div></div><div class="public anchor" id="var-sort"><h3>sort</h3><div class="usage"><code>(sort &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a sorted copy of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array to be sorted. axis : int or None, optional  Axis along which to sort. If None, the array is flattened before  sorting. The default is -1, which sorts along the last axis. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, optional  Sorting algorithm. The default is ‘quicksort’. Note that both ‘stable’  and ‘mergesort’ use timsort or radix sort under the covers and, in general,  the actual implementation will vary with data type. The ‘mergesort’ option  is retained for backwards compatibility.</p>
+<pre><code>.. versionchanged:: 1.15.0.
+   The 'stable' option was added.
+</code></pre>
+<p>order : str or list of str, optional  When <code>a</code> is an array with fields defined, this argument specifies  which fields to compare first, second, etc. A single field can  be specified as a string, and not all fields need be specified,  but unspecified fields will still be used, in the order in which  they come up in the dtype, to break ties.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>sorted_array : ndarray  Array of the same type and shape as <code>a</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.sort : Method to sort an array in-place. argsort : Indirect sort. lexsort : Indirect stable sort on multiple keys. searchsorted : Find elements in a sorted array. partition : Partial sort.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The various sorting algorithms are characterized by their average speed, worst case performance, work space size, and whether they are stable. A stable sort keeps items with the same key in the same relative order. The four algorithms implemented in NumPy have the following properties:</p>
+<p>=========== ======= ============= ============ ========  kind speed worst case work space stable =========== ======= ============= ============ ======== ‘quicksort’ 1 O(n^2) 0 no ‘heapsort’ 3 O(n*log(n)) 0 no ‘mergesort’ 2 O(n*log(n)) ~n/2 yes ‘timsort’ 2 O(n*log(n)) ~n/2 yes =========== ======= ============= ============ ========</p>
+<p>.. note:: The datatype determines which of ‘mergesort’ or ‘timsort’  is actually used, even if ‘mergesort’ is specified. User selection  at a finer scale is not currently available.</p>
+<p>All the sort algorithms make temporary copies of the data when sorting along any but the last axis. Consequently, sorting along the last axis is faster and uses less space than sorting along any other axis.</p>
+<p>The sort order for complex numbers is lexicographic. If both the real and imaginary parts are non-nan then the order is determined by the real parts except when they are equal, in which case the order is determined by the imaginary parts.</p>
+<p>Previous to numpy 1.4.0 sorting real and complex arrays containing nan values led to undefined behaviour. In numpy versions &gt;= 1.4.0 nan values are sorted to the end. The extended sort order is:</p>
+<ul>
+  <li>Real: [R, nan]</li>
+  <li>Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]</li>
+</ul>
+<p>where R is a non-nan real value. Complex values with the same nan placements are sorted according to the non-nan part if it exists. Non-nan values are sorted as before.</p>
+<p>.. versionadded:: 1.12.0</p>
+<p>quicksort has been changed to <code>introsort &lt;https://en.wikipedia.org/wiki/Introsort&gt;</code>_. When sorting does not make enough progress it switches to <code>heapsort &lt;https://en.wikipedia.org/wiki/Heapsort&gt;</code>_. This implementation makes quicksort O(n*log(n)) in the worst case.</p>
+<p>‘stable’ automatically chooses the best stable sorting algorithm for the data type being sorted. It, along with ‘mergesort’ is currently mapped to <code>timsort &lt;https://en.wikipedia.org/wiki/Timsort&gt;</code>_ or <code>radix sort &lt;https://en.wikipedia.org/wiki/Radix_sort&gt;</code>_ depending on the data type. API forward compatibility currently limits the ability to select the implementation and it is hardwired for the different data types.</p>
+<p>.. versionadded:: 1.17.0</p>
+<p>Timsort is added for better performance on already or nearly sorted data. On random data timsort is almost identical to mergesort. It is now used for stable sort while quicksort is still the default sort if none is chosen. For timsort details, refer to <code>CPython listsort.txt &lt;https://github.com/python/cpython/blob/3.7/Objects/listsort.txt&gt;</code>_. ‘mergesort’ and ‘stable’ are mapped to radix sort for integer data types. Radix sort is an O(n) sort instead of O(n log n).</p>
+<p>.. versionchanged:: 1.17.0</p>
+<p>NaT now sorts to the end of arrays for consistency with NaN.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1,4],[3,1</a>) np.sort(a) # sort along the last axis array(<a href="null">1, 4],
+       [1, 3</a>) np.sort(a, axis=None) # sort the flattened array array([1, 1, 3, 4]) np.sort(a, axis=0) # sort along the first axis array(<a href="null">1, 1],
+       [3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Use the <code>order</code> keyword to specify a field to use when sorting a structured array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>dtype = [(‘name’, ‘S10’), (‘height’, float), (‘age’, int)] values = [(‘Arthur’, 1.8, 41), (‘Lancelot’, 1.9, 38), … (‘Galahad’, 1.7, 38)] a = np.array(values, dtype=dtype) # create a structured array np.sort(a, order=‘height’) # doctest: +SKIP array([(‘Galahad’, 1.7, 38), (‘Arthur’, 1.8, 41),  (‘Lancelot’, 1.8999999999999999, 38)],  dtype=[(‘name’, ‘|S10’), (‘height’, ‘&lt;f8’), (‘age’, ‘&lt;i4’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Sort by age, then height if ages are equal:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sort(a, order=[‘age’, ‘height’]) # doctest: +SKIP array([(‘Galahad’, 1.7, 38), (‘Lancelot’, 1.8999999999999999, 38),  (‘Arthur’, 1.8, 41)],  dtype=[(‘name’, ‘|S10’), (‘height’, ‘&lt;f8’), (‘age’, ‘&lt;i4’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12643">view source</a></div></div><div class="public anchor" id="var-sort_complex"><h3>sort_complex</h3><div class="usage"><code>(sort_complex &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Sort a complex array using the real part first, then the imaginary part.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : complex ndarray  Always returns a sorted complex array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sort_complex([5, 3, 6, 2, 1]) array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])</p>
+      <p>np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j]) array([1.+2.j, 2.-1.j, 3.-3.j, 3.-2.j, 3.+5.j])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20437">view source</a></div></div><div class="public anchor" id="var-source"><h3>source</h3><div class="usage"><code>(source object &amp; [{output :output}])</code><code>(source object)</code></div><div class="doc"><div class="markdown"><p>Print or write to a file the source code for a NumPy object.</p>
+<p>The source code is only returned for objects written in Python. Many functions and classes are defined in C and will therefore not return useful information.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>object : numpy object  Input object. This can be any object (function, class, module,  …). output : file object, optional  If <code>output</code> not supplied then source code is printed to screen  (sys.stdout). File object must be created with either write ‘w’ or  append ‘a’ modes.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>lookfor, info</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.source(np.interp) #doctest: +SKIP In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py def interp(x, xp, fp, left=None, right=None):  ""“…. (full docstring printed)”""  if isinstance(x, (float, int, number)):  return compiled_interp([x], xp, fp, left, right).item()  else:  return compiled_interp(x, xp, fp, left, right)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The source code is only returned for objects written in Python.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.source(np.array) #doctest: +SKIP Not available for this object.</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20351">view source</a></div></div><div class="public anchor" id="var-spacing"><h3>spacing</h3><div class="usage"><code>(spacing self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>spacing(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the distance between x and the nearest adjacent number.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Values to find the spacing of. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  The spacing of values of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>It can be considered as a generalization of EPS: <code>spacing(np.float64(1)) == np.finfo(np.float64).eps</code>, and there should not be any representable number between <code>x + spacing(x)</code> and x for any finite x.</p>
+<p>Spacing of +- inf and NaN is NaN.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.spacing(1) == np.finfo(np.float64).eps True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2491">view source</a></div></div><div class="public anchor" id="var-split"><h3>split</h3><div class="usage"><code>(split &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Split an array into multiple sub-arrays as views into <code>ary</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>ary : ndarray  Array to be divided into sub-arrays. indices_or_sections : int or 1-D array  If <code>indices_or_sections</code> is an integer, N, the array will be divided  into N equal arrays along <code>axis</code>. If such a split is not possible,  an error is raised.</p>
+<pre><code>If `indices_or_sections` is a 1-D array of sorted integers, the entries
+indicate where along `axis` the array is split.  For example,
+``[2, 3]`` would, for ``axis=0``, result in
+
+  - ary[:2]
+  - ary[2:3]
+  - ary[3:]
+
+If an index exceeds the dimension of the array along `axis`,
+an empty sub-array is returned correspondingly.
+</code></pre>
+<p>axis : int, optional  The axis along which to split, default is 0.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>sub-arrays : list of ndarrays  A list of sub-arrays as views into <code>ary</code>.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If <code>indices_or_sections</code> is given as an integer, but  a split does not result in equal division.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>array_split : Split an array into multiple sub-arrays of equal or  near-equal size. Does not raise an exception if  an equal division cannot be made. hsplit : Split array into multiple sub-arrays horizontally (column-wise). vsplit : Split array into multiple sub-arrays vertically (row wise). dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). concatenate : Join a sequence of arrays along an existing axis. stack : Join a sequence of arrays along a new axis. hstack : Stack arrays in sequence horizontally (column wise). vstack : Stack arrays in sequence vertically (row wise). dstack : Stack arrays in sequence depth wise (along third dimension).</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(9.0) np.split(x, 3) [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7., 8.])]</p>
+      <p>x = np.arange(8.0) np.split(x, [3, 5, 6, 10]) [array([0., 1., 2.]),  array([3., 4.]),  array([5.]),  array([6., 7.]),  array([], dtype=float64)]</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17212">view source</a></div></div><div class="public anchor" id="var-sqrt"><h3>sqrt</h3><div class="usage"><code>(sqrt self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>sqrt(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the non-negative square-root of an array, element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  The values whose square-roots are required. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  An array of the same shape as <code>x</code>, containing the positive  square-root of each element in <code>x</code>. If any element in <code>x</code> is  complex, a complex array is returned (and the square-roots of  negative reals are calculated). If all of the elements in <code>x</code>  are real, so is <code>y</code>, with negative elements returning <code>nan</code>.  If <code>out</code> was provided, <code>y</code> is a reference to it.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>lib.scimath.sqrt  A version which returns complex numbers when given negative reals.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p><em>sqrt</em> has–consistent with common convention–as its branch cut the real “interval” [<code>-inf</code>, 0), and is continuous from above on it. A branch cut is a curve in the complex plane across which a given complex function fails to be continuous.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sqrt([1,4,9]) array([ 1., 2., 3.])</p>
+      <p>np.sqrt([4, -1, -3+4J]) array([ 2.+0.j, 0.+1.j, 1.+2.j])</p>
+      <p>np.sqrt([4, -1, np.inf]) array([ 2., nan, inf])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18184">view source</a></div></div><div class="public anchor" id="var-square"><h3>square</h3><div class="usage"><code>(square self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>square(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the element-wise square of the input.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input data. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  Element-wise <code>x*x</code>, of the same shape and dtype as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.linalg.matrix_power sqrt power</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.square([-1j, 1]) array([-1.-0.j, 1.+0.j])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20252">view source</a></div></div><div class="public anchor" id="var-squeeze"><h3>squeeze</h3><div class="usage"><code>(squeeze &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Remove single-dimensional entries from the shape of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  .. versionadded:: 1.7.0</p>
+<pre><code>Selects a subset of the single-dimensional entries in the
+shape. If an axis is selected with shape entry greater than
+one, an error is raised.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>squeezed : ndarray  The input array, but with all or a subset of the  dimensions of length 1 removed. This is always <code>a</code> itself  or a view into <code>a</code>.</p>
+<h2><a href="#raises" name="raises"></a>Raises</h2>
+<p>ValueError  If <code>axis</code> is not None, and an axis being squeezed is not of length 1</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>expand_dims : The inverse operation, adding singleton dimensions reshape : Insert, remove, and combine dimensions, and resize existing ones</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">[0], [1], [2</a>]) x.shape (1, 3, 1) np.squeeze(x).shape (3,) np.squeeze(x, axis=0).shape (3, 1) np.squeeze(x, axis=1).shape Traceback (most recent call last): … ValueError: cannot select an axis to squeeze out which has size not equal to one np.squeeze(x, axis=2).shape (1, 3)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3628">view source</a></div></div><div class="public anchor" id="var-stack"><h3>stack</h3><div class="usage"><code>(stack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Join a sequence of arrays along a new axis.</p>
+<p>The <code>axis</code> parameter specifies the index of the new axis in the dimensions of the result. For example, if <code>axis=0</code> it will be the first dimension and if <code>axis=-1</code> it will be the last dimension.</p>
+<p>.. versionadded:: 1.10.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arrays : sequence of array_like  Each array must have the same shape.</p>
+<p>axis : int, optional  The axis in the result array along which the input arrays are stacked.</p>
+<p>out : ndarray, optional  If provided, the destination to place the result. The shape must be  correct, matching that of what stack would have returned if no  out argument were specified.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>stacked : ndarray  The stacked array has one more dimension than the input arrays.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>concatenate : Join a sequence of arrays along an existing axis. split : Split array into a list of multiple sub-arrays of equal size. block : Assemble arrays from blocks.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>arrays = [np.random.randn(3, 4) for _ in range(10)] np.stack(arrays, axis=0).shape (10, 3, 4)</p>
+      <p>np.stack(arrays, axis=1).shape (3, 10, 4)</p>
+      <p>np.stack(arrays, axis=2).shape (3, 4, 10)</p>
+      <p>a = np.array([1, 2, 3]) b = np.array([2, 3, 4]) np.stack((a, b)) array(<a href="null">1, 2, 3],
+       [2, 3, 4</a>)</p>
+      <p>np.stack((a, b), axis=-1) array(<a href="null">1, 2],
+       [2, 3],
+       [3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27919">view source</a></div></div><div class="public anchor" id="var-std"><h3>std</h3><div class="usage"><code>(std &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the standard deviation along the specified axis.</p>
+<p>Returns the standard deviation, a measure of the spread of a distribution, of the array elements. The standard deviation is computed for the flattened array by default, otherwise over the specified axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Calculate the standard deviation of these values. axis : None or int or tuple of ints, optional  Axis or axes along which the standard deviation is computed. The  default is to compute the standard deviation of the flattened array.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If this is a tuple of ints, a standard deviation is performed over
+multiple axes, instead of a single axis or all the axes as before.
+</code></pre>
+<p>dtype : dtype, optional  Type to use in computing the standard deviation. For arrays of  integer type the default is float64, for arrays of float types it is  the same as the array type. out : ndarray, optional  Alternative output array in which to place the result. It must have  the same shape as the expected output but the type (of the calculated  values) will be cast if necessary. ddof : int, optional  Means Delta Degrees of Freedom. The divisor used in calculations  is <code>N - ddof</code>, where <code>N</code> represents the number of elements.  By default <code>ddof</code> is zero. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `std` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>standard_deviation : ndarray, see dtype parameter above.  If <code>out</code> is None, return a new array containing the standard deviation,  otherwise return a reference to the output array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>var, mean, nanmean, nanstd, nanvar ufuncs-output-type</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The standard deviation is the square root of the average of the squared deviations from the mean, i.e., <code>std = sqrt(mean(abs(x - x.mean())**2))</code>.</p>
+<p>The average squared deviation is normally calculated as <code>x.sum() / N</code>, where <code>N = len(x)</code>. If, however, <code>ddof</code> is specified, the divisor <code>N - ddof</code> is used instead. In standard statistical practice, <code>ddof=1</code> provides an unbiased estimator of the variance of the infinite population. <code>ddof=0</code> provides a maximum likelihood estimate of the variance for normally distributed variables. The standard deviation computed in this function is the square root of the estimated variance, so even with <code>ddof=1</code>, it will not be an unbiased estimate of the standard deviation per se.</p>
+<p>Note that, for complex numbers, <code>std</code> takes the absolute value before squaring, so that the result is always real and nonnegative.</p>
+<p>For floating-point input, the <em>std</em> is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for float32 (see example below). Specifying a higher-accuracy accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 2], [3, 4</a>) np.std(a) 1.1180339887498949 # may vary np.std(a, axis=0) array([1., 1.]) np.std(a, axis=1) array([0.5, 0.5])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>In single precision, std() can be inaccurate:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.zeros((2, 512*512), dtype=np.float32) a[0, :] = 1.0 a[1, :] = 0.1 np.std(a) 0.45000005</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Computing the standard deviation in float64 is more accurate:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.std(a, dtype=np.float64) 0.44999999925494177 # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3383">view source</a></div></div><div class="public anchor" id="var-str"><h3>str</h3><div class="usage"><code>(str self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>str(object=’’) -&gt; str str(bytes_or_buffer[, encoding[, errors]]) -&gt; str</p>
+<p>Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to ‘strict’.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7592">view source</a></div></div><div class="public anchor" id="var-str0"><h3>str0</h3><div class="usage"><code>(str0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17522">view source</a></div></div><div class="public anchor" id="var-str_"><h3>str_</h3><div class="usage"><code>(str_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24356">view source</a></div></div><div class="public anchor" id="var-string_"><h3>string_</h3><div class="usage"><code>(string_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18536">view source</a></div></div><div class="public anchor" id="var-subtract"><h3>subtract</h3><div class="usage"><code>(subtract self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>subtract(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Subtract arguments, element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1, x2 : array_like  The arrays to be subtracted from each other. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The difference of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Equivalent to <code>x1 - x2</code> in terms of array broadcasting.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.subtract(1.0, 4.0) -3.0</p>
+      <p>x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.subtract(x1, x2) array(<a href="null"> 0.,  0.,  0.],
+       [ 3.,  3.,  3.],
+       [ 6.,  6.,  6.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16748">view source</a></div></div><div class="public anchor" id="var-sum"><h3>sum</h3><div class="usage"><code>(sum &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Sum of array elements over a given axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Elements to sum. axis : None or int or tuple of ints, optional  Axis or axes along which a sum is performed. The default,  axis=None, will sum all of the elements of the input array. If  axis is negative it counts from the last to the first axis.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If axis is a tuple of ints, a sum is performed on all of the axes
+specified in the tuple instead of a single axis or all the axes as
+before.
+</code></pre>
+<p>dtype : dtype, optional  The type of the returned array and of the accumulator in which the  elements are summed. The dtype of <code>a</code> is used by default unless <code>a</code>  has an integer dtype of less precision than the default platform  integer. In that case, if <code>a</code> is signed then the platform integer  is used while if <code>a</code> is unsigned then an unsigned integer of the  same precision as the platform integer is used. out : ndarray, optional  Alternative output array in which to place the result. It must have  the same shape as the expected output, but the type of the output  values will be cast if necessary. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `sum` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<p>initial : scalar, optional  Starting value for the sum. See <code>~numpy.ufunc.reduce</code> for details.</p>
+<pre><code>.. versionadded:: 1.15.0
+</code></pre>
+<p>where : array_like of bool, optional  Elements to include in the sum. See <code>~numpy.ufunc.reduce</code> for details.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>sum_along_axis : ndarray  An array with the same shape as <code>a</code>, with the specified  axis removed. If <code>a</code> is a 0-d array, or if <code>axis</code> is None, a scalar  is returned. If an output array is specified, a reference to  <code>out</code> is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ndarray.sum : Equivalent method.</p>
+<p>add.reduce : Equivalent functionality of <code>add</code>.</p>
+<p>cumsum : Cumulative sum of array elements.</p>
+<p>trapz : Integration of array values using the composite trapezoidal rule.</p>
+<p>mean, average</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Arithmetic is modular when using integer types, and no error is raised on overflow.</p>
+<p>The sum of an empty array is the neutral element 0:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sum([]) 0.0</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>For floating point numbers the numerical precision of sum (and <code>np.add.reduce</code>) is in general limited by directly adding each number individually to the result causing rounding errors in every step. However, often numpy will use a numerically better approach (partial pairwise summation) leading to improved precision in many use-cases. This improved precision is always provided when no <code>axis</code> is given. When <code>axis</code> is given, it will depend on which axis is summed. Technically, to provide the best speed possible, the improved precision is only used when the summation is along the fast axis in memory. Note that the exact precision may vary depending on other parameters. In contrast to NumPy, Python’s <code>math.fsum</code> function uses a slower but more precise approach to summation. Especially when summing a large number of lower precision floating point numbers, such as <code>float32</code>, numerical errors can become significant. In such cases it can be advisable to use <code>dtype="float64"</code> to use a higher precision for the output.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sum([0.5, 1.5]) 2.0 np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32) 1 np.sum(<a href="null">0, 1], [0, 5</a>) 6 np.sum(<a href="null">0, 1], [0, 5</a>, axis=0) array([0, 6]) np.sum(<a href="null">0, 1], [0, 5</a>, axis=1) array([1, 5]) np.sum(<a href="null">0, 1], [np.nan, 5</a>, where=[False, True], axis=1) array([1., 5.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>If the accumulator is too small, overflow occurs:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.ones(128, dtype=np.int8).sum(dtype=np.int8) -128</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>You can also start the sum with a value other than zero:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sum([10], initial=5) 15</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7470">view source</a></div></div><div class="public anchor" id="var-swapaxes"><h3>swapaxes</h3><div class="usage"><code>(swapaxes &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Interchange two axes of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. axis1 : int  First axis. axis2 : int  Second axis.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>a_swapped : ndarray  For NumPy &gt;= 1.10.0, if <code>a</code> is an ndarray, then a view of <code>a</code> is  returned; otherwise a new array is created. For earlier NumPy  versions a view of <code>a</code> is returned only if the order of the  axes is changed, otherwise the input array is returned.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array(<a href="null">1,2,3</a>) np.swapaxes(x,0,1) array(<a href="null">1],
+       [2],
+       [3</a>)</p>
+      <p>x = np.array(<a href="null">[0,1],[2,3</a>,<a href="null">4,5],[6,7</a>]) x array(<a href="null">[0, 1],
+        [2, 3</a>,  <a href="null">4, 5],
+        [6, 7</a>])</p>
+      <p>np.swapaxes(x,0,2) array(<a href="null">[0, 4],
+        [2, 6</a>,  <a href="null">1, 5],
+        [3, 7</a>])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20391">view source</a></div></div><div class="public anchor" id="var-sys"><h3>sys</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>This module provides access to some objects used or maintained by the interpreter and to functions that interact strongly with the interpreter.</p>
+<p>Dynamic objects:</p>
+<p>argv – command line arguments; argv[0] is the script pathname if known path – module search path; path[0] is the script directory, else ’’ modules – dictionary of loaded modules</p>
+<p>displayhook – called to show results in an interactive session excepthook – called to handle any uncaught exception other than SystemExit  To customize printing in an interactive session or to install a custom  top-level exception handler, assign other functions to replace these.</p>
+<p>stdin – standard input file object; used by input() stdout – standard output file object; used by print() stderr – standard error object; used for error messages  By assigning other file objects (or objects that behave like files)  to these, it is possible to redirect all of the interpreter’s I/O.</p>
+<p>last_type – type of last uncaught exception last_value – value of last uncaught exception last_traceback – traceback of last uncaught exception  These three are only available in an interactive session after a  traceback has been printed.</p>
+<p>Static objects:</p>
+<p>builtin_module_names – tuple of module names built into this interpreter copyright – copyright notice pertaining to this interpreter exec_prefix – prefix used to find the machine-specific Python library executable – absolute path of the executable binary of the Python interpreter float_info – a named tuple with information about the float implementation. float_repr_style – string indicating the style of repr() output for floats hash_info – a named tuple with information about the hash algorithm. hexversion – version information encoded as a single integer implementation – Python implementation information. int_info – a named tuple with information about the int implementation. maxsize – the largest supported length of containers. maxunicode – the value of the largest Unicode code point platform – platform identifier prefix – prefix used to find the Python library thread_info – a named tuple with information about the thread implementation. version – the version of this interpreter as a string version_info – version information as a named tuple <strong>stdin</strong> – the original stdin; don’t touch! <strong>stdout</strong> – the original stdout; don’t touch! <strong>stderr</strong> – the original stderr; don’t touch! <strong>displayhook</strong> – the original displayhook; don’t touch! <strong>excepthook</strong> – the original excepthook; don’t touch!</p>
+<p>Functions:</p>
+<p>displayhook() – print an object to the screen, and save it in builtins._ excepthook() – print an exception and its traceback to sys.stderr exc_info() – return thread-safe information about the current exception exit() – exit the interpreter by raising SystemExit getdlopenflags() – returns flags to be used for dlopen() calls getprofile() – get the global profiling function getrefcount() – return the reference count for an object (plus one :-) getrecursionlimit() – return the max recursion depth for the interpreter getsizeof() – return the size of an object in bytes gettrace() – get the global debug tracing function setcheckinterval() – control how often the interpreter checks for events setdlopenflags() – set the flags to be used for dlopen() calls setprofile() – set the global profiling function setrecursionlimit() – set the max recursion depth for the interpreter settrace() – set the global debug tracing function</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23485">view source</a></div></div><div class="public anchor" id="var-take"><h3>take</h3><div class="usage"><code>(take &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Take elements from an array along an axis.</p>
+<p>When axis is not None, this function does the same thing as “fancy” indexing (indexing arrays using arrays); however, it can be easier to use if you need elements along a given axis. A call such as <code>np.take(arr, indices, axis=3)</code> is equivalent to <code>arr[:,:,:,indices,...]</code>.</p>
+<p>Explained without fancy indexing, this is equivalent to the following use of <code>ndindex</code>, which sets each of <code>ii</code>, <code>jj</code>, and <code>kk</code> to a tuple of indices::</p>
+<pre><code>Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+Nj = indices.shape
+for ii in ndindex(Ni):
+    for jj in ndindex(Nj):
+        for kk in ndindex(Nk):
+            out[ii + jj + kk] = a[ii + (indices[jj],) + kk]
+</code></pre>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like (Ni…, M, Nk…)  The source array. indices : array_like (Nj…)  The indices of the values to extract.</p>
+<pre><code>.. versionadded:: 1.8.0
+
+Also allow scalars for indices.
+</code></pre>
+<p>axis : int, optional  The axis over which to select values. By default, the flattened  input array is used. out : ndarray, optional (Ni…, Nj…, Nk…)  If provided, the result will be placed in this array. It should  be of the appropriate shape and dtype. Note that <code>out</code> is always  buffered if <code>mode='raise'</code>; use other modes for better performance. mode : {‘raise’, ‘wrap’, ‘clip’}, optional  Specifies how out-of-bounds indices will behave.</p>
+<pre><code>* 'raise' -- raise an error (default)
+* 'wrap' -- wrap around
+* 'clip' -- clip to the range
+
+'clip' mode means that all indices that are too large are replaced
+by the index that addresses the last element along that axis. Note
+that this disables indexing with negative numbers.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray (Ni…, Nj…, Nk…)  The returned array has the same type as <code>a</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>compress : Take elements using a boolean mask ndarray.take : equivalent method take_along_axis : Take elements by matching the array and the index arrays</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>By eliminating the inner loop in the description above, and using <code>s_</code> to build simple slice objects, <code>take</code> can be expressed in terms of applying fancy indexing to each 1-d slice::</p>
+<pre><code>Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+for ii in ndindex(Ni):
+    for kk in ndindex(Nj):
+        out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices]
+</code></pre>
+<p>For this reason, it is equivalent to (but faster than) the following use of <code>apply_along_axis</code>::</p>
+<pre><code>out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a)
+</code></pre>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = [4, 3, 5, 7, 6, 8] indices = [0, 1, 4] np.take(a, indices) array([4, 3, 6])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>In this example if <code>a</code> is an ndarray, “fancy” indexing can be used.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(a) a[indices] array([4, 3, 6])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>If <code>indices</code> is not one dimensional, the output also has these dimensions.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.take(a, <a href="null">0, 1], [2, 3</a>) array(<a href="null">4, 3],
+       [5, 7</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11788">view source</a></div></div><div class="public anchor" id="var-take_along_axis"><h3>take_along_axis</h3><div class="usage"><code>(take_along_axis &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Take values from the input array by matching 1d index and data slices.</p>
+<p>This iterates over matching 1d slices oriented along the specified axis in the index and data arrays, and uses the former to look up values in the latter. These slices can be different lengths.</p>
+<p>Functions returning an index along an axis, like <code>argsort</code> and <code>argpartition</code>, produce suitable indices for this function.</p>
+<p>.. versionadded:: 1.15.0</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr: ndarray (Ni…, M, Nk…)  Source array indices: ndarray (Ni…, J, Nk…)  Indices to take along each 1d slice of <code>arr</code>. This must match the  dimension of arr, but dimensions Ni and Nj only need to broadcast  against <code>arr</code>. axis: int  The axis to take 1d slices along. If axis is None, the input array is  treated as if it had first been flattened to 1d, for consistency with  <code>sort</code> and <code>argsort</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out: ndarray (Ni…, J, Nk…)  The indexed result.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>This is equivalent to (but faster than) the following use of <code>ndindex</code> and <code>s_</code>, which sets each of <code>ii</code> and <code>kk</code> to a tuple of indices::</p>
+<pre><code>Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
+J = indices.shape[axis]  # Need not equal M
+out = np.empty(Ni + (J,) + Nk)
+
+for ii in ndindex(Ni):
+    for kk in ndindex(Nk):
+        a_1d       = a      [ii + s_[:,] + kk]
+        indices_1d = indices[ii + s_[:,] + kk]
+        out_1d     = out    [ii + s_[:,] + kk]
+        for j in range(J):
+            out_1d[j] = a_1d[indices_1d[j]]
+</code></pre>
+<p>Equivalently, eliminating the inner loop, the last two lines would be::</p>
+<pre><code>        out_1d[:] = a_1d[indices_1d]
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>take : Take along an axis, using the same indices for every 1d slice put_along_axis :  Put values into the destination array by matching 1d index and data slices</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>For this sample array</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">10, 30, 20], [60, 40, 50</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>We can sort either by using sort directly, or argsort and this function</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.sort(a, axis=1) array(<a href="null">10, 20, 30],
+       [40, 50, 60</a>) ai = np.argsort(a, axis=1); ai array(<a href="null">0, 2, 1],
+       [1, 2, 0</a>) np.take_along_axis(a, ai, axis=1) array(<a href="null">10, 20, 30],
+       [40, 50, 60</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The same works for max and min, if you expand the dimensions:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.expand_dims(np.max(a, axis=1), axis=1) array(<a href="null">30],
+       [60</a>) ai = np.expand_dims(np.argmax(a, axis=1), axis=1) ai array(<a href="null">1],
+       [0</a>) np.take_along_axis(a, ai, axis=1) array(<a href="null">30],
+       [60</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>If we want to get the max and min at the same time, we can stack the indices first</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>ai_min = np.expand_dims(np.argmin(a, axis=1), axis=1) ai_max = np.expand_dims(np.argmax(a, axis=1), axis=1) ai = np.concatenate([ai_min, ai_max], axis=1) ai array(<a href="null">0, 1],
+       [1, 0</a>) np.take_along_axis(a, ai, axis=1) array(<a href="null">10, 30],
+       [40, 60</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7138">view source</a></div></div><div class="public anchor" id="var-tan"><h3>tan</h3><div class="usage"><code>(tan self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>tan(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute tangent element-wise.</p>
+<p>Equivalent to <code>np.sin(x)/np.cos(x)</code> element-wise.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The corresponding tangent values.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If <code>out</code> is provided, the function writes the result into it, and returns a reference to <code>out</code>. (See Examples)</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. New York, NY: Dover, 1972.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from math import pi np.tan(np.array([-pi,pi/2,pi])) array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16])</p>
+      <h1><a href="#example-of-providing-the-optional-output-parameter-illustrating" name="example-of-providing-the-optional-output-parameter-illustrating"></a>Example of providing the optional output parameter illustrating</h1>
+      <h1><a href="#that-what-is-returned-is-a-reference-to-said-parameter" name="that-what-is-returned-is-a-reference-to-said-parameter"></a>that what is returned is a reference to said parameter</h1>
+      <p>out1 = np.array([0], dtype=‘d’) out2 = np.cos([0.1], out1) out2 is out1 True</p>
+      <h1><a href="#example-of-valueerror-due-to-provision-of-shape-mis-matched" name="example-of-valueerror-due-to-provision-of-shape-mis-matched"></a>Example of ValueError due to provision of shape mis-matched <code>out</code></h1>
+      <p>np.cos(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> ValueError: operands could not be broadcast together with shapes (3,3) (2,2)</module></stdin></p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19003">view source</a></div></div><div class="public anchor" id="var-tanh"><h3>tanh</h3><div class="usage"><code>(tanh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>tanh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Compute hyperbolic tangent element-wise.</p>
+<p>Equivalent to <code>np.sinh(x)/np.cosh(x)</code> or <code>-1j * np.tan(1j*x)</code>.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray  The corresponding hyperbolic tangent values.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If <code>out</code> is provided, the function writes the result into it, and returns a reference to <code>out</code>. (See Examples)</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.  New York, NY: Dover, 1972, pg. 83.  <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a></p>
+<p>.. [2] Wikipedia, “Hyperbolic function”,  <a href="https://en.wikipedia.org/wiki/Hyperbolic_function">https://en.wikipedia.org/wiki/Hyperbolic_function</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.tanh((0, np.pi*1j, np.pi*1j/2)) array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j])</p>
+      <h1><a href="#example-of-providing-the-optional-output-parameter-illustrating" name="example-of-providing-the-optional-output-parameter-illustrating"></a>Example of providing the optional output parameter illustrating</h1>
+      <h1><a href="#that-what-is-returned-is-a-reference-to-said-parameter" name="that-what-is-returned-is-a-reference-to-said-parameter"></a>that what is returned is a reference to said parameter</h1>
+      <p>out1 = np.array([0], dtype=‘d’) out2 = np.tanh([0.1], out1) out2 is out1 True</p>
+      <h1><a href="#example-of-valueerror-due-to-provision-of-shape-mis-matched" name="example-of-valueerror-due-to-provision-of-shape-mis-matched"></a>Example of ValueError due to provision of shape mis-matched <code>out</code></h1>
+      <p>np.tanh(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> ValueError: operands could not be broadcast together with shapes (3,3) (2,2)</module></stdin></p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26875">view source</a></div></div><div class="public anchor" id="var-tensordot"><h3>tensordot</h3><div class="usage"><code>(tensordot &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute tensor dot product along specified axes.</p>
+<p>Given two tensors, <code>a</code> and <code>b</code>, and an array_like object containing two array_like objects, <code>(a_axes, b_axes)</code>, sum the products of <code>a</code>’s and <code>b</code>’s elements (components) over the axes specified by <code>a_axes</code> and <code>b_axes</code>. The third argument can be a single non-negative integer_like scalar, <code>N</code>; if it is such, then the last <code>N</code> dimensions of <code>a</code> and the first <code>N</code> dimensions of <code>b</code> are summed over.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a, b : array_like  Tensors to “dot”.</p>
+<p>axes : int or (2,) array_like  * integer_like  If an int N, sum over the last N axes of <code>a</code> and the first N axes  of <code>b</code> in order. The sizes of the corresponding axes must match.  * (2,) array_like  Or, a list of axes to be summed over, first sequence applying to <code>a</code>,  second to <code>b</code>. Both elements array_like must be of the same length.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>output : ndarray  The tensor dot product of the input.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>dot, einsum</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Three common use cases are:  * <code>axes = 0</code> : tensor product :math:<code>a\otimes b</code>  * <code>axes = 1</code> : tensor dot product :math:<code>a\cdot b</code>  * <code>axes = 2</code> : (default) tensor double contraction :math:<code>a:b</code></p>
+<p>When <code>axes</code> is integer_like, the sequence for evaluation will be: first the -Nth axis in <code>a</code> and 0th axis in <code>b</code>, and the -1th axis in <code>a</code> and Nth axis in <code>b</code> last.</p>
+<p>When there is more than one axis to sum over - and they are not the last (first) axes of <code>a</code> (<code>b</code>) - the argument <code>axes</code> should consist of two sequences of the same length, with the first axis to sum over given first in both sequences, the second axis second, and so forth.</p>
+<p>The shape of the result consists of the non-contracted axes of the first tensor, followed by the non-contracted axes of the second.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>A “traditional” example:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(60.).reshape(3,4,5) b = np.arange(24.).reshape(4,3,2) c = np.tensordot(a,b, axes=([1,0],[0,1])) c.shape (5, 2) c array(<a href="null">4400., 4730.],
+       [4532., 4874.],
+       [4664., 5018.],
+       [4796., 5162.],
+       [4928., 5306.</a>)</p>
+      <h1><a href="#a-slower-but-equivalent-way-of-computing-the-same" name="a-slower-but-equivalent-way-of-computing-the-same"></a>A slower but equivalent way of computing the same…</h1>
+      <p>d = np.zeros((5,2)) for i in range(5): … for j in range(2): … for k in range(3): … for n in range(4): … d[i,j] += a[k,n,i] * b[n,k,j] c == d array(<a href="null"> True,  True],
+       [ True,  True],
+       [ True,  True],
+       [ True,  True],
+       [ True,  True</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>An extended example taking advantage of the overloading of + and *:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(range(1, 9)) a.shape = (2, 2, 2) A = np.array((‘a’, ‘b’, ‘c’, ‘d’), dtype=object) A.shape = (2, 2) a; A array(<a href="null">[1, 2],
+        [3, 4</a>,  <a href="null">5, 6],
+        [7, 8</a>]) array(<a href="null">'a', 'b'],
+       ['c', 'd'</a>, dtype=object)</p>
+      <p>np.tensordot(a, A) # third argument default is 2 for double-contraction array([‘abbcccdddd’, ‘aaaaabbbbbbcccccccdddddddd’], dtype=object)</p>
+      <p>np.tensordot(a, A, 1) array(<a href="null">['acc', 'bdd'],
+        ['aaacccc', 'bbbdddd'</a>,  <a href="null">'aaaaacccccc', 'bbbbbdddddd'],
+        ['aaaaaaacccccccc', 'bbbbbbbdddddddd'</a>], dtype=object)</p>
+      <p>np.tensordot(a, A, 0) # tensor product (result too long to incl.) array(<a href="null">[[['a', 'b'],
+          ['c', 'd'</a>,  …</p>
+      <p>np.tensordot(a, A, (0, 1)) array(<a href="null">['abbbbb', 'cddddd'],
+        ['aabbbbbb', 'ccdddddd'</a>,  <a href="null">'aaabbbbbbb', 'cccddddddd'],
+        ['aaaabbbbbbbb', 'ccccdddddddd'</a>], dtype=object)</p>
+      <p>np.tensordot(a, A, (2, 1)) array(<a href="null">['abb', 'cdd'],
+        ['aaabbbb', 'cccdddd'</a>,  <a href="null">'aaaaabbbbbb', 'cccccdddddd'],
+        ['aaaaaaabbbbbbbb', 'cccccccdddddddd'</a>], dtype=object)</p>
+      <p>np.tensordot(a, A, ((0, 1), (0, 1))) array([‘abbbcccccddddddd’, ‘aabbbbccccccdddddddd’], dtype=object)</p>
+      <p>np.tensordot(a, A, ((2, 1), (1, 0))) array([‘acccbbdddd’, ‘aaaaacccccccbbbbbbdddddddd’], dtype=object)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19235">view source</a></div></div><div class="public anchor" id="var-test"><h3>test</h3><div class="usage"><code>(test self module_name)</code></div><div class="doc"><div class="markdown"><p>Pytest test runner.</p>
+<p>A test function is typically added to a package’s <strong>init</strong>.py like so::</p>
+<p>from numpy._pytesttester import PytestTester  test = PytestTester(__name__).test  del PytestTester</p>
+<p>Calling this test function finds and runs all tests associated with the module and all its sub-modules.</p>
+<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
+<p>module_name : str  Full path to the package to test.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>module_name : module name  The name of the module to test.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Unlike the previous <code>nose</code>-based implementation, this class is not publicly exposed as it performs some <code>numpy</code>-specific warning suppression.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27850">view source</a></div></div><div class="public anchor" id="var-tile"><h3>tile</h3><div class="usage"><code>(tile &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Construct an array by repeating A the number of times given by reps.</p>
+<p>If <code>reps</code> has length <code>d</code>, the result will have dimension of <code>max(d, A.ndim)</code>.</p>
+<p>If <code>A.ndim &lt; d</code>, <code>A</code> is promoted to be d-dimensional by prepending new axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication, or shape (1, 1, 3) for 3-D replication. If this is not the desired behavior, promote <code>A</code> to d-dimensions manually before calling this function.</p>
+<p>If <code>A.ndim &gt; d</code>, <code>reps</code> is promoted to <code>A</code>.ndim by pre-pending 1’s to it. Thus for an <code>A</code> of shape (2, 3, 4, 5), a <code>reps</code> of (2, 2) is treated as (1, 1, 2, 2).</p>
+<p>Note : Although tile may be used for broadcasting, it is strongly recommended to use numpy’s broadcasting operations and functions.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>A : array_like  The input array. reps : array_like  The number of repetitions of <code>A</code> along each axis.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>c : ndarray  The tiled output array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>repeat : Repeat elements of an array. broadcast_to : Broadcast an array to a new shape</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([0, 1, 2]) np.tile(a, 2) array([0, 1, 2, 0, 1, 2]) np.tile(a, (2, 2)) array(<a href="null">0, 1, 2, 0, 1, 2],
+       [0, 1, 2, 0, 1, 2</a>) np.tile(a, (2, 1, 2)) array(<a href="null">[0, 1, 2, 0, 1, 2</a>,  <a href="null">0, 1, 2, 0, 1, 2</a>])</p>
+      <p>b = np.array(<a href="null">1, 2], [3, 4</a>) np.tile(b, 2) array(<a href="null">1, 2, 1, 2],
+       [3, 4, 3, 4</a>) np.tile(b, (2, 1)) array(<a href="null">1, 2],
+       [3, 4],
+       [1, 2],
+       [3, 4</a>)</p>
+      <p>c = np.array([1,2,3,4]) np.tile(c,(4,1)) array(<a href="null">1, 2, 3, 4],
+       [1, 2, 3, 4],
+       [1, 2, 3, 4],
+       [1, 2, 3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16170">view source</a></div></div><div class="public anchor" id="var-timedelta64"><h3>timedelta64</h3><div class="usage"><code>(timedelta64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13344">view source</a></div></div><div class="public anchor" id="var-TooHardError"><h3>TooHardError</h3><div class="usage"><code>(TooHardError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1646">view source</a></div></div><div class="public anchor" id="var-trace"><h3>trace</h3><div class="usage"><code>(trace &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the sum along diagonals of the array.</p>
+<p>If <code>a</code> is 2-D, the sum along its diagonal with the given offset is returned, i.e., the sum of elements <code>a[i,i+offset]</code> for all i.</p>
+<p>If <code>a</code> has more than two dimensions, then the axes specified by axis1 and axis2 are used to determine the 2-D sub-arrays whose traces are returned. The shape of the resulting array is the same as that of <code>a</code> with <code>axis1</code> and <code>axis2</code> removed.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array, from which the diagonals are taken. offset : int, optional  Offset of the diagonal from the main diagonal. Can be both positive  and negative. Defaults to 0. axis1, axis2 : int, optional  Axes to be used as the first and second axis of the 2-D sub-arrays  from which the diagonals should be taken. Defaults are the first two  axes of <code>a</code>. dtype : dtype, optional  Determines the data-type of the returned array and of the accumulator  where the elements are summed. If dtype has the value None and <code>a</code> is  of integer type of precision less than the default integer  precision, then the default integer precision is used. Otherwise,  the precision is the same as that of <code>a</code>. out : ndarray, optional  Array into which the output is placed. Its type is preserved and  it must be of the right shape to hold the output.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>sum_along_diagonals : ndarray  If <code>a</code> is 2-D, the sum along the diagonal is returned. If <code>a</code> has  larger dimensions, then an array of sums along diagonals is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>diag, diagonal, diagflat</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.trace(np.eye(3)) 3.0 a = np.arange(8).reshape((2,2,2)) np.trace(a) array([6, 8])</p>
+      <p>a = np.arange(24).reshape((2,2,2,3)) np.trace(a).shape (2, 3)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7909">view source</a></div></div><div class="public anchor" id="var-tracemalloc_domain"><h3>tracemalloc_domain</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L436">view source</a></div></div><div class="public anchor" id="var-transpose"><h3>transpose</h3><div class="usage"><code>(transpose &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Permute the dimensions of an array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Input array. axes : list of ints, optional  By default, reverse the dimensions, otherwise permute the axes  according to the values given.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>p : ndarray  <code>a</code> with its axes permuted. A view is returned whenever  possible.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>moveaxis argsort</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Use <code>transpose(a, argsort(axes))</code> to invert the transposition of tensors when using the <code>axes</code> keyword argument.</p>
+<p>Transposing a 1-D array returns an unchanged view of the original array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(4).reshape((2,2)) x array(<a href="null">0, 1],
+       [2, 3</a>)</p>
+      <p>np.transpose(x) array(<a href="null">0, 2],
+       [1, 3</a>)</p>
+      <p>x = np.ones((1, 2, 3)) np.transpose(x, (1, 0, 2)).shape (2, 1, 3)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26425">view source</a></div></div><div class="public anchor" id="var-trapz"><h3>trapz</h3><div class="usage"><code>(trapz &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Integrate along the given axis using the composite trapezoidal rule.</p>
+<p>Integrate <code>y</code> (<code>x</code>) along given axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>y : array_like  Input array to integrate. x : array_like, optional  The sample points corresponding to the <code>y</code> values. If <code>x</code> is None,  the sample points are assumed to be evenly spaced <code>dx</code> apart. The  default is None. dx : scalar, optional  The spacing between sample points when <code>x</code> is None. The default is 1. axis : int, optional  The axis along which to integrate.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>trapz : float  Definite integral as approximated by trapezoidal rule.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>sum, cumsum</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Image [2]_ illustrates trapezoidal rule – y-axis locations of points will be taken from <code>y</code> array, by default x-axis distances between points will be 1.0, alternatively they can be provided with <code>x</code> array or with <code>dx</code> scalar. Return value will be equal to combined area under the red lines.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] Wikipedia page: <a href="https://en.wikipedia.org/wiki/Trapezoidal_rule">https://en.wikipedia.org/wiki/Trapezoidal_rule</a></p>
+<p>.. [2] Illustration image:  <a href="https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png">https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png</a></p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.trapz([1,2,3]) 4.0 np.trapz([1,2,3], x=[4,6,8]) 8.0 np.trapz([1,2,3], dx=2) 8.0 a = np.arange(6).reshape(2, 3) a array(<a href="null">0, 1, 2],
+       [3, 4, 5</a>) np.trapz(a, axis=0) array([1.5, 2.5, 3.5]) np.trapz(a, axis=1) array([2., 8.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5039">view source</a></div></div><div class="public anchor" id="var-tri"><h3>tri</h3><div class="usage"><code>(tri N &amp; [{M :M, k :k, dtype :dtype}])</code><code>(tri N &amp; [{M :M, k :k}])</code><code>(tri N &amp; [{M :M}])</code><code>(tri N)</code></div><div class="doc"><div class="markdown"><p>An array with ones at and below the given diagonal and zeros elsewhere.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>N : int  Number of rows in the array. M : int, optional  Number of columns in the array.  By default, <code>M</code> is taken equal to <code>N</code>. k : int, optional  The sub-diagonal at and below which the array is filled.  <code>k</code> = 0 is the main diagonal, while <code>k</code> &lt; 0 is below it,  and <code>k</code> &gt; 0 is above. The default is 0. dtype : dtype, optional  Data type of the returned array. The default is float.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>tri : ndarray of shape (N, M)  Array with its lower triangle filled with ones and zero elsewhere;  in other words <code>T[i,j] == 1</code> for <code>j &lt;= i + k</code>, 0 otherwise.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.tri(3, 5, 2, dtype=int) array(<a href="null">1, 1, 1, 0, 0],
+       [1, 1, 1, 1, 0],
+       [1, 1, 1, 1, 1</a>)</p>
+      <p>np.tri(3, 5, -1) array(<a href="null">0.,  0.,  0.,  0.,  0.],
+       [1.,  0.,  0.,  0.,  0.],
+       [1.,  1.,  0.,  0.,  0.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27112">view source</a></div></div><div class="public anchor" id="var-tril"><h3>tril</h3><div class="usage"><code>(tril &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Lower triangle of an array.</p>
+<p>Return a copy of an array with elements above the <code>k</code>-th diagonal zeroed.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>m : array_like, shape (M, N)  Input array. k : int, optional  Diagonal above which to zero elements. <code>k = 0</code> (the default) is the  main diagonal, <code>k &lt; 0</code> is below it and <code>k &gt; 0</code> is above.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>tril : ndarray, shape (M, N)  Lower triangle of <code>m</code>, of same shape and data-type as <code>m</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>triu : same thing, only for the upper triangle</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.tril(<a href="null">1,2,3],[4,5,6],[7,8,9],[10,11,12</a>, -1) array(<a href="null"> 0,  0,  0],
+       [ 4,  0,  0],
+       [ 7,  8,  0],
+       [10, 11, 12</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14615">view source</a></div></div><div class="public anchor" id="var-tril_indices"><h3>tril_indices</h3><div class="usage"><code>(tril_indices n &amp; [{k :k, m :m}])</code><code>(tril_indices n &amp; [{k :k}])</code><code>(tril_indices n)</code></div><div class="doc"><div class="markdown"><p>Return the indices for the lower-triangle of an (n, m) array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>n : int  The row dimension of the arrays for which the returned  indices will be valid. k : int, optional  Diagonal offset (see <code>tril</code> for details). m : int, optional  .. versionadded:: 1.9.0</p>
+<pre><code>The column dimension of the arrays for which the returned
+arrays will be valid.
+By default `m` is taken equal to `n`.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>inds : tuple of arrays  The indices for the triangle. The returned tuple contains two arrays,  each with the indices along one dimension of the array.</p>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>triu_indices : similar function, for upper-triangular. mask_indices : generic function accepting an arbitrary mask function. tril, triu</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.4.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Compute two different sets of indices to access 4x4 arrays, one for the lower triangular part starting at the main diagonal, and one starting two diagonals further right:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>il1 = np.tril_indices(4) il2 = np.tril_indices(4, 2)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Here is how they can be used with a sample array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(16).reshape(4, 4) a array(<a href="null"> 0,  1,  2,  3],
+       [ 4,  5,  6,  7],
+       [ 8,  9, 10, 11],
+       [12, 13, 14, 15</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Both for indexing:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a[il1] array([ 0, 4, 5, …, 13, 14, 15])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>And for assigning values:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a[il1] = -1 a array(<a href="null">-1,  1,  2,  3],
+       [-1, -1,  6,  7],
+       [-1, -1, -1, 11],
+       [-1, -1, -1, -1</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>These cover almost the whole array (two diagonals right of the main one):</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a[il2] = -10 a array(<a href="null">-10, -10, -10,   3],
+       [-10, -10, -10, -10],
+       [-10, -10, -10, -10],
+       [-10, -10, -10, -10</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26472">view source</a></div></div><div class="public anchor" id="var-tril_indices_from"><h3>tril_indices_from</h3><div class="usage"><code>(tril_indices_from &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices for the lower-triangle of arr.</p>
+<p>See <code>tril_indices</code> for full details.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr : array_like  The indices will be valid for square arrays whose dimensions are  the same as arr. k : int, optional  Diagonal offset (see <code>tril</code> for details).</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>tril_indices, tril</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.4.0</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20777">view source</a></div></div><div class="public anchor" id="var-trim_zeros"><h3>trim_zeros</h3><div class="usage"><code>(trim_zeros &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Trim the leading and/or trailing zeros from a 1-D array or sequence.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>filt : 1-D array or sequence  Input array. trim : str, optional  A string with ‘f’ representing trim from front and ‘b’ to trim from  back. Default is ‘fb’, trim zeros from both front and back of the  array.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>trimmed : 1-D array or sequence  The result of trimming the input. The input data type is preserved.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0)) np.trim_zeros(a) array([1, 2, 3, 0, 2, 1])</p>
+      <p>np.trim_zeros(a, ‘b’) array([0, 0, 0, …, 0, 2, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The input data type is preserved, list/tuple in means list/tuple out.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.trim_zeros([0, 1, 2, 0]) [1, 2]</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21775">view source</a></div></div><div class="public anchor" id="var-triu"><h3>triu</h3><div class="usage"><code>(triu &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Upper triangle of an array.</p>
+<p>Return a copy of a matrix with the elements below the <code>k</code>-th diagonal zeroed.</p>
+<p>Please refer to the documentation for <code>tril</code> for further details.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>tril : lower triangle of an array</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.triu(<a href="null">1,2,3],[4,5,6],[7,8,9],[10,11,12</a>, -1) array(<a href="null"> 1,  2,  3],
+       [ 4,  5,  6],
+       [ 0,  8,  9],
+       [ 0,  0, 12</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25622">view source</a></div></div><div class="public anchor" id="var-triu_indices"><h3>triu_indices</h3><div class="usage"><code>(triu_indices n &amp; [{k :k, m :m}])</code><code>(triu_indices n &amp; [{k :k}])</code><code>(triu_indices n)</code></div><div class="doc"><div class="markdown"><p>Return the indices for the upper-triangle of an (n, m) array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>n : int  The size of the arrays for which the returned indices will  be valid. k : int, optional  Diagonal offset (see <code>triu</code> for details). m : int, optional  .. versionadded:: 1.9.0</p>
+<pre><code>The column dimension of the arrays for which the returned
+arrays will be valid.
+By default `m` is taken equal to `n`.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>inds : tuple, shape(2) of ndarrays, shape(<code>n</code>)  The indices for the triangle. The returned tuple contains two arrays,  each with the indices along one dimension of the array. Can be used  to slice a ndarray of shape(<code>n</code>, <code>n</code>).</p>
+<h2><a href="#see-also" name="see-also"></a>See also</h2>
+<p>tril_indices : similar function, for lower-triangular. mask_indices : generic function accepting an arbitrary mask function. triu, tril</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.4.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<p>Compute two different sets of indices to access 4x4 arrays, one for the upper triangular part starting at the main diagonal, and one starting two diagonals further right:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>iu1 = np.triu_indices(4) iu2 = np.triu_indices(4, 2)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Here is how they can be used with a sample array:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(16).reshape(4, 4) a array(<a href="null"> 0,  1,  2,  3],
+       [ 4,  5,  6,  7],
+       [ 8,  9, 10, 11],
+       [12, 13, 14, 15</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Both for indexing:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a[iu1] array([ 0, 1, 2, …, 10, 11, 15])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>And for assigning values:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a[iu1] = -1 a array(<a href="null">-1, -1, -1, -1],
+       [ 4, -1, -1, -1],
+       [ 8,  9, -1, -1],
+       [12, 13, 14, -1</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>These cover only a small part of the whole array (two diagonals right of the main one):</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a[iu2] = -10 a array(<a href="null"> -1,  -1, -10, -10],
+       [  4,  -1,  -1, -10],
+       [  8,   9,  -1,  -1],
+       [ 12,  13,  14,  -1</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19814">view source</a></div></div><div class="public anchor" id="var-triu_indices_from"><h3>triu_indices_from</h3><div class="usage"><code>(triu_indices_from &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices for the upper-triangle of arr.</p>
+<p>See <code>triu_indices</code> for full details.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>arr : ndarray, shape(N, N)  The indices will be valid for square arrays. k : int, optional  Diagonal offset (see <code>triu</code> for details).</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>triu_indices_from : tuple, shape(2) of ndarray, shape(N)  Indices for the upper-triangle of <code>arr</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>triu_indices, triu</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.4.0</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24460">view source</a></div></div><div class="public anchor" id="var-True_"><h3>True_</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11014">view source</a></div></div><div class="public anchor" id="var-true_divide"><h3>true_divide</h3><div class="usage"><code>(true_divide self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>true_divide(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Returns a true division of the inputs, element-wise.</p>
+<p>Instead of the Python traditional ‘floor division’, this returns a true division. True division adjusts the output type to present the best answer, regardless of input types.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x1 : array_like  Dividend array. x2 : array_like  Divisor array. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray or scalar  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The floor division operator <code>//</code> was added in Python 2.2 making <code>//</code> and <code>/</code> equivalent operators. The default floor division operation of <code>/</code> can be replaced by true division with <code>from
+__future__ import division</code>.</p>
+<p>In Python 3.0, <code>//</code> is the floor division operator and <code>/</code> the true division operator. The <code>true_divide(x1, x2)</code> function is equivalent to true division in Python.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(5) np.true_divide(x, 4) array([ 0. , 0.25, 0.5 , 0.75, 1. ])</p>
+      <p>x//4 array([0, 0, 0, 0, 1])</p>
+      <p>from <strong>future</strong> import division x/4 array([ 0. , 0.25, 0.5 , 0.75, 1. ]) x//4 array([0, 0, 0, 0, 1])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23555">view source</a></div></div><div class="public anchor" id="var-trunc"><h3>trunc</h3><div class="usage"><code>(trunc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>trunc(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
+<p>Return the truncated value of the input, element-wise.</p>
+<p>The truncated value of the scalar <code>x</code> is the nearest integer <code>i</code> which is closer to zero than <code>x</code> is. In short, the fractional part of the signed number <code>x</code> is discarded.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  Input data. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>y : ndarray or scalar  The truncated value of each element in <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ceil, floor, rint</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>.. versionadded:: 1.3.0</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.trunc(a) array([-1., -1., -0., 0., 1., 1., 2.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19521">view source</a></div></div><div class="public anchor" id="var-typecodes"><h3>typecodes</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14605">view source</a></div></div><div class="public anchor" id="var-typeDict"><h3>typeDict</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17202">view source</a></div></div><div class="public anchor" id="var-typeNA"><h3>typeNA</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3139">view source</a></div></div><div class="public anchor" id="var-typename"><h3>typename</h3><div class="usage"><code>(typename char)</code></div><div class="doc"><div class="markdown"><p>Return a description for the given data type code.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>char : str  Data type code.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : str  Description of the input data type code.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>dtype, typecodes</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>typechars = [‘S1’, ‘?’, ‘B’, ‘D’, ‘G’, ‘F’, ‘I’, ‘H’, ‘L’, ‘O’, ‘Q’, … ‘S’, ‘U’, ‘V’, ‘b’, ‘d’, ‘g’, ‘f’, ‘i’, ‘h’, ‘l’, ‘q’] for typechar in typechars: … print(typechar, ‘ : ’, np.typename(typechar)) … S1 : character ? : bool B : unsigned char D : complex double precision G : complex long double precision F : complex single precision I : unsigned integer H : unsigned short L : unsigned long integer O : object Q : unsigned long long integer S : string U : unicode V : void b : signed char d : double precision g : long precision f : single precision i : integer h : short l : long integer q : long long integer</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27800">view source</a></div></div><div class="public anchor" id="var-ubyte"><h3>ubyte</h3><div class="usage"><code>(ubyte self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned char</code>. Character code: <code>'B'</code>. Canonical name: <code>np.ubyte</code>. Alias <em>on this platform</em>: <code>np.uint8</code>: 8-bit unsigned integer (0 to 255).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25616">view source</a></div></div><div class="public anchor" id="var-ufunc"><h3>ufunc</h3><div class="usage"><code>(ufunc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Functions that operate element by element on whole arrays.</p>
+<p>To see the documentation for a specific ufunc, use <code>info</code>. For example, <code>np.info(np.sin)</code>. Because ufuncs are written in C (for speed) and linked into Python with NumPy’s ufunc facility, Python’s help() function finds this page whenever help() is called on a ufunc.</p>
+<p>A detailed explanation of ufuncs can be found in the docs for :ref:<code>ufuncs</code>.</p>
+<h1><a href="#calling-ufuncs-" name="calling-ufuncs-"></a>Calling ufuncs:</h1>
+<p>op(*x[, out], where=True, **kwargs) Apply <code>op</code> to the arguments <code>*x</code> elementwise, broadcasting the arguments.</p>
+<p>The broadcasting rules are:</p>
+<ul>
+  <li>Dimensions of length 1 may be prepended to either array.</li>
+  <li>Arrays may be repeated along dimensions of length 1.</li>
+</ul>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>*x : array_like  Input arrays. out : ndarray, None, or tuple of ndarray and None, optional  Alternate array object(s) in which to put the result; if provided, it  must have a shape that the inputs broadcast to. A tuple of arrays  (possible only as a keyword argument) must have length equal to the  number of outputs; use None for uninitialized outputs to be  allocated by the ufunc. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>r : ndarray or tuple of ndarray  <code>r</code> will have the shape that the arrays in <code>x</code> broadcast to; if <code>out</code> is  provided, it will be returned. If not, <code>r</code> will be allocated and  may contain uninitialized values. If the function has more than one  output, then the result will be a tuple of arrays.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1596">view source</a></div></div><div class="public anchor" id="var-UFUNC_BUFSIZE_DEFAULT"><h3>UFUNC_BUFSIZE_DEFAULT</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1395">view source</a></div></div><div class="public anchor" id="var-UFUNC_PYVALS_NAME"><h3>UFUNC_PYVALS_NAME</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15736">view source</a></div></div><div class="public anchor" id="var-uint"><h3>uint</h3><div class="usage"><code>(uint self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned long</code>. Character code: <code>'L'</code>. Canonical name: <code>np.uint</code>. Alias <em>on this platform</em>: <code>np.uint64</code>: 64-bit unsigned integer (0 to 18446744073709551615). Alias <em>on this platform</em>: <code>np.uintp</code>: Unsigned integer large enough to fit pointer, compatible with C <code>uintptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5411">view source</a></div></div><div class="public anchor" id="var-uint0"><h3>uint0</h3><div class="usage"><code>(uint0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned long</code>. Character code: <code>'L'</code>. Canonical name: <code>np.uint</code>. Alias <em>on this platform</em>: <code>np.uint64</code>: 64-bit unsigned integer (0 to 18446744073709551615). Alias <em>on this platform</em>: <code>np.uintp</code>: Unsigned integer large enough to fit pointer, compatible with C <code>uintptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2277">view source</a></div></div><div class="public anchor" id="var-uint16"><h3>uint16</h3><div class="usage"><code>(uint16 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned short</code>. Character code: <code>'H'</code>. Canonical name: <code>np.ushort</code>. Alias <em>on this platform</em>: <code>np.uint16</code>: 16-bit unsigned integer (0 to 65535).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5702">view source</a></div></div><div class="public anchor" id="var-uint32"><h3>uint32</h3><div class="usage"><code>(uint32 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned int</code>. Character code: <code>'I'</code>. Canonical name: <code>np.uintc</code>. Alias <em>on this platform</em>: <code>np.uint32</code>: 32-bit unsigned integer (0 to 4294967295).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6901">view source</a></div></div><div class="public anchor" id="var-uint64"><h3>uint64</h3><div class="usage"><code>(uint64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned long</code>. Character code: <code>'L'</code>. Canonical name: <code>np.uint</code>. Alias <em>on this platform</em>: <code>np.uint64</code>: 64-bit unsigned integer (0 to 18446744073709551615). Alias <em>on this platform</em>: <code>np.uintp</code>: Unsigned integer large enough to fit pointer, compatible with C <code>uintptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15910">view source</a></div></div><div class="public anchor" id="var-uint8"><h3>uint8</h3><div class="usage"><code>(uint8 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned char</code>. Character code: <code>'B'</code>. Canonical name: <code>np.ubyte</code>. Alias <em>on this platform</em>: <code>np.uint8</code>: 8-bit unsigned integer (0 to 255).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16626">view source</a></div></div><div class="public anchor" id="var-uintc"><h3>uintc</h3><div class="usage"><code>(uintc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned int</code>. Character code: <code>'I'</code>. Canonical name: <code>np.uintc</code>. Alias <em>on this platform</em>: <code>np.uint32</code>: 32-bit unsigned integer (0 to 4294967295).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23719">view source</a></div></div><div class="public anchor" id="var-uintp"><h3>uintp</h3><div class="usage"><code>(uintp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned long</code>. Character code: <code>'L'</code>. Canonical name: <code>np.uint</code>. Alias <em>on this platform</em>: <code>np.uint64</code>: 64-bit unsigned integer (0 to 18446744073709551615). Alias <em>on this platform</em>: <code>np.uintp</code>: Unsigned integer large enough to fit pointer, compatible with C <code>uintptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25609">view source</a></div></div><div class="public anchor" id="var-ulonglong"><h3>ulonglong</h3><div class="usage"><code>(ulonglong self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>unsigned long long</code>. Character code: <code>'Q'</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17199">view source</a></div></div><div class="public anchor" id="var-unicode"><h3>unicode</h3><div class="usage"><code>(unicode self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>str(object=’’) -&gt; str str(bytes_or_buffer[, encoding[, errors]]) -&gt; str</p>
+<p>Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to ‘strict’.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12022">view source</a></div></div><div class="public anchor" id="var-unicode_"><h3>unicode_</h3><div class="usage"><code>(unicode_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14993">view source</a></div></div><div class="public anchor" id="var-union1d"><h3>union1d</h3><div class="usage"><code>(union1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the union of two arrays.</p>
+<p>Return the unique, sorted array of values that are in either of the two input arrays.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>ar1, ar2 : array_like  Input arrays. They are flattened if they are not already 1D.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>union1d : ndarray  Unique, sorted union of the input arrays.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.union1d([-1, 0, 1], [-2, 0, 2]) array([-2, -1, 0, 1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>To find the union of more than two arrays, use functools.reduce:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>from functools import reduce reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) array([1, 2, 3, 4, 6])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20587">view source</a></div></div><div class="public anchor" id="var-unique"><h3>unique</h3><div class="usage"><code>(unique &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the unique elements of an array.</p>
+<p>Returns the sorted unique elements of an array. There are three optional outputs in addition to the unique elements:</p>
+<ul>
+  <li>the indices of the input array that give the unique values</li>
+  <li>the indices of the unique array that reconstruct the input array</li>
+  <li>the number of times each unique value comes up in the input array</li>
+</ul>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>ar : array_like  Input array. Unless <code>axis</code> is specified, this will be flattened if it  is not already 1-D. return_index : bool, optional  If True, also return the indices of <code>ar</code> (along the specified axis,  if provided, or in the flattened array) that result in the unique array. return_inverse : bool, optional  If True, also return the indices of the unique array (for the specified  axis, if provided) that can be used to reconstruct <code>ar</code>. return_counts : bool, optional  If True, also return the number of times each unique item appears  in <code>ar</code>.</p>
+<pre><code>.. versionadded:: 1.9.0
+</code></pre>
+<p>axis : int or None, optional  The axis to operate on. If None, <code>ar</code> will be flattened. If an integer,  the subarrays indexed by the given axis will be flattened and treated  as the elements of a 1-D array with the dimension of the given axis,  see the notes for more details. Object arrays or structured arrays  that contain objects are not supported if the <code>axis</code> kwarg is used. The  default is None.</p>
+<pre><code>.. versionadded:: 1.13.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>unique : ndarray  The sorted unique values. unique_indices : ndarray, optional  The indices of the first occurrences of the unique values in the  original array. Only provided if <code>return_index</code> is True. unique_inverse : ndarray, optional  The indices to reconstruct the original array from the  unique array. Only provided if <code>return_inverse</code> is True. unique_counts : ndarray, optional  The number of times each of the unique values comes up in the  original array. Only provided if <code>return_counts</code> is True.</p>
+<pre><code>.. versionadded:: 1.9.0
+</code></pre>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>When an axis is specified the subarrays indexed by the axis are sorted. This is done by making the specified axis the first dimension of the array (move the axis to the first dimension to keep the order of the other axes) and then flattening the subarrays in C order. The flattened subarrays are then viewed as a structured type with each element given a label, with the effect that we end up with a 1-D array of structured types that can be treated in the same way as any other 1-D array. The result is that the flattened subarrays are sorted in lexicographic order starting with the first element.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.unique([1, 1, 2, 2, 3, 3]) array([1, 2, 3]) a = np.array(<a href="null">1, 1], [2, 3</a>) np.unique(a) array([1, 2, 3])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Return the unique rows of a 2D array</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 0, 0], [1, 0, 0], [2, 3, 4</a>) np.unique(a, axis=0) array(<a href="null">1, 0, 0], [2, 3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Return the indices of the original array that give the unique values:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([‘a’, ‘b’, ‘b’, ‘c’, ‘a’]) u, indices = np.unique(a, return_index=True) u array([‘a’, ‘b’, ‘c’], dtype=‘&lt;U1’) indices array([0, 1, 3]) a[indices] array([‘a’, ‘b’, ‘c’], dtype=‘&lt;U1’)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Reconstruct the input array from the unique values:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1, 2, 6, 4, 2, 3, 2]) u, indices = np.unique(a, return_inverse=True) u array([1, 2, 3, 4, 6]) indices array([0, 1, 4, …, 1, 2, 1]) u[indices] array([1, 2, 6, …, 2, 3, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1692">view source</a></div></div><div class="public anchor" id="var-unpackbits"><h3>unpackbits</h3><div class="usage"><code>(unpackbits &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>unpackbits(a, axis=None, count=None, bitorder=‘big’)</p>
+<p>Unpacks elements of a uint8 array into a binary-valued output array.</p>
+<p>Each element of <code>a</code> represents a bit-field that should be unpacked into a binary-valued output array. The shape of the output array is either 1-D (if <code>axis</code> is <code>None</code>) or the same shape as the input array with unpacking done along the axis specified.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : ndarray, uint8 type  Input array. axis : int, optional  The dimension over which bit-unpacking is done.  <code>None</code> implies unpacking the flattened array. count : int or None, optional  The number of elements to unpack along <code>axis</code>, provided as a way  of undoing the effect of packing a size that is not a multiple  of eight. A non-negative number means to only unpack <code>count</code>  bits. A negative number means to trim off that many bits from  the end. <code>None</code> means to unpack the entire array (the  default). Counts larger than the available number of bits will  add zero padding to the output. Negative counts must not  exceed the available number of bits.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<p>bitorder : {‘big’, ‘little’}, optional  The order of the returned bits. ‘big’ will mimic bin(val),  <code>3 = 0b00000011 =&gt; [0, 0, 0, 0, 0, 0, 1, 1]</code>, ‘little’ will reverse  the order to <code>[1, 1, 0, 0, 0, 0, 0, 0]</code>.  Defaults to ‘big’.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>unpacked : ndarray, uint8 type  The elements are binary-valued (0 or 1).</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>packbits : Packs the elements of a binary-valued array into bits in  a uint8 array.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">2], [7], [23</a>, dtype=np.uint8) a array(<a href="null"> 2],
+       [ 7],
+       [23</a>, dtype=uint8) b = np.unpackbits(a, axis=1) b array(<a href="null">0, 0, 0, 0, 0, 0, 1, 0],
+       [0, 0, 0, 0, 0, 1, 1, 1],
+       [0, 0, 0, 1, 0, 1, 1, 1</a>, dtype=uint8) c = np.unpackbits(a, axis=1, count=-3) c array(<a href="null">0, 0, 0, 0, 0],
+       [0, 0, 0, 0, 0],
+       [0, 0, 0, 1, 0</a>, dtype=uint8)</p>
+      <p>p = np.packbits(b, axis=0) np.unpackbits(p, axis=0) array(<a href="null">0, 0, 0, 0, 0, 0, 1, 0],
+       [0, 0, 0, 0, 0, 1, 1, 1],
+       [0, 0, 0, 1, 0, 1, 1, 1],
+       [0, 0, 0, 0, 0, 0, 0, 0],
+       [0, 0, 0, 0, 0, 0, 0, 0],
+       [0, 0, 0, 0, 0, 0, 0, 0],
+       [0, 0, 0, 0, 0, 0, 0, 0],
+       [0, 0, 0, 0, 0, 0, 0, 0</a>, dtype=uint8) np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0])) True</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20506">view source</a></div></div><div class="public anchor" id="var-unravel_index"><h3>unravel_index</h3><div class="usage"><code>(unravel_index &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>unravel_index(indices, shape, order=‘C’)</p>
+<p>Converts a flat index or array of flat indices into a tuple of coordinate arrays.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>indices : array_like  An integer array whose elements are indices into the flattened  version of an array of dimensions <code>shape</code>. Before version 1.6.0,  this function accepted just one index value. shape : tuple of ints  The shape of the array to use for unraveling <code>indices</code>.</p>
+<pre><code>.. versionchanged:: 1.16.0
+    Renamed from ``dims`` to ``shape``.
+</code></pre>
+<p>order : {‘C’, ‘F’}, optional  Determines whether the indices should be viewed as indexing in  row-major (C-style) or column-major (Fortran-style) order.</p>
+<pre><code>.. versionadded:: 1.6.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>unraveled_coords : tuple of ndarray  Each array in the tuple has the same shape as the <code>indices</code>  array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>ravel_multi_index</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.unravel_index([22, 41, 37], (7,6)) (array([3, 6, 6]), array([4, 5, 1])) np.unravel_index([31, 41, 13], (7,6), order=‘F’) (array([3, 6, 6]), array([4, 5, 1]))</p>
+      <p>np.unravel_index(1621, (6,7,8,9)) (3, 1, 4, 1)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16006">view source</a></div></div><div class="public anchor" id="var-unsignedinteger"><h3>unsignedinteger</h3><div class="usage"><code>(unsignedinteger self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all unsigned integer scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23812">view source</a></div></div><div class="public anchor" id="var-unwrap"><h3>unwrap</h3><div class="usage"><code>(unwrap &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unwrap by changing deltas between values to 2*pi complement.</p>
+<p>Unwrap radian phase <code>p</code> by changing absolute jumps greater than <code>discont</code> to their 2*pi complement along the given axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>p : array_like  Input array. discont : float, optional  Maximum discontinuity between values, default is <code>pi</code>. axis : int, optional  Axis along which unwrap will operate, default is the last axis.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Output array.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>rad2deg, deg2rad</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If the discontinuity in <code>p</code> is smaller than <code>pi</code>, but larger than <code>discont</code>, no unwrapping is done because taking the 2*pi complement would only make the discontinuity larger.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>phase = np.linspace(0, np.pi, num=5) phase[3:] += np.pi phase array([ 0. , 0.78539816, 1.57079633, 5.49778714, 6.28318531]) # may vary np.unwrap(phase) array([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ]) # may vary</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12353">view source</a></div></div><div class="public anchor" id="var-ushort"><h3>ushort</h3><div class="usage"><code>(ushort self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned short</code>. Character code: <code>'H'</code>. Canonical name: <code>np.ushort</code>. Alias <em>on this platform</em>: <code>np.uint16</code>: 16-bit unsigned integer (0 to 65535).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12066">view source</a></div></div><div class="public anchor" id="var-vander"><h3>vander</h3><div class="usage"><code>(vander &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Generate a Vandermonde matrix.</p>
+<p>The columns of the output matrix are powers of the input vector. The order of the powers is determined by the <code>increasing</code> boolean argument. Specifically, when <code>increasing</code> is False, the <code>i</code>-th output column is the input vector raised element-wise to the power of <code>N - i - 1</code>. Such a matrix with a geometric progression in each row is named for Alexandre- Theophile Vandermonde.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>x : array_like  1-D input array. N : int, optional  Number of columns in the output. If <code>N</code> is not specified, a square  array is returned (<code>N = len(x)</code>). increasing : bool, optional  Order of the powers of the columns. If True, the powers increase  from left to right, if False (the default) they are reversed.</p>
+<pre><code>.. versionadded:: 1.9.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Vandermonde matrix. If <code>increasing</code> is False, the first column is  <code>x^(N-1)</code>, the second <code>x^(N-2)</code> and so forth. If <code>increasing</code> is  True, the columns are <code>x^0, x^1, ..., x^(N-1)</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>polynomial.polynomial.polyvander</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.array([1, 2, 3, 5]) N = 3 np.vander(x, N) array(<a href="null"> 1,  1,  1],
+       [ 4,  2,  1],
+       [ 9,  3,  1],
+       [25,  5,  1</a>)</p>
+      <p>np.column_stack([x**(N-1-i) for i in range(N)]) array(<a href="null"> 1,  1,  1],
+       [ 4,  2,  1],
+       [ 9,  3,  1],
+       [25,  5,  1</a>)</p>
+      <p>x = np.array([1, 2, 3, 5]) np.vander(x) array(<a href="null">  1,   1,   1,   1],
+       [  8,   4,   2,   1],
+       [ 27,   9,   3,   1],
+       [125,  25,   5,   1</a>) np.vander(x, increasing=True) array(<a href="null">  1,   1,   1,   1],
+       [  1,   2,   4,   8],
+       [  1,   3,   9,  27],
+       [  1,   5,  25, 125</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The determinant of a square Vandermonde matrix is the product of the differences between the values of the input vector:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.linalg.det(np.vander(x)) 48.000000000000043 # may vary (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1) 48</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21007">view source</a></div></div><div class="public anchor" id="var-var"><h3>var</h3><div class="usage"><code>(var &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the variance along the specified axis.</p>
+<p>Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  Array containing numbers whose variance is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : None or int or tuple of ints, optional  Axis or axes along which the variance is computed. The default is to  compute the variance of the flattened array.</p>
+<pre><code>.. versionadded:: 1.7.0
+
+If this is a tuple of ints, a variance is performed over multiple axes,
+instead of a single axis or all the axes as before.
+</code></pre>
+<p>dtype : data-type, optional  Type to use in computing the variance. For arrays of integer type  the default is <code>float64</code>; for arrays of float types it is the same as  the array type. out : ndarray, optional  Alternate output array in which to place the result. It must have  the same shape as the expected output, but the type is cast if  necessary. ddof : int, optional  “Delta Degrees of Freedom”: the divisor used in the calculation is  <code>N - ddof</code>, where <code>N</code> represents the number of elements. By  default <code>ddof</code> is zero. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
+<pre><code>If the default value is passed, then `keepdims` will not be
+passed through to the `var` method of sub-classes of
+`ndarray`, however any non-default value will be.  If the
+sub-class' method does not implement `keepdims` any
+exceptions will be raised.
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>variance : ndarray, see dtype parameter above  If <code>out=None</code>, returns a new array containing the variance;  otherwise, a reference to the output array is returned.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>std, mean, nanmean, nanstd, nanvar ufuncs-output-type</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The variance is the average of the squared deviations from the mean, i.e., <code>var = mean(abs(x - x.mean())**2)</code>.</p>
+<p>The mean is normally calculated as <code>x.sum() / N</code>, where <code>N = len(x)</code>. If, however, <code>ddof</code> is specified, the divisor <code>N - ddof</code> is used instead. In standard statistical practice, <code>ddof=1</code> provides an unbiased estimator of the variance of a hypothetical infinite population. <code>ddof=0</code> provides a maximum likelihood estimate of the variance for normally distributed variables.</p>
+<p>Note that for complex numbers, the absolute value is taken before squaring, so that the result is always real and nonnegative.</p>
+<p>For floating-point input, the variance is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for <code>float32</code> (see example below). Specifying a higher-accuracy accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 2], [3, 4</a>) np.var(a) 1.25 np.var(a, axis=0) array([1., 1.]) np.var(a, axis=1) array([0.25, 0.25])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>In single precision, var() can be inaccurate:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.zeros((2, 512*512), dtype=np.float32) a[0, :] = 1.0 a[1, :] = 0.1 np.var(a) 0.20250003</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Computing the variance in float64 is more accurate:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.var(a, dtype=np.float64) 0.20249999932944759 # may vary ((1-0.55)**2 + (0.1-0.55)**2)/2 0.2025</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7035">view source</a></div></div><div class="public anchor" id="var-vdot"><h3>vdot</h3><div class="usage"><code>(vdot &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>vdot(a, b)</p>
+<p>Return the dot product of two vectors.</p>
+<p>The vdot(<code>a</code>, <code>b</code>) function handles complex numbers differently than dot(<code>a</code>, <code>b</code>). If the first argument is complex the complex conjugate of the first argument is used for the calculation of the dot product.</p>
+<p>Note that <code>vdot</code> handles multidimensional arrays differently than <code>dot</code>: it does <em>not</em> perform a matrix product, but flattens input arguments to 1-D vectors first. Consequently, it should only be used for vectors.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  If <code>a</code> is complex the complex conjugate is taken before calculation  of the dot product. b : array_like  Second argument to the dot product.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>output : ndarray  Dot product of <code>a</code> and <code>b</code>. Can be an int, float, or  complex depending on the types of <code>a</code> and <code>b</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>dot : Return the dot product without using the complex conjugate of the  first argument.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1+2j,3+4j]) b = np.array([5+6j,7+8j]) np.vdot(a, b) (70-8j) np.vdot(b, a) (70+8j)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Note that higher-dimensional arrays are flattened!</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array(<a href="null">1, 4], [5, 6</a>) b = np.array(<a href="null">4, 1], [2, 2</a>) np.vdot(a, b) 30 np.vdot(b, a) 30 1*4 + 4*1 + 5*2 + 6*2 30</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L140">view source</a></div></div><div class="public anchor" id="var-vectorize"><h3>vectorize</h3><div class="usage"><code>(vectorize self pyfunc &amp; [{otypes :otypes, doc :doc, excluded :excluded, cache :cache, signature :signature}])</code><code>(vectorize self pyfunc &amp; [{otypes :otypes, doc :doc, excluded :excluded, cache :cache}])</code><code>(vectorize self pyfunc &amp; [{otypes :otypes, doc :doc, excluded :excluded}])</code><code>(vectorize self pyfunc &amp; [{otypes :otypes, doc :doc}])</code><code>(vectorize self pyfunc &amp; [{otypes :otypes}])</code><code>(vectorize self pyfunc)</code></div><div class="doc"><div class="markdown"><p>vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False,  signature=None)</p>
+<p>Generalized function class.</p>
+<p>Define a vectorized function which takes a nested sequence of objects or numpy arrays as inputs and returns a single numpy array or a tuple of numpy arrays. The vectorized function evaluates <code>pyfunc</code> over successive tuples of the input arrays like the python map function, except it uses the broadcasting rules of numpy.</p>
+<p>The data type of the output of <code>vectorized</code> is determined by calling the function with the first element of the input. This can be avoided by specifying the <code>otypes</code> argument.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>pyfunc : callable  A python function or method. otypes : str or list of dtypes, optional  The output data type. It must be specified as either a string of  typecode characters or a list of data type specifiers. There should  be one data type specifier for each output. doc : str, optional  The docstring for the function. If None, the docstring will be the  <code>pyfunc.__doc__</code>. excluded : set, optional  Set of strings or integers representing the positional or keyword  arguments for which the function will not be vectorized. These will be  passed directly to <code>pyfunc</code> unmodified.</p>
+<pre><code>.. versionadded:: 1.7.0
+</code></pre>
+<p>cache : bool, optional  If <code>True</code>, then cache the first function call that determines the number  of outputs if <code>otypes</code> is not provided.</p>
+<pre><code>.. versionadded:: 1.7.0
+</code></pre>
+<p>signature : string, optional  Generalized universal function signature, e.g., <code>(m,n),(n)-&gt;(m)</code> for  vectorized matrix-vector multiplication. If provided, <code>pyfunc</code> will  be called with (and expected to return) arrays with shapes given by the  size of corresponding core dimensions. By default, <code>pyfunc</code> is  assumed to take scalars as input and output.</p>
+<pre><code>.. versionadded:: 1.12.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>vectorized : callable  Vectorized function.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>frompyfunc : Takes an arbitrary Python function and returns a ufunc</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>The <code>vectorize</code> function is provided primarily for convenience, not for performance. The implementation is essentially a for loop.</p>
+<p>If <code>otypes</code> is not specified, then a call to the function with the first argument will be used to determine the number of outputs. The results of this call will be cached if <code>cache</code> is <code>True</code> to prevent calling the function twice. However, to implement the cache, the original function must be wrapped which will slow down subsequent calls, so only do this if your function is expensive.</p>
+<p>The new keyword argument interface and <code>excluded</code> argument support further degrades performance.</p>
+<h2><a href="#references" name="references"></a>References</h2>
+<p>.. [1] NumPy Reference, section <code>Generalized Universal Function API
+       &lt;https://docs.scipy.org/doc/numpy/reference/c-api.generalized-ufuncs.html&gt;</code>_.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>def myfunc(a, b): … “Return a-b if a&gt;b, otherwise return a+b” … if a &gt; b: … return a - b … else: … return a + b</p>
+      <p>vfunc = np.vectorize(myfunc) vfunc([1, 2, 3, 4], 2) array([3, 4, 1, 2])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The docstring is taken from the input function to <code>vectorize</code> unless it is specified:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>vfunc.__doc__ ‘Return a-b if a&gt;b, otherwise return a+b’ vfunc = np.vectorize(myfunc, doc=‘Vectorized <code>myfunc</code>’) vfunc.__doc__ ‘Vectorized <code>myfunc</code>’</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The output type is determined by evaluating the first element of the input, unless it is specified:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>out = vfunc([1, 2, 3, 4], 2) type(out[0]) &lt;class ‘numpy.int64’&gt; vfunc = np.vectorize(myfunc, otypes=[float]) out = vfunc([1, 2, 3, 4], 2) type(out[0]) &lt;class ‘numpy.float64’&gt;</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The <code>excluded</code> argument can be used to prevent vectorizing over certain arguments. This can be useful for array-like arguments of a fixed length such as the coefficients for a polynomial as in <code>polyval</code>:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>def mypolyval(p, x): … _p = list(p) … res = _p.pop(0) … while _p: … res = res*x + _p.pop(0) … return res vpolyval = np.vectorize(mypolyval, excluded=[‘p’]) vpolyval(p=[1, 2, 3], x=[0, 1]) array([3, 6])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Positional arguments may also be excluded by specifying their position:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>vpolyval.excluded.add(0) vpolyval([1, 2, 3], x=[0, 1]) array([3, 6])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The <code>signature</code> argument allows for vectorizing functions that act on non-scalar arrays of fixed length. For example, you can use it for a vectorized calculation of Pearson correlation coefficient and its p-value:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>import scipy.stats pearsonr = np.vectorize(scipy.stats.pearsonr, … signature=‘(n),(n)-&gt;(),()’) pearsonr(<a href="null">0, 1, 2, 3</a>, <a href="null">1, 2, 3, 4], [4, 3, 2, 1</a>) (array([ 1., -1.]), array([ 0., 0.]))</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>Or for a vectorized convolution:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>convolve = np.vectorize(np.convolve, signature=‘(n),(m)-&gt;(k)’) convolve(np.eye(4), [1, 2, 1]) array(<a href="null">1., 2., 1., 0., 0., 0.],
+       [0., 1., 2., 1., 0., 0.],
+       [0., 0., 1., 2., 1., 0.],
+       [0., 0., 0., 1., 2., 1.</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15421">view source</a></div></div><div class="public anchor" id="var-version"><h3>version</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21265">view source</a></div></div><div class="public anchor" id="var-VisibleDeprecationWarning"><h3>VisibleDeprecationWarning</h3><div class="usage"><code>(VisibleDeprecationWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Visible deprecation warning.</p>
+<p>By default, python will not show deprecation warnings, so this class can be used when a very visible warning is helpful, for example because the usage is most likely a user bug.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25026">view source</a></div></div><div class="public anchor" id="var-void"><h3>void</h3><div class="usage"><code>(void self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4380">view source</a></div></div><div class="public anchor" id="var-void0"><h3>void0</h3><div class="usage"><code>(void0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2341">view source</a></div></div><div class="public anchor" id="var-vsplit"><h3>vsplit</h3><div class="usage"><code>(vsplit &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Split an array into multiple sub-arrays vertically (row-wise).</p>
+<p>Please refer to the <code>split</code> documentation. <code>vsplit</code> is equivalent to <code>split</code> with <code>axis=0</code> (default), the array is always split along the first axis regardless of the array dimension.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>split : Split an array into multiple sub-arrays of equal size.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(16.0).reshape(4, 4) x array(<a href="null"> 0.,   1.,   2.,   3.],
+       [ 4.,   5.,   6.,   7.],
+       [ 8.,   9.,  10.,  11.],
+       [12.,  13.,  14.,  15.</a>) np.vsplit(x, 2) [array([[0., 1., 2., 3.],  [4., 5., 6., 7.]]), array([[ 8., 9., 10., 11.],  [12., 13., 14., 15.]])] np.vsplit(x, np.array([3, 6])) [array([[ 0., 1., 2., 3.],  [ 4., 5., 6., 7.],  [ 8., 9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([], shape=(0, 4), dtype=float64)]</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>With a higher dimensional array the split is still along the first axis.</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(8.0).reshape(2, 2, 2) x array(<a href="null">[0.,  1.],
+        [2.,  3.</a>,  <a href="null">4.,  5.],
+        [6.,  7.</a>]) np.vsplit(x, 2) [array([[[0., 1.],  [2., 3.]]]), array([[[4., 5.],  [6., 7.]]])]</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9223">view source</a></div></div><div class="public anchor" id="var-vstack"><h3>vstack</h3><div class="usage"><code>(vstack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Stack arrays in sequence vertically (row wise).</p>
+<p>This is equivalent to concatenation along the first axis after 1-D arrays of shape <code>(N,)</code> have been reshaped to <code>(1,N)</code>. Rebuilds arrays divided by <code>vsplit</code>.</p>
+<p>This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions <code>concatenate</code>, <code>stack</code> and <code>block</code> provide more general stacking and concatenation operations.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>tup : sequence of ndarrays  The arrays must have the same shape along all but the first axis.  1-D arrays must have the same length.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>stacked : ndarray  The array formed by stacking the given arrays, will be at least 2-D.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>stack : Join a sequence of arrays along a new axis. hstack : Stack arrays in sequence horizontally (column wise). dstack : Stack arrays in sequence depth wise (along third dimension). concatenate : Join a sequence of arrays along an existing axis. vsplit : Split array into a list of multiple sub-arrays vertically. block : Assemble arrays from blocks.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.array([1, 2, 3]) b = np.array([2, 3, 4]) np.vstack((a,b)) array(<a href="null">1, 2, 3],
+       [2, 3, 4</a>)</p>
+      <p>a = np.array(<a href="null">1], [2], [3</a>) b = np.array(<a href="null">2], [3], [4</a>) np.vstack((a,b)) array(<a href="null">1],
+       [2],
+       [3],
+       [2],
+       [3],
+       [4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21212">view source</a></div></div><div class="public anchor" id="var-warnings"><h3>warnings</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Python part of the warnings subsystem.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23717">view source</a></div></div><div class="public anchor" id="var-where"><h3>where</h3><div class="usage"><code>(where &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>where(condition, [x, y])</p>
+<p>Return elements chosen from <code>x</code> or <code>y</code> depending on <code>condition</code>.</p>
+<p>.. note::  When only <code>condition</code> is provided, this function is a shorthand for  <code>np.asarray(condition).nonzero()</code>. Using <code>nonzero</code> directly should be  preferred, as it behaves correctly for subclasses. The rest of this  documentation covers only the case where all three arguments are  provided.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>condition : array_like, bool  Where True, yield <code>x</code>, otherwise yield <code>y</code>. x, y : array_like  Values from which to choose. <code>x</code>, <code>y</code> and <code>condition</code> need to be  broadcastable to some shape.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  An array with elements from <code>x</code> where <code>condition</code> is True, and elements  from <code>y</code> elsewhere.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>choose nonzero : The function that is called when x and y are omitted</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>If all the arrays are 1-D, <code>where</code> is equivalent to::</p>
+<pre><code>[xv if c else yv
+ for c, xv, yv in zip(condition, x, y)]
+</code></pre>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(10) a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) np.where(a &lt; 5, a, 10*a) array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90])</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>This can be used on multidimensional arrays too:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.where(<a href="null">True, False], [True, True</a>, … <a href="null">1, 2], [3, 4</a>, … <a href="null">9, 8], [7, 6</a>) array(<a href="null">1, 8],
+       [3, 4</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote>
+<p>The shapes of x, y, and the condition are broadcast together:</p>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x, y = np.ogrid[:3, :4] np.where(x &lt; y, x, 10 + y) # both x and 10+y are broadcast array(<a href="null">10,  0,  0,  0],
+       [10, 11,  1,  1],
+       [10, 11, 12,  2</a>)</p>
+      <p>a = np.array(<a href="null">0, 1, 2],
+...               [0, 2, 4],
+...               [0, 3, 6</a>) np.where(a &lt; 4, a, -1) # -1 is broadcast array(<a href="null"> 0,  1,  2],
+       [ 0,  2, -1],
+       [ 0,  3, -1</a>)</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10439">view source</a></div></div><div class="public anchor" id="var-who"><h3>who</h3><div class="usage"><code>(who &amp; [{vardict :vardict}])</code><code>(who)</code></div><div class="doc"><div class="markdown"><p>Print the NumPy arrays in the given dictionary.</p>
+<p>If there is no dictionary passed in or <code>vardict</code> is None then returns NumPy arrays in the globals() dictionary (all NumPy arrays in the namespace).</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>vardict : dict, optional  A dictionary possibly containing ndarrays. Default is globals().</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : None  Returns ‘None’.</p>
+<h2><a href="#notes" name="notes"></a>Notes</h2>
+<p>Prints out the name, shape, bytes and type of all of the ndarrays present in <code>vardict</code>.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>a = np.arange(10) b = np.ones(20) np.who()</p>
+      <h1><a href="#name-shape-bytes-type" name="name-shape-bytes-type"></a>Name Shape Bytes Type</h1>
+      <p>a 10 80 int64 b 20 160 float64 Upper bound on total bytes = 240</p>
+      <p>d = {‘x’: np.arange(2.0), ‘y’: np.arange(3.0), ‘txt’: ‘Some str’, … ‘idx’:5} np.who(d)</p>
+      <h1><a href="#name-shape-bytes-type" name="name-shape-bytes-type"></a>Name Shape Bytes Type</h1>
+      <p>x 2 16 float64 y 3 24 float64 Upper bound on total bytes = 40</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3141">view source</a></div></div><div class="public anchor" id="var-WRAP"><h3>WRAP</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22283">view source</a></div></div><div class="public anchor" id="var-zeros"><h3>zeros</h3><div class="usage"><code>(zeros self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>zeros(shape, dtype=float, order=‘C’)</p>
+<p>Return a new array of given shape and type, filled with zeros.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>shape : int or tuple of ints  Shape of the new array, e.g., <code>(2, 3)</code> or <code>2</code>. dtype : data-type, optional  The desired data-type for the array, e.g., <code>numpy.int8</code>. Default is  <code>numpy.float64</code>. order : {‘C’, ‘F’}, optional, default: ‘C’  Whether to store multi-dimensional data in row-major  (C-style) or column-major (Fortran-style) order in  memory.</p>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Array of zeros with the given shape, dtype, and order.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>zeros_like : Return an array of zeros with shape and type of input. empty : Return a new uninitialized array. ones : Return a new array setting values to one. full : Return a new array of given shape filled with value.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>np.zeros(5) array([ 0., 0., 0., 0., 0.])</p>
+      <p>np.zeros((5,), dtype=int) array([0, 0, 0, 0, 0])</p>
+      <p>np.zeros((2, 1)) array(<a href="null"> 0.],
+       [ 0.</a>)</p>
+      <p>s = (2,2) np.zeros(s) array(<a href="null"> 0.,  0.],
+       [ 0.,  0.</a>)</p>
+      <p>np.zeros((2,), dtype=[(‘x’, ‘i4’), (‘y’, ‘i4’)]) # custom dtype array([(0, 0), (0, 0)],  dtype=[(‘x’, ‘&lt;i4’), (‘y’, ‘&lt;i4’)])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2074">view source</a></div></div><div class="public anchor" id="var-zeros_like"><h3>zeros_like</h3><div class="usage"><code>(zeros_like &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an array of zeros with the same shape and type as a given array.</p>
+<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
+<p>a : array_like  The shape and data-type of <code>a</code> define these same attributes of  the returned array. dtype : data-type, optional  Overrides the data type of the result.</p>
+<pre><code>.. versionadded:: 1.6.0
+</code></pre>
+<p>order : {‘C’, ‘F’, ‘A’, or ‘K’}, optional  Overrides the memory layout of the result. ‘C’ means C-order,  ‘F’ means F-order, ‘A’ means ‘F’ if <code>a</code> is Fortran contiguous,  ‘C’ otherwise. ‘K’ means match the layout of <code>a</code> as closely  as possible.</p>
+<pre><code>.. versionadded:: 1.6.0
+</code></pre>
+<p>subok : bool, optional.  If True, then the newly created array will use the sub-class  type of ‘a’, otherwise it will be a base-class array. Defaults  to True. shape : int or sequence of ints, optional.  Overrides the shape of the result. If order=‘K’ and the number of  dimensions is unchanged, will try to keep order, otherwise,  order=‘C’ is implied.</p>
+<pre><code>.. versionadded:: 1.17.0
+</code></pre>
+<h2><a href="#returns" name="returns"></a>Returns</h2>
+<p>out : ndarray  Array of zeros with the same shape and type as <code>a</code>.</p>
+<h2><a href="#see-also" name="see-also"></a>See Also</h2>
+<p>empty_like : Return an empty array with shape and type of input. ones_like : Return an array of ones with shape and type of input. full_like : Return a new array with shape of input filled with value. zeros : Return a new array setting values to zero.</p>
+<h2><a href="#examples" name="examples"></a>Examples</h2>
+<blockquote>
+  <blockquote>
+    <blockquote>
+      <p>x = np.arange(6) x = x.reshape((2, 3)) x array(<a href="null">0, 1, 2],
+       [3, 4, 5</a>) np.zeros_like(x) array(<a href="null">0, 0, 0],
+       [0, 0, 0</a>)</p>
+      <p>y = np.arange(3, dtype=float) y array([0., 1., 2.]) np.zeros_like(y) array([0., 0., 0.])</p>
+    </blockquote>
+  </blockquote>
+</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28326">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index e067a65..b24a05c 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index ce73da2..3712b96 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-4</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -114px;"><span class="top" style="height: 123px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index df6a9b0..e63e8a5 100644
--- a/project.clj
+++ b/project.clj
@@ -1,11 +1,11 @@
-(defproject clj-python/libpython-clj "2.00-beta-5-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-beta-5"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2" :scope "provided"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.06"]
+                 [cnuernber/dtype-next   "6.07"]
                  [net.java.dev.jna/jna "5.7.0"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]
@@ -14,8 +14,8 @@
                                  "-Dforeign.restricted=permit"
                                  "-Djava.library.path=/usr/lib/x86_64-linux-gnu"]}
              :codox
-             {:dependencies [[codox-theme-rdash "0.1.2"]]
-              :plugins [[lein-codox "0.10.7"]]
+             {:dependencies [[codox-theme-rdash "0.1.2"]
+                             [codox "0.10.7" :exclusions [org.ow2.asm/asm-all]]]
               :codox {:project {:name "libpython-clj"}
                       :metadata {:doc/format :markdown}
                       :themes [:rdash]
@@ -26,6 +26,7 @@
                       :namespaces [libpython-clj2.python
                                    libpython-clj2.codegen
                                    libpython-clj2.python.np-array
+                                   libpython-clj2.require
                                    python.builtins
                                    python.numpy]}}}
-  :aliases {"codox" ["with-profile" "codox,dev" "codox"]})
+  :aliases {"codox" ["with-profile" "codox,dev" "run" "-m" "tech.v3.libs.lein-codox"]})
diff --git a/topics/environments.md b/topics/environments.md
new file mode 100644
index 0000000..4a5693b
--- /dev/null
+++ b/topics/environments.md
@@ -0,0 +1,16 @@
+# Python Environments
+
+## pyenv
+
+pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.
+
+* [pyenv shared library issue](https://github.com/pyenv/pyenv/issues/392)
+* [libpython-clj related issue](https://github.com/clj-python/libpython-clj/issues/123)
+
+
+## Conda
+
+Conda requires that we set the LD_LIBRARY_PATH to the conda install.
+
+* [example conda repl launcher](https://github.com/clj-python/libpython-clj/blob/master/scripts/conda-repl)
+* [libpython-clj issue for Conda](https://github.com/clj-python/libpython-clj/issues/18)

From b0c34d8a2f8ccce938c38163aacc147d9595b697 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 6 Mar 2021 10:03:59 -0700
Subject: [PATCH 286/456] snap

---
 CHANGELOG.md | 4 ++++
 project.clj  | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 99ccdd2..2ea23d1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-5
+ * Fix codox document generation issue.
+ * Added a document on environments.
+
 ## 2.00-beta-4
  * [static namespace generation](https://clj-python.github.io/libpython-clj/libpython-clj2.codegen.html#var-write-namespace.21) - Generate AOT-safe clojure code that will
  dynamically find the symbol and cache it upon first call.
diff --git a/project.clj b/project.clj
index e63e8a5..b624ed2 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-5"
+(defproject clj-python/libpython-clj "2.00-beta-6-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From ccd32c8d18e4cc6719a0d06a5cc3503add3e5ff7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 8 Mar 2021 06:54:34 -0700
Subject: [PATCH 287/456] Reverting init back to older argument structure.

---
 src/libpython_clj2/python.clj     | 11 ++++++++---
 src/libpython_clj2/python/ffi.clj |  3 +++
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 3fe6570..f5d22a2 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -33,6 +33,7 @@ user> (py/py. np linspace 2 3 :num 10)
             [libpython-clj2.python.gc :as pygc]
             [libpython-clj2.python.windows :as win]
             [tech.v3.datatype.ffi :as dtype-ffi]
+            [tech.v3.datatype.errors :as errors]
             [clojure.tools.logging :as log])
   (:import [java.util Map List]
            [clojure.lang IFn]))
@@ -63,9 +64,10 @@ user> (py/py. np linspace 2 3 :num 10)
      during it's normal course of operation.  For more information see:
        * [used signals](https://docs.oracle.com/javase/10/troubleshoot/handle-signals-and-exceptions.htm#JSTGD356)
        * [signal-chaining](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html)"
-  [& [{:keys [windows-anaconda-activate-bat
-              library-path
-              no-io-redirect?]} options]]
+  [& {:keys [windows-anaconda-activate-bat
+             library-path
+             no-io-redirect?]
+      :as options}]
   (if-not (and (py-ffi/library-loaded?)
                  (= 1 (py-ffi/Py_IsInitialized)))
     (let [info (py-info/detect-startup-info options)
@@ -76,6 +78,9 @@ user> (py/py. np linspace 2 3 :num 10)
                                   (boolean (dtype-ffi/library-loadable? %))
                                   (catch Throwable e false)))
                        (first))]
+      (errors/when-not-errorf
+       libname
+       "Failed to find a valid python library!")
       (log/infof "Loading python library: %s" libname)
       (py-ffi/initialize!
        libname (:python-home info)
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index fcfb1bb..95852aa 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -324,6 +324,9 @@ Each call must be matched with PyGILState_Release"}
 
 (defn set-library!
   [libpath]
+  (errors/when-not-error
+   (seq libpath)
+   "set-library! called with nil or empty libpath")
   (when @library*
     (log/warnf "Python library is being reinitialized to (%s).  Is this what you want?"
                libpath))

From 685b8bd78c187a6aa85dcc3739dbe8681b522d93 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 8 Mar 2021 06:58:21 -0700
Subject: [PATCH 288/456] 2.00-beta-6

---
 CHANGELOG.md                             |  7 +++++--
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.python.html          | 22 +++++++++++-----------
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/python.builtins.html                |  2 +-
 docs/python.numpy.html                   |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 project.clj                              |  2 +-
 15 files changed, 29 insertions(+), 26 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2ea23d1..bc999a7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,8 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-6
+ * Revert initialize! back to v1 optional argument style.
+
 ## 2.00-beta-5
  * Fix codox document generation issue.
  * Added a document on environments.
@@ -7,7 +10,7 @@
 ## 2.00-beta-4
  * [static namespace generation](https://clj-python.github.io/libpython-clj/libpython-clj2.codegen.html#var-write-namespace.21) - Generate AOT-safe clojure code that will
  dynamically find the symbol and cache it upon first call.
- 
+
 ## 2.00-beta-3
  * Fixes to allow Conda to work - [cnuernber/facial-rec](https://github.com/cnuernber/facial-rec) lives again!!
 
@@ -23,7 +26,7 @@
 
 ## 1.45
  * tech.datatype - 5.0 release
- 
+
 ## 1.43
  * `tech.datatype` - latest version to work with `tech.ml.dataset`.
 
diff --git a/docs/Usage.html b/docs/Usage.html
index c04b4c9..31da87e 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index b302531..a3a9ca1 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/environments.html b/docs/environments.html
index 1923104..513b2f4 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 2712141..501b215 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-5</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></h1><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-6</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></h1><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index ae8d0b4..64a4ea5 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 7fe9724..4c3d07c 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -12,9 +12,9 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L448">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L459">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L235">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L306">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L294">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L300">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L143">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L429">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L241">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L253">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L229">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L166">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L172">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L277">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L418">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L453">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L464">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L240">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L311">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L299">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L148">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L434">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L246">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L258">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L252">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L171">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L282">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L423">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -38,7 +38,7 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L383">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L161">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L203">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; [{:keys [windows-anaconda-activate-bat library-path no-io-redirect?]} options])</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L388">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L166">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L182">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L208">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L202">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L137">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -53,16 +53,16 @@
       <li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
     </ul>
   </li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L42">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L265">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L345">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L369">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L152">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L43">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L270">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L350">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L374">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L157">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
 <p>Options:</p>
 <ul>
   <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L594">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L599">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L505">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L476">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L469">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L488">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L510">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L481">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L474">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -72,8 +72,8 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L540">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L259">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L545">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L264">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L312">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L183">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L190">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L209">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L96">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L440">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L109">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L118">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L317">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L188">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L195">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L214">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L221">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L101">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L445">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L114">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index d035b58..3bfc6ff 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 51f301f..d0add32 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 61e9439..d466b22 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index 460d68d..4a410a6 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index 47fa465..73c9de5 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index b24a05c..56019ba 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 3712b96..b05836a 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-5</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index b624ed2..34cf148 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-6-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-beta-6"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 87600543cf2fc31ba550e7d9bd1d2ae464d4d4cd Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 8 Mar 2021 06:58:30 -0700
Subject: [PATCH 289/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 34cf148..4c50637 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-6"
+(defproject clj-python/libpython-clj "2.00-beta-7-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From e72eeda62e154fb311007bbc3021b1b82ac0fda7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 8 Mar 2021 11:44:40 -0700
Subject: [PATCH 290/456] Adding back in java library path shenanigans

---
 project.clj                        |  2 +-
 scripts/conda-repl                 |  3 +--
 scripts/py38-repl                  |  3 +--
 src/libpython_clj2/python.clj      |  9 ++++++++-
 src/libpython_clj2/python/ffi.clj  | 10 ++++++++++
 src/libpython_clj2/python/info.clj |  4 ++--
 6 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/project.clj b/project.clj
index 4c50637..9e035f5 100644
--- a/project.clj
+++ b/project.clj
@@ -5,7 +5,7 @@
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2" :scope "provided"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.07"]
+                 [cnuernber/dtype-next   "6.08"]
                  [net.java.dev.jna/jna "5.7.0"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]
diff --git a/scripts/conda-repl b/scripts/conda-repl
index e1af4fc..912e720 100755
--- a/scripts/conda-repl
+++ b/scripts/conda-repl
@@ -7,6 +7,5 @@ source activate pyclj
 export LD_LIBRARY_PATH="$(python3-config --prefix)/lib"
 
 lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
-     -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
+     -- update-in :plugins conj \[cider/cider-nrepl\ \"0.25.5\"\]\
      -- repl :headless :host localhost
-
diff --git a/scripts/py38-repl b/scripts/py38-repl
index fe9624f..647e5dd 100755
--- a/scripts/py38-repl
+++ b/scripts/py38-repl
@@ -1,6 +1,5 @@
 #!/bin/bash
 
 lein update-in :dependencies conj \[nrepl\ \"0.6.0\"\]\
-     -- update-in :plugins conj \[cider/cider-nrepl\ \"0.22.4\"\]\
+     -- update-in :plugins conj \[cider/cider-nrepl\ \"0.25.5\"\]\
      -- repl :headless :host localhost
-
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index f5d22a2..a180bc3 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -72,6 +72,10 @@ user> (py/py. np linspace 2 3 :num 10)
                  (= 1 (py-ffi/Py_IsInitialized)))
     (let [info (py-info/detect-startup-info options)
           _ (log/infof "Startup info %s" info)
+          _ (when-let [lib-path (:java-library-path-addendum
+                                 options (:java-library-path-addendum info))]
+              (log/infof "Prefixing java library path: %s" lib-path)
+              (py-ffi/append-java-library-path! lib-path))
           libname (->> (concat (when library-path [library-path]) (:libnames info))
                        (dechunk-map identity)
                        (filter #(try
@@ -86,7 +90,10 @@ user> (py/py. np linspace 2 3 :num 10)
        libname (:python-home info)
        (assoc options
               :program-name (:program-name options (:executable info))
-              :python-home (:python-home options (:python-home info))))
+              :python-home (:python-home options (:python-home info))
+              :java-library-path-addendum (:java-library-path-addendum
+                                           options
+                                           (:java-library-path-addendum info))))
 
       (when-not (nil? windows-anaconda-activate-bat)
         (win/setup-windows-conda! windows-anaconda-activate-bat
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index 95852aa..0d494a5 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -531,6 +531,16 @@ Each call must be matched with PyGILState_Release"}
   @format-exc-pyfn*)
 
 
+(defn append-java-library-path!
+  [new-search-path]
+  (let [existing-paths (-> (System/getProperty "java.library.path")
+                           (s/split #":"))]
+    (when-not (contains? (set existing-paths) new-search-path)
+      (let [new-path-str (s/join ":" (concat [new-search-path]
+                                             existing-paths))]
+        (System/setProperty "java.library.path" new-path-str)))))
+
+
 (defn initialize!
   [libpath python-home & [{:keys [signals? program-name python-home]
                            :or {signals? true
diff --git a/src/libpython_clj2/python/info.clj b/src/libpython_clj2/python/info.clj
index fca3a7d..2004ba9 100644
--- a/src/libpython_clj2/python/info.clj
+++ b/src/libpython_clj2/python/info.clj
@@ -73,7 +73,7 @@ print(json.dumps(
 
 
 (defn java-library-path-addendum
-  [system-info & [{:keys [python-home]}]]
+  [python-home]
   (when python-home
     (-> (Paths/get python-home
                    (into-array String ["lib"]))
@@ -87,7 +87,7 @@ print(json.dumps(
     (log/info "Detecting startup info"))
   (let [system-info (find-python-info options)
         python-home (find-python-home system-info options)
-        java-lib-path (java-library-path-addendum system-info options)
+        java-lib-path (java-library-path-addendum python-home)
         [ver-maj ver-med _ver-min] (:version system-info)
         lib-version                (format "%s.%s" ver-maj ver-med)
         libname                    (or library-path

From 9a37bdefda970735bfcade2808dabfbbb0d9ab00 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 8 Mar 2021 11:48:05 -0700
Subject: [PATCH 291/456] 2.00-beta-7

---
 CHANGELOG.md                             |  4 ++++
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.python.html          | 22 +++++++++++-----------
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/python.builtins.html                |  2 +-
 docs/python.numpy.html                   |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 project.clj                              |  2 +-
 15 files changed, 28 insertions(+), 24 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bc999a7..af55c63 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-7
+ * Upgrade to dtype-next to ensure that JNA is the preferred FFI framework.
+ * Re-introduce java.library.path shenanigans in order to support pyenv type systems.
+
 ## 2.00-beta-6
  * Revert initialize! back to v1 optional argument style.
 
diff --git a/docs/Usage.html b/docs/Usage.html
index 31da87e..5c4daef 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index a3a9ca1..7d411fa 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/environments.html b/docs/environments.html
index 513b2f4..1077443 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 501b215..cc772c7 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-6</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></h1><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-7</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></h1><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 64a4ea5..b351757 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 4c3d07c..9769f9c 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -12,9 +12,9 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L453">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L464">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L240">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L311">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L299">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L148">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L434">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L246">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L258">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L252">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L171">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L282">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L423">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L460">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L471">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L318">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L306">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L312">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L235">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L155">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L441">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L253">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L265">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L259">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L241">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L178">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L184">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L289">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L430">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -38,7 +38,7 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L388">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L166">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L182">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L208">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L202">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L137">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L395">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L173">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L189">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L215">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L209">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L144">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -53,16 +53,16 @@
       <li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
     </ul>
   </li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L43">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L270">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L350">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L374">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L157">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L43">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L277">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L357">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L381">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L164">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
 <p>Options:</p>
 <ul>
   <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L599">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L606">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L488">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L510">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L481">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L474">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L495">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L517">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L488">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L481">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -72,8 +72,8 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L545">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L264">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L552">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L271">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L317">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L188">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L195">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L214">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L221">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L101">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L445">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L114">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L324">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L195">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L202">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L221">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L108">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L452">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L121">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L130">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 3bfc6ff..9196724 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index d0add32..2f58ef0 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index d466b22..a2d63ac 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index 4a410a6..bb3fb1e 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index 73c9de5..7bc8ca8 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 56019ba..1e62b04 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index b05836a..bd001d3 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-6</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 9e035f5..06566d0 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-7-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-beta-7"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 83c2d7e3247b11e3d49c29ed9f4fd36c88b45098 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 8 Mar 2021 11:48:13 -0700
Subject: [PATCH 292/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 06566d0..4d614f0 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-7"
+(defproject clj-python/libpython-clj "2.00-beta-8-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From f494196a7116f2a8bd04cf50e0cd3f3db3bc186c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 8 Mar 2021 15:48:34 -0700
Subject: [PATCH 293/456] 2.00-beta-8

---
 CHANGELOG.md                             |  3 +++
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.python.html          | 22 +++++++++++-----------
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/python.builtins.html                |  2 +-
 docs/python.numpy.html                   |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 project.clj                              |  4 ++--
 src/libpython_clj2/python.clj            |  5 ++---
 16 files changed, 30 insertions(+), 28 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index af55c63..c8c08b1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,8 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-8
+ * Add back in dynamically searching for libraries based on `java.library.path`.
+
 ## 2.00-beta-7
  * Upgrade to dtype-next to ensure that JNA is the preferred FFI framework.
  * Re-introduce java.library.path shenanigans in order to support pyenv type systems.
diff --git a/docs/Usage.html b/docs/Usage.html
index 5c4daef..25c2dc6 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 7d411fa..3d8600d 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/environments.html b/docs/environments.html
index 1077443..313eff5 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index cc772c7..c0d77a1 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-7</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></h1><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-8</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></h1><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index b351757..c03841b 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 9769f9c..a02a81e 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -12,9 +12,9 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L460">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L471">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L318">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L306">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L312">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L235">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L155">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L441">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L253">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L265">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L259">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L241">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L178">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L184">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L289">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L430">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L459">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L470">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L246">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L317">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L311">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L154">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L440">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L252">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L264">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L258">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L240">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L183">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L288">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L429">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -38,7 +38,7 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L395">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L173">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L189">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L215">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L209">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L144">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L394">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L172">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L188">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L214">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L208">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L143">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -53,16 +53,16 @@
       <li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
     </ul>
   </li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L43">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L277">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L357">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L381">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L164">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L43">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L276">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L356">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L380">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L163">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
 <p>Options:</p>
 <ul>
   <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L606">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L605">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L495">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L517">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L488">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L481">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L494">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L516">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L487">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L480">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -72,8 +72,8 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L552">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L271">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L551">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L270">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L324">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L195">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L202">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L221">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L108">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L452">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L121">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L130">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L323">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L194">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L201">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L220">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L227">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L107">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L451">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L120">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L129">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 9196724..54454ab 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 2f58ef0..1f10fe1 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index a2d63ac..95e856a 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index bb3fb1e..6b9707b 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index 7bc8ca8..2b3c7ef 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 1e62b04..cfaaf7e 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index bd001d3..5644809 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-7</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index 4d614f0..1fcf97c 100644
--- a/project.clj
+++ b/project.clj
@@ -1,11 +1,11 @@
-(defproject clj-python/libpython-clj "2.00-beta-8-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-beta-8"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"
             :url  "http://www.eclipse.org/legal/epl-v10.html"}
   :dependencies [[org.clojure/clojure    "1.10.2" :scope "provided"]
                  [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.08"]
+                 [cnuernber/dtype-next   "6.09"]
                  [net.java.dev.jna/jna "5.7.0"]
                  [org.clojure/data.json  "1.0.0"]]
   :profiles {:dev {:dependencies [[criterium "0.4.5"]
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index a180bc3..3eca4ca 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -78,9 +78,8 @@ user> (py/py. np linspace 2 3 :num 10)
               (py-ffi/append-java-library-path! lib-path))
           libname (->> (concat (when library-path [library-path]) (:libnames info))
                        (dechunk-map identity)
-                       (filter #(try
-                                  (boolean (dtype-ffi/library-loadable? %))
-                                  (catch Throwable e false)))
+                       (map dtype-ffi/find-library)
+                       (remove nil?)
                        (first))]
       (errors/when-not-errorf
        libname

From bef136e28076a5e224d9027fe4f385f0e377541c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 8 Mar 2021 15:48:44 -0700
Subject: [PATCH 294/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 1fcf97c..ae38ab6 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-8"
+(defproject clj-python/libpython-clj "2.00-beta-9-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From c40ebabbe3efbd0a952996f64176b1b2246bf428 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 9 Mar 2021 07:37:15 -0700
Subject: [PATCH 295/456] Quieting failures when something passes the sequence
 check.

---
 src/libpython_clj2/python.clj      |  2 +-
 src/libpython_clj2/python/copy.clj | 40 +++++++++++++++++-------------
 2 files changed, 24 insertions(+), 18 deletions(-)

diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 3eca4ca..6077461 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -616,7 +616,7 @@ user> (py/call-attr inst \"addarg\" 10)
                              (catch Throwable e nil))]
       (if reload?
         (let [import-lib (import-module "importlib")]
-          (call-attr import-lib "reload" item-path))
+          (call-attr import-lib "reload" module-retval))
         module-retval)
       (let [butlast (module-path-string item-path)]
         (if-let [parent-mod (path->py-obj butlast :reload? reload?)]
diff --git a/src/libpython_clj2/python/copy.clj b/src/libpython_clj2/python/copy.clj
index 9b1af56..5aada00 100644
--- a/src/libpython_clj2/python/copy.clj
+++ b/src/libpython_clj2/python/copy.clj
@@ -39,13 +39,18 @@
   (when-not (= 1 (py-ffi/PySequence_Check pyobj))
     (errors/throwf "Object does not implement sequence protocol: %s"
                    (py-proto/python-type pyobj)))
-  (->> (range (py-ffi/PySequence_Length pyobj))
-       (mapv (fn [idx]
-               (let [pyitem (py-ffi/PySequence_GetItem pyobj idx)]
-                 (try
-                   (py-base/->jvm pyitem)
-                   (finally
-                     (py-ffi/Py_DecRef pyitem))))))))
+  ;; Unfortunately sometimes things that pass the sequence check will fail
+  ;; when you request their length.  In those cases we return an empty vector
+  ;; as that is what older versions of libpython-clj would do.
+  (try
+    (->> (range (py-ffi/with-error-check (py-ffi/PySequence_Length pyobj)))
+         (mapv (fn [idx]
+                 (let [pyitem (py-ffi/PySequence_GetItem pyobj idx)]
+                   (try
+                     (py-base/->jvm pyitem)
+                     (finally
+                       (py-ffi/Py_DecRef pyitem)))))))
+    (catch Throwable e [])))
 
 
 (defmethod py-proto/pyobject->jvm :str
@@ -176,16 +181,17 @@
     ;;Things could implement mapping and sequence logically so mapping
     ;;takes precedence
     (= 1 (py-ffi/PyMapping_Check pyobj))
-    (if-let [map-items (py-ffi/PyMapping_Items pyobj)]
-      (try
-        (python->jvm-copy-hashmap pyobj map-items)
-        (finally
-          (py-ffi/Py_DecRef map-items)))
-      (do
-        ;;Ignore error.  The mapping check isn't thorough enough to work for all
-        ;;python objects.
-        (py-ffi/PyErr_Clear)
-        (python->jvm-copy-persistent-vector pyobj)))
+    (do
+      (if-let [map-items (py-ffi/PyMapping_Items pyobj)]
+        (try
+          (python->jvm-copy-hashmap pyobj map-items)
+          (finally
+            (py-ffi/Py_DecRef map-items)))
+        (do
+          ;;Ignore error.  The mapping check isn't thorough enough to work for all
+          ;;python objects.
+          (py-ffi/PyErr_Clear)
+          (python->jvm-copy-persistent-vector pyobj))))
     ;;Sequences become persistent vectors
     (= 1 (py-ffi/PySequence_Check pyobj))
     (python->jvm-copy-persistent-vector pyobj)

From bfc78e70324f42c231020dea491557e99756293d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 9 Mar 2021 07:40:38 -0700
Subject: [PATCH 296/456] 2.00-beta-9

---
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/python.builtins.html                | 2 +-
 docs/python.numpy.html                   | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 project.clj                              | 2 +-
 14 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index 25c2dc6..277dd1e 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 3d8600d..7a03c25 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/environments.html b/docs/environments.html
index 313eff5..11e02a2 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index c0d77a1..56b14d0 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-8</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></h1><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-9</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></h1><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index c03841b..1fce93d 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index a02a81e..d4bbbe6 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 54454ab..614f67a 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 1f10fe1..3f47558 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 95e856a..26a98b1 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index 6b9707b..ee239b2 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index 2b3c7ef..6fd2c54 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index cfaaf7e..bfb84bf 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 5644809..8eb980d 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-8</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/project.clj b/project.clj
index ae38ab6..1896ebe 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-9-SNAPSHOT"
+(defproject clj-python/libpython-clj "2.00-beta-9"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From 0b80cdb30b45d721f66ca3cb493945ab08417d2f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 9 Mar 2021 07:40:46 -0700
Subject: [PATCH 297/456] snap

---
 project.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project.clj b/project.clj
index 1896ebe..eab0158 100644
--- a/project.clj
+++ b/project.clj
@@ -1,4 +1,4 @@
-(defproject clj-python/libpython-clj "2.00-beta-9"
+(defproject clj-python/libpython-clj "2.00-beta-10-SNAPSHOT"
   :description "libpython bindings for Clojure"
   :url "http://github.com/cnuernber/libpython-clj"
   :license {:name "Eclipse Public License"

From f6883d65607e73ca348586bc2b074fa366a0617f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 9 Mar 2021 09:11:33 -0700
Subject: [PATCH 298/456] Moving to deps now that we don't have java.

---
 .travis.yml |  7 ++++---
 deps.edn    | 37 +++++++++++++++++++++++++++++++++++++
 2 files changed, 41 insertions(+), 3 deletions(-)
 create mode 100644 deps.edn

diff --git a/.travis.yml b/.travis.yml
index bad2cf7..cdf4651 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,14 +6,15 @@ before_install:
   - sudo apt-get -y install python3 python3-pip
   - sudo python3 -mpip install setuptools
   - sudo python3 -mpip install numpy
-  - curl -O https://download.clojure.org/install/linux-install-1.10.1.507.sh
-  - chmod +x linux-install-1.10.1.507.sh
-  - sudo ./linux-install-1.10.1.507.sh
+  - curl -O https://download.clojure.org/install/linux-install-1.10.2.796.sh
+  - chmod +x linux-install-1.10.2.796.sh
+  - sudo ./linux-install-1.10.2.796.sh
   - clojure -Sdescribe
 addons:
   apt:
     update: true
 install: clojure -Sdescribe
+script: clojure -M:test
 cache:
   directories:
     - "$HOME/.m2"
diff --git a/deps.edn b/deps.edn
new file mode 100644
index 0000000..f078343
--- /dev/null
+++ b/deps.edn
@@ -0,0 +1,37 @@
+{:paths ["src"]
+ :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
+        camel-snake-kebab/camel-snake-kebab    {:mvn/version "0.4.0"}
+        cnuernber/dtype-next {:mvn/version "6.09"}
+        net.java.dev.jna/jna {:mvn/version "5.7.0"}
+        org.clojure/data.json  {:mvn/version "1.0.0"}}
+
+ :aliases {:dev
+           {:extra-deps {criterium/criterium {:mvn/version"0.4.5"}
+                         ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}}
+           :codox
+           {:extra-deps {codox-theme-rdash/codox-theme-rdash {:mvn/version "0.1.2"}
+                         codox/codox {:mvn/version "0.10.7"
+                                      :exclusions [org.ow2.asm/asm-all]}}}
+           :test
+           {:extra-deps {com.cognitect/test-runner
+                         {:git/url "https://github.com/cognitect-labs/test-runner"
+                          :sha "209b64504cb3bd3b99ecfec7937b358a879f55c1"}
+                         ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
+            :extra-paths ["test"]
+            :main-opts ["-m" "cognitect.test-runner"]}
+           :depstar
+           {: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.00-beta-11-SNAPSHOT"
+                        :sync-pom true
+                        :jar "target/libpython-clj.jar"}}
+           :deploy
+           {: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.jar"}}}}

From 023ddf4a31c2609244a5455e6333c80e841967ab Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 9 Mar 2021 09:14:35 -0700
Subject: [PATCH 299/456] Moving to deps-based project is complete :-)

---
 project.clj | 32 --------------------------------
 1 file changed, 32 deletions(-)
 delete mode 100644 project.clj

diff --git a/project.clj b/project.clj
deleted file mode 100644
index eab0158..0000000
--- a/project.clj
+++ /dev/null
@@ -1,32 +0,0 @@
-(defproject clj-python/libpython-clj "2.00-beta-10-SNAPSHOT"
-  :description "libpython bindings for Clojure"
-  :url "http://github.com/cnuernber/libpython-clj"
-  :license {:name "Eclipse Public License"
-            :url  "http://www.eclipse.org/legal/epl-v10.html"}
-  :dependencies [[org.clojure/clojure    "1.10.2" :scope "provided"]
-                 [camel-snake-kebab      "0.4.0"]
-                 [cnuernber/dtype-next   "6.09"]
-                 [net.java.dev.jna/jna "5.7.0"]
-                 [org.clojure/data.json  "1.0.0"]]
-  :profiles {:dev {:dependencies [[criterium "0.4.5"]
-                                  [ch.qos.logback/logback-classic "1.1.3"]]}
-             :jdk-16 {:jvm-opts ["--add-modules" "jdk.incubator.foreign"
-                                 "-Dforeign.restricted=permit"
-                                 "-Djava.library.path=/usr/lib/x86_64-linux-gnu"]}
-             :codox
-             {:dependencies [[codox-theme-rdash "0.1.2"]
-                             [codox "0.10.7" :exclusions [org.ow2.asm/asm-all]]]
-              :codox {:project {:name "libpython-clj"}
-                      :metadata {:doc/format :markdown}
-                      :themes [:rdash]
-                      :source-paths ["src"]
-                      :output-path "docs"
-                      :doc-paths ["topics"]
-                      :source-uri "https://github.com/clj-python/libpython-clj/blob/master/{filepath}#L{line}"
-                      :namespaces [libpython-clj2.python
-                                   libpython-clj2.codegen
-                                   libpython-clj2.python.np-array
-                                   libpython-clj2.require
-                                   python.builtins
-                                   python.numpy]}}}
-  :aliases {"codox" ["with-profile" "codox,dev" "run" "-m" "tech.v3.libs.lein-codox"]})

From bf5d4a1c14c30d06fdf763bac71ec0932854835f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 9 Mar 2021 09:49:02 -0700
Subject: [PATCH 300/456] Everything in the release process is now working.

---
 .gitignore |  4 +++-
 deps.edn   | 20 ++++++++++++++++++--
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index 8cf6946..ffb199c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,4 +13,6 @@ pom.xml.asc
 __pycache__
 .cpcache/
 cpython
-a.out
\ No newline at end of file
+a.out
+*.pom
+*.pom.asc
\ No newline at end of file
diff --git a/deps.edn b/deps.edn
index f078343..5505039 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,7 +1,7 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
         camel-snake-kebab/camel-snake-kebab    {:mvn/version "0.4.0"}
-        cnuernber/dtype-next {:mvn/version "6.09"}
+        cnuernber/dtype-next {:mvn/version "6.12"}
         net.java.dev.jna/jna {:mvn/version "5.7.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
@@ -11,7 +11,23 @@
            :codox
            {:extra-deps {codox-theme-rdash/codox-theme-rdash {:mvn/version "0.1.2"}
                          codox/codox {:mvn/version "0.10.7"
-                                      :exclusions [org.ow2.asm/asm-all]}}}
+                                      :exclusions [org.ow2.asm/asm-all]}}
+            :ns-default tech.v3.libs.lein-codox
+            :exec-fn tech.v3.libs.lein-codox/-main
+            :exec-args {:arg-paths [[:aliases :depstar :exec-args]]
+                        :description "Python bindings for Clojure"
+                        :metadata {:doc/format :markdown}
+                        :themes [:rdash]
+                        :source-paths ["src"]
+                        :output-path "docs"
+                        :doc-paths ["topics"]
+                        :source-uri "https://github.com/clj-python/libpython-clj/blob/master/{filepath}#L{line}"
+                        :namespaces [libpython-clj2.python
+                                     libpython-clj2.codegen
+                                     libpython-clj2.python.np-array
+                                     libpython-clj2.require
+                                     python.builtins
+                                     python.numpy]}}
            :test
            {:extra-deps {com.cognitect/test-runner
                          {:git/url "https://github.com/cognitect-labs/test-runner"

From b8477c5e0c927b5f1a304c252251982f07129536 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 10 Mar 2021 12:29:05 -0700
Subject: [PATCH 301/456] Working with javabridge, I have a python repl
 launching a clojure repl.

---
 jbridge.py                        | 103 ++++++++++++++++++++++++++++++
 src/libpython_clj2/python.clj     |  60 +++++++++++++++++
 src/libpython_clj2/python/ffi.clj |  16 ++---
 3 files changed, 171 insertions(+), 8 deletions(-)
 create mode 100644 jbridge.py

diff --git a/jbridge.py b/jbridge.py
new file mode 100644
index 0000000..117598c
--- /dev/null
+++ b/jbridge.py
@@ -0,0 +1,103 @@
+import subprocess
+import javabridge
+
+try:
+    from collections.abc import Callable  # noqa
+except ImportError:
+    from collections import Callable
+
+def deps_classpath(*clj_args):
+    return subprocess.check_output(['clojure'] + list(clj_args) + ['-Spath']).decode("utf-8").strip().split(':')
+
+
+def repl_classpath():
+    return deps_classpath("-Sdeps", '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}')
+
+
+def start_vm():
+    javabridge.start_vm(run_headless=True, class_path=deps_classpath())
+
+
+def start_repl_vm():
+    javabridge.start_vm(run_headless=True, class_path=repl_classpath())
+
+
+def init_clojure():
+    start_vm()
+    javabridge.static_call("clojure/lang/RT", "init", "()V")
+    return True
+
+
+def find_clj_fn(fn_ns, fn_name):
+    return javabridge.static_call("clojure/lang/RT",
+                                  "var",
+                                  "(Ljava/lang/String;Ljava/lang/String;)Lclojure/lang/Var;",
+                                  fn_ns,
+                                  fn_name)
+
+
+class CLJFn(Callable):
+    applyTo = javabridge.make_method("applyTo", "(clojure/lang/ISeq;)Ljava/lang/Object;")
+    def __init__(self, fn_ns, fn_name):
+        self.o = find_clj_fn(fn_ns, fn_name)
+
+    def __call__(self, *args, **kw_args):
+        if not kw_args:
+            invoker = getattr(self, "invoke"+str(len(args)))
+            return invoker(*args)
+        else:
+            raise Exception("Unable to handle hwargs for now")
+        print(len(args), len(kw_args))
+
+
+for i in range(20):
+    opargs = ""
+    for j in range(i):
+        opargs += "Ljava/lang/Object;"
+    setattr(CLJFn, "invoke" + str(i),
+            javabridge.make_method("invoke", "(" + opargs + ")Ljava/lang/Object;" ))
+
+
+def symbol(sym_name):
+    return javabridge.static_call("clojure/lang/Symbol", "intern",
+                                  "(Ljava/lang/String;)Lclojure/lang/Symbol;", sym_name)
+
+__REQUIRE_FN = None
+
+def require(ns_name):
+    if not __REQUIRE_FN:
+        _REQUIRE_FN = CLJFn("clojure.core", "require")
+    return _REQUIRE_FN(symbol(ns_name))
+
+
+def init_libpy_embedded():
+    embed_fn = CLJFn("libpython-clj2.python", "initialize-embedded!")
+    return embed_fn()
+
+
+class GenericJavaObj:
+    __str__ = javabridge.make_method("toString", "()Ljava/lang/String;")
+    get_class = javabridge.make_method("getClass", "()Ljava/lang/Class;")
+    def __init__(self, jobj):
+        self.o = jobj
+
+
+def longCast(jobj):
+    return javabridge.static_call("clojure/lang/RT", "longCast",
+                                  "(Ljava/lang/Object;)J", jobj)
+
+
+def to_ptr(pyobj):
+    return javabridge.static_call("tech/v3/datatype/ffi/Pointer", "constructNonZero",
+                                  "(J)Ltech/v3/datatype/ffi/Pointer;", id(pyobj))
+
+
+def init_clojure_repl():
+    start_repl_vm()
+    require("libpython-clj2.python")
+    init = CLJFn("libpython-clj2.python", "initialize-embedded!")
+    init()
+    repl_fn = CLJFn("libpython-clj2.python", "start-embedded-repl!")
+    # This will no return; the GIL will be released and a port will be opened up
+    # that you can connect to for full cider lovin.
+    repl_fn()
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 6077461..96f0662 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -39,6 +39,9 @@ user> (py/py. np linspace 2 3 :num 10)
            [clojure.lang IFn]))
 
 
+(set! *warn-on-reflection* true)
+
+
 
 (defn initialize!
     "Initialize the python library.  If library path is not provided, then the system
@@ -104,6 +107,63 @@ user> (py/py. np linspace 2 3 :num 10)
     :already-initialized))
 
 
+(defn initialize-embedded!
+  "Initialize python when this library is being called *from* a python program.  In
+  that case, unless libpath is explicitly provided the system will look for the
+  python symbols in the current executable."
+  ([] (py-ffi/set-library! nil))
+  ([libpath] (py-ffi/set-library! libpath)))
+
+
+(defonce ^:private repl-server* (atom nil))
+
+
+(defn stop-embedded-repl!
+  "If an existing repl has been started, stop it.  This returns control to the
+  python process."
+  []
+  (swap! repl-server*
+         (fn [server]
+           (when server
+             (let [close-fn (requiring-resolve 'nrepl.server/stop-server)]
+               (try
+                 (locking #'repl-server*
+                   (close-fn server)
+
+                   (.notifyAll ^Object #'repl-server*))
+                    nil
+                    (catch Throwable e
+                      (log/errorf e "Failed to stop nrepl server!")
+                      nil)))))))
+
+
+(defn start-embedded-repl!
+  "This is called to start a clojure repl from python.  Do not ever call this if
+  not from a python thread as it starts with releasing the GIL.  This function
+  does not return until another thread calls stop-embedded-repl!"
+  []
+  (stop-embedded-repl!)
+  (let [tstate (when (== 1 (long (py-ffi/PyGILState_Check)))
+                 (py-ffi/PyEval_SaveThread))]
+    (try
+      (let [server-opts-fn (requiring-resolve 'nrepl.cmdline/server-opts)
+            options (server-opts-fn {:middleware '[cider.nrepl/cider-middleware]})
+            server-fn (requiring-resolve 'nrepl.cmdline/start-server)
+            ack-fn (requiring-resolve 'nrepl.cmdline/ack-server)
+            message-fn (requiring-resolve 'nrepl.cmdline/server-started-message)
+            portfile-fn (requiring-resolve 'nrepl.cmdline/save-port-file)
+            server (server-fn options)
+            _ (reset! repl-server* server)]
+        (ack-fn server options)
+        (portfile-fn server options)
+        (log/info (message-fn server options))
+        (locking #'repl-server*
+          (.wait ^Object #'repl-server*)))
+      (finally
+        (when tstate
+          (py-ffi/PyEval_RestoreThread tstate))))))
+
+
 (defmacro stack-resource-context
   "Create a stack-based resource context.  All python objects allocated within this
   context will be released at the termination of this context.
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index 0d494a5..f49cf2e 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -72,6 +72,11 @@ Required for some python modules"}
    :PyEval_SaveThread {:rettype :pointer
                        :requires-gil? false
                        :doc "Release the GIL on the current thread"}
+
+   :PyEval_RestoreThread {:rettype :void
+                          :requires-gil? false
+                          :argtypes [['threadstate :pointer]]
+                          :doc "Restore the python thread state thread"}
    :PyGILState_Ensure {:rettype :int32
                        :requires-gil? false
                        :doc "Ensure this thread owns the python GIL.
@@ -319,23 +324,18 @@ Each call must be matched with PyGILState_Release"}
 (defn reset-library!
   []
   (when @library-path*
-    (reset! library* (dt-ffi/instantiate-library @python-lib-def* @library-path*))))
+    (reset! library* (dt-ffi/instantiate-library @python-lib-def*
+                                                 (:libpath @library-path*)))))
 
 
 (defn set-library!
   [libpath]
-  (errors/when-not-error
-   (seq libpath)
-   "set-library! called with nil or empty libpath")
   (when @library*
     (log/warnf "Python library is being reinitialized to (%s).  Is this what you want?"
                libpath))
-  (reset! library-path* libpath)
+  (reset! library-path* {:libpath libpath})
   (reset-library!))
 
-
-
-
 ;;Useful for repling around - this regenerates the library function bindings
 (reset-library!)
 

From e5e9fc78f6c59b376f4b48e4d3b3f8e0f0362620 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 11 Mar 2021 08:15:43 -0700
Subject: [PATCH 302/456] Refine embedded (#150)

* Refactored embedding code out of the base python library into it's own namespace.  Refining jbridge a bit.

* Finished up first round of embedded work.
---
 cljbridge.py                    | 167 ++++++++++++++++++++++++++++++++
 deps.edn                        |   1 +
 jbridge.py                      | 103 --------------------
 src/libpython_clj2/embedded.clj |  71 ++++++++++++++
 src/libpython_clj2/python.clj   |  57 -----------
 5 files changed, 239 insertions(+), 160 deletions(-)
 create mode 100644 cljbridge.py
 delete mode 100644 jbridge.py
 create mode 100644 src/libpython_clj2/embedded.clj

diff --git a/cljbridge.py b/cljbridge.py
new file mode 100644
index 0000000..a264064
--- /dev/null
+++ b/cljbridge.py
@@ -0,0 +1,167 @@
+"""Python bindings to start a Clojure repl from a python process.  Relies on
+libpython-clj being in a deps.edn pathway as clojure is called from the command
+ line to build the classpath.  Expects javabridge to be installed and functional.
+
+Javabridge will dynamically find the java library that corresponds with calling 'java'
+ from the command line and load it.  We then initialize Clojure and provide pathways
+to require namespaces, find symbols, and call functions.
+
+There are two import initialization methods - init_clojure and init_clojure_repl - these
+take care of starting up everything in the correct order.
+"""
+import subprocess
+import javabridge
+
+try:
+    from collections.abc import Callable  # noqa
+except ImportError:
+    from collections import Callable
+
+
+def init_clojure_runtime():
+    """Initialize the clojure runtime.  This needs to happen at least once before
+attempting to require a namespace or lookup a clojure var."""
+    javabridge.static_call("clojure/lang/RT", "init", "()V")
+
+
+def find_clj_var(fn_ns, fn_name):
+    """Use the clojure runtime to find a var.  Clojure vars are placeholders in namespaces that forward their operations to the data they point to.  This allows someone to hold
+a var and but recompile a namespace to get different behavior.  They implement both
+`clojure.lang.IFn` and `clojure.lang.IDeref` so they can act like a function and
+you can dereference them to get to their original value."""
+    return javabridge.static_call("clojure/lang/RT",
+                                  "var",
+                                  "(Ljava/lang/String;Ljava/lang/String;)Lclojure/lang/Var;",
+                                  fn_ns,
+                                  fn_name)
+
+
+class CLJFn(Callable):
+    """Construct a python callable from a clojure object.  This callable will forward
+function calls to it's Clojure object expecting a clojure.lang.IFn interface."""
+    applyTo = javabridge.make_method("applyTo", "(clojure/lang/ISeq;)Ljava/lang/Object;")
+    def __init__(self, ifn_obj):
+        self.o = ifn_obj
+
+    def __call__(self, *args, **kw_args):
+        if not kw_args:
+            invoker = getattr(self, "invoke"+str(len(args)))
+            return invoker(*args)
+        else:
+            raise Exception("Unable to handle kw_args for now")
+        print(len(args), len(kw_args))
+
+
+for i in range(20):
+    opargs = ""
+    for j in range(i):
+        opargs += "Ljava/lang/Object;"
+    setattr(CLJFn, "invoke" + str(i),
+            javabridge.make_method("invoke", "(" + opargs + ")Ljava/lang/Object;" ))
+
+
+def resolve_fn(namespaced_name):
+    """Resolve a clojure var given a fully qualified namespace name.  The return value
+    is callable.  Note that the namespace itself needs to be required first."""
+    ns_name, sym_name = namespaced_name.split("/")
+    return CLJFn(find_clj_var(ns_name, sym_name))
+
+
+def resolve_call_fn(namespaced_fn_name, *args):
+    """Resolve a function given a fully qualified namespace name and call it."""
+    return resolve_fn(namespaced_fn_name)(*args)
+
+def symbol(sym_name):
+    """Create a clojure symbol from a string"""
+    return javabridge.static_call("clojure/lang/Symbol", "intern",
+                                  "(Ljava/lang/String;)Lclojure/lang/Symbol;", sym_name)
+
+__REQUIRE_FN = None
+
+def require(ns_name):
+    """Require a clojure namespace.  This needs to happen before you find symbols
+    in that namespace else you will be uninitialized var errors."""
+    if not __REQUIRE_FN:
+        _REQUIRE_FN = resolve_fn("clojure.core/require")
+    return _REQUIRE_FN(symbol(ns_name))
+
+
+def init_libpy_embedded():
+    """Initialize libpy on a mode where it looks for symbols in the local process and
+    it itself doesn't attempt to run the python intialization procedures but expects
+    the python system to be previously initialized."""
+    require("libpython-clj2.embedded")
+    return resolve_call_fn("libpython-clj2.embedded/initialize!")
+
+
+def classpath(classpath_args=[]):
+    """Call clojure at the command line and return the classpath in as a list of
+    strings.  Clojure will pick up a local deps.edn or deps can be specified inline."""
+    return subprocess.check_output(['clojure'] + list(classpath_args) + ['-Spath']).decode("utf-8").strip().split(':')
+
+
+DEFAULT_NREPL_VERSION = "0.8.3"
+DEFAULT_CIDER_NREPL_VERSION = "0.25.5"
+
+
+def repl_classpath(nrepl_version=DEFAULT_NREPL_VERSION,
+                   cider_nrepl_version=DEFAULT_CIDER_NREPL_VERSION,
+                   classpath_args=[]):
+    """Return the classpath with the correct deps to run nrepl and cider.
+    Positional arguments are added after the -Sdeps argument to start the
+    nrepl server."""
+    return classpath(classpath_args=["-Sdeps", '{:deps {nrepl/nrepl {:mvn/version "%s"} cider/cider-nrepl {:mvn/version "%s"}}}' % (nrepl_version, cider_nrepl_version)]
+                        + list(classpath_args))
+
+
+def init_clojure(classpath_args=[]):
+    """Initialize a vanilla clojure process using the clojure command line to output
+    the classpath to use for the java vm. At the return of this function clojure is
+    initialized and libpython-clj2.python's public functions will work.
+
+    * classpath_args - List of arguments that will be passed to the clojure command
+    line process when building the classpath. """
+    javabridge.start_vm(run_headless=True,
+                        class_path=classpath(classpath_args=classpath_args))
+    init_clojure_runtime()
+    init_libpy_embedded()
+    return True
+
+
+def init_clojure_repl(**kw_args):
+    """Initialize clojure with extra arguments specifically for embedding a cider-nrepl
+    server.  Then start an nrepl server.  The port will both be printed to stdout and
+    output to a .nrepl_server file.  This function does not return as it leaves the GIL
+    released so that repl threads have access to Python.  libpython-clj2.python is
+    initialized 'require-python' pathways should work.
+
+    * classpath_args - List of additional arguments that be passed to the clojure
+      process when building the classpath."""
+    javabridge.start_vm(run_headless=True, class_path=repl_classpath(**kw_args))
+    init_clojure_runtime()
+    init_libpy_embedded()
+    resolve_call_fn("libpython-clj2.embedded/start-repl!")
+
+
+class GenericJavaObj:
+    __str__ = javabridge.make_method("toString", "()Ljava/lang/String;")
+    get_class = javabridge.make_method("getClass", "()Ljava/lang/Class;")
+    __repl__ = javabridge.make_method("toString", "()Ljava/lang/String;")
+    def __init__(self, jobj):
+        self.o = jobj
+
+
+def longCast(jobj):
+    "Cast a java object to a primitive long value."
+    return javabridge.static_call("clojure/lang/RT", "longCast",
+                                  "(Ljava/lang/Object;)J", jobj)
+
+
+def to_ptr(pyobj):
+    """Create a tech.v3.datatype.ffi.Pointer java object from a python object.  This
+    allows you to pass python objects directly into libpython-clj2.python-derived
+    pathways (such as ->jvm).  If java is going to hold onto the python data for
+    a long time and it will fall out of Python scope  object should be
+    'incref-tracked' - 'libpython-clj2.python.ffi/incref-track-pyobject'."""
+    return javabridge.static_call("tech/v3/datatype/ffi/Pointer", "constructNonZero",
+                                  "(J)Ltech/v3/datatype/ffi/Pointer;", id(pyobj))
diff --git a/deps.edn b/deps.edn
index 5505039..21ead4c 100644
--- a/deps.edn
+++ b/deps.edn
@@ -26,6 +26,7 @@
                                      libpython-clj2.codegen
                                      libpython-clj2.python.np-array
                                      libpython-clj2.require
+                                     libpython-clj2.embedded
                                      python.builtins
                                      python.numpy]}}
            :test
diff --git a/jbridge.py b/jbridge.py
deleted file mode 100644
index 117598c..0000000
--- a/jbridge.py
+++ /dev/null
@@ -1,103 +0,0 @@
-import subprocess
-import javabridge
-
-try:
-    from collections.abc import Callable  # noqa
-except ImportError:
-    from collections import Callable
-
-def deps_classpath(*clj_args):
-    return subprocess.check_output(['clojure'] + list(clj_args) + ['-Spath']).decode("utf-8").strip().split(':')
-
-
-def repl_classpath():
-    return deps_classpath("-Sdeps", '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}')
-
-
-def start_vm():
-    javabridge.start_vm(run_headless=True, class_path=deps_classpath())
-
-
-def start_repl_vm():
-    javabridge.start_vm(run_headless=True, class_path=repl_classpath())
-
-
-def init_clojure():
-    start_vm()
-    javabridge.static_call("clojure/lang/RT", "init", "()V")
-    return True
-
-
-def find_clj_fn(fn_ns, fn_name):
-    return javabridge.static_call("clojure/lang/RT",
-                                  "var",
-                                  "(Ljava/lang/String;Ljava/lang/String;)Lclojure/lang/Var;",
-                                  fn_ns,
-                                  fn_name)
-
-
-class CLJFn(Callable):
-    applyTo = javabridge.make_method("applyTo", "(clojure/lang/ISeq;)Ljava/lang/Object;")
-    def __init__(self, fn_ns, fn_name):
-        self.o = find_clj_fn(fn_ns, fn_name)
-
-    def __call__(self, *args, **kw_args):
-        if not kw_args:
-            invoker = getattr(self, "invoke"+str(len(args)))
-            return invoker(*args)
-        else:
-            raise Exception("Unable to handle hwargs for now")
-        print(len(args), len(kw_args))
-
-
-for i in range(20):
-    opargs = ""
-    for j in range(i):
-        opargs += "Ljava/lang/Object;"
-    setattr(CLJFn, "invoke" + str(i),
-            javabridge.make_method("invoke", "(" + opargs + ")Ljava/lang/Object;" ))
-
-
-def symbol(sym_name):
-    return javabridge.static_call("clojure/lang/Symbol", "intern",
-                                  "(Ljava/lang/String;)Lclojure/lang/Symbol;", sym_name)
-
-__REQUIRE_FN = None
-
-def require(ns_name):
-    if not __REQUIRE_FN:
-        _REQUIRE_FN = CLJFn("clojure.core", "require")
-    return _REQUIRE_FN(symbol(ns_name))
-
-
-def init_libpy_embedded():
-    embed_fn = CLJFn("libpython-clj2.python", "initialize-embedded!")
-    return embed_fn()
-
-
-class GenericJavaObj:
-    __str__ = javabridge.make_method("toString", "()Ljava/lang/String;")
-    get_class = javabridge.make_method("getClass", "()Ljava/lang/Class;")
-    def __init__(self, jobj):
-        self.o = jobj
-
-
-def longCast(jobj):
-    return javabridge.static_call("clojure/lang/RT", "longCast",
-                                  "(Ljava/lang/Object;)J", jobj)
-
-
-def to_ptr(pyobj):
-    return javabridge.static_call("tech/v3/datatype/ffi/Pointer", "constructNonZero",
-                                  "(J)Ltech/v3/datatype/ffi/Pointer;", id(pyobj))
-
-
-def init_clojure_repl():
-    start_repl_vm()
-    require("libpython-clj2.python")
-    init = CLJFn("libpython-clj2.python", "initialize-embedded!")
-    init()
-    repl_fn = CLJFn("libpython-clj2.python", "start-embedded-repl!")
-    # This will no return; the GIL will be released and a port will be opened up
-    # that you can connect to for full cider lovin.
-    repl_fn()
diff --git a/src/libpython_clj2/embedded.clj b/src/libpython_clj2/embedded.clj
new file mode 100644
index 0000000..4dc7ff5
--- /dev/null
+++ b/src/libpython_clj2/embedded.clj
@@ -0,0 +1,71 @@
+(ns libpython-clj2.embedded
+  "Tools for embedding clojure into a python host process.
+  See jbridge.py for python details.  This namespace relies on
+  the classpath having nrepl and cider-nrepl on it.  For example:
+
+```console
+clojure -Sdeps '{:deps {nrepl/nrepl {:mvn/version \"0.8.3\"} cider/cider-nrepl {:mvn/version \"0.25.5\"}}}' ...
+```"
+  (:require [libpython-clj2.python.ffi :as py-ffi]
+            [nrepl.server :as server]
+            [nrepl.cmdline :as cmdline]
+            [clojure.tools.logging :as log]))
+
+
+(defn initialize!
+  "Initialize python when this library is being called *from* a python program.  In
+  that case, unless libpath is explicitly provided the system will look for the
+  python symbols in the current executable."
+  ([] (py-ffi/set-library! nil))
+  ([libpath] (py-ffi/set-library! libpath)))
+
+
+(defonce ^:private repl-server* (atom nil))
+
+
+(defn stop-repl!
+  "If an existing repl has been started, stop it.  This returns control to the
+  python process."
+  []
+  (swap! repl-server*
+         (fn [server]
+           (when server
+             (try
+               (locking #'repl-server*
+                 (server/stop-server server)
+                 (.notifyAll ^Object #'repl-server*))
+               nil
+               (catch Throwable e
+                 (log/errorf e "Failed to stop nrepl server!")
+                 nil))))))
+
+
+(defn start-repl!
+  "This is called to start a clojure repl from python.  Do not ever call this if
+  not from a python thread as it starts with releasing the GIL.  This function
+  does not return until another thread calls stop-embedded-repl!.
+
+  If an existing repl server has been started this returns the port of the previous
+  server else it returns the port of the new server.
+
+  Options are the same as the command line options found in nrepl.cmdline."
+  ([options]
+   (when-not @repl-server*
+     (let [tstate (when (== 1 (long (py-ffi/PyGILState_Check)))
+                    (py-ffi/PyEval_SaveThread))]
+       (try
+         (let [options (cmdline/server-opts
+                        (merge {:middleware '[cider.nrepl/cider-middleware]}
+                               options))
+               server (cmdline/start-server options)
+               _ (reset! repl-server* server)]
+           (cmdline/ack-server server options)
+           (cmdline/save-port-file server options)
+           (log/info (cmdline/server-started-message server options))
+           (locking #'repl-server*
+             (.wait ^Object #'repl-server*)))
+         (finally
+           (when tstate
+             (py-ffi/PyEval_RestoreThread tstate))))))
+   (:port @repl-server*))
+  ([] (start-repl! nil)))
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 96f0662..a88a83e 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -107,63 +107,6 @@ user> (py/py. np linspace 2 3 :num 10)
     :already-initialized))
 
 
-(defn initialize-embedded!
-  "Initialize python when this library is being called *from* a python program.  In
-  that case, unless libpath is explicitly provided the system will look for the
-  python symbols in the current executable."
-  ([] (py-ffi/set-library! nil))
-  ([libpath] (py-ffi/set-library! libpath)))
-
-
-(defonce ^:private repl-server* (atom nil))
-
-
-(defn stop-embedded-repl!
-  "If an existing repl has been started, stop it.  This returns control to the
-  python process."
-  []
-  (swap! repl-server*
-         (fn [server]
-           (when server
-             (let [close-fn (requiring-resolve 'nrepl.server/stop-server)]
-               (try
-                 (locking #'repl-server*
-                   (close-fn server)
-
-                   (.notifyAll ^Object #'repl-server*))
-                    nil
-                    (catch Throwable e
-                      (log/errorf e "Failed to stop nrepl server!")
-                      nil)))))))
-
-
-(defn start-embedded-repl!
-  "This is called to start a clojure repl from python.  Do not ever call this if
-  not from a python thread as it starts with releasing the GIL.  This function
-  does not return until another thread calls stop-embedded-repl!"
-  []
-  (stop-embedded-repl!)
-  (let [tstate (when (== 1 (long (py-ffi/PyGILState_Check)))
-                 (py-ffi/PyEval_SaveThread))]
-    (try
-      (let [server-opts-fn (requiring-resolve 'nrepl.cmdline/server-opts)
-            options (server-opts-fn {:middleware '[cider.nrepl/cider-middleware]})
-            server-fn (requiring-resolve 'nrepl.cmdline/start-server)
-            ack-fn (requiring-resolve 'nrepl.cmdline/ack-server)
-            message-fn (requiring-resolve 'nrepl.cmdline/server-started-message)
-            portfile-fn (requiring-resolve 'nrepl.cmdline/save-port-file)
-            server (server-fn options)
-            _ (reset! repl-server* server)]
-        (ack-fn server options)
-        (portfile-fn server options)
-        (log/info (message-fn server options))
-        (locking #'repl-server*
-          (.wait ^Object #'repl-server*)))
-      (finally
-        (when tstate
-          (py-ffi/PyEval_RestoreThread tstate))))))
-
-
 (defmacro stack-resource-context
   "Create a stack-based resource context.  All python objects allocated within this
   context will be released at the termination of this context.

From f089f9f169f9ad53366ccf9854cc317d127c8fd9 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 11 Mar 2021 08:20:34 -0700
Subject: [PATCH 303/456] 2.00-beta-11

---
 deps.edn                                 |  4 +++-
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.python.html          | 22 +++++++++++-----------
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/python.builtins.html                |  2 +-
 docs/python.numpy.html                   |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 14 files changed, 26 insertions(+), 24 deletions(-)

diff --git a/deps.edn b/deps.edn
index 21ead4c..f3578af 100644
--- a/deps.edn
+++ b/deps.edn
@@ -10,6 +10,8 @@
                          ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}}
            :codox
            {:extra-deps {codox-theme-rdash/codox-theme-rdash {:mvn/version "0.1.2"}
+                         nrepl/nrepl {:mvn/version "0.8.3"}
+                         cider/cider-nrepl {:mvn/version "0.25.5"}
                          codox/codox {:mvn/version "0.10.7"
                                       :exclusions [org.ow2.asm/asm-all]}}
             :ns-default tech.v3.libs.lein-codox
@@ -43,7 +45,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-11-SNAPSHOT"
+                        :version "2.00-beta-11"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 277dd1e..2630551 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 7a03c25..f8e2664 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/environments.html b/docs/environments.html
index 11e02a2..a445120 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 56b14d0..6b03afe 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.00-beta-9</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></h1><div class="doc"><p>libpython bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-11</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 1fce93d..5f487e4 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index d4bbbe6..89f7f19 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -12,9 +12,9 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L459">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L470">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L246">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L317">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L311">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L154">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L440">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L252">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L264">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L258">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L240">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L183">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L288">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L429">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L462">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L473">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L249">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L320">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L308">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L314">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L237">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L157">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L443">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L255">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L267">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L261">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L243">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L180">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L291">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L432">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -38,7 +38,7 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L394">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L172">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L188">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L214">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L208">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L143">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L397">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -53,16 +53,16 @@
       <li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
     </ul>
   </li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L43">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L276">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L356">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L380">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L163">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L279">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L359">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L383">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L166">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
 <p>Options:</p>
 <ul>
   <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L605">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L608">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L494">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L516">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L487">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L480">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L497">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L519">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L490">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -72,8 +72,8 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L551">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L270">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L554">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L273">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L323">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L194">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L201">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L220">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L227">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L107">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L451">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L120">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L129">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L326">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L110">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L454">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 614f67a..ee7cdfa 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 3f47558..a9a4faa 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 26a98b1..1ed8283 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index ee239b2..1974b40 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index 6fd2c54..362f899 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index bfb84bf..88ad97f 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 8eb980d..67f987a 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.00-beta-9</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -145px;"><span class="top" style="height: 154px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From 94c72ca0ac94b210a9b126805cd4112024ad0b96 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 11 Mar 2021 08:20:49 -0700
Subject: [PATCH 304/456] snap

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index f3578af..3797115 100644
--- a/deps.edn
+++ b/deps.edn
@@ -45,7 +45,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-11"
+                        :version "2.00-beta-12-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From 257ea31365cd1181741c10fa158fcc00c116f885 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 11 Mar 2021 09:32:11 -0700
Subject: [PATCH 305/456] 2.00-beta-12

---
 CHANGELOG.md                             |   9 ++
 deps.edn                                 |   2 +-
 docs/Usage.html                          |   2 +-
 docs/design.html                         |   2 +-
 docs/embedded.html                       | 104 +++++++++++++++++++++++
 docs/environments.html                   |   2 +-
 docs/index.html                          |   2 +-
 docs/libpython-clj2.codegen.html         |   2 +-
 docs/libpython-clj2.embedded.html        |   7 ++
 docs/libpython-clj2.python.html          |   2 +-
 docs/libpython-clj2.python.np-array.html |   2 +-
 docs/libpython-clj2.require.html         |   2 +-
 docs/new-to-clojure.html                 |   2 +-
 docs/python.builtins.html                |   2 +-
 docs/python.numpy.html                   |   2 +-
 docs/scopes-and-gc.html                  |   2 +-
 docs/slicing.html                        |   2 +-
 src/libpython_clj2/embedded.clj          |  26 +++---
 18 files changed, 144 insertions(+), 30 deletions(-)
 create mode 100644 docs/embedded.html
 create mode 100644 docs/libpython-clj2.embedded.html

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c8c08b1..5852850 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,14 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-12
+ * Small refinements around embedding and documentation.
+
+## 2.00-beta-11
+ * Major improvements to get libpython-clj v2 to work as robustly as v1 did across
+   several operating systems.
+ * First release that includes embedded functionality (!!).  See the embedded topic
+   for more details.
+
 ## 2.00-beta-8
  * Add back in dynamically searching for libraries based on `java.library.path`.
 
diff --git a/deps.edn b/deps.edn
index 3797115..9030c30 100644
--- a/deps.edn
+++ b/deps.edn
@@ -45,7 +45,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-12-SNAPSHOT"
+                        :version "2.00-beta-12"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 2630551..da320b2 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index f8e2664..ea1c09a 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
new file mode 100644
index 0000000..7fa5bea
--- /dev/null
+++ b/docs/embedded.html
@@ -0,0 +1,104 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the python shared library and having some capability to setup various python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
+<ol>
+  <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host python from Clojur is for them a missive and potentially disruptive change.</li>
+  <li>The python ecosystem is moving away from the shared library and towards compiling a statically linked executable. This can never work with libpython-clj’s default pathway.</li>
+  <li>Embedded Python cannot use all of Python functionality available due to the fact that the host process isn’t <code>python</code>. Specifically the multithreading module relies on forking the host process and thus produces a hang if the JVM is the main underlying process.</li>
+  <li>Replicating the exact python environment is error prone especially when Python environment managers such as <code>pyenv</code> and <code>Conda</code> are taken into account.</li>
+</ol>
+<p>Due to the above reasons there is a solid argument for, if possible, embedding Clojure into Python allowing the Python executable to be the host process.</p>
+<h2><a href="#enter-javabridge" name="enter-javabridge"></a>Enter: javabridge</h2>
+<p>Python already had a nascent system for embedding Java in Python - the <a href="https://pypi.org/project/javabridge/">javabridge module</a>. You will need to have javabridge installed in your Python environment. In order to compile <code>javabridge</code> requires the JDK installed and <strong>not just the JRE</strong>.</p>
+<pre><code class="console">python3 -mpip install javabridge
+</code></pre>
+<p>If the installation cannot find ‘jni.h’ then most likely you have the Java runtime (JRE) installed as opposed to the Java development kit (JDK).</p>
+<h2><a href="#from-the-python-repl" name="from-the-python-repl"></a>From the Python REPL</h2>
+<p>The next step involves starting a python repl from our libpython-clj3 base directory. This is only required because we have a special <a href="https://github.com/clj-python/libpython-clj/blob/master/cljbridge.py">python script</a> that has code to start a Java VM with a correct classpath. So we start by importing that script:</p>
+<pre><code class="python">Python 3.8.5 (default, Jan 27 2021, 15:41:15)
+[GCC 9.3.0] on linux
+Type "help", "copyright", "credits" or "license" for more information.
+&gt;&gt;&gt; import cljbridge
+&gt;&gt;&gt; test_var=10
+&gt;&gt;&gt; cljbridge.init_clojure_repl()
+Mar 11, 2021 9:08:47 AM clojure.tools.logging$eval3186$fn__3189 invoke
+INFO: nREPL server started on port 40241 on host localhost - nrepl://localhost:40241
+</code></pre>
+<p>At this point we do not get control back; we have released the GIL and java is blocking this thread to allow the Clojure REPL systems access to the GIL. We have two important libraries for clojure loaded, nrepl and cider which allow a rich, interactive development experience so let’s now connect to that port with our favorite Clojure editor - emacs of course ;-).</p>
+<h2><a href="#from-the-clojure-repl" name="from-the-clojure-repl"></a>From the Clojure REPL</h2>
+<p>From emacs, I run the command ‘cider-connect’ which allows me to specify a host and port to connect to. Once connected, I get a minimal repl environment:</p>
+<pre><code class="clojure">;; M-x cider-connect ...localhost...40241
+;; I am not sure why but to initialize the user namespace I have to eval ns user
+
+user&gt; (eval '(ns user))
+nil
+user&gt; (require '[libpython-clj2.python :as py])
+nil
+;; Python has been initialized and libpython-clj can detect this
+user&gt; (py/initialize!)
+:already-initialized
+user&gt; ;;We can share data via the main module
+user&gt; (def main-mod (py/add-module "__main__"))
+#'user/main-mod
+user&gt; (def mod-dict (py/module-dict main-mod))
+#'user/mod-dict
+user&gt; (keys mod-dict)
+("__name__"
+ "__doc__"
+ "__package__"
+ "__loader__"
+ "__spec__"
+ "__annotations__"
+ "__builtins__"
+ "cljbridge"
+ "test_var")
+user&gt; (get mod-dict "test_var")
+10
+user&gt; (.put mod-dict "clj_fn" (fn [&amp; args] (println "Printing from Clojure: " (vec args))))
+nil
+user&gt; ;;Now if we stop the repl server we can access our python environment again
+user&gt; (require '[libpython-clj2.embedded :as embedded])
+nil
+user&gt; (embedded/stop-repl!)
+</code></pre>
+<h2><a href="#and-back-to-python-" name="and-back-to-python-"></a>And Back to Python!!</h2>
+<p>Shutting down the repl always gives us an exception; something perhaps to work on. But the important thing is that we can access variables and data that we set in the main module -</p>
+<pre><code class="python">&gt;&gt;&gt; Exception in thread "nREPL-session-d684061e-f21c-4265-a9a2-828b99dcaf42" java.net.SocketException: Socket closed
+	at java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:118)
+	at java.net.SocketOutputStream.write(SocketOutputStream.java:155)
+	at java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)
+	at java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)
+	at nrepl.transport$bencode$fn__7714.invoke(transport.clj:121)
+	at nrepl.transport.FnTransport.send(transport.clj:28)
+	at nrepl.middleware.print$send_streamed.invokeStatic(print.clj:136)
+	at nrepl.middleware.print$send_streamed.invoke(print.clj:122)
+	at nrepl.middleware.print$printing_transport$reify__8149.send(print.clj:173)
+	at cider.nrepl.middleware.track_state$make_transport$reify__17923.send(track_state.clj:228)
+	at nrepl.middleware.caught$caught_transport$reify__8184.send(caught.clj:58)
+	at nrepl.middleware.interruptible_eval$evaluate$fn__8250.invoke(interruptible_eval.clj:132)
+	at clojure.main$repl$fn__9121.invoke(main.clj:460)
+	at clojure.main$repl.invokeStatic(main.clj:458)
+	at clojure.main$repl.doInvoke(main.clj:368)
+	at clojure.lang.RestFn.invoke(RestFn.java:1523)
+	at nrepl.middleware.interruptible_eval$evaluate.invokeStatic(interruptible_eval.clj:84)
+	at nrepl.middleware.interruptible_eval$evaluate.invoke(interruptible_eval.clj:56)
+	at nrepl.middleware.interruptible_eval$interruptible_eval$fn__8258$fn__8262.invoke(interruptible_eval.clj:152)
+	at clojure.lang.AFn.run(AFn.java:22)
+	at nrepl.middleware.session$session_exec$main_loop__8326$fn__8330.invoke(session.clj:202)
+	at nrepl.middleware.session$session_exec$main_loop__8326.invoke(session.clj:201)
+	at clojure.lang.AFn.run(AFn.java:22)
+	at java.lang.Thread.run(Thread.java:748)
+
+&gt;&gt;&gt; # So let's call our new clojure fn
+&gt;&gt;&gt; clj_fn(1, 2, 3, 4, "Embedded Clojure FTW!!")
+Printing from Clojure:  [1 2 3 4 Embedded Clojure FTW!!]
+&gt;&gt;&gt;
+</code></pre>
+<h2><a href="#are-you-not-entertained-" name="are-you-not-entertained-"></a>Are You Not Entertained???</h2>
+<p>So there you have it, embedding a Clojure repl in a Python process and passing data in between these two systems. This sidesteps a <em>ton</em> of issues with embedding Python and provides another interesting set of possibilities, essentially extending existing Python systems with some of the greatest tech the JVM has to offer :-).</p>
+<ul>
+  <li><a href="https://github.com/LeeKamentsky/python-javabridge">javabridge github</a></li>
+  <li><a href="https://github.com/clj-python/libpython-clj/blob/94c72ca0ac94b210a9b126805cd4112024ad0b96/cljbridge.py">libpython-clj cljbridge.py</a></li>
+  <li><a href="https://clj-python.github.io/libpython-clj/libpython-clj2.embedded.html">libpython-clj embedded docs</a></li>
+</ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/environments.html b/docs/environments.html
index a445120..55497b0 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 6b03afe..a1788c1 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-11</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-12</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 5f487e4..a2af7db 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
new file mode 100644
index 0000000..bf855f4
--- /dev/null
+++ b/docs/libpython-clj2.embedded.html
@@ -0,0 +1,7 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<pre><code class="console">clojure -Sdeps '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
+</code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl from python. Do not ever call this if not from a python thread as it starts with releasing the GIL. This function does not return until another thread calls stop-embedded-repl!.</p>
+<p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
+<p>Options are the same as the command line options found in nrepl.cmdline.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L43">view source</a></div></div><div class="public anchor" id="var-stop-repl.21"><h3>stop-repl!</h3><div class="usage"><code>(stop-repl!)</code></div><div class="doc"><div class="markdown"><p>If an existing repl has been started, stop it. This returns control to the python process.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L26">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 89f7f19..29e420c 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index ee7cdfa..0b57082 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index a9a4faa..adb4155 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 1ed8283..80b1644 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index 1974b40..6cad129 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index 362f899..be6a499 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 88ad97f..8fb1f82 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 67f987a..2d12bde 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-11</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/src/libpython_clj2/embedded.clj b/src/libpython_clj2/embedded.clj
index 4dc7ff5..3bdb3ed 100644
--- a/src/libpython_clj2/embedded.clj
+++ b/src/libpython_clj2/embedded.clj
@@ -51,21 +51,15 @@ clojure -Sdeps '{:deps {nrepl/nrepl {:mvn/version \"0.8.3\"} cider/cider-nrepl {
   Options are the same as the command line options found in nrepl.cmdline."
   ([options]
    (when-not @repl-server*
-     (let [tstate (when (== 1 (long (py-ffi/PyGILState_Check)))
-                    (py-ffi/PyEval_SaveThread))]
-       (try
-         (let [options (cmdline/server-opts
-                        (merge {:middleware '[cider.nrepl/cider-middleware]}
-                               options))
-               server (cmdline/start-server options)
-               _ (reset! repl-server* server)]
-           (cmdline/ack-server server options)
-           (cmdline/save-port-file server options)
-           (log/info (cmdline/server-started-message server options))
-           (locking #'repl-server*
-             (.wait ^Object #'repl-server*)))
-         (finally
-           (when tstate
-             (py-ffi/PyEval_RestoreThread tstate))))))
+     (let [options (cmdline/server-opts
+                    (merge {:middleware '[cider.nrepl/cider-middleware]}
+                           options))
+           server (cmdline/start-server options)
+           _ (reset! repl-server* server)]
+       (cmdline/ack-server server options)
+       (cmdline/save-port-file server options)
+       (log/info (cmdline/server-started-message server options))
+       (locking #'repl-server*
+         (.wait ^Object #'repl-server*))))
    (:port @repl-server*))
   ([] (start-repl! nil)))

From 47de29180fe4dd103b121ec753b0f5e986f0990e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 11 Mar 2021 09:32:31 -0700
Subject: [PATCH 306/456] snap

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 9030c30..b718b36 100644
--- a/deps.edn
+++ b/deps.edn
@@ -45,7 +45,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-12"
+                        :version "2.00-beta-13-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From 9dac2353d4690b0dbaeaaba4901b3f8fe8da3c24 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 11 Mar 2021 09:40:10 -0700
Subject: [PATCH 307/456] Documenting embedded pathway

---
 README.md                         |   1 +
 docs/libpython-clj2.embedded.html |   5 +-
 src/libpython_clj2/embedded.clj   |  11 +-
 topics/embedded.md                | 167 ++++++++++++++++++++++++++++++
 4 files changed, 178 insertions(+), 6 deletions(-)
 create mode 100644 topics/embedded.md

diff --git a/README.md b/README.md
index e9acba7..1add98e 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,7 @@
  * [Static code generation](https://clj-python.github.io/libpython-clj/libpython-clj2.codegen.html#var-write-namespace.21) - generate clojure namespaces 
    wrapping python modules that are safe to use with AOT and load much faster than analogous `require-python` calls.  These namespace will not
    automatically initialize the python subsystem -- initialize! must be called first (or a nice exception is throw).
+ * You can now [Embed Clojure in Python](https://clj-python.github.io/libpython-clj/embedded.html)
 
 ## libpython-clj features
 
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index bf855f4..4fad6c0 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -2,6 +2,7 @@
     "">
 <html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -Sdeps '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
-</code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl from python. Do not ever call this if not from a python thread as it starts with releasing the GIL. This function does not return until another thread calls stop-embedded-repl!.</p>
+</code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
-<p>Options are the same as the command line options found in nrepl.cmdline.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L43">view source</a></div></div><div class="public anchor" id="var-stop-repl.21"><h3>stop-repl!</h3><div class="usage"><code>(stop-repl!)</code></div><div class="doc"><div class="markdown"><p>If an existing repl has been started, stop it. This returns control to the python process.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L26">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>To return control to the calling thread call <code>stop-repl!</code>.</p>
+<p>Options are the same as the command line options found in nrepl.cmdline.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L43">view source</a></div></div><div class="public anchor" id="var-stop-repl.21"><h3>stop-repl!</h3><div class="usage"><code>(stop-repl!)</code></div><div class="doc"><div class="markdown"><p>If an existing repl has been started, stop it. This returns control to the thread that called `start-repl!.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L26">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/src/libpython_clj2/embedded.clj b/src/libpython_clj2/embedded.clj
index 3bdb3ed..10e68c2 100644
--- a/src/libpython_clj2/embedded.clj
+++ b/src/libpython_clj2/embedded.clj
@@ -25,7 +25,7 @@ clojure -Sdeps '{:deps {nrepl/nrepl {:mvn/version \"0.8.3\"} cider/cider-nrepl {
 
 (defn stop-repl!
   "If an existing repl has been started, stop it.  This returns control to the
-  python process."
+  thread that called `start-repl!."
   []
   (swap! repl-server*
          (fn [server]
@@ -41,13 +41,16 @@ clojure -Sdeps '{:deps {nrepl/nrepl {:mvn/version \"0.8.3\"} cider/cider-nrepl {
 
 
 (defn start-repl!
-  "This is called to start a clojure repl from python.  Do not ever call this if
-  not from a python thread as it starts with releasing the GIL.  This function
-  does not return until another thread calls stop-embedded-repl!.
+  "This is called to start a clojure repl and block the thread.  This function does not return
+  control to the calling thread until another thread calls `stop-repl!; this design is
+  explicit to ensure the python GIL is released and thus when connected to the REPL you can
+  use Python.
 
   If an existing repl server has been started this returns the port of the previous
   server else it returns the port of the new server.
 
+  To return control to the calling thread call `stop-repl!`.
+
   Options are the same as the command line options found in nrepl.cmdline."
   ([options]
    (when-not @repl-server*
diff --git a/topics/embedded.md b/topics/embedded.md
new file mode 100644
index 0000000..0c75d39
--- /dev/null
+++ b/topics/embedded.md
@@ -0,0 +1,167 @@
+# Embedding Clojure In Python
+
+
+The initial development push for `libpython-clj` was simply to embed Python in
+Clojure allowing Clojure developers to use Python modules simply transparently.
+This approach relied on `libpython-clj` being able to find the python shared library
+and having some capability to setup various python system variables before loading
+any modules.  While this works great most of the time there are several reasons for
+which this approach is less than ideal:
+
+
+1.  In some cases a mainly Python team wants to use some Clojure for a small part of
+    their work.  Telling them to host python from Clojur is for them a missive and
+    potentially disruptive change.
+2.  The python ecosystem is moving away from the shared library and towards
+    compiling a statically linked executable.  This can never work with
+    libpython-clj's default pathway.
+3.  Embedded Python cannot use all of Python functionality available due to the fact
+    that the host process isn't `python`.  Specifically the multithreading module
+    relies on forking the host process and thus produces a hang if the JVM is the
+    main underlying process.
+4.  Replicating the exact python environment is error prone especially when Python
+    environment managers such as `pyenv` and `Conda` are taken into account.
+
+
+Due to the above reasons there is a solid argument for, if possible, embedding
+Clojure into Python allowing the Python executable to be the host process.
+
+
+## Enter: javabridge
+
+
+Python already had a nascent system for embedding Java in Python - the
+[javabridge module](https://pypi.org/project/javabridge/).  You will need to have
+javabridge installed in your Python environment.  In order to compile `javabridge`
+requires the JDK installed and **not just the JRE**.
+
+```console
+python3 -mpip install javabridge
+```
+
+If the installation cannot find 'jni.h' then most likely you have the Java runtime
+(JRE) installed as opposed to the Java development kit (JDK).
+
+
+## From the Python REPL
+
+
+The next step involves starting a python repl from our libpython-clj3 base directory.
+This is only required because we have a special
+[python script](https://github.com/clj-python/libpython-clj/blob/master/cljbridge.py)
+that has code to start a Java VM with a correct classpath.  So we start by importing
+that script:
+
+
+```python
+Python 3.8.5 (default, Jan 27 2021, 15:41:15)
+[GCC 9.3.0] on linux
+Type "help", "copyright", "credits" or "license" for more information.
+>>> import cljbridge
+>>> test_var=10
+>>> cljbridge.init_clojure_repl()
+Mar 11, 2021 9:08:47 AM clojure.tools.logging$eval3186$fn__3189 invoke
+INFO: nREPL server started on port 40241 on host localhost - nrepl://localhost:40241
+```
+
+At this point we do not get control back; we have released the GIL and java
+is blocking this thread to allow the Clojure REPL systems access to the GIL.  We have
+two important libraries for clojure loaded, nrepl and cider which allow a rich,
+interactive development experience so let's now connect to that port with our favorite
+Clojure editor - emacs of course ;-).
+
+
+## From the Clojure REPL
+
+
+From emacs, I run the command 'cider-connect' which allows me to specify a host
+and port to connect to.  Once connected, I get a minimal repl environment:
+
+
+```clojure
+;; M-x cider-connect ...localhost...40241
+;; I am not sure why but to initialize the user namespace I have to eval ns user
+
+user> (eval '(ns user))
+nil
+user> (require '[libpython-clj2.python :as py])
+nil
+;; Python has been initialized and libpython-clj can detect this
+user> (py/initialize!)
+:already-initialized
+user> ;;We can share data via the main module
+user> (def main-mod (py/add-module "__main__"))
+#'user/main-mod
+user> (def mod-dict (py/module-dict main-mod))
+#'user/mod-dict
+user> (keys mod-dict)
+("__name__"
+ "__doc__"
+ "__package__"
+ "__loader__"
+ "__spec__"
+ "__annotations__"
+ "__builtins__"
+ "cljbridge"
+ "test_var")
+user> (get mod-dict "test_var")
+10
+user> (.put mod-dict "clj_fn" (fn [& args] (println "Printing from Clojure: " (vec args))))
+nil
+user> ;;Now if we stop the repl server we can access our python environment again
+user> (require '[libpython-clj2.embedded :as embedded])
+nil
+user> (embedded/stop-repl!)
+```
+
+## And Back to Python!!
+
+Shutting down the repl always gives us an exception; something perhaps to work on.
+But the important thing is that we can access variables and data that we set
+in the main module -
+```python
+>>> Exception in thread "nREPL-session-d684061e-f21c-4265-a9a2-828b99dcaf42" java.net.SocketException: Socket closed
+	at java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:118)
+	at java.net.SocketOutputStream.write(SocketOutputStream.java:155)
+	at java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)
+	at java.io.BufferedOutputStream.flush(BufferedOutputStream.java:140)
+	at nrepl.transport$bencode$fn__7714.invoke(transport.clj:121)
+	at nrepl.transport.FnTransport.send(transport.clj:28)
+	at nrepl.middleware.print$send_streamed.invokeStatic(print.clj:136)
+	at nrepl.middleware.print$send_streamed.invoke(print.clj:122)
+	at nrepl.middleware.print$printing_transport$reify__8149.send(print.clj:173)
+	at cider.nrepl.middleware.track_state$make_transport$reify__17923.send(track_state.clj:228)
+	at nrepl.middleware.caught$caught_transport$reify__8184.send(caught.clj:58)
+	at nrepl.middleware.interruptible_eval$evaluate$fn__8250.invoke(interruptible_eval.clj:132)
+	at clojure.main$repl$fn__9121.invoke(main.clj:460)
+	at clojure.main$repl.invokeStatic(main.clj:458)
+	at clojure.main$repl.doInvoke(main.clj:368)
+	at clojure.lang.RestFn.invoke(RestFn.java:1523)
+	at nrepl.middleware.interruptible_eval$evaluate.invokeStatic(interruptible_eval.clj:84)
+	at nrepl.middleware.interruptible_eval$evaluate.invoke(interruptible_eval.clj:56)
+	at nrepl.middleware.interruptible_eval$interruptible_eval$fn__8258$fn__8262.invoke(interruptible_eval.clj:152)
+	at clojure.lang.AFn.run(AFn.java:22)
+	at nrepl.middleware.session$session_exec$main_loop__8326$fn__8330.invoke(session.clj:202)
+	at nrepl.middleware.session$session_exec$main_loop__8326.invoke(session.clj:201)
+	at clojure.lang.AFn.run(AFn.java:22)
+	at java.lang.Thread.run(Thread.java:748)
+
+>>> # So let's call our new clojure fn
+>>> clj_fn(1, 2, 3, 4, "Embedded Clojure FTW!!")
+Printing from Clojure:  [1 2 3 4 Embedded Clojure FTW!!]
+>>>
+```
+
+
+## Are You Not Entertained???
+
+
+So there you have it, embedding a Clojure repl in a Python process and passing data
+in between these two systems.  This sidesteps a *ton* of issues with embedding Python
+and provides another interesting set of possibilities, essentially extending existing
+Python systems with some of the greatest tech the JVM has to offer :-).
+
+
+* [javabridge github](https://github.com/LeeKamentsky/python-javabridge)
+* [libpython-clj cljbridge.py](https://github.com/clj-python/libpython-clj/blob/94c72ca0ac94b210a9b126805cd4112024ad0b96/cljbridge.py)
+* [libpython-clj embedded docs](https://clj-python.github.io/libpython-clj/libpython-clj2.embedded.html)

From 6980fcd3275084b418ded92857c7d1f5418241bc Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 11 Mar 2021 12:26:26 -0700
Subject: [PATCH 308/456] README editing

---
 README.md | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/README.md b/README.md
index 1add98e..f575f16 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# JNA libpython bindings to Clojure.
+`z# JNA libpython bindings to Clojure.
 
 ### Version Info
 
@@ -6,14 +6,9 @@
 [![travis integration](https://travis-ci.com/clj-python/libpython-clj.svg?branch=master)](https://travis-ci.com/clj-python/libpython-clj)
 
 
- ## BETA 1 Is OUT!
-
- 
- This brings JDK-16 support as well as 32 bit support using a brand new 
- [ffi interface](https://cnuernber.github.io/dtype-next/tech.v3.datatype.ffi.html) and
- removing about 1/2 of the existing code.  The library's API has not changed majorly 
- aside from deprecated methods have been removed.
+ ## BETA Versions Are HOT!  Huge New Features! You Can't Afford To Miss Out!
  
+ * You can now [Embed Clojure in Python](https://clj-python.github.io/libpython-clj/embedded.html) - you can launch a Clojure REPL from a Python host process.
  * Main namespace is now `libpython-clj2` -- docs have not been updated.
  * **32 bit support**!!
  * Partial support for JDK-16 - The tests pass for core Python functionality but numpy
@@ -28,7 +23,7 @@
  * [Static code generation](https://clj-python.github.io/libpython-clj/libpython-clj2.codegen.html#var-write-namespace.21) - generate clojure namespaces 
    wrapping python modules that are safe to use with AOT and load much faster than analogous `require-python` calls.  These namespace will not
    automatically initialize the python subsystem -- initialize! must be called first (or a nice exception is throw).
- * You can now [Embed Clojure in Python](https://clj-python.github.io/libpython-clj/embedded.html)
+   
 
 ## libpython-clj features
 

From 9c5475f1050e2c424c7701e04ba6e917ed9a1290 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 11 Mar 2021 13:24:43 -0700
Subject: [PATCH 309/456] editing

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f575f16..6b6768d 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-`z# JNA libpython bindings to Clojure.
+# Deep Clojure/Python Integration.
 
 ### Version Info
 

From 7fed1df767f5fffb08eb79d2cd2b2d33821c38b6 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 11 Mar 2021 13:24:57 -0700
Subject: [PATCH 310/456] editing

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 6b6768d..fdbbc2d 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Deep Clojure/Python Integration.
+# Deep Clojure/Python Integration
 
 ### Version Info
 

From e0b159759fea25d32be2ec6739e9b0e51da4f0db Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 11 Mar 2021 17:01:05 -0700
Subject: [PATCH 311/456] Doc fixes/additions.

---
 docs/embedded.html | 5 +++--
 topics/embedded.md | 8 ++++++--
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/docs/embedded.html b/docs/embedded.html
index 7fa5bea..4833931 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -10,12 +10,12 @@
 </ol>
 <p>Due to the above reasons there is a solid argument for, if possible, embedding Clojure into Python allowing the Python executable to be the host process.</p>
 <h2><a href="#enter-javabridge" name="enter-javabridge"></a>Enter: javabridge</h2>
-<p>Python already had a nascent system for embedding Java in Python - the <a href="https://pypi.org/project/javabridge/">javabridge module</a>. You will need to have javabridge installed in your Python environment. In order to compile <code>javabridge</code> requires the JDK installed and <strong>not just the JRE</strong>.</p>
+<p>Python already had a nascent system for embedding Java in Python - the <a href="https://pypi.org/project/javabridge/">javabridge module</a>. You will need to have javabridge installed in your Python environment. In order to compile <code>javabridge</code> requires the JDK installed and <strong>not just the JRE</strong>. <a href="https://github.com/tristanstraub/">tristanstraub</a> had found a way to use this in order to work with <a href="https://github.com/tristanstraub/blender-clj/">Blender</a>. We took a bit more time and worked out ways to smooth out these interactions and make sure they were supported throught the system.</p>
 <pre><code class="console">python3 -mpip install javabridge
 </code></pre>
 <p>If the installation cannot find ‘jni.h’ then most likely you have the Java runtime (JRE) installed as opposed to the Java development kit (JDK).</p>
 <h2><a href="#from-the-python-repl" name="from-the-python-repl"></a>From the Python REPL</h2>
-<p>The next step involves starting a python repl from our libpython-clj3 base directory. This is only required because we have a special <a href="https://github.com/clj-python/libpython-clj/blob/master/cljbridge.py">python script</a> that has code to start a Java VM with a correct classpath. So we start by importing that script:</p>
+<p>The next step involves starting a python repl from our libpython-clj base directory. This is only required because we have a special <a href="https://github.com/clj-python/libpython-clj/blob/master/cljbridge.py">python script</a> that has code to start a Java VM with a correct classpath. So we start by importing that script:</p>
 <pre><code class="python">Python 3.8.5 (default, Jan 27 2021, 15:41:15)
 [GCC 9.3.0] on linux
 Type "help", "copyright", "credits" or "license" for more information.
@@ -101,4 +101,5 @@ <h2><a href="#are-you-not-entertained-" name="are-you-not-entertained-"></a>Are
   <li><a href="https://github.com/LeeKamentsky/python-javabridge">javabridge github</a></li>
   <li><a href="https://github.com/clj-python/libpython-clj/blob/94c72ca0ac94b210a9b126805cd4112024ad0b96/cljbridge.py">libpython-clj cljbridge.py</a></li>
   <li><a href="https://clj-python.github.io/libpython-clj/libpython-clj2.embedded.html">libpython-clj embedded docs</a></li>
+  <li><a href="https://github.com/tristanstraub/blender-clj/">blender-clj - the inspiration</a></li>
 </ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/topics/embedded.md b/topics/embedded.md
index 0c75d39..94947ff 100644
--- a/topics/embedded.md
+++ b/topics/embedded.md
@@ -33,7 +33,10 @@ Clojure into Python allowing the Python executable to be the host process.
 Python already had a nascent system for embedding Java in Python - the
 [javabridge module](https://pypi.org/project/javabridge/).  You will need to have
 javabridge installed in your Python environment.  In order to compile `javabridge`
-requires the JDK installed and **not just the JRE**.
+requires the JDK installed and **not just the JRE**.  [tristanstraub](https://github.com/tristanstraub/)
+had found a way to use this in order to work with [Blender](https://github.com/tristanstraub/blender-clj/).
+We took a bit more time and worked out ways to smooth out these interactions
+and make sure they were supported throught the system.
 
 ```console
 python3 -mpip install javabridge
@@ -46,7 +49,7 @@ If the installation cannot find 'jni.h' then most likely you have the Java runti
 ## From the Python REPL
 
 
-The next step involves starting a python repl from our libpython-clj3 base directory.
+The next step involves starting a python repl from our libpython-clj base directory.
 This is only required because we have a special
 [python script](https://github.com/clj-python/libpython-clj/blob/master/cljbridge.py)
 that has code to start a Java VM with a correct classpath.  So we start by importing
@@ -165,3 +168,4 @@ Python systems with some of the greatest tech the JVM has to offer :-).
 * [javabridge github](https://github.com/LeeKamentsky/python-javabridge)
 * [libpython-clj cljbridge.py](https://github.com/clj-python/libpython-clj/blob/94c72ca0ac94b210a9b126805cd4112024ad0b96/cljbridge.py)
 * [libpython-clj embedded docs](https://clj-python.github.io/libpython-clj/libpython-clj2.embedded.html)
+* [blender-clj - the inspiration](https://github.com/tristanstraub/blender-clj/)

From a36ad2f8f9b0ab0367505de7ed5fbbee2ebee3b5 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 11 Mar 2021 17:05:25 -0700
Subject: [PATCH 312/456] Small docstring fix.

---
 src/libpython_clj2/embedded.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libpython_clj2/embedded.clj b/src/libpython_clj2/embedded.clj
index 10e68c2..816c908 100644
--- a/src/libpython_clj2/embedded.clj
+++ b/src/libpython_clj2/embedded.clj
@@ -25,7 +25,7 @@ clojure -Sdeps '{:deps {nrepl/nrepl {:mvn/version \"0.8.3\"} cider/cider-nrepl {
 
 (defn stop-repl!
   "If an existing repl has been started, stop it.  This returns control to the
-  thread that called `start-repl!."
+  thread that called `start-repl!`."
   []
   (swap! repl-server*
          (fn [server]

From 79320ed073c9c790930e155e3ed0909539eca581 Mon Sep 17 00:00:00 2001
From: David Pham <davidpham87@users.noreply.github.com>
Date: Mon, 15 Mar 2021 17:04:03 +0100
Subject: [PATCH 313/456] Typo's fix. (#152)

---
 topics/embedded.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/topics/embedded.md b/topics/embedded.md
index 94947ff..513543c 100644
--- a/topics/embedded.md
+++ b/topics/embedded.md
@@ -10,7 +10,7 @@ which this approach is less than ideal:
 
 
 1.  In some cases a mainly Python team wants to use some Clojure for a small part of
-    their work.  Telling them to host python from Clojur is for them a missive and
+    their work.  Telling them to host python from Clojure is for them a missive and
     potentially disruptive change.
 2.  The python ecosystem is moving away from the shared library and towards
     compiling a statically linked executable.  This can never work with
@@ -39,7 +39,7 @@ We took a bit more time and worked out ways to smooth out these interactions
 and make sure they were supported throught the system.
 
 ```console
-python3 -mpip install javabridge
+python3 -m pip install javabridge
 ```
 
 If the installation cannot find 'jni.h' then most likely you have the Java runtime

From a254b9fcc3b765e2ba645d166e3ba0d89ffb4fb5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Henrik=20Kjerringv=C3=A5g?= <hkjels@me.com>
Date: Wed, 17 Mar 2021 19:10:08 +0100
Subject: [PATCH 314/456] Corrected a typo (#153)

Appreciated!
---
 topics/Usage.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/topics/Usage.md b/topics/Usage.md
index 596d339..bad4c37 100644
--- a/topics/Usage.md
+++ b/topics/Usage.md
@@ -287,7 +287,7 @@ user/linspace
 ```
 
 * `from-import` - sugar around python `from a import b`.  Takes multiple b's.
-* `import-as` - surgar around python `import a as b`.
+* `import-as` - sugar around python `import a as b`.
 * `$a` - call an attribute using symbol att name.  Keywords map to kwargs
 * `$c` - call an object mapping keywords to kwargs
 

From f9487c055894839f82d833bd08218e44b5fcb369 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 18 Mar 2021 07:54:56 -0600
Subject: [PATCH 315/456] Updating live documentation.

---
 docs/embedded.html                |  6 +++---
 docs/libpython-clj2.embedded.html |  2 +-
 topics/embedded.md                | 10 +++++-----
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/docs/embedded.html b/docs/embedded.html
index 4833931..ab650ec 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,16 +1,16 @@
 <!DOCTYPE html PUBLIC ""
     "">
 <html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
-<p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the python shared library and having some capability to setup various python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
+<p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
-  <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host python from Clojur is for them a missive and potentially disruptive change.</li>
+  <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
   <li>The python ecosystem is moving away from the shared library and towards compiling a statically linked executable. This can never work with libpython-clj’s default pathway.</li>
   <li>Embedded Python cannot use all of Python functionality available due to the fact that the host process isn’t <code>python</code>. Specifically the multithreading module relies on forking the host process and thus produces a hang if the JVM is the main underlying process.</li>
   <li>Replicating the exact python environment is error prone especially when Python environment managers such as <code>pyenv</code> and <code>Conda</code> are taken into account.</li>
 </ol>
 <p>Due to the above reasons there is a solid argument for, if possible, embedding Clojure into Python allowing the Python executable to be the host process.</p>
 <h2><a href="#enter-javabridge" name="enter-javabridge"></a>Enter: javabridge</h2>
-<p>Python already had a nascent system for embedding Java in Python - the <a href="https://pypi.org/project/javabridge/">javabridge module</a>. You will need to have javabridge installed in your Python environment. In order to compile <code>javabridge</code> requires the JDK installed and <strong>not just the JRE</strong>. <a href="https://github.com/tristanstraub/">tristanstraub</a> had found a way to use this in order to work with <a href="https://github.com/tristanstraub/blender-clj/">Blender</a>. We took a bit more time and worked out ways to smooth out these interactions and make sure they were supported throught the system.</p>
+<p>Python already had a nascent system for embedding Java in Python - the <a href="https://pypi.org/project/javabridge/">javabridge module</a>. You will need to have javabridge installed in your Python environment. In order to compile <code>javabridge</code> requires the JDK installed and <strong>not just the JRE</strong>. <a href="https://github.com/tristanstraub/">tristanstraub</a> had found a way to use this in order to work with <a href="https://github.com/tristanstraub/blender-clj/">Blender</a>. We took a bit more time and worked out ways to smooth out these interactions and make sure they were supported throughout the system.</p>
 <pre><code class="console">python3 -mpip install javabridge
 </code></pre>
 <p>If the installation cannot find ‘jni.h’ then most likely you have the Java runtime (JRE) installed as opposed to the Java development kit (JDK).</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 4fad6c0..cd6305b 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -5,4 +5,4 @@
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
 <p>To return control to the calling thread call <code>stop-repl!</code>.</p>
-<p>Options are the same as the command line options found in nrepl.cmdline.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L43">view source</a></div></div><div class="public anchor" id="var-stop-repl.21"><h3>stop-repl!</h3><div class="usage"><code>(stop-repl!)</code></div><div class="doc"><div class="markdown"><p>If an existing repl has been started, stop it. This returns control to the thread that called `start-repl!.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L26">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>Options are the same as the command line options found in nrepl.cmdline.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L43">view source</a></div></div><div class="public anchor" id="var-stop-repl.21"><h3>stop-repl!</h3><div class="usage"><code>(stop-repl!)</code></div><div class="doc"><div class="markdown"><p>If an existing repl has been started, stop it. This returns control to the thread that called <code>start-repl!</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L26">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/topics/embedded.md b/topics/embedded.md
index 94947ff..b367ac1 100644
--- a/topics/embedded.md
+++ b/topics/embedded.md
@@ -3,15 +3,15 @@
 
 The initial development push for `libpython-clj` was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
-This approach relied on `libpython-clj` being able to find the python shared library
-and having some capability to setup various python system variables before loading
+This approach relied on `libpython-clj` being able to find the Python shared library
+and having some capability to setup various Python system variables before loading
 any modules.  While this works great most of the time there are several reasons for
 which this approach is less than ideal:
 
 
 1.  In some cases a mainly Python team wants to use some Clojure for a small part of
-    their work.  Telling them to host python from Clojur is for them a missive and
-    potentially disruptive change.
+    their work.  Telling them to host Python from Clojure is for them a potentially
+	very disruptive change.
 2.  The python ecosystem is moving away from the shared library and towards
     compiling a statically linked executable.  This can never work with
     libpython-clj's default pathway.
@@ -36,7 +36,7 @@ javabridge installed in your Python environment.  In order to compile `javabridg
 requires the JDK installed and **not just the JRE**.  [tristanstraub](https://github.com/tristanstraub/)
 had found a way to use this in order to work with [Blender](https://github.com/tristanstraub/blender-clj/).
 We took a bit more time and worked out ways to smooth out these interactions
-and make sure they were supported throught the system.
+and make sure they were supported throughout the system.
 
 ```console
 python3 -mpip install javabridge

From 29ba5fc262e50fbf9fdba7cb7941df89d576c77d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 22 Mar 2021 10:02:25 -0600
Subject: [PATCH 316/456] Unreleased but updated version to support graal
 native static compilation.

---
 CHANGELOG.md                      |  4 ++++
 deps.edn                          |  2 +-
 src/libpython_clj2/python/ffi.clj | 19 +++++++++++++++----
 3 files changed, 20 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5852850..b636b21 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-13
+ * Update to dtype-next to support graal native static ffi and library generation.
+ * Update to dtype-next to have correct definitions of ptr-t, offset-t, and size-t types.
+
 ## 2.00-beta-12
  * Small refinements around embedding and documentation.
 
diff --git a/deps.edn b/deps.edn
index b718b36..512a457 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,7 +1,7 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
         camel-snake-kebab/camel-snake-kebab    {:mvn/version "0.4.0"}
-        cnuernber/dtype-next {:mvn/version "6.12"}
+        cnuernber/dtype-next {:mvn/version "6.23"}
         net.java.dev.jna/jna {:mvn/version "5.7.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index f49cf2e..57d6b26 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -80,6 +80,7 @@ Required for some python modules"}
    :PyGILState_Ensure {:rettype :int32
                        :requires-gil? false
                        :doc "Ensure this thread owns the python GIL.
+
 Each call must be matched with PyGILState_Release"}
    :PyGILState_Check {:rettype :int32
                       :requires-gil? false
@@ -291,7 +292,17 @@ Each call must be matched with PyGILState_Release"}
    })
 
 
-(def python-lib-def* (delay (dt-ffi/define-library python-library-fns)))
+(def python-lib-def* (delay (dt-ffi/define-library
+                              python-library-fns
+                              ["_Py_NoneStruct"
+                               "_Py_FalseStruct"
+                               "_Py_TrueStruct"
+                               "PyType_Type"
+                               "PyExc_StopIteration"
+                               "PyRange_Type"
+                               "PyExc_Exception"]
+                              nil
+                              )))
 (defonce pyobject-struct-type*
   (delay (dt-struct/define-datatype!
            :pyobject [{:name :ob_refcnt :datatype (ffi-size-t/size-t-type)}
@@ -439,7 +450,7 @@ Each call must be matched with PyGILState_Release"}
 
 (defn- deref-ptr-ptr
   ^Pointer [^Pointer val]
-  (Pointer. (case (ffi-size-t/size-t-type)
+  (Pointer. (case (ffi-size-t/offset-t-type)
               :int32 (.getInt (native-buffer/unsafe) (.address val))
               :int64 (.getLong (native-buffer/unsafe) (.address val)))))
 
@@ -721,8 +732,8 @@ Each call must be matched with PyGILState_Release"}
 (defn pystr->str
   ^String [pyobj]
   ;;manually allocate/deallocate for speed; this gets called a lot
-  (let [size-obj (dt-ffi/make-ptr (ffi-size-t/size-t-type) 0 {:resource-type nil
-                                                              :uninitialized? true})
+  (let [size-obj (dt-ffi/make-ptr :pointer 0 {:resource-type nil
+                                              :uninitialized? true})
         ^Pointer str-ptr (PyUnicode_AsUTF8AndSize pyobj size-obj)
         nbuf (native-buffer/wrap-address (.address str-ptr)
                                          (size-obj 0)

From e53112d00157f3744fd4c9d31809360b8460993a Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Wed, 24 Mar 2021 22:52:36 +0100
Subject: [PATCH 317/456] should be `tech.v3.datatype` (#155)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index fdbbc2d..8006dce 100644
--- a/README.md
+++ b/README.md
@@ -55,7 +55,7 @@ This code is a concrete example that generates an
 (ns facial-rec.face-feature
   (:require [libpython-clj2.require :refer [require-python]]
             [libpython-clj2.python :refer [py. py.. py.-] :as py]
-            [tech.v2.datatype :as dtype]))
+            [tech.v3.datatype :as dtype]))
 
 
 

From 22347c2d52482dffbb72da0f0bff3577991f058f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 26 Mar 2021 13:10:05 -0600
Subject: [PATCH 318/456] Update dtype to latest.

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 512a457..4a5bcce 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,7 +1,7 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
         camel-snake-kebab/camel-snake-kebab    {:mvn/version "0.4.0"}
-        cnuernber/dtype-next {:mvn/version "6.23"}
+        cnuernber/dtype-next {:mvn/version "7.00"}
         net.java.dev.jna/jna {:mvn/version "5.7.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 

From 9353b5d5345a8e1872c8a64a1522e8587ca2bbf4 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 28 Mar 2021 08:07:19 -0600
Subject: [PATCH 319/456] Fixing cljbridge.

---
 cljbridge.py                    | 35 +++++++++++++++++++++++++--------
 deps.edn                        |  2 +-
 src/libpython_clj2/embedded.clj |  2 +-
 3 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/cljbridge.py b/cljbridge.py
index a264064..1385047 100644
--- a/cljbridge.py
+++ b/cljbridge.py
@@ -25,10 +25,11 @@ def init_clojure_runtime():
 
 
 def find_clj_var(fn_ns, fn_name):
-    """Use the clojure runtime to find a var.  Clojure vars are placeholders in namespaces that forward their operations to the data they point to.  This allows someone to hold
-a var and but recompile a namespace to get different behavior.  They implement both
-`clojure.lang.IFn` and `clojure.lang.IDeref` so they can act like a function and
-you can dereference them to get to their original value."""
+    """Use the clojure runtime to find a var.  Clojure vars are placeholders in
+namespaces that forward their operations to the data they point to.  This allows
+someone to hold a var and but recompile a namespace to get different behavior.  They
+implement both `clojure.lang.IFn` and `clojure.lang.IDeref` so they can act like a
+function and you can dereference them to get to their original value."""
     return javabridge.static_call("clojure/lang/RT",
                                   "var",
                                   "(Ljava/lang/String;Ljava/lang/String;)Lclojure/lang/Var;",
@@ -106,7 +107,7 @@ def classpath(classpath_args=[]):
 
 def repl_classpath(nrepl_version=DEFAULT_NREPL_VERSION,
                    cider_nrepl_version=DEFAULT_CIDER_NREPL_VERSION,
-                   classpath_args=[]):
+                   classpath_args=[], **kw_args):
     """Return the classpath with the correct deps to run nrepl and cider.
     Positional arguments are added after the -Sdeps argument to start the
     nrepl server."""
@@ -128,6 +129,15 @@ def init_clojure(classpath_args=[]):
     return True
 
 
+def py_dict_to_keyword_map(py_dict):
+    hash_map = None
+    keyword = resolve_fn("clojure.core/keyword")
+    assoc  = resolve_fn("clojure.core/assoc")
+    for k in py_dict:
+        hash_map = assoc(hash_map, keyword(k), py_dict[k])
+    return hash_map
+
+
 def init_clojure_repl(**kw_args):
     """Initialize clojure with extra arguments specifically for embedding a cider-nrepl
     server.  Then start an nrepl server.  The port will both be printed to stdout and
@@ -135,12 +145,21 @@ def init_clojure_repl(**kw_args):
     released so that repl threads have access to Python.  libpython-clj2.python is
     initialized 'require-python' pathways should work.
 
-    * classpath_args - List of additional arguments that be passed to the clojure
-      process when building the classpath."""
+
+    Keyword arguments in python are mapped to a hash-map of keyword options and
+    passed directly to clojure so any nrepl are valid arguments to this function.
+
+    * `classpath_args` - List of additional arguments that be passed to the clojure
+      process when building the classpath.
+    * `port` - Integer port to open up repl.  A random port will be found if not 
+      provided.
+    * `bind` - Bind address.  If you are having connectivity issues try 
+      bind=\"0.0.0.0\""""
     javabridge.start_vm(run_headless=True, class_path=repl_classpath(**kw_args))
     init_clojure_runtime()
     init_libpy_embedded()
-    resolve_call_fn("libpython-clj2.embedded/start-repl!")
+    resolve_call_fn("libpython-clj2.embedded/start-repl!",
+                    py_dict_to_keyword_map(kw_args))
 
 
 class GenericJavaObj:
diff --git a/deps.edn b/deps.edn
index 4a5bcce..2a01045 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,7 +1,7 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
         camel-snake-kebab/camel-snake-kebab    {:mvn/version "0.4.0"}
-        cnuernber/dtype-next {:mvn/version "7.00"}
+        cnuernber/dtype-next {:mvn/version "7.01"}
         net.java.dev.jna/jna {:mvn/version "5.7.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
diff --git a/src/libpython_clj2/embedded.clj b/src/libpython_clj2/embedded.clj
index 816c908..674541d 100644
--- a/src/libpython_clj2/embedded.clj
+++ b/src/libpython_clj2/embedded.clj
@@ -4,7 +4,7 @@
   the classpath having nrepl and cider-nrepl on it.  For example:
 
 ```console
-clojure -Sdeps '{:deps {nrepl/nrepl {:mvn/version \"0.8.3\"} cider/cider-nrepl {:mvn/version \"0.25.5\"}}}' ...
+clojure -SPath '{:deps {nrepl/nrepl {:mvn/version \"0.8.3\"} cider/cider-nrepl {:mvn/version \"0.25.5\"}}}' ...
 ```"
   (:require [libpython-clj2.python.ffi :as py-ffi]
             [nrepl.server :as server]

From d362f65158c022315b205380e066d155055a076e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 30 Mar 2021 17:01:05 -0600
Subject: [PATCH 320/456] Add (with example) .  Fixes issue #156

---
 src/libpython_clj2/python.clj | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index a88a83e..bb2c4f0 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -626,3 +626,24 @@ user> (py/call-attr inst \"addarg\" 10)
           (get-attr parent-mod (module-path-last-string item-path))
           (throw (Exception. (format "Failed to find module or class %s"
                                      item-path))))))))
+
+
+(defmacro def-unpack
+  "Unpack a set of symbols into a set of defs.  Useful when trying to match Python
+  idioms - this is definitely not idiomatic Clojure.
+
+  Example:
+
+```clojure
+user> (py/def-unpack [a b c] (py/->py-tuple [1 2 3]))
+#'user/c
+user> a
+1
+user> b
+2
+user> c
+3
+```"
+  [symbols input]
+  `(let [~symbols ~input]
+     ~@(for [s symbols] `(def ~s ~s))))

From 887c48232521483e465fa918660fea6061908fa4 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 30 Mar 2021 17:07:05 -0600
Subject: [PATCH 321/456] 2.00-beta-13

---
 deps.edn                                 |  2 +-
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  4 ++--
 docs/libpython-clj2.python.html          | 14 ++++++++++++--
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/python.builtins.html                |  2 +-
 docs/python.numpy.html                   |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 16 files changed, 28 insertions(+), 18 deletions(-)

diff --git a/deps.edn b/deps.edn
index 2a01045..c0b2f13 100644
--- a/deps.edn
+++ b/deps.edn
@@ -45,7 +45,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-13-SNAPSHOT"
+                        :version "2.00-beta-13"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 642627d..0d6501e 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index ea1c09a..2009330 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index bde4918..94c5b65 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 55497b0..a5adf00 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index a1788c1..180ea95 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-12</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-13</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index a2af7db..c4e6129 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index cd6305b..275eec2 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
-<pre><code class="console">clojure -Sdeps '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
 <p>To return control to the calling thread call <code>stop-repl!</code>.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 29e420c..1a58ccf 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -38,7 +38,17 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L397">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L397">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
+<p>Example:</p>
+<pre><code class="clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
+#'user/c
+user&gt; a
+1
+user&gt; b
+2
+user&gt; c
+3
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L631">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 0b57082..9b9a32b 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index adb4155..ea97725 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 80b1644..836ad38 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index 6cad129..ea0409d 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index be6a499..d9be9bf 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 8fb1f82..3b8eed7 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 2d12bde..b9135ae 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-12</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From 067c1934c56f16d060ae7272f082d2ae0003920b Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 30 Mar 2021 17:07:20 -0600
Subject: [PATCH 322/456] snap

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index c0b2f13..b2a45a4 100644
--- a/deps.edn
+++ b/deps.edn
@@ -45,7 +45,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-13"
+                        :version "2.00-beta-14-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From c58e9af6fc614616eba8151f9c2f82eb746a5dc3 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 9 Apr 2021 13:39:03 -0600
Subject: [PATCH 323/456] Fixes #157

---
 deps.edn                                    |  2 +-
 src/libpython_clj2/python/bridge_as_jvm.clj | 12 ++++++++----
 src/libpython_clj2/python/ffi.clj           |  7 +++++--
 test/libpython_clj2/python_test.clj         | 16 ++++++++++++++--
 4 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/deps.edn b/deps.edn
index b2a45a4..2ba74cf 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,7 +1,7 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
         camel-snake-kebab/camel-snake-kebab    {:mvn/version "0.4.0"}
-        cnuernber/dtype-next {:mvn/version "7.01"}
+        cnuernber/dtype-next {:mvn/version "7.07"}
         net.java.dev.jna/jna {:mvn/version "5.7.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
diff --git a/src/libpython_clj2/python/bridge_as_jvm.clj b/src/libpython_clj2/python/bridge_as_jvm.clj
index d0329e4..b74bbe0 100644
--- a/src/libpython_clj2/python/bridge_as_jvm.clj
+++ b/src/libpython_clj2/python/bridge_as_jvm.clj
@@ -196,12 +196,16 @@
                (py-proto/set-item! @pyobj*# item-name# item-value#))))
          py-proto/PyCall
          (call [callable# arglist# kw-arg-map#]
-           (-> (py-fn/call-py-fn @pyobj*# arglist# kw-arg-map# py-base/->python)
-               (py-base/as-jvm)))
+           (with-gil
+             (-> (py-fn/call-py-fn @pyobj*# arglist# kw-arg-map# py-base/->python)
+                 (py-base/as-jvm))))
          (marshal-return [callable# retval#]
-           (py-base/as-jvm retval#))
+           (with-gil
+             (py-base/as-jvm retval#)))
          clj-proto/Datafiable
-         (datafy [callable#] (py-proto/pydatafy callable#))
+         (datafy [callable#]
+           (with-gil
+             (py-proto/pydatafy callable#)))
          Object
          (toString [this#]
            (with-gil
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index 57d6b26..5ff4be1 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -370,8 +370,11 @@ Each call must be matched with PyGILState_Release"}
 ;;When this is true, generated functions will throw an exception if called when the
 ;;GIL is not captured.  It makes sense to periodically enable this flag in order
 ;;to ensure we aren't getting away with sneaky non-GIL access to Python.
-(def enable-api-gilcheck false)
+(def enable-api-gilcheck* (atom false))
 
+(defn enable-gil-check!
+  ([] (reset! enable-api-gilcheck* true))
+  ([value] (reset! enable-api-gilcheck* (boolean value))))
 
 (defn- find-pylib-fn
   [fn-kwd]
@@ -409,7 +412,7 @@ Each call must be matched with PyGILState_Release"}
            (let [fn-symbol (symbol (name fn-name))
                  requires-resctx? (first (filter #(= :string %)
                                                  (map second argtypes)))
-                 gilcheck? (when enable-api-gilcheck
+                 gilcheck? (when @enable-api-gilcheck*
                              (if (contains? fn-data :requires-gil?)
                                (fn-data :requires-gil?)
                                true))]
diff --git a/test/libpython_clj2/python_test.clj b/test/libpython_clj2/python_test.clj
index 6103e9b..f0e575a 100644
--- a/test/libpython_clj2/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -14,6 +14,7 @@
 
 
 (py/initialize!)
+(py-ffi/enable-gil-check!)
 ;; Useful to see how many times we convert a string to a python object.
 ;; (dt-ffi/enable-string->c-stats!)
 ;; (.addShutdownHook (Runtime/getRuntime) (Thread.
@@ -386,8 +387,19 @@ class Foo:
 
 (deftest numpy-all
   (let [np (py/import-module "numpy")]
-    (is (= true (py/call-attr np "all" (py/call-attr np "array" [true true true]))))
-    (is (= false (py/call-attr np "all" (py/call-attr np "array" [true false true]))))))
+    (is (= true (py/call-attr np "all"
+                              (py/call-attr np "array" [true true true]))))
+    (is (= false (py/call-attr np "all"
+                               (py/call-attr np "array" [true false true]))))))
+
+
+(deftest np-dot
+  (let [np (py/import-module "numpy")
+        np-dot (py/get-attr np "dot")
+        np-ary (py/call-attr np "array" [1 2 3])]
+    (is (== 14 (np-dot np-ary np-ary)))))
+
+
 
 
 (comment

From 457eeddc6f048cb460cebd2463763ea9318a87f0 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 9 Apr 2021 13:43:59 -0600
Subject: [PATCH 324/456] 2.00-beta-14

---
 deps.edn                                 | 2 +-
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/python.builtins.html                | 2 +-
 docs/python.numpy.html                   | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 16 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/deps.edn b/deps.edn
index 2ba74cf..33fc7ba 100644
--- a/deps.edn
+++ b/deps.edn
@@ -45,7 +45,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-14-SNAPSHOT"
+                        :version "2.00-beta-14"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 0d6501e..12b06db 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 2009330..fcc44e6 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 94c5b65..97bdd58 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index a5adf00..935d037 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 180ea95..0f92cbe 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-13</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-14</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index c4e6129..c7e02b0 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 275eec2..9cb7d8c 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 1a58ccf..43e8398 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 9b9a32b..b03a43f 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index ea97725..efd41f5 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 836ad38..7c6e0c2 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index ea0409d..62707cc 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index d9be9bf..623a3bb 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 3b8eed7..0416eec 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index b9135ae..bd26428 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-13</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From 54c4b72c1315a5982df95416936b89af3cf71ca7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 9 Apr 2021 13:44:15 -0600
Subject: [PATCH 325/456] snap

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 33fc7ba..998c50c 100644
--- a/deps.edn
+++ b/deps.edn
@@ -45,7 +45,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-14"
+                        :version "2.00-beta-15-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From 75bae4c83c7bd517e2b4734ab7e928b36e6f64a8 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 30 Apr 2021 08:51:08 -0600
Subject: [PATCH 326/456] Removing outdated dep; csk now comes from dtype-next.

---
 deps.edn | 1 -
 1 file changed, 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 998c50c..ef6dfc4 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,5 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        camel-snake-kebab/camel-snake-kebab    {:mvn/version "0.4.0"}
         cnuernber/dtype-next {:mvn/version "7.07"}
         net.java.dev.jna/jna {:mvn/version "5.7.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}

From 52fbb728b654e9c43a699da60423b9512fc70fe3 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 30 Apr 2021 09:26:48 -0600
Subject: [PATCH 327/456] Fixes #160

---
 src/libpython_clj2/python/bridge_as_jvm.clj | 30 ++++++++++++++++++---
 src/libpython_clj2/python/copy.clj          |  3 +--
 test/libpython_clj2/python_test.clj         |  5 ++++
 3 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/src/libpython_clj2/python/bridge_as_jvm.clj b/src/libpython_clj2/python/bridge_as_jvm.clj
index b74bbe0..65601f9 100644
--- a/src/libpython_clj2/python/bridge_as_jvm.clj
+++ b/src/libpython_clj2/python/bridge_as_jvm.clj
@@ -3,13 +3,16 @@
   with the JVM --  Python dicts become java.util.Maps, for instance."
   (:require [libpython-clj2.python.protocols :as py-proto]
             [libpython-clj2.python.base :as py-base]
+            [libpython-clj2.python.copy :as py-copy]
             [libpython-clj2.python.fn :as py-fn]
             [libpython-clj2.python.ffi :refer [with-gil] :as py-ffi]
             [libpython-clj2.python.gc :as pygc]
+            [tech.v3.datatype :as dtype]
+            [tech.v3.datatype.protocols :as dt-proto]
             [tech.v3.datatype.errors :as errors]
             [tech.v3.datatype.ffi :as dt-ffi]
             [clojure.core.protocols :as clj-proto])
-  (:import [java.util Map]
+  (:import [java.util Map Set]
            [clojure.lang IFn MapEntry Fn]
            [tech.v3.datatype.ffi Pointer]
            [tech.v3.datatype ObjectBuffer]))
@@ -197,7 +200,7 @@
          py-proto/PyCall
          (call [callable# arglist# kw-arg-map#]
            (with-gil
-             (-> (py-fn/call-py-fn @pyobj*# arglist# kw-arg-map# py-base/->python)
+             (-> (py-fn/call-py-fn @pyobj*# arglist# kw-arg-map# fn-arg->python)
                  (py-base/as-jvm))))
          (marshal-return [callable# retval#]
            (with-gil
@@ -234,12 +237,33 @@
   (.write ^java.io.Writer w ^String (.toString ^Object pyobj)))
 
 
+(defn fn-arg->python
+  "Slightly clever so we can pass ranges and such as function arguments."
+  ([item opts]
+   (cond
+     (dt-proto/convertible-to-range? item)
+     (py-copy/->py-range item)
+     (dtype/reader? item)
+     (py-proto/->python (dtype/->reader item) opts)
+     ;;There is one more case here for iterables that aren't anything else -
+     ;; - specifically for sequences.
+     (and (instance? Iterable item)
+          (not (instance? Map item))
+          (not (instance? String item))
+          (not (instance? Set item)))
+     (py-proto/as-python item opts)
+     :else
+     (py-base/->python item opts)))
+  ([item]
+   (fn-arg->python item nil)))
+
+
 (defn call-impl-fn
   [fn-name att-map args]
   (if-let [py-fn* (get att-map fn-name)]
     ;;laziness is carefully constructed here in order to allow the arguments to
     ;;be released within the context of the function call during fn.clj call-py-fn.
-    (-> (py-fn/call-py-fn @py-fn* args nil py-base/->python)
+    (-> (py-fn/call-py-fn @py-fn* args nil fn-arg->python)
         (py-base/as-jvm))
     (throw (UnsupportedOperationException.
             (format "Python object has no attribute: %s"
diff --git a/src/libpython_clj2/python/copy.clj b/src/libpython_clj2/python/copy.clj
index 5aada00..c8a0599 100644
--- a/src/libpython_clj2/python/copy.clj
+++ b/src/libpython_clj2/python/copy.clj
@@ -326,8 +326,7 @@
       (py-proto/->python (dtype/->reader item) opts)
       ;;There is one more case here for iterables (sequences)
       (instance? Iterable item)
-      ;;Iterables we *have* to convert lazily; we cannot copy them.
-      (py-proto/as-python item opts)
+      (py-proto/->python (vec item) opts)
       (instance? IFn item)
       (py-proto/as-python item opts)
       :else
diff --git a/test/libpython_clj2/python_test.clj b/test/libpython_clj2/python_test.clj
index f0e575a..e81f32b 100644
--- a/test/libpython_clj2/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -400,6 +400,11 @@ class Foo:
     (is (== 14 (np-dot np-ary np-ary)))))
 
 
+(deftest ->python-expands-sequences
+  (let [test-dict {:a (seq [1 2 3 4 5 7 8 9])}
+        py-dict (py/->python test-dict)
+        py-data (py/get-item py-dict "a")]
+    (is (= 8 (py/call-attr py-data "__len__")))))
 
 
 (comment

From 7e5d7e95603fc97f74860897b4fa78ae1187546a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 30 Apr 2021 09:34:26 -0600
Subject: [PATCH 328/456] 2.00-beta-15

---
 CHANGELOG.md                             | 4 ++++
 deps.edn                                 | 2 +-
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/python.builtins.html                | 2 +-
 docs/python.numpy.html                   | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 17 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b636b21..6a52b53 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-15
+ * Fix for [issue 160](https://github.com/clj-python/libpython-clj/issues/160) - ->python has to realize lazy seqs.
+ * Remove camel-snake-kebab as direct dependency; it comes in via dtype-next.
+
 ## 2.00-beta-13
  * Update to dtype-next to support graal native static ffi and library generation.
  * Update to dtype-next to have correct definitions of ptr-t, offset-t, and size-t types.
diff --git a/deps.edn b/deps.edn
index ef6dfc4..abf139f 100644
--- a/deps.edn
+++ b/deps.edn
@@ -44,7 +44,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-15-SNAPSHOT"
+                        :version "2.00-beta-15"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 12b06db..6ce7d0e 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index fcc44e6..184715c 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 97bdd58..4169a9c 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 935d037..b48cb57 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 0f92cbe..f7793cd 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-14</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-15</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index c7e02b0..b839c24 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 9cb7d8c..d4d448c 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 43e8398..670ba64 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index b03a43f..91fd3a0 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index efd41f5..88b3470 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 7c6e0c2..fd14b92 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index 62707cc..86d7cce 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index 623a3bb..13ae3d0 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 0416eec..631e008 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index bd26428..a8063a3 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-14</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From 08ae96eaa34a0d1a447e5d0eb2a67cd7781d1ee2 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 30 Apr 2021 09:34:48 -0600
Subject: [PATCH 329/456] snap

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index abf139f..b0e0d9a 100644
--- a/deps.edn
+++ b/deps.edn
@@ -44,7 +44,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-15"
+                        :version "2.00-beta-16-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From 5751d8e27473bb03dda17e97b6dd277b4a95ba40 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 4 May 2021 12:22:21 -0600
Subject: [PATCH 330/456] 2.00-beta-16

---
 CHANGELOG.md                             | 4 ++++
 deps.edn                                 | 6 ++++--
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/python.builtins.html                | 2 +-
 docs/python.numpy.html                   | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 17 files changed, 23 insertions(+), 17 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6a52b53..0ddb02d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-16
+ * Fix for [issue 162](https://github.com/clj-python/libpython-clj/issues/162) - many things failing when using JDK-16.
+   Note there is now a :jdk-16 alias in deps.edn that shows how to use libpython-clj with JDK-16.
+
 ## 2.00-beta-15
  * Fix for [issue 160](https://github.com/clj-python/libpython-clj/issues/160) - ->python has to realize lazy seqs.
  * Remove camel-snake-kebab as direct dependency; it comes in via dtype-next.
diff --git a/deps.edn b/deps.edn
index b0e0d9a..4d04308 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,12 +1,14 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "7.07"}
+        cnuernber/dtype-next {:mvn/version "7.13"}
         net.java.dev.jna/jna {:mvn/version "5.7.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
  :aliases {:dev
            {:extra-deps {criterium/criterium {:mvn/version"0.4.5"}
                          ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}}
+           :jdk-16
+           {:jvm-opts ["--add-modules" "jdk.incubator.foreign" "-Dforeign.restricted=permit"]}
            :codox
            {:extra-deps {codox-theme-rdash/codox-theme-rdash {:mvn/version "0.1.2"}
                          nrepl/nrepl {:mvn/version "0.8.3"}
@@ -44,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-16-SNAPSHOT"
+                        :version "2.00-beta-16"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 6ce7d0e..2501691 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 184715c..83dd005 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 4169a9c..2d76b06 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index b48cb57..1ce467a 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index f7793cd..ae480dd 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-15</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-16</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index b839c24..cbe36be 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index d4d448c..781cc3e 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 670ba64..c8e0ed7 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 91fd3a0..98ec393 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 88b3470..6aeadf4 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index fd14b92..d4bc642 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index 86d7cce..6d297de 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index 13ae3d0..00f7621 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 631e008..33fc14c 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index a8063a3..c074a12 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-15</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From cb6cb96236e876bf03337aebf29a12d30b190872 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 4 May 2021 12:22:44 -0600
Subject: [PATCH 331/456] Fixes #162

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 4d04308..57b0ad8 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-16"
+                        :version "2.00-beta-17-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From 89164a42e723496869ad3297bd7bc7df7cb1e371 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 10 May 2021 07:13:49 -0600
Subject: [PATCH 332/456] Fixes #163

---
 src/libpython_clj2/codegen.clj | 58 ++++++++++++++++++++--------------
 1 file changed, 34 insertions(+), 24 deletions(-)

diff --git a/src/libpython_clj2/codegen.clj b/src/libpython_clj2/codegen.clj
index 541d97d..cddbf15 100644
--- a/src/libpython_clj2/codegen.clj
+++ b/src/libpython_clj2/codegen.clj
@@ -66,20 +66,37 @@
 
 
 (defn- output-module-generic
-  [^Writer writer clj-name k v]
-  (.write writer
-          (format "
+  [^Writer writer clj-name k v vv]
+  (if (or (number? vv)
+          (string? vv)
+          (nil? vv))
+        (.write writer
+            (format "
+
+(def ^{:doc \"%s\"} %s %s)"
+                    (get-docs v)
+                    clj-name
+                    (if (string? vv)
+                      (format "\"%s\"" vv)
+                      vv)))
+    (.write writer
+            (format "
 
 (def ^{:doc \"%s\"} %s (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* \"%s\"))))"
-                  (get-docs v)
-                  clj-name
-                  k)))
+                    (get-docs v)
+                    clj-name
+                    k))))
 
 
 (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])
+    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!
@@ -164,26 +181,19 @@ user> (doto (python/list)
                            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)]
-                 ;;If the value is atomic
-                 (if (or (string? v)
-                         (number? v)
-                         (boolean? v))
-                   (.write writer (format "\n\n(def ^{:doc %s} %s %s)"
-                                          (escape-quotes (:doc v "No documentation"))
-                                          clj-name
-                                          (if (string? v)
-                                            (str "\"" (escape-quotes v) "\"")
-                                            v)))
-                   (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))))))))
+                 (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)))

From 17d8eb8a33455d0c340c435e992e722eae475a7e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 10 May 2021 07:16:33 -0600
Subject: [PATCH 333/456] 2.00-beta-17

---
 deps.edn                                 | 2 +-
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 4 ++--
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/python.builtins.html                | 2 +-
 docs/python.numpy.html                   | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 16 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/deps.edn b/deps.edn
index 57b0ad8..a12dc29 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-17-SNAPSHOT"
+                        :version "2.00-beta-17"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 2501691..c7d5cab 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 83dd005..e87c7b1 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 2d76b06..489cc82 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 1ce467a..068e352 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index ae480dd..767eeec 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-16</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-17</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index cbe36be..9c21af0 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
@@ -34,4 +34,4 @@
         (.add 1)
         (.add 2))
 [1, 2]
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/codegen.clj#L85">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/codegen.clj#L102">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 781cc3e..08db92e 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index c8e0ed7..cb6eb54 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 98ec393..c06a69a 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 6aeadf4..561a345 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index d4bc642..a22ba90 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index 6d297de..7c232b1 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index 00f7621..6bf91f6 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 33fc14c..d8bb0e1 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index c074a12..60eb6a5 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-16</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From 32adb4791b148bfbbc538281b551037bcdfbe8a5 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 10 May 2021 07:16:50 -0600
Subject: [PATCH 334/456] snap

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index a12dc29..f491888 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-17"
+                        :version "2.00-beta-18-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From f9bfbf264865b4d0905b17465ae78350326bcc9f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 10 May 2021 09:55:06 -0600
Subject: [PATCH 335/456] 2.00-beta-18

---
 CHANGELOG.md                             | 4 ++++
 deps.edn                                 | 2 +-
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 4 ++--
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/python.builtins.html                | 2 +-
 docs/python.numpy.html                   | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 src/libpython_clj2/codegen.clj           | 1 +
 src/libpython_clj2/python/ffi.clj        | 5 ++++-
 19 files changed, 26 insertions(+), 18 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0ddb02d..014cbce 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-17
+ * Additional fix for 162 to allow booleans to be considered primitives and be output inline.
+ * Experimental fix for [issue 164](https://github.com/clj-python/libpython-clj/issues/164).
+
 ## 2.00-beta-16
  * Fix for [issue 162](https://github.com/clj-python/libpython-clj/issues/162) - many things failing when using JDK-16.
    Note there is now a :jdk-16 alias in deps.edn that shows how to use libpython-clj with JDK-16.
diff --git a/deps.edn b/deps.edn
index f491888..518b8c4 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-18-SNAPSHOT"
+                        :version "2.00-beta-18"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index c7d5cab..5ddd838 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index e87c7b1..3b58dde 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 489cc82..4d1840e 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 068e352..d9965de 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 767eeec..80273d4 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-17</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-18</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 9c21af0..24b60fe 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
@@ -34,4 +34,4 @@
         (.add 1)
         (.add 2))
 [1, 2]
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/codegen.clj#L102">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/codegen.clj#L103">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 08db92e..a03bc6e 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index cb6eb54..2b819dc 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index c06a69a..2aa14e7 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 561a345..401519a 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index a22ba90..3ed607c 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index 7c232b1..e12f3bb 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index 6bf91f6..4da6747 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index d8bb0e1..69d57d2 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 60eb6a5..06cd037 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-17</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/src/libpython_clj2/codegen.clj b/src/libpython_clj2/codegen.clj
index cddbf15..4aa0e4b 100644
--- a/src/libpython_clj2/codegen.clj
+++ b/src/libpython_clj2/codegen.clj
@@ -69,6 +69,7 @@
   [^Writer writer clj-name k v vv]
   (if (or (number? vv)
           (string? vv)
+          (boolean? vv)
           (nil? vv))
         (.write writer
             (format "
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index 5ff4be1..0062236 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -230,6 +230,9 @@ Each call must be matched with PyGILState_Release"}
    :PyLong_AsLongLong {:rettype :int64
                        :argtypes [['pyobj :pointer]]
                        :doc "Get the long value from a python integer"}
+   :PyLong_AsUnsignedLongLongMask {:rettype :int64
+                                   :argtypes [['pyobj :pointer]]
+                                   :doc "Get the unsigned long value from a python integer with no overflow checking"}
    :PyLong_FromLongLong {:rettype :pointer
                          :argtypes [['data :int64]]
                          :doc "Get a pyobject form a long."}
@@ -910,7 +913,7 @@ Object's refcount is bad.  Crash is imminent"
           nil)
       (case (pyobject-type-kwd pyobj)
         :int (with-decref [pyobj pyobj]
-               (PyLong_AsLongLong pyobj))
+               (PyLong_AsUnsignedLongLongMask pyobj))
         :float (with-decref [pyobj pyobj]
                  (PyFloat_AsDouble pyobj))
         :str (with-decref [pyobj pyobj]

From 3b0c79faac6cf5d15f58fade225902d7e766d57c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 10 May 2021 09:57:03 -0600
Subject: [PATCH 336/456] snap

---
 CHANGELOG.md | 8 ++++++--
 deps.edn     | 2 +-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 014cbce..b2773af 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,12 @@
 # Time for a ChangeLog!
 
-## 2.00-beta-17
+## 2.00-beta-18
  * Additional fix for 162 to allow booleans to be considered primitives and be output inline.
- * Experimental fix for [issue 164](https://github.com/clj-python/libpython-clj/issues/164).
+ * Experimental fix for [issue 164](https://github.com/clj-python/libpython-clj/issues/164) - Unsigned int64 fails with
+   `OverflowError: int too big to convert`.
+ 
+## 2.00-beta-17
+ * Almost fix fo [issue 163](https://github.com/clj-python/libpython-clj/issues/163) - codegen fails with JVM primitives.
 
 ## 2.00-beta-16
  * Fix for [issue 162](https://github.com/clj-python/libpython-clj/issues/162) - many things failing when using JDK-16.
diff --git a/deps.edn b/deps.edn
index 518b8c4..d3d7ef2 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-18"
+                        :version "2.00-beta-19-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From c71d67465c3cd3748c5c94167f981f68a61b622e Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 16 May 2021 10:08:42 -0600
Subject: [PATCH 337/456] Fixes #126

---
 CHANGELOG.md                                | 3 +++
 deps.edn                                    | 2 +-
 src/libpython_clj2/python/bridge_as_jvm.clj | 5 ++++-
 test/libpython_clj2/python_test.clj         | 7 +++++++
 4 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b2773af..94f2401 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,8 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-19
+ * [issue 126](https://github.com/clj-python/libpython-clj/issues/126) - Python maps sometimes fail to destructure.
+
 ## 2.00-beta-18
  * Additional fix for 162 to allow booleans to be considered primitives and be output inline.
  * Experimental fix for [issue 164](https://github.com/clj-python/libpython-clj/issues/164) - Unsigned int64 fails with
diff --git a/deps.edn b/deps.edn
index d3d7ef2..1bdab0a 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "7.13"}
+        cnuernber/dtype-next {:mvn/version "8.00"}
         net.java.dev.jna/jna {:mvn/version "5.7.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
diff --git a/src/libpython_clj2/python/bridge_as_jvm.clj b/src/libpython_clj2/python/bridge_as_jvm.clj
index 65601f9..21829a9 100644
--- a/src/libpython_clj2/python/bridge_as_jvm.clj
+++ b/src/libpython_clj2/python/bridge_as_jvm.clj
@@ -310,7 +310,10 @@
                iterator-seq
                set)))
        (get [this obj-key]
-            (py-call "__getitem__" obj-key))
+            ;;Specifically return nil to match java map expectations
+            ;;and thus allow destructuring.
+            (when (py-call "__contains__" obj-key)
+              (py-call "__getitem__" obj-key)))
        (getOrDefault [item obj-key obj-default-value]
                      (if (.containsKey item obj-key)
                        (.get item obj-key)
diff --git a/test/libpython_clj2/python_test.clj b/test/libpython_clj2/python_test.clj
index e81f32b..4761cf6 100644
--- a/test/libpython_clj2/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -407,6 +407,13 @@ class Foo:
     (is (= 8 (py/call-attr py-data "__len__")))))
 
 
+(deftest python-as-jvm-destructuring
+  (let [py-dict (py/->python {:a 1})
+        jvm-py-dict (py/as-jvm py-dict)
+        {:keys [a b]} jvm-py-dict]
+    (is (nil? b))))
+
+
 (comment
   (require '[libpython-clj.require :refer [require-python]])
 

From fbf208c16264d5f8dad1c4d33fe2999b1521cda7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 16 May 2021 10:13:20 -0600
Subject: [PATCH 338/456] 2.00-beta-19

---
 deps.edn                                 | 2 +-
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/python.builtins.html                | 2 +-
 docs/python.numpy.html                   | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 16 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/deps.edn b/deps.edn
index 1bdab0a..4275d20 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-19-SNAPSHOT"
+                        :version "2.00-beta-19"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 5ddd838..13c3f2c 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 3b58dde..59c436a 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 4d1840e..b8c830b 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index d9965de..c2a6608 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 80273d4..f9197ed 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-18</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-19</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 24b60fe..2b71127 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index a03bc6e..e352991 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 2b819dc..9152d70 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 2aa14e7..3c13a53 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 401519a..a805cb2 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 3ed607c..23f9fa0 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
index e12f3bb..2d4956d 100644
--- a/docs/python.builtins.html
+++ b/docs/python.builtins.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
+<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
 <p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
 <p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
 <p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
index 4da6747..e510ef4 100644
--- a/docs/python.numpy.html
+++ b/docs/python.numpy.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
+<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
 <p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
 <p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 69d57d2..b145cfe 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 06cd037..c2250dc 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-18</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From bd697ad38479c0c847a834668d8cbe2377eec08a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 16 May 2021 10:13:39 -0600
Subject: [PATCH 339/456] snap

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 4275d20..d2be636 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-19"
+                        :version "2.00-beta-20-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From 5bd4864893b1138825fcc051175e0a285c378a0c Mon Sep 17 00:00:00 2001
From: Stephen Hopper <stephenmhopper@gmail.com>
Date: Thu, 20 May 2021 07:43:39 -0500
Subject: [PATCH 340/456] Remove codegen builtins and numpy namespaces to avoid
 collisions and version conflicts. (#165)

---
 .gitignore              |     4 +-
 src/python/builtins.clj |   975 --
 src/python/numpy.clj    | 29133 --------------------------------------
 3 files changed, 3 insertions(+), 30109 deletions(-)
 delete mode 100644 src/python/builtins.clj
 delete mode 100644 src/python/numpy.clj

diff --git a/.gitignore b/.gitignore
index ffb199c..8776644 100644
--- a/.gitignore
+++ b/.gitignore
@@ -15,4 +15,6 @@ __pycache__
 cpython
 a.out
 *.pom
-*.pom.asc
\ No newline at end of file
+*.pom.asc
+/.idea
+*.iml
\ No newline at end of file
diff --git a/src/python/builtins.clj b/src/python/builtins.clj
deleted file mode 100644
index 98c03f0..0000000
--- a/src/python/builtins.clj
+++ /dev/null
@@ -1,975 +0,0 @@
-(ns python.builtins
-"No documentation provided"
-(: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 [+ - * / 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]))
-
-(defonce ^:private src-obj* (py-global-delay (py/path->py-obj "builtins")))
-
-(def float (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float"))))
-(alter-meta! #'float assoc :doc "Convert a string or number to a floating point number, if possible." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ConnectionResetError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ConnectionResetError"))))
-(alter-meta! #'ConnectionResetError assoc :doc "Connection reset." :arglists '[[self & [args {:as kwargs}]]])
-
-(def map (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "map"))))
-(alter-meta! #'map assoc :doc "map(func, *iterables) --> map object
-
-Make an iterator that computes the function using arguments from
-each of the iterables.  Stops when the shortest iterable is exhausted." :arglists '[[self & [args {:as kwargs}]]])
-
-(def RecursionError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "RecursionError"))))
-(alter-meta! #'RecursionError assoc :doc "Recursion limit exceeded." :arglists '[[self & [args {:as kwargs}]]])
-
-(def int (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int"))))
-(alter-meta! #'int assoc :doc "int([x]) -> integer
-int(x, base=10) -> integer
-
-Convert a number or string to an integer, or return 0 if no arguments
-are given.  If x is a number, return x.__int__().  For floating point
-numbers, this truncates towards zero.
-
-If x is not a number or if base is given, then x must be a string,
-bytes, or bytearray instance representing an integer literal in the
-given base.  The literal can be preceded by '+' or '-' and be surrounded
-by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
-Base 0 means to interpret the base from the string as an integer literal.
->>> int('0b100', base=0)
-4" :arglists '[[self & [args {:as kwargs}]]])
-
-(def object (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "object"))))
-(alter-meta! #'object assoc :doc "The base class of the class hierarchy.
-
-When called, it accepts no arguments and returns a new featureless
-instance that has no instance attributes and cannot be given any.
-" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} NotImplemented (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "NotImplemented"))))
-
-(def range (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "range"))))
-(alter-meta! #'range assoc :doc "range(stop) -> range object
-range(start, stop[, step]) -> range object
-
-Return an object that produces a sequence of integers from start (inclusive)
-to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
-start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
-These are exactly the valid indices for a list of 4 elements.
-When step is given, it specifies the increment (or decrement)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def TypeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "TypeError"))))
-(alter-meta! #'TypeError assoc :doc "Inappropriate argument type." :arglists '[[self & [args {:as kwargs}]]])
-
-(def PermissionError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "PermissionError"))))
-(alter-meta! #'PermissionError assoc :doc "Not enough permissions." :arglists '[[self & [args {:as kwargs}]]])
-
-(def MemoryError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "MemoryError"))))
-(alter-meta! #'MemoryError assoc :doc "Out of memory." :arglists '[[self & [args {:as kwargs}]]])
-
-(def KeyboardInterrupt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "KeyboardInterrupt"))))
-(alter-meta! #'KeyboardInterrupt assoc :doc "Program interrupted by user." :arglists '[[self & [args {:as kwargs}]]])
-
-(def BytesWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "BytesWarning"))))
-(alter-meta! #'BytesWarning assoc :doc "Base class for warnings about bytes and buffer related problems, mostly
-related to conversion from str or comparing to str." :arglists '[[self & [args {:as kwargs}]]])
-
-(def min (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "min"))))
-(alter-meta! #'min assoc :doc "min(iterable, *[, default=obj, key=func]) -> value
-min(arg1, arg2, *args, *[, key=func]) -> value
-
-With a single iterable argument, return its smallest item. The
-default keyword-only argument specifies an object to return if
-the provided iterable is empty.
-With two or more arguments, return the smallest argument." :arglists '[[self & [args {:as kwargs}]]])
-
-(def FileNotFoundError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "FileNotFoundError"))))
-(alter-meta! #'FileNotFoundError assoc :doc "File not found." :arglists '[[self & [args {:as kwargs}]]])
-
-(def reversed (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "reversed"))))
-(alter-meta! #'reversed assoc :doc "Return a reverse iterator over the values of the given sequence." :arglists '[[self & [args {:as kwargs}]]])
-
-(def list (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "list"))))
-(alter-meta! #'list assoc :doc "Built-in mutable sequence.
-
-If no argument is given, the constructor creates a new empty list.
-The argument must be an iterable if specified." :arglists '[[self & [args {:as kwargs}]]])
-
-(def license (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "license"))))
-(alter-meta! #'license assoc :doc "interactive prompt objects for printing the license text, a list of
-    contributors and the copyright notice." :arglists '[[self name data & [{files :files, dirs :dirs}]] [self name data & [{files :files}]] [self name data]])
-
-(def ascii (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ascii"))))
-(alter-meta! #'ascii assoc :doc "Return an ASCII-only representation of an object.
-
-As repr(), return a string containing a printable representation of an
-object, but escape the non-ASCII characters in the string returned by
-repr() using \\\\x, \\\\u or \\\\U escapes. This generates a string similar
-to that returned by repr() in Python 2." :arglists '[[obj]])
-
-(def next (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "next"))))
-(alter-meta! #'next assoc :doc "next(iterator[, default])
-
-Return the next item from the iterator. If default is given and the iterator
-is exhausted, it is returned instead of raising StopIteration." :arglists '[[self & [args {:as kwargs}]]])
-
-(def SyntaxWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "SyntaxWarning"))))
-(alter-meta! #'SyntaxWarning assoc :doc "Base class for warnings about dubious syntax." :arglists '[[self & [args {:as kwargs}]]])
-
-(def chr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "chr"))))
-(alter-meta! #'chr assoc :doc "Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff." :arglists '[[i]])
-
-(def ArithmeticError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ArithmeticError"))))
-(alter-meta! #'ArithmeticError assoc :doc "Base class for arithmetic errors." :arglists '[[self & [args {:as kwargs}]]])
-
-(def BlockingIOError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "BlockingIOError"))))
-(alter-meta! #'BlockingIOError assoc :doc "I/O operation would block." :arglists '[[self & [args {:as kwargs}]]])
-
-(def staticmethod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "staticmethod"))))
-(alter-meta! #'staticmethod assoc :doc "staticmethod(function) -> method
-
-Convert a function to be a static method.
-
-A static method does not receive an implicit first argument.
-To declare a static method, use this idiom:
-
-     class C:
-         @staticmethod
-         def f(arg1, arg2, ...):
-             ...
-
-It can be called either on the class (e.g. C.f()) or on an instance
-(e.g. C().f()). Both the class and the instance are ignored, and
-neither is passed implicitly as the first argument to the method.
-
-Static methods in Python are similar to those found in Java or C++.
-For a more advanced concept, see the classmethod builtin." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ImportWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ImportWarning"))))
-(alter-meta! #'ImportWarning assoc :doc "Base class for warnings about probable mistakes in module imports" :arglists '[[self & [args {:as kwargs}]]])
-
-(def FutureWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "FutureWarning"))))
-(alter-meta! #'FutureWarning assoc :doc "Base class for warnings about constructs that will change semantically
-in the future." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ResourceWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ResourceWarning"))))
-(alter-meta! #'ResourceWarning assoc :doc "Base class for warnings about resource usage." :arglists '[[self & [args {:as kwargs}]]])
-
-(def classmethod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "classmethod"))))
-(alter-meta! #'classmethod assoc :doc "classmethod(function) -> method
-
-Convert a function to be a class method.
-
-A class method receives the class as implicit first argument,
-just like an instance method receives the instance.
-To declare a class method, use this idiom:
-
-  class C:
-      @classmethod
-      def f(cls, arg1, arg2, ...):
-          ...
-
-It can be called either on the class (e.g. C.f()) or on an instance
-(e.g. C().f()).  The instance is ignored except for its class.
-If a class method is called for a derived class, the derived class
-object is passed as the implied first argument.
-
-Class methods are different than C++ or Java static methods.
-If you want those, see the staticmethod builtin." :arglists '[[self & [args {:as kwargs}]]])
-
-(def IndexError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "IndexError"))))
-(alter-meta! #'IndexError assoc :doc "Sequence index out of range." :arglists '[[self & [args {:as kwargs}]]])
-
-(def hex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hex"))))
-(alter-meta! #'hex assoc :doc "Return the hexadecimal representation of an integer.
-
-   >>> hex(12648430)
-   '0xc0ffee'" :arglists '[[number]])
-
-(def sum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sum"))))
-(alter-meta! #'sum assoc :doc "Return the sum of a 'start' value (default: 0) plus an iterable of numbers
-
-When the iterable is empty, return the start value.
-This function is intended specifically for use with numeric values and may
-reject non-numeric types." :arglists '[[iterable & [{start :start}]] [iterable]])
-
-(def str (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "str"))))
-(alter-meta! #'str assoc :doc "str(object='') -> str
-str(bytes_or_buffer[, encoding[, errors]]) -> str
-
-Create a new string object from the given object. If encoding or
-errors is specified, then the object must expose a data buffer
-that will be decoded using the given encoding and error handler.
-Otherwise, returns the result of object.__str__() (if defined)
-or repr(object).
-encoding defaults to sys.getdefaultencoding().
-errors defaults to 'strict'." :arglists '[[self & [args {:as kwargs}]]])
-
-(def hash (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hash"))))
-(alter-meta! #'hash assoc :doc "Return the hash value for the given object.
-
-Two objects that compare equal must also have the same hash value, but the
-reverse is not necessarily true." :arglists '[[obj]])
-
-(def breakpoint (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "breakpoint"))))
-(alter-meta! #'breakpoint assoc :doc "breakpoint(*args, **kws)
-
-Call sys.breakpointhook(*args, **kws).  sys.breakpointhook() must accept
-whatever arguments are passed.
-
-By default, this drops you into the pdb debugger." :arglists '[[self & [args {:as kwargs}]]])
-
-(def sorted (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sorted"))))
-(alter-meta! #'sorted assoc :doc "Return a new list containing all items from the iterable in ascending order.
-
-A custom key function can be supplied to customize the sort order, and the
-reverse flag can be set to request the result in descending order." :arglists '[[iterable & [{key :key, reverse :reverse}]]])
-
-(def repr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "repr"))))
-(alter-meta! #'repr assoc :doc "Return the canonical string representation of the object.
-
-For many object types, including most builtins, eval(repr(obj)) == obj." :arglists '[[obj]])
-
-(def __loader__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__loader__"))))
-(alter-meta! #'__loader__ assoc :doc "Meta path import for built-in modules.
-
-    All methods are either class or static methods to avoid the need to
-    instantiate the class.
-
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def NotADirectoryError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "NotADirectoryError"))))
-(alter-meta! #'NotADirectoryError assoc :doc "Operation only works on directories." :arglists '[[self & [args {:as kwargs}]]])
-
-(def max (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "max"))))
-(alter-meta! #'max assoc :doc "max(iterable, *[, default=obj, key=func]) -> value
-max(arg1, arg2, *args, *[, key=func]) -> value
-
-With a single iterable argument, return its biggest item. The
-default keyword-only argument specifies an object to return if
-the provided iterable is empty.
-With two or more arguments, return the largest argument." :arglists '[[self & [args {:as kwargs}]]])
-
-(def SystemError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "SystemError"))))
-(alter-meta! #'SystemError assoc :doc "Internal error in the Python interpreter.
-
-Please report this to the Python maintainer, along with the traceback,
-the Python version, and the hardware/OS platform and version." :arglists '[[self & [args {:as kwargs}]]])
-
-(def isinstance (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isinstance"))))
-(alter-meta! #'isinstance assoc :doc "Return whether an object is an instance of a class or of a subclass thereof.
-
-A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
-check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
-or ...`` etc." :arglists '[[obj class_or_tuple]])
-
-(def id (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "id"))))
-(alter-meta! #'id assoc :doc "Return the identity of an object.
-
-This is guaranteed to be unique among simultaneously existing objects.
-(CPython uses the object's memory address.)" :arglists '[[obj]])
-
-(def pow (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "pow"))))
-(alter-meta! #'pow assoc :doc "Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
-
-Some types, such as ints, are able to use a more efficient algorithm when
-invoked using the three argument form." :arglists '[[base exp & [{mod :mod}]] [base exp]])
-
-(def TimeoutError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "TimeoutError"))))
-(alter-meta! #'TimeoutError assoc :doc "Timeout expired." :arglists '[[self & [args {:as kwargs}]]])
-
-(def delattr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "delattr"))))
-(alter-meta! #'delattr assoc :doc "Deletes the named attribute from the given object.
-
-delattr(x, 'y') is equivalent to ``del x.y''" :arglists '[[obj name]])
-
-(def FloatingPointError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "FloatingPointError"))))
-(alter-meta! #'FloatingPointError assoc :doc "Floating point operation failed." :arglists '[[self & [args {:as kwargs}]]])
-
-(def GeneratorExit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "GeneratorExit"))))
-(alter-meta! #'GeneratorExit assoc :doc "Request that a generator exit." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ConnectionAbortedError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ConnectionAbortedError"))))
-(alter-meta! #'ConnectionAbortedError assoc :doc "Connection aborted." :arglists '[[self & [args {:as kwargs}]]])
-
-(def UnicodeTranslateError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnicodeTranslateError"))))
-(alter-meta! #'UnicodeTranslateError assoc :doc "Unicode translation error." :arglists '[[self & [args {:as kwargs}]]])
-
-(def UnicodeDecodeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnicodeDecodeError"))))
-(alter-meta! #'UnicodeDecodeError assoc :doc "Unicode decoding error." :arglists '[[self & [args {:as kwargs}]]])
-
-(def exec (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "exec"))))
-(alter-meta! #'exec assoc :doc "Execute the given source in the context of globals and locals.
-
-The source may be a string representing one or more Python statements
-or a code object as returned by compile().
-The globals must be a dictionary and locals can be any mapping,
-defaulting to the current globals and locals.
-If only globals is given, locals defaults to it." :arglists '[[source & [{globals :globals, locals :locals}]] [source & [{globals :globals}]] [source]])
-
-(def divmod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "divmod"))))
-(alter-meta! #'divmod assoc :doc "Return the tuple (x//y, x%y).  Invariant: div*y + mod == x." :arglists '[[x y]])
-
-(def any (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "any"))))
-(alter-meta! #'any assoc :doc "Return True if bool(x) is True for any x in the iterable.
-
-If the iterable is empty, return False." :arglists '[[iterable]])
-
-(def super (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "super"))))
-(alter-meta! #'super assoc :doc "super() -> same as super(__class__, <first argument>)
-super(type) -> unbound super object
-super(type, obj) -> bound super object; requires isinstance(obj, type)
-super(type, type2) -> bound super object; requires issubclass(type2, type)
-Typical use to call a cooperative superclass method:
-class C(B):
-    def meth(self, arg):
-        super().meth(arg)
-This works for class methods too:
-class C(B):
-    @classmethod
-    def cmeth(cls, arg):
-        super().cmeth(arg)
-" :arglists '[[self & [args {:as kwargs}]]])
-
-(def memoryview (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "memoryview"))))
-(alter-meta! #'memoryview assoc :doc "Create a new memoryview object which references the given object." :arglists '[[self & [args {:as kwargs}]]])
-
-(def enumerate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "enumerate"))))
-(alter-meta! #'enumerate assoc :doc "Return an enumerate object.
-
-  iterable
-    an object supporting iteration
-
-The enumerate object yields pairs containing a count (from start, which
-defaults to zero) and a value yielded by the iterable argument.
-
-enumerate is useful for obtaining an indexed list:
-    (0, seq[0]), (1, seq[1]), (2, seq[2]), ..." :arglists '[[self & [args {:as kwargs}]]])
-
-(def dict (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dict"))))
-(alter-meta! #'dict assoc :doc "dict() -> new empty dictionary
-dict(mapping) -> new dictionary initialized from a mapping object's
-    (key, value) pairs
-dict(iterable) -> new dictionary initialized as if via:
-    d = {}
-    for k, v in iterable:
-        d[k] = v
-dict(**kwargs) -> new dictionary initialized with the name=value pairs
-    in the keyword argument list.  For example:  dict(one=1, two=2)" :arglists '[[self & [args {:as kwargs}]]])
-
-(def OSError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "OSError"))))
-(alter-meta! #'OSError assoc :doc "Base class for I/O related errors." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ReferenceError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ReferenceError"))))
-(alter-meta! #'ReferenceError assoc :doc "Weak ref proxy used after referent went away." :arglists '[[self & [args {:as kwargs}]]])
-
-(def UnicodeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnicodeError"))))
-(alter-meta! #'UnicodeError assoc :doc "Unicode related error." :arglists '[[self & [args {:as kwargs}]]])
-
-(def FileExistsError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "FileExistsError"))))
-(alter-meta! #'FileExistsError assoc :doc "File already exists." :arglists '[[self & [args {:as kwargs}]]])
-
-(def InterruptedError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "InterruptedError"))))
-(alter-meta! #'InterruptedError assoc :doc "Interrupted by signal." :arglists '[[self & [args {:as kwargs}]]])
-
-(def Warning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "Warning"))))
-(alter-meta! #'Warning assoc :doc "Base class for warning categories." :arglists '[[self & [args {:as kwargs}]]])
-
-(def eval (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "eval"))))
-(alter-meta! #'eval assoc :doc "Evaluate the given source in the context of globals and locals.
-
-The source may be a string representing a Python expression
-or a code object as returned by compile().
-The globals must be a dictionary and locals can be any mapping,
-defaulting to the current globals and locals.
-If only globals is given, locals defaults to it." :arglists '[[source & [{globals :globals, locals :locals}]] [source & [{globals :globals}]] [source]])
-
-(def bool (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bool"))))
-(alter-meta! #'bool assoc :doc "bool(x) -> bool
-
-Returns True when the argument x is true, False otherwise.
-The builtins True and False are the only two instances of the class bool.
-The class bool is a subclass of the class int, and cannot be subclassed." :arglists '[[self & [args {:as kwargs}]]])
-
-(def SyntaxError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "SyntaxError"))))
-(alter-meta! #'SyntaxError assoc :doc "Invalid syntax." :arglists '[[self & [args {:as kwargs}]]])
-
-(def UnicodeEncodeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnicodeEncodeError"))))
-(alter-meta! #'UnicodeEncodeError assoc :doc "Unicode encoding error." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ord (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ord"))))
-(alter-meta! #'ord assoc :doc "Return the Unicode code point for a one-character string." :arglists '[[c]])
-
-(def callable (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "callable"))))
-(alter-meta! #'callable assoc :doc "Return whether the object is callable (i.e., some kind of function).
-
-Note that classes are callable, as are instances of classes with a
-__call__() method." :arglists '[[obj]])
-
-(def EnvironmentError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "EnvironmentError"))))
-(alter-meta! #'EnvironmentError assoc :doc "Base class for I/O related errors." :arglists '[[self & [args {:as kwargs}]]])
-
-(def RuntimeWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "RuntimeWarning"))))
-(alter-meta! #'RuntimeWarning assoc :doc "Base class for warnings about dubious runtime behavior." :arglists '[[self & [args {:as kwargs}]]])
-
-(def quit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "quit"))))
-(alter-meta! #'quit assoc :doc "" :arglists '[[self name eof]])
-
-(def NameError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "NameError"))))
-(alter-meta! #'NameError assoc :doc "Name not found globally." :arglists '[[self & [args {:as kwargs}]]])
-
-(def DeprecationWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "DeprecationWarning"))))
-(alter-meta! #'DeprecationWarning assoc :doc "Base class for warnings about deprecated features." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ProcessLookupError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ProcessLookupError"))))
-(alter-meta! #'ProcessLookupError assoc :doc "Process not found." :arglists '[[self & [args {:as kwargs}]]])
-
-(def bin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bin"))))
-(alter-meta! #'bin assoc :doc "Return the binary representation of an integer.
-
-   >>> bin(2796202)
-   '0b1010101010101010101010'" :arglists '[[number]])
-
-(def ^{:doc "The specification for a module, used for loading.
-
-    A module's spec is the source for information about the module.  For
-    data associated with the module, including source, use the spec's
-    loader.
-
-    `name` is the absolute name of the module.  `loader` is the loader
-    to use when loading the module.  `parent` is the name of the
-    package the module is in.  The parent is derived from the name.
-
-    `is_package` determines if the module is considered a package or
-    not.  On modules this is reflected by the `__path__` attribute.
-
-    `origin` is the specific location used by the loader from which to
-    load the module, if that information is available.  When filename is
-    set, origin will match.
-
-    `has_location` indicates that a spec's \"origin\" reflects a location.
-    When this is True, `__file__` attribute of the module is set.
-
-    `cached` is the location of the cached bytecode file, if any.  It
-    corresponds to the `__cached__` attribute.
-
-    `submodule_search_locations` is the sequence of path entries to
-    search when importing submodules.  If set, is_package should be
-    True--and False otherwise.
-
-    Packages are simply modules that (may) have submodules.  If a spec
-    has a non-None value in `submodule_search_locations`, the import
-    system will consider modules loaded from the spec as packages.
-
-    Only finders (see importlib.abc.MetaPathFinder and
-    importlib.abc.PathEntryFinder) should modify ModuleSpec instances.
-
-    "} __spec__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__spec__"))))
-
-(def bytes (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bytes"))))
-(alter-meta! #'bytes assoc :doc "bytes(iterable_of_ints) -> bytes
-bytes(string, encoding[, errors]) -> bytes
-bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
-bytes(int) -> bytes object of size given by the parameter initialized with null bytes
-bytes() -> empty bytes object
-
-Construct an immutable array of bytes from:
-  - an iterable yielding integers in range(256)
-  - a text string encoded using the specified encoding
-  - any object implementing the buffer API.
-  - an integer" :arglists '[[self & [args {:as kwargs}]]])
-
-(def dir (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dir"))))
-(alter-meta! #'dir assoc :doc "dir([object]) -> list of strings
-
-If called without an argument, return the names in the current scope.
-Else, return an alphabetized list of names comprising (some of) the attributes
-of the given object, and of attributes reachable from it.
-If the object supplies a method named __dir__, it will be used; otherwise
-the default dir() logic is used and returns:
-  for a module object: the module's attributes.
-  for a class object:  its attributes, and recursively the attributes
-    of its bases.
-  for any other object: its attributes, its class's attributes, and
-    recursively the attributes of its class's base classes." :arglists '[[self & [args {:as kwargs}]]])
-
-(def filter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "filter"))))
-(alter-meta! #'filter assoc :doc "filter(function or None, iterable) --> filter object
-
-Return an iterator yielding those items of iterable for which function(item)
-is true. If function is None, return the items that are true." :arglists '[[self & [args {:as kwargs}]]])
-
-(def property (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "property"))))
-(alter-meta! #'property assoc :doc "Property attribute.
-
-  fget
-    function to be used for getting an attribute value
-  fset
-    function to be used for setting an attribute value
-  fdel
-    function to be used for del'ing an attribute
-  doc
-    docstring
-
-Typical use is to define a managed attribute x:
-
-class C(object):
-    def getx(self): return self._x
-    def setx(self, value): self._x = value
-    def delx(self): del self._x
-    x = property(getx, setx, delx, \"I'm the 'x' property.\")
-
-Decorators make defining new properties or modifying existing ones easy:
-
-class C(object):
-    @property
-    def x(self):
-        \"I am the 'x' property.\"
-        return self._x
-    @x.setter
-    def x(self, value):
-        self._x = value
-    @x.deleter
-    def x(self):
-        del self._x" :arglists '[[self & [args {:as kwargs}]]])
-
-(def KeyError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "KeyError"))))
-(alter-meta! #'KeyError assoc :doc "Mapping key not found." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} __debug__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__debug__"))))
-
-(def IOError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "IOError"))))
-(alter-meta! #'IOError assoc :doc "Base class for I/O related errors." :arglists '[[self & [args {:as kwargs}]]])
-
-(def BufferError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "BufferError"))))
-(alter-meta! #'BufferError assoc :doc "Buffer error." :arglists '[[self & [args {:as kwargs}]]])
-
-(def bytearray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bytearray"))))
-(alter-meta! #'bytearray assoc :doc "bytearray(iterable_of_ints) -> bytearray
-bytearray(string, encoding[, errors]) -> bytearray
-bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
-bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
-bytearray() -> empty bytes array
-
-Construct a mutable bytearray object from:
-  - an iterable yielding integers in range(256)
-  - a text string encoded using the specified encoding
-  - a bytes or a buffer object
-  - any object implementing the buffer API.
-  - an integer" :arglists '[[self & [args {:as kwargs}]]])
-
-(def compile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "compile"))))
-(alter-meta! #'compile assoc :doc "Compile source into a code object that can be executed by exec() or eval().
-
-The source code may represent a Python module, statement or expression.
-The filename will be used for run-time error messages.
-The mode must be 'exec' to compile a module, 'single' to compile a
-single (interactive) statement, or 'eval' to compile an expression.
-The flags argument, if present, controls which future statements influence
-the compilation of the code.
-The dont_inherit argument, if true, stops the compilation inheriting
-the effects of any future statements in effect in the code calling
-compile; if absent or false these statements do influence the compilation,
-in addition to any features explicitly specified." :arglists '[[source filename mode & [{flags :flags, dont_inherit :dont_inherit, optimize :optimize, _feature_version :_feature_version}]] [source filename mode & [{flags :flags, dont_inherit :dont_inherit, _feature_version :_feature_version}]] [source filename mode & [{flags :flags, _feature_version :_feature_version}]] [source filename mode & [{_feature_version :_feature_version}]]])
-
-(def input (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "input"))))
-(alter-meta! #'input assoc :doc "Read a string from standard input.  The trailing newline is stripped.
-
-The prompt string, if given, is printed to standard output without a
-trailing newline before reading input.
-
-If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
-On *nix systems, readline is used if available." :arglists '[[& [{prompt :prompt}]] []])
-
-(def BaseException (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "BaseException"))))
-(alter-meta! #'BaseException assoc :doc "Common base class for all exceptions" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ImportError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ImportError"))))
-(alter-meta! #'ImportError assoc :doc "Import can't find module, or can't find name in module." :arglists '[[self & [args {:as kwargs}]]])
-
-(def setattr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "setattr"))))
-(alter-meta! #'setattr assoc :doc "Sets the named attribute on the given object to the specified value.
-
-setattr(x, 'y', v) is equivalent to ``x.y = v''" :arglists '[[obj name value]])
-
-(def __build_class__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__build_class__"))))
-(alter-meta! #'__build_class__ assoc :doc "__build_class__(func, name, /, *bases, [metaclass], **kwds) -> class
-
-Internal helper function used by the class statement." :arglists '[[self & [args {:as kwargs}]]])
-
-(def copyright (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "copyright"))))
-(alter-meta! #'copyright assoc :doc "interactive prompt objects for printing the license text, a list of
-    contributors and the copyright notice." :arglists '[[self name data & [{files :files, dirs :dirs}]] [self name data & [{files :files}]] [self name data]])
-
-(def type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "type"))))
-(alter-meta! #'type assoc :doc "type(object_or_name, bases, dict)
-type(object) -> the object's type
-type(name, bases, dict) -> a new type" :arglists '[[self & [args {:as kwargs}]]])
-
-(def LookupError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "LookupError"))))
-(alter-meta! #'LookupError assoc :doc "Base class for lookup errors." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ZeroDivisionError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ZeroDivisionError"))))
-(alter-meta! #'ZeroDivisionError assoc :doc "Second argument to a division or modulo operation was zero." :arglists '[[self & [args {:as kwargs}]]])
-
-(def globals (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "globals"))))
-(alter-meta! #'globals assoc :doc "Return the dictionary containing the current scope's global variables.
-
-NOTE: Updates to this dictionary *will* affect name lookups in the current
-global scope and vice-versa." :arglists '[[]])
-
-(def OverflowError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "OverflowError"))))
-(alter-meta! #'OverflowError assoc :doc "Result too large to be represented." :arglists '[[self & [args {:as kwargs}]]])
-
-(def abs (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "abs"))))
-(alter-meta! #'abs assoc :doc "Return the absolute value of the argument." :arglists '[[x]])
-
-(def ConnectionRefusedError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ConnectionRefusedError"))))
-(alter-meta! #'ConnectionRefusedError assoc :doc "Connection refused." :arglists '[[self & [args {:as kwargs}]]])
-
-(def help (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "help"))))
-(alter-meta! #'help assoc :doc "Define the builtin 'help'.
-
-    This is a wrapper around pydoc.help that provides a helpful message
-    when 'help' is typed at the Python interactive prompt.
-
-    Calling help() at the Python prompt starts an interactive help session.
-    Calling help(thing) prints help for the python object 'thing'.
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def UserWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UserWarning"))))
-(alter-meta! #'UserWarning assoc :doc "Base class for warnings generated by user code." :arglists '[[self & [args {:as kwargs}]]])
-
-(def slice (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "slice"))))
-(alter-meta! #'slice assoc :doc "slice(stop)
-slice(start, stop[, step])
-
-Create a slice object.  This is used for extended slicing (e.g. a[0:10:2])." :arglists '[[self & [args {:as kwargs}]]])
-
-(def TabError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "TabError"))))
-(alter-meta! #'TabError assoc :doc "Improper mixture of spaces and tabs." :arglists '[[self & [args {:as kwargs}]]])
-
-(def print (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "print"))))
-(alter-meta! #'print assoc :doc "print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)
-
-Prints the values to a stream, or to sys.stdout by default.
-Optional keyword arguments:
-file:  a file-like object (stream); defaults to the current sys.stdout.
-sep:   string inserted between values, default a space.
-end:   string appended after the last value, default a newline.
-flush: whether to forcibly flush the stream." :arglists '[[self & [args {:as kwargs}]]])
-
-(def exit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "exit"))))
-(alter-meta! #'exit assoc :doc "" :arglists '[[self name eof]])
-
-(def EOFError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "EOFError"))))
-(alter-meta! #'EOFError assoc :doc "Read beyond end of file." :arglists '[[self & [args {:as kwargs}]]])
-
-(def PyAssertionError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "AssertionError"))))
-(alter-meta! #'PyAssertionError assoc :doc "Assertion failed." :arglists '[[self & [args {:as kwargs}]]])
-
-(def hasattr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hasattr"))))
-(alter-meta! #'hasattr assoc :doc "Return whether the object has an attribute with the given name.
-
-This is done by calling getattr(obj, name) and catching AttributeError." :arglists '[[obj name]])
-
-(def len (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "len"))))
-(alter-meta! #'len assoc :doc "Return the number of items in a container." :arglists '[[obj]])
-
-(def set (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "set"))))
-(alter-meta! #'set assoc :doc "set() -> new empty set object
-set(iterable) -> new set object
-
-Build an unordered collection of unique elements." :arglists '[[self & [args {:as kwargs}]]])
-
-(def BrokenPipeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "BrokenPipeError"))))
-(alter-meta! #'BrokenPipeError assoc :doc "Broken pipe." :arglists '[[self & [args {:as kwargs}]]])
-
-(def all (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "all"))))
-(alter-meta! #'all assoc :doc "Return True if bool(x) is True for all values x in the iterable.
-
-If the iterable is empty, return True." :arglists '[[iterable]])
-
-(def PendingDeprecationWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "PendingDeprecationWarning"))))
-(alter-meta! #'PendingDeprecationWarning assoc :doc "Base class for warnings about features which will be deprecated
-in the future." :arglists '[[self & [args {:as kwargs}]]])
-
-(def tuple (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tuple"))))
-(alter-meta! #'tuple assoc :doc "Built-in immutable sequence.
-
-If no argument is given, the constructor returns an empty tuple.
-If iterable is specified the tuple is initialized from iterable's items.
-
-If the argument is a tuple, the return value is the same object." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ChildProcessError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ChildProcessError"))))
-(alter-meta! #'ChildProcessError assoc :doc "Child process error." :arglists '[[self & [args {:as kwargs}]]])
-
-(def UnboundLocalError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnboundLocalError"))))
-(alter-meta! #'UnboundLocalError assoc :doc "Local name referenced but not bound to a value." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ModuleNotFoundError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ModuleNotFoundError"))))
-(alter-meta! #'ModuleNotFoundError assoc :doc "Module not found." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ValueError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ValueError"))))
-(alter-meta! #'ValueError assoc :doc "Inappropriate argument value (of correct type)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def iter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iter"))))
-(alter-meta! #'iter assoc :doc "iter(iterable) -> iterator
-iter(callable, sentinel) -> iterator
-
-Get an iterator from an object.  In the first form, the argument must
-supply its own iterator, or be a sequence.
-In the second form, the callable is called until it returns the sentinel." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} Ellipsis (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "Ellipsis"))))
-
-(def open (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "open"))))
-(alter-meta! #'open assoc :doc "Open file and return a stream.  Raise OSError upon failure.
-
-file is either a text or byte string giving the name (and the path
-if the file isn't in the current working directory) of the file to
-be opened or an integer file descriptor of the file to be
-wrapped. (If a file descriptor is given, it is closed when the
-returned I/O object is closed, unless closefd is set to False.)
-
-mode is an optional string that specifies the mode in which the file
-is opened. It defaults to 'r' which means open for reading in text
-mode.  Other common values are 'w' for writing (truncating the file if
-it already exists), 'x' for creating and writing to a new file, and
-'a' for appending (which on some Unix systems, means that all writes
-append to the end of the file regardless of the current seek position).
-In text mode, if encoding is not specified the encoding used is platform
-dependent: locale.getpreferredencoding(False) is called to get the
-current locale encoding. (For reading and writing raw bytes use binary
-mode and leave encoding unspecified.) The available modes are:
-
-========= ===============================================================
-Character Meaning
---------- ---------------------------------------------------------------
-'r'       open for reading (default)
-'w'       open for writing, truncating the file first
-'x'       create a new file and open it for writing
-'a'       open for writing, appending to the end of the file if it exists
-'b'       binary mode
-'t'       text mode (default)
-'+'       open a disk file for updating (reading and writing)
-'U'       universal newline mode (deprecated)
-========= ===============================================================
-
-The default mode is 'rt' (open for reading text). For binary random
-access, the mode 'w+b' opens and truncates the file to 0 bytes, while
-'r+b' opens the file without truncation. The 'x' mode implies 'w' and
-raises an `FileExistsError` if the file already exists.
-
-Python distinguishes between files opened in binary and text modes,
-even when the underlying operating system doesn't. Files opened in
-binary mode (appending 'b' to the mode argument) return contents as
-bytes objects without any decoding. In text mode (the default, or when
-'t' is appended to the mode argument), the contents of the file are
-returned as strings, the bytes having been first decoded using a
-platform-dependent encoding or using the specified encoding if given.
-
-'U' mode is deprecated and will raise an exception in future versions
-of Python.  It has no effect in Python 3.  Use newline to control
-universal newlines mode.
-
-buffering is an optional integer used to set the buffering policy.
-Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
-line buffering (only usable in text mode), and an integer > 1 to indicate
-the size of a fixed-size chunk buffer.  When no buffering argument is
-given, the default buffering policy works as follows:
-
-* Binary files are buffered in fixed-size chunks; the size of the buffer
-  is chosen using a heuristic trying to determine the underlying device's
-  \"block size\" and falling back on `io.DEFAULT_BUFFER_SIZE`.
-  On many systems, the buffer will typically be 4096 or 8192 bytes long.
-
-* \"Interactive\" text files (files for which isatty() returns True)
-  use line buffering.  Other text files use the policy described above
-  for binary files.
-
-encoding is the name of the encoding used to decode or encode the
-file. This should only be used in text mode. The default encoding is
-platform dependent, but any encoding supported by Python can be
-passed.  See the codecs module for the list of supported encodings.
-
-errors is an optional string that specifies how encoding errors are to
-be handled---this argument should not be used in binary mode. Pass
-'strict' to raise a ValueError exception if there is an encoding error
-(the default of None has the same effect), or pass 'ignore' to ignore
-errors. (Note that ignoring encoding errors can lead to data loss.)
-See the documentation for codecs.register or run 'help(codecs.Codec)'
-for a list of the permitted encoding error strings.
-
-newline controls how universal newlines works (it only applies to text
-mode). It can be None, '', '\\n', '\\r', and '\\r\\n'.  It works as
-follows:
-
-* On input, if newline is None, universal newlines mode is
-  enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and
-  these are translated into '\\n' before being returned to the
-  caller. If it is '', universal newline mode is enabled, but line
-  endings are returned to the caller untranslated. If it has any of
-  the other legal values, input lines are only terminated by the given
-  string, and the line ending is returned to the caller untranslated.
-
-* On output, if newline is None, any '\\n' characters written are
-  translated to the system default line separator, os.linesep. If
-  newline is '' or '\\n', no translation takes place. If newline is any
-  of the other legal values, any '\\n' characters written are translated
-  to the given string.
-
-If closefd is False, the underlying file descriptor will be kept open
-when the file is closed. This does not work when a file name is given
-and must be True in that case.
-
-A custom opener can be used by passing a callable as *opener*. The
-underlying file descriptor for the file object is then obtained by
-calling *opener* with (*file*, *flags*). *opener* must return an open
-file descriptor (passing os.open as *opener* results in functionality
-similar to passing None).
-
-open() returns a file object whose type depends on the mode, and
-through which the standard file operations such as reading and writing
-are performed. When open() is used to open a file in a text mode ('w',
-'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
-a file in a binary mode, the returned class varies: in read binary
-mode, it returns a BufferedReader; in write binary and append binary
-modes, it returns a BufferedWriter, and in read/write mode, it returns
-a BufferedRandom.
-
-It is also possible to use a string or bytearray as a file for both
-reading and writing. For strings StringIO can be used like a file
-opened in a text mode, and for bytes a BytesIO can be used like a file
-opened in a binary mode." :arglists '[[file & [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline, closefd :closefd, opener :opener}]] [file & [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline, closefd :closefd}]] [file & [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline}]] [file & [{mode :mode, buffering :buffering, encoding :encoding, errors :errors}]] [file & [{mode :mode, buffering :buffering, encoding :encoding}]] [file & [{mode :mode, buffering :buffering}]] [file & [{mode :mode}]] [file]])
-
-(def ^{:doc ""} __doc__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__doc__"))))
-
-(def __import__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__import__"))))
-(alter-meta! #'__import__ assoc :doc "__import__(name, globals=None, locals=None, fromlist=(), level=0) -> module
-
-Import a module. Because this function is meant for use by the Python
-interpreter and not for general use, it is better to use
-importlib.import_module() to programmatically import a module.
-
-The globals argument is only used to determine the context;
-they are not modified.  The locals argument is unused.  The fromlist
-should be a list of names to emulate ``from name import ...'', or an
-empty list to emulate ``import name''.
-When importing a module from a package, note that __import__('A.B', ...)
-returns package A when fromlist is empty, but its submodule B when
-fromlist is not empty.  The level argument is used to determine whether to
-perform absolute or relative imports: 0 is absolute, while a positive number
-is the number of parent directories to search relative to the current module." :arglists '[[self & [args {:as kwargs}]]])
-
-(def SystemExit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "SystemExit"))))
-(alter-meta! #'SystemExit assoc :doc "Request to exit from the interpreter." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ConnectionError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ConnectionError"))))
-(alter-meta! #'ConnectionError assoc :doc "Connection error." :arglists '[[self & [args {:as kwargs}]]])
-
-(def round (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "round"))))
-(alter-meta! #'round assoc :doc "Round a number to a given precision in decimal digits.
-
-The return value is an integer if ndigits is omitted or None.  Otherwise
-the return value has the same type as the number.  ndigits may be negative." :arglists '[[number & [{ndigits :ndigits}]] [number]])
-
-(def complex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex"))))
-(alter-meta! #'complex assoc :doc "Create a complex number from a real part and an optional imaginary part.
-
-This is equivalent to (real + imag*1j) where imag defaults to 0." :arglists '[[self & [args {:as kwargs}]]])
-
-(def UnicodeWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "UnicodeWarning"))))
-(alter-meta! #'UnicodeWarning assoc :doc "Base class for warnings about Unicode related problems, mostly
-related to conversion problems." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} __name__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__name__"))))
-
-(def oct (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "oct"))))
-(alter-meta! #'oct assoc :doc "Return the octal representation of an integer.
-
-   >>> oct(342391)
-   '0o1234567'" :arglists '[[number]])
-
-(def locals (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "locals"))))
-(alter-meta! #'locals assoc :doc "Return a dictionary containing the current scope's local variables.
-
-NOTE: Whether or not updates to this dictionary will affect name lookups in
-the local scope and vice-versa is *implementation dependent* and not
-covered by any backwards compatibility guarantees." :arglists '[[]])
-
-(def NotImplementedError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "NotImplementedError"))))
-(alter-meta! #'NotImplementedError assoc :doc "Method or function hasn't been implemented yet." :arglists '[[self & [args {:as kwargs}]]])
-
-(def getattr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "getattr"))))
-(alter-meta! #'getattr assoc :doc "getattr(object, name[, default]) -> value
-
-Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
-When a default argument is given, it is returned when the attribute doesn't
-exist; without it, an exception is raised in that case." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} True (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "True"))))
-
-(def zip (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "zip"))))
-(alter-meta! #'zip assoc :doc "zip(*iterables) --> A zip object yielding tuples until an input is exhausted.
-
-   >>> list(zip('abcdefg', range(3), range(4)))
-   [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]
-
-The zip object yields n-length tuples, where n is the number of iterables
-passed as positional arguments to zip().  The i-th element in every tuple
-comes from the i-th iterable argument to zip().  This continues until the
-shortest argument is exhausted." :arglists '[[self & [args {:as kwargs}]]])
-
-(def PyException (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "Exception"))))
-(alter-meta! #'PyException assoc :doc "Common base class for all non-exit exceptions." :arglists '[[self & [args {:as kwargs}]]])
-
-(def IndentationError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "IndentationError"))))
-(alter-meta! #'IndentationError assoc :doc "Improper indentation." :arglists '[[self & [args {:as kwargs}]]])
-
-(def RuntimeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "RuntimeError"))))
-(alter-meta! #'RuntimeError assoc :doc "Unspecified run-time error." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} __package__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__package__"))))
-
-(def format (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "format"))))
-(alter-meta! #'format assoc :doc "Return value.__format__(format_spec)
-
-format_spec defaults to the empty string.
-See the Format Specification Mini-Language section of help('FORMATTING') for
-details." :arglists '[[value & [{format_spec :format_spec}]] [value]])
-
-(def credits (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "credits"))))
-(alter-meta! #'credits assoc :doc "interactive prompt objects for printing the license text, a list of
-    contributors and the copyright notice." :arglists '[[self name data & [{files :files, dirs :dirs}]] [self name data & [{files :files}]] [self name data]])
-
-(def StopIteration (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "StopIteration"))))
-(alter-meta! #'StopIteration assoc :doc "Signal the end from iterator.__next__()." :arglists '[[self & [args {:as kwargs}]]])
-
-(def StopAsyncIteration (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "StopAsyncIteration"))))
-(alter-meta! #'StopAsyncIteration assoc :doc "Signal the end from iterator.__anext__()." :arglists '[[self & [args {:as kwargs}]]])
-
-(def frozenset (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "frozenset"))))
-(alter-meta! #'frozenset assoc :doc "frozenset() -> empty frozenset object
-frozenset(iterable) -> frozenset object
-
-Build an immutable unordered collection of unique elements." :arglists '[[self & [args {:as kwargs}]]])
-
-(def AttributeError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "AttributeError"))))
-(alter-meta! #'AttributeError assoc :doc "Attribute not found." :arglists '[[self & [args {:as kwargs}]]])
-
-(def vars (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vars"))))
-(alter-meta! #'vars assoc :doc "vars([object]) -> dictionary
-
-Without arguments, equivalent to locals().
-With an argument, equivalent to object.__dict__." :arglists '[[self & [args {:as kwargs}]]])
-
-(def IsADirectoryError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "IsADirectoryError"))))
-(alter-meta! #'IsADirectoryError assoc :doc "Operation doesn't work on directories." :arglists '[[self & [args {:as kwargs}]]])
-
-(def issubclass (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issubclass"))))
-(alter-meta! #'issubclass assoc :doc "Return whether 'cls' is a derived from another class or is the same class.
-
-A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to
-check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)
-or ...`` etc." :arglists '[[cls class_or_tuple]])
\ No newline at end of file
diff --git a/src/python/numpy.clj b/src/python/numpy.clj
deleted file mode 100644
index 95ee657..0000000
--- a/src/python/numpy.clj
+++ /dev/null
@@ -1,29133 +0,0 @@
-(ns python.numpy
-"No documentation provided"
-(: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 [+ - * / 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]))
-
-(defonce ^:private src-obj* (py-global-delay (py/path->py-obj "numpy")))
-
-(def result_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "result_type"))))
-(alter-meta! #'result_type assoc :doc "
-    result_type(*arrays_and_dtypes)
-
-    Returns the type that results from applying the NumPy
-    type promotion rules to the arguments.
-
-    Type promotion in NumPy works similarly to the rules in languages
-    like C++, with some slight differences.  When both scalars and
-    arrays are used, the array's type takes precedence and the actual value
-    of the scalar is taken into account.
-
-    For example, calculating 3*a, where a is an array of 32-bit floats,
-    intuitively should result in a 32-bit float output.  If the 3 is a
-    32-bit integer, the NumPy rules indicate it can't convert losslessly
-    into a 32-bit float, so a 64-bit float should be the result type.
-    By examining the value of the constant, '3', we see that it fits in
-    an 8-bit integer, which can be cast losslessly into the 32-bit float.
-
-    Parameters
-    ----------
-    arrays_and_dtypes : list of arrays and dtypes
-        The operands of some operation whose result type is needed.
-
-    Returns
-    -------
-    out : dtype
-        The result type.
-
-    See also
-    --------
-    dtype, promote_types, min_scalar_type, can_cast
-
-    Notes
-    -----
-    .. versionadded:: 1.6.0
-
-    The specific algorithm used is as follows.
-
-    Categories are determined by first checking which of boolean,
-    integer (int/uint), or floating point (float/complex) the maximum
-    kind of all the arrays and the scalars are.
-
-    If there are only scalars or the maximum category of the scalars
-    is higher than the maximum category of the arrays,
-    the data types are combined with :func:`promote_types`
-    to produce the return value.
-
-    Otherwise, `min_scalar_type` is called on each array, and
-    the resulting data types are all combined with :func:`promote_types`
-    to produce the return value.
-
-    The set of int values is not a subset of the uint values for types
-    with the same number of bits, something not reflected in
-    :func:`min_scalar_type`, but handled as a special case in `result_type`.
-
-    Examples
-    --------
-    >>> np.result_type(3, np.arange(7, dtype='i1'))
-    dtype('int8')
-
-    >>> np.result_type('i4', 'c8')
-    dtype('complex128')
-
-    >>> np.result_type(3.0, -2)
-    dtype('float64')
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def float (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float"))))
-(alter-meta! #'float assoc :doc "Convert a string or number to a floating point number, if possible." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ravel_multi_index (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ravel_multi_index"))))
-(alter-meta! #'ravel_multi_index assoc :doc "
-    ravel_multi_index(multi_index, dims, mode='raise', order='C')
-
-    Converts a tuple of index arrays into an array of flat
-    indices, applying boundary modes to the multi-index.
-
-    Parameters
-    ----------
-    multi_index : tuple of array_like
-        A tuple of integer arrays, one array for each dimension.
-    dims : tuple of ints
-        The shape of array into which the indices from ``multi_index`` apply.
-    mode : {'raise', 'wrap', 'clip'}, optional
-        Specifies how out-of-bounds indices are handled.  Can specify
-        either one mode or a tuple of modes, one mode per index.
-
-        * 'raise' -- raise an error (default)
-        * 'wrap' -- wrap around
-        * 'clip' -- clip to the range
-
-        In 'clip' mode, a negative index which would normally
-        wrap will clip to 0 instead.
-    order : {'C', 'F'}, optional
-        Determines whether the multi-index should be viewed as
-        indexing in row-major (C-style) or column-major
-        (Fortran-style) order.
-
-    Returns
-    -------
-    raveled_indices : ndarray
-        An array of indices into the flattened version of an array
-        of dimensions ``dims``.
-
-    See Also
-    --------
-    unravel_index
-
-    Notes
-    -----
-    .. versionadded:: 1.6.0
-
-    Examples
-    --------
-    >>> arr = np.array([[3,6,6],[4,5,1]])
-    >>> np.ravel_multi_index(arr, (7,6))
-    array([22, 41, 37])
-    >>> np.ravel_multi_index(arr, (7,6), order='F')
-    array([31, 41, 13])
-    >>> np.ravel_multi_index(arr, (4,6), mode='clip')
-    array([22, 23, 19])
-    >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap'))
-    array([12, 13, 13])
-
-    >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9))
-    1621
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def vdot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vdot"))))
-(alter-meta! #'vdot assoc :doc "
-    vdot(a, b)
-
-    Return the dot product of two vectors.
-
-    The vdot(`a`, `b`) function handles complex numbers differently than
-    dot(`a`, `b`).  If the first argument is complex the complex conjugate
-    of the first argument is used for the calculation of the dot product.
-
-    Note that `vdot` handles multidimensional arrays differently than `dot`:
-    it does *not* perform a matrix product, but flattens input arguments
-    to 1-D vectors first. Consequently, it should only be used for vectors.
-
-    Parameters
-    ----------
-    a : array_like
-        If `a` is complex the complex conjugate is taken before calculation
-        of the dot product.
-    b : array_like
-        Second argument to the dot product.
-
-    Returns
-    -------
-    output : ndarray
-        Dot product of `a` and `b`.  Can be an int, float, or
-        complex depending on the types of `a` and `b`.
-
-    See Also
-    --------
-    dot : Return the dot product without using the complex conjugate of the
-          first argument.
-
-    Examples
-    --------
-    >>> a = np.array([1+2j,3+4j])
-    >>> b = np.array([5+6j,7+8j])
-    >>> np.vdot(a, b)
-    (70-8j)
-    >>> np.vdot(b, a)
-    (70+8j)
-
-    Note that higher-dimensional arrays are flattened!
-
-    >>> a = np.array([[1, 4], [5, 6]])
-    >>> b = np.array([[4, 1], [2, 2]])
-    >>> np.vdot(a, b)
-    30
-    >>> np.vdot(b, a)
-    30
-    >>> 1*4 + 4*1 + 5*2 + 6*2
-    30
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def int16 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int16"))))
-(alter-meta! #'int16 assoc :doc "Signed integer type, compatible with C ``short``.
-    Character code: ``'h'``.
-    Canonical name: ``np.short``.
-    Alias *on this platform*: ``np.int16``: 16-bit signed integer (-32768 to 32767)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} NaN (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "NaN"))))
-
-(def MachAr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "MachAr"))))
-(alter-meta! #'MachAr assoc :doc "
-    Diagnosing machine parameters.
-
-    Attributes
-    ----------
-    ibeta : int
-        Radix in which numbers are represented.
-    it : int
-        Number of base-`ibeta` digits in the floating point mantissa M.
-    machep : int
-        Exponent of the smallest (most negative) power of `ibeta` that,
-        added to 1.0, gives something different from 1.0
-    eps : float
-        Floating-point number ``beta**machep`` (floating point precision)
-    negep : int
-        Exponent of the smallest power of `ibeta` that, subtracted
-        from 1.0, gives something different from 1.0.
-    epsneg : float
-        Floating-point number ``beta**negep``.
-    iexp : int
-        Number of bits in the exponent (including its sign and bias).
-    minexp : int
-        Smallest (most negative) power of `ibeta` consistent with there
-        being no leading zeros in the mantissa.
-    xmin : float
-        Floating point number ``beta**minexp`` (the smallest [in
-        magnitude] usable floating value).
-    maxexp : int
-        Smallest (positive) power of `ibeta` that causes overflow.
-    xmax : float
-        ``(1-epsneg) * beta**maxexp`` (the largest [in magnitude]
-        usable floating value).
-    irnd : int
-        In ``range(6)``, information on what kind of rounding is done
-        in addition, and on how underflow is handled.
-    ngrd : int
-        Number of 'guard digits' used when truncating the product
-        of two mantissas to fit the representation.
-    epsilon : float
-        Same as `eps`.
-    tiny : float
-        Same as `xmin`.
-    huge : float
-        Same as `xmax`.
-    precision : float
-        ``- int(-log10(eps))``
-    resolution : float
-        ``- 10**(-precision)``
-
-    Parameters
-    ----------
-    float_conv : function, optional
-        Function that converts an integer or integer array to a float
-        or float array. Default is `float`.
-    int_conv : function, optional
-        Function that converts a float or float array to an integer or
-        integer array. Default is `int`.
-    float_to_float : function, optional
-        Function that converts a float array to float. Default is `float`.
-        Note that this does not seem to do anything useful in the current
-        implementation.
-    float_to_str : function, optional
-        Function that converts a single float to a string. Default is
-        ``lambda v:'%24.16e' %v``.
-    title : str, optional
-        Title that is printed in the string representation of `MachAr`.
-
-    See Also
-    --------
-    finfo : Machine limits for floating point types.
-    iinfo : Machine limits for integer types.
-
-    References
-    ----------
-    .. [1] Press, Teukolsky, Vetterling and Flannery,
-           \"Numerical Recipes in C++,\" 2nd ed,
-           Cambridge University Press, 2002, p. 31.
-
-    " :arglists '[[self & [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float, float_to_str :float_to_str, title :title}]] [self & [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float, float_to_str :float_to_str}]] [self & [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float}]] [self & [{float_conv :float_conv, int_conv :int_conv}]] [self & [{float_conv :float_conv}]] [self]])
-
-(def kron (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "kron"))))
-(alter-meta! #'kron assoc :doc "
-    Kronecker product of two arrays.
-
-    Computes the Kronecker product, a composite array made of blocks of the
-    second array scaled by the first.
-
-    Parameters
-    ----------
-    a, b : array_like
-
-    Returns
-    -------
-    out : ndarray
-
-    See Also
-    --------
-    outer : The outer product
-
-    Notes
-    -----
-    The function assumes that the number of dimensions of `a` and `b`
-    are the same, if necessary prepending the smallest with ones.
-    If `a.shape = (r0,r1,..,rN)` and `b.shape = (s0,s1,...,sN)`,
-    the Kronecker product has shape `(r0*s0, r1*s1, ..., rN*SN)`.
-    The elements are products of elements from `a` and `b`, organized
-    explicitly by::
-
-        kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]
-
-    where::
-
-        kt = it * st + jt,  t = 0,...,N
-
-    In the common 2-D case (N=1), the block structure can be visualized::
-
-        [[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
-         [  ...                              ...   ],
-         [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]]
-
-
-    Examples
-    --------
-    >>> np.kron([1,10,100], [5,6,7])
-    array([  5,   6,   7, ..., 500, 600, 700])
-    >>> np.kron([5,6,7], [1,10,100])
-    array([  5,  50, 500, ...,   7,  70, 700])
-
-    >>> np.kron(np.eye(2), np.ones((2,2)))
-    array([[1.,  1.,  0.,  0.],
-           [1.,  1.,  0.,  0.],
-           [0.,  0.,  1.,  1.],
-           [0.,  0.,  1.,  1.]])
-
-    >>> a = np.arange(100).reshape((2,5,2,5))
-    >>> b = np.arange(24).reshape((2,3,4))
-    >>> c = np.kron(a,b)
-    >>> c.shape
-    (2, 10, 6, 20)
-    >>> I = (1,3,0,2)
-    >>> J = (0,2,1)
-    >>> J1 = (0,) + J             # extend to ndim=4
-    >>> S1 = (1,) + b.shape
-    >>> K = tuple(np.array(I) * np.array(S1) + np.array(J1))
-    >>> c[K] == a[I]*b[J]
-    True
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def flexible (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flexible"))))
-(alter-meta! #'flexible assoc :doc "Abstract base class of all scalar types without predefined length.
-    The actual size of these types depends on the specific `np.dtype`
-    instantiation." :arglists '[[self & [args {:as kwargs}]]])
-
-(def recfromcsv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "recfromcsv"))))
-(alter-meta! #'recfromcsv assoc :doc "
-    Load ASCII data stored in a comma-separated file.
-
-    The returned array is a record array (if ``usemask=False``, see
-    `recarray`) or a masked record array (if ``usemask=True``,
-    see `ma.mrecords.MaskedRecords`).
-
-    Parameters
-    ----------
-    fname, kwargs : For a description of input parameters, see `genfromtxt`.
-
-    See Also
-    --------
-    numpy.genfromtxt : generic function to load ASCII data.
-
-    Notes
-    -----
-    By default, `dtype` is None, which means that the data-type of the output
-    array will be determined from the data.
-
-    " :arglists '[[fname & [{:as kwargs}]]])
-
-(def inexact (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "inexact"))))
-(alter-meta! #'inexact assoc :doc "Abstract base class of all numeric scalar types with a (potentially)
-    inexact representation of the values in its range, such as
-    floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def floor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "floor"))))
-(alter-meta! #'floor assoc :doc "floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the floor of the input, element-wise.
-
-The floor of the scalar `x` is the largest integer `i`, such that
-`i <= x`.  It is often denoted as :math:`\\lfloor x \\rfloor`.
-
-Parameters
-----------
-x : array_like
-    Input data.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or scalar
-    The floor of each element in `x`.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-ceil, trunc, rint
-
-Notes
------
-Some spreadsheet programs calculate the \"floor-towards-zero\", in other
-words ``floor(-2.5) == -2``.  NumPy instead uses the definition of
-`floor` where `floor(-2.5) == -3`.
-
-Examples
---------
->>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
->>> np.floor(a)
-array([-2., -2., -1.,  0.,  1.,  1.,  2.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} tracemalloc_domain (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "tracemalloc_domain"))))
-
-(def compress (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "compress"))))
-(alter-meta! #'compress assoc :doc "
-    Return selected slices of an array along given axis.
-
-    When working along a given axis, a slice along that axis is returned in
-    `output` for each index where `condition` evaluates to True. When
-    working on a 1-D array, `compress` is equivalent to `extract`.
-
-    Parameters
-    ----------
-    condition : 1-D array of bools
-        Array that selects which entries to return. If len(condition)
-        is less than the size of `a` along the given axis, then output is
-        truncated to the length of the condition array.
-    a : array_like
-        Array from which to extract a part.
-    axis : int, optional
-        Axis along which to take slices. If None (default), work on the
-        flattened array.
-    out : ndarray, optional
-        Output array.  Its type is preserved and it must be of the right
-        shape to hold the output.
-
-    Returns
-    -------
-    compressed_array : ndarray
-        A copy of `a` without the slices along axis for which `condition`
-        is false.
-
-    See Also
-    --------
-    take, choose, diag, diagonal, select
-    ndarray.compress : Equivalent method in ndarray
-    np.extract: Equivalent method when working on 1-D arrays
-    ufuncs-output-type
-
-    Examples
-    --------
-    >>> a = np.array([[1, 2], [3, 4], [5, 6]])
-    >>> a
-    array([[1, 2],
-           [3, 4],
-           [5, 6]])
-    >>> np.compress([0, 1], a, axis=0)
-    array([[3, 4]])
-    >>> np.compress([False, True, True], a, axis=0)
-    array([[3, 4],
-           [5, 6]])
-    >>> np.compress([False, True], a, axis=1)
-    array([[2],
-           [4],
-           [6]])
-
-    Working on the flattened array does not return slices along an axis but
-    selects elements.
-
-    >>> np.compress([False, True], a)
-    array([2])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def longfloat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longfloat"))))
-(alter-meta! #'longfloat assoc :doc "Extended-precision floating-point number type, compatible with C
-    ``long double`` but not necessarily with IEEE 754 quadruple-precision.
-    Character code: ``'g'``.
-    Canonical name: ``np.longdouble``.
-    Alias: ``np.longfloat``.
-    Alias *on this platform*: ``np.float128``: 128-bit extended-precision floating-point number type." :arglists '[[self & [args {:as kwargs}]]])
-
-(def log1p (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log1p"))))
-(alter-meta! #'log1p assoc :doc "log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the natural logarithm of one plus the input array, element-wise.
-
-Calculates ``log(1 + x)``.
-
-Parameters
-----------
-x : array_like
-    Input values.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    Natural logarithm of `1 + x`, element-wise.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-expm1 : ``exp(x) - 1``, the inverse of `log1p`.
-
-Notes
------
-For real-valued input, `log1p` is accurate also for `x` so small
-that `1 + x == 1` in floating-point accuracy.
-
-Logarithm is a multivalued function: for each `x` there is an infinite
-number of `z` such that `exp(z) = 1 + x`. The convention is to return
-the `z` whose imaginary part lies in `[-pi, pi]`.
-
-For real-valued input data types, `log1p` always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields ``nan`` and sets the `invalid` floating point error flag.
-
-For complex-valued input, `log1p` is a complex analytical function that
-has a branch cut `[-inf, -1]` and is continuous from above on it.
-`log1p` handles the floating-point negative zero as an infinitesimal
-negative number, conforming to the C99 standard.
-
-References
-----------
-.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
-       10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/
-.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm
-
-Examples
---------
->>> np.log1p(1e-99)
-1e-99
->>> np.log(1 + 1e-99)
-0.0" :arglists '[[self & [args {:as kwargs}]]])
-
-(def arctan2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arctan2"))))
-(alter-meta! #'arctan2 assoc :doc "arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.
-
-The quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is
-the signed angle in radians between the ray ending at the origin and
-passing through the point (1,0), and the ray ending at the origin and
-passing through the point (`x2`, `x1`).  (Note the role reversal: the
-\"`y`-coordinate\" is the first function parameter, the \"`x`-coordinate\"
-is the second.)  By IEEE convention, this function is defined for
-`x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see
-Notes for specific values).
-
-This function is not defined for complex-valued arguments; for the
-so-called argument of complex values, use `angle`.
-
-Parameters
-----------
-x1 : array_like, real-valued
-    `y`-coordinates.
-x2 : array_like, real-valued
-    `x`-coordinates. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-angle : ndarray
-    Array of angles in radians, in the range ``[-pi, pi]``.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-arctan, tan, angle
-
-Notes
------
-*arctan2* is identical to the `atan2` function of the underlying
-C library.  The following special values are defined in the C
-standard: [1]_
-
-====== ====== ================
-`x1`   `x2`   `arctan2(x1,x2)`
-====== ====== ================
-+/- 0  +0     +/- 0
-+/- 0  -0     +/- pi
- > 0   +/-inf +0 / +pi
- < 0   +/-inf -0 / -pi
-+/-inf +inf   +/- (pi/4)
-+/-inf -inf   +/- (3*pi/4)
-====== ====== ================
-
-Note that +0 and -0 are distinct floating point numbers, as are +inf
-and -inf.
-
-References
-----------
-.. [1] ISO/IEC standard 9899:1999, \"Programming language C.\"
-
-Examples
---------
-Consider four points in different quadrants:
-
->>> x = np.array([-1, +1, +1, -1])
->>> y = np.array([-1, -1, +1, +1])
->>> np.arctan2(y, x) * 180 / np.pi
-array([-135.,  -45.,   45.,  135.])
-
-Note the order of the parameters. `arctan2` is defined also when `x2` = 0
-and at several other special points, obtaining values in
-the range ``[-pi, pi]``:
-
->>> np.arctan2([1., -1.], [0., 0.])
-array([ 1.57079633, -1.57079633])
->>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf])
-array([ 0.        ,  3.14159265,  0.78539816])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ceil (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ceil"))))
-(alter-meta! #'ceil assoc :doc "ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the ceiling of the input, element-wise.
-
-The ceil of the scalar `x` is the smallest integer `i`, such that
-`i >= x`.  It is often denoted as :math:`\\lceil x \\rceil`.
-
-Parameters
-----------
-x : array_like
-    Input data.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or scalar
-    The ceiling of each element in `x`, with `float` dtype.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-floor, trunc, rint
-
-Examples
---------
->>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
->>> np.ceil(a)
-array([-1., -1., -0.,  1.,  2.,  2.,  2.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def int (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int"))))
-(alter-meta! #'int assoc :doc "int([x]) -> integer
-int(x, base=10) -> integer
-
-Convert a number or string to an integer, or return 0 if no arguments
-are given.  If x is a number, return x.__int__().  For floating point
-numbers, this truncates towards zero.
-
-If x is not a number or if base is given, then x must be a string,
-bytes, or bytearray instance representing an integer literal in the
-given base.  The literal can be preceded by '+' or '-' and be surrounded
-by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
-Base 0 means to interpret the base from the string as an integer literal.
->>> int('0b100', base=0)
-4" :arglists '[[self & [args {:as kwargs}]]])
-
-(def asfortranarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asfortranarray"))))
-(alter-meta! #'asfortranarray assoc :doc "
-    Return an array (ndim >= 1) laid out in Fortran order in memory.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    dtype : str or dtype object, optional
-        By default, the data-type is inferred from the input data.
-
-    Returns
-    -------
-    out : ndarray
-        The input `a` in Fortran, or column-major, order.
-
-    See Also
-    --------
-    ascontiguousarray : Convert input to a contiguous (C order) array.
-    asanyarray : Convert input to an ndarray with either row or
-        column-major memory order.
-    require : Return an ndarray that satisfies requirements.
-    ndarray.flags : Information about the memory layout of the array.
-
-    Examples
-    --------
-    >>> x = np.arange(6).reshape(2,3)
-    >>> y = np.asfortranarray(x)
-    >>> x.flags['F_CONTIGUOUS']
-    False
-    >>> y.flags['F_CONTIGUOUS']
-    True
-
-    Note: This function returns an array with at least one-dimension (1-d) 
-    so it will not preserve 0-d arrays.  
-
-    " :arglists '[[a & [{dtype :dtype}]] [a]])
-
-(def logical_and (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_and"))))
-(alter-meta! #'logical_and assoc :doc "logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute the truth value of x1 AND x2 element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or bool
-    Boolean result of the logical AND operation applied to the elements
-    of `x1` and `x2`; the shape is determined by broadcasting.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-logical_or, logical_not, logical_xor
-bitwise_and
-
-Examples
---------
->>> np.logical_and(True, False)
-False
->>> np.logical_and([True, False], [False, False])
-array([False, False])
-
->>> x = np.arange(5)
->>> np.logical_and(x>1, x<4)
-array([False, False,  True,  True, False])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def object (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "object"))))
-(alter-meta! #'object assoc :doc "The base class of the class hierarchy.
-
-When called, it accepts no arguments and returns a new featureless
-instance that has no instance attributes and cannot be given any.
-" :arglists '[[self & [args {:as kwargs}]]])
-
-(def flatnonzero (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flatnonzero"))))
-(alter-meta! #'flatnonzero assoc :doc "
-    Return indices that are non-zero in the flattened version of a.
-
-    This is equivalent to np.nonzero(np.ravel(a))[0].
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-
-    Returns
-    -------
-    res : ndarray
-        Output array, containing the indices of the elements of `a.ravel()`
-        that are non-zero.
-
-    See Also
-    --------
-    nonzero : Return the indices of the non-zero elements of the input array.
-    ravel : Return a 1-D array containing the elements of the input array.
-
-    Examples
-    --------
-    >>> x = np.arange(-2, 3)
-    >>> x
-    array([-2, -1,  0,  1,  2])
-    >>> np.flatnonzero(x)
-    array([0, 1, 3, 4])
-
-    Use the indices of the non-zero elements as an index array to extract
-    these elements:
-
-    >>> x.ravel()[np.flatnonzero(x)]
-    array([-2, -1,  1,  2])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def isscalar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isscalar"))))
-(alter-meta! #'isscalar assoc :doc "
-    Returns True if the type of `element` is a scalar type.
-
-    Parameters
-    ----------
-    element : any
-        Input argument, can be of any type and shape.
-
-    Returns
-    -------
-    val : bool
-        True if `element` is a scalar type, False if it is not.
-
-    See Also
-    --------
-    ndim : Get the number of dimensions of an array
-
-    Notes
-    -----
-    If you need a stricter way to identify a *numerical* scalar, use
-    ``isinstance(x, numbers.Number)``, as that returns ``False`` for most
-    non-numerical elements such as strings.
-
-    In most cases ``np.ndim(x) == 0`` should be used instead of this function,
-    as that will also return true for 0d arrays. This is how numpy overloads
-    functions in the style of the ``dx`` arguments to `gradient` and the ``bins``
-    argument to `histogram`. Some key differences:
-
-    +--------------------------------------+---------------+-------------------+
-    | x                                    |``isscalar(x)``|``np.ndim(x) == 0``|
-    +======================================+===============+===================+
-    | PEP 3141 numeric objects (including  | ``True``      | ``True``          |
-    | builtins)                            |               |                   |
-    +--------------------------------------+---------------+-------------------+
-    | builtin string and buffer objects    | ``True``      | ``True``          |
-    +--------------------------------------+---------------+-------------------+
-    | other builtin objects, like          | ``False``     | ``True``          |
-    | `pathlib.Path`, `Exception`,         |               |                   |
-    | the result of `re.compile`           |               |                   |
-    +--------------------------------------+---------------+-------------------+
-    | third-party objects like             | ``False``     | ``True``          |
-    | `matplotlib.figure.Figure`           |               |                   |
-    +--------------------------------------+---------------+-------------------+
-    | zero-dimensional numpy arrays        | ``False``     | ``True``          |
-    +--------------------------------------+---------------+-------------------+
-    | other numpy arrays                   | ``False``     | ``False``         |
-    +--------------------------------------+---------------+-------------------+
-    | `list`, `tuple`, and other sequence  | ``False``     | ``False``         |
-    | objects                              |               |                   |
-    +--------------------------------------+---------------+-------------------+
-
-    Examples
-    --------
-    >>> np.isscalar(3.1)
-    True
-    >>> np.isscalar(np.array(3.1))
-    False
-    >>> np.isscalar([3.1])
-    False
-    >>> np.isscalar(False)
-    True
-    >>> np.isscalar('numpy')
-    True
-
-    NumPy supports PEP 3141 numbers:
-
-    >>> from fractions import Fraction
-    >>> np.isscalar(Fraction(5, 17))
-    True
-    >>> from numbers import Number
-    >>> np.isscalar(Number())
-    True
-
-    " :arglists '[[element]])
-
-(def common_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "common_type"))))
-(alter-meta! #'common_type assoc :doc "
-    Return a scalar type which is common to the input arrays.
-
-    The return type will always be an inexact (i.e. floating point) scalar
-    type, even if all the arrays are integer arrays. If one of the inputs is
-    an integer array, the minimum precision type that is returned is a
-    64-bit floating point dtype.
-
-    All input arrays except int64 and uint64 can be safely cast to the
-    returned dtype without loss of information.
-
-    Parameters
-    ----------
-    array1, array2, ... : ndarrays
-        Input arrays.
-
-    Returns
-    -------
-    out : data type code
-        Data type code.
-
-    See Also
-    --------
-    dtype, mintypecode
-
-    Examples
-    --------
-    >>> np.common_type(np.arange(2, dtype=np.float32))
-    <class 'numpy.float32'>
-    >>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2))
-    <class 'numpy.float64'>
-    >>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0]))
-    <class 'numpy.complex128'>
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def clongdouble (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "clongdouble"))))
-(alter-meta! #'clongdouble assoc :doc "Complex number type composed of two extended-precision floating-point
-    numbers.
-    Character code: ``'G'``.
-    Canonical name: ``np.clongdouble``.
-    Alias: ``np.clongfloat``.
-    Alias: ``np.longcomplex``.
-    Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def diag (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diag"))))
-(alter-meta! #'diag assoc :doc "
-    Extract a diagonal or construct a diagonal array.
-
-    See the more detailed documentation for ``numpy.diagonal`` if you use this
-    function to extract a diagonal and wish to write to the resulting array;
-    whether it returns a copy or a view depends on what version of numpy you
-    are using.
-
-    Parameters
-    ----------
-    v : array_like
-        If `v` is a 2-D array, return a copy of its `k`-th diagonal.
-        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
-        diagonal.
-    k : int, optional
-        Diagonal in question. The default is 0. Use `k>0` for diagonals
-        above the main diagonal, and `k<0` for diagonals below the main
-        diagonal.
-
-    Returns
-    -------
-    out : ndarray
-        The extracted diagonal or constructed diagonal array.
-
-    See Also
-    --------
-    diagonal : Return specified diagonals.
-    diagflat : Create a 2-D array with the flattened input as a diagonal.
-    trace : Sum along diagonals.
-    triu : Upper triangle of an array.
-    tril : Lower triangle of an array.
-
-    Examples
-    --------
-    >>> x = np.arange(9).reshape((3,3))
-    >>> x
-    array([[0, 1, 2],
-           [3, 4, 5],
-           [6, 7, 8]])
-
-    >>> np.diag(x)
-    array([0, 4, 8])
-    >>> np.diag(x, k=1)
-    array([1, 5])
-    >>> np.diag(x, k=-1)
-    array([3, 7])
-
-    >>> np.diag(np.diag(x))
-    array([[0, 0, 0],
-           [0, 4, 0],
-           [0, 0, 8]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def nanmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmax"))))
-(alter-meta! #'nanmax assoc :doc "
-    Return the maximum of an array or maximum along an axis, ignoring any
-    NaNs.  When all-NaN slices are encountered a ``RuntimeWarning`` is
-    raised and NaN is returned for that slice.
-
-    Parameters
-    ----------
-    a : array_like
-        Array containing numbers whose maximum is desired. If `a` is not an
-        array, a conversion is attempted.
-    axis : {int, tuple of int, None}, optional
-        Axis or axes along which the maximum is computed. The default is to compute
-        the maximum of the flattened array.
-    out : ndarray, optional
-        Alternate output array in which to place the result.  The default
-        is ``None``; if provided, it must have the same shape as the
-        expected output, but the type will be cast if necessary. See
-        `ufuncs-output-type` for more details.
-
-        .. versionadded:: 1.8.0
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the original `a`.
-
-        If the value is anything but the default, then
-        `keepdims` will be passed through to the `max` method
-        of sub-classes of `ndarray`.  If the sub-classes methods
-        does not implement `keepdims` any exceptions will be raised.
-
-        .. versionadded:: 1.8.0
-
-    Returns
-    -------
-    nanmax : ndarray
-        An array with the same shape as `a`, with the specified axis removed.
-        If `a` is a 0-d array, or if axis is None, an ndarray scalar is
-        returned.  The same dtype as `a` is returned.
-
-    See Also
-    --------
-    nanmin :
-        The minimum value of an array along a given axis, ignoring any NaNs.
-    amax :
-        The maximum value of an array along a given axis, propagating any NaNs.
-    fmax :
-        Element-wise maximum of two arrays, ignoring any NaNs.
-    maximum :
-        Element-wise maximum of two arrays, propagating any NaNs.
-    isnan :
-        Shows which elements are Not a Number (NaN).
-    isfinite:
-        Shows which elements are neither NaN nor infinity.
-
-    amin, fmin, minimum
-
-    Notes
-    -----
-    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
-    (IEEE 754). This means that Not a Number is not equivalent to infinity.
-    Positive infinity is treated as a very large number and negative
-    infinity is treated as a very small (i.e. negative) number.
-
-    If the input has a integer type the function is equivalent to np.max.
-
-    Examples
-    --------
-    >>> a = np.array([[1, 2], [3, np.nan]])
-    >>> np.nanmax(a)
-    3.0
-    >>> np.nanmax(a, axis=0)
-    array([3.,  2.])
-    >>> np.nanmax(a, axis=1)
-    array([2.,  3.])
-
-    When positive infinity and negative infinity are present:
-
-    >>> np.nanmax([1, 2, np.nan, np.NINF])
-    2.0
-    >>> np.nanmax([1, 2, np.nan, np.inf])
-    inf
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def generic (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "generic"))))
-(alter-meta! #'generic assoc :doc "Base class for numpy scalar types.
-
-    Class from which most (all?) numpy scalar types are derived.  For
-    consistency, exposes the same API as `ndarray`, despite many
-    consequent attributes being either \"get-only,\" or completely irrelevant.
-    This is the class from which it is strongly suggested users should derive
-    custom scalar types." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} __cached__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__cached__"))))
-
-(def digitize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "digitize"))))
-(alter-meta! #'digitize assoc :doc "
-    Return the indices of the bins to which each value in input array belongs.
-
-    =========  =============  ============================
-    `right`    order of bins  returned index `i` satisfies
-    =========  =============  ============================
-    ``False``  increasing     ``bins[i-1] <= x < bins[i]``
-    ``True``   increasing     ``bins[i-1] < x <= bins[i]``
-    ``False``  decreasing     ``bins[i-1] > x >= bins[i]``
-    ``True``   decreasing     ``bins[i-1] >= x > bins[i]``
-    =========  =============  ============================
-
-    If values in `x` are beyond the bounds of `bins`, 0 or ``len(bins)`` is
-    returned as appropriate.
-
-    Parameters
-    ----------
-    x : array_like
-        Input array to be binned. Prior to NumPy 1.10.0, this array had to
-        be 1-dimensional, but can now have any shape.
-    bins : array_like
-        Array of bins. It has to be 1-dimensional and monotonic.
-    right : bool, optional
-        Indicating whether the intervals include the right or the left bin
-        edge. Default behavior is (right==False) indicating that the interval
-        does not include the right edge. The left bin end is open in this
-        case, i.e., bins[i-1] <= x < bins[i] is the default behavior for
-        monotonically increasing bins.
-
-    Returns
-    -------
-    indices : ndarray of ints
-        Output array of indices, of same shape as `x`.
-
-    Raises
-    ------
-    ValueError
-        If `bins` is not monotonic.
-    TypeError
-        If the type of the input is complex.
-
-    See Also
-    --------
-    bincount, histogram, unique, searchsorted
-
-    Notes
-    -----
-    If values in `x` are such that they fall outside the bin range,
-    attempting to index `bins` with the indices that `digitize` returns
-    will result in an IndexError.
-
-    .. versionadded:: 1.10.0
-
-    `np.digitize` is  implemented in terms of `np.searchsorted`. This means
-    that a binary search is used to bin the values, which scales much better
-    for larger number of bins than the previous linear search. It also removes
-    the requirement for the input array to be 1-dimensional.
-
-    For monotonically _increasing_ `bins`, the following are equivalent::
-
-        np.digitize(x, bins, right=True)
-        np.searchsorted(bins, x, side='left')
-
-    Note that as the order of the arguments are reversed, the side must be too.
-    The `searchsorted` call is marginally faster, as it does not do any
-    monotonicity checks. Perhaps more importantly, it supports all dtypes.
-
-    Examples
-    --------
-    >>> x = np.array([0.2, 6.4, 3.0, 1.6])
-    >>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])
-    >>> inds = np.digitize(x, bins)
-    >>> inds
-    array([1, 4, 3, 2])
-    >>> for n in range(x.size):
-    ...   print(bins[inds[n]-1], \"<=\", x[n], \"<\", bins[inds[n]])
-    ...
-    0.0 <= 0.2 < 1.0
-    4.0 <= 6.4 < 10.0
-    2.5 <= 3.0 < 4.0
-    1.0 <= 1.6 < 2.5
-
-    >>> x = np.array([1.2, 10.0, 12.4, 15.5, 20.])
-    >>> bins = np.array([0, 5, 10, 15, 20])
-    >>> np.digitize(x,bins,right=True)
-    array([1, 2, 3, 4, 4])
-    >>> np.digitize(x,bins,right=False)
-    array([1, 3, 3, 4, 5])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def array_split (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_split"))))
-(alter-meta! #'array_split assoc :doc "
-    Split an array into multiple sub-arrays.
-
-    Please refer to the ``split`` documentation.  The only difference
-    between these functions is that ``array_split`` allows
-    `indices_or_sections` to be an integer that does *not* equally
-    divide the axis. For an array of length l that should be split
-    into n sections, it returns l % n sub-arrays of size l//n + 1
-    and the rest of size l//n.
-
-    See Also
-    --------
-    split : Split array into multiple sub-arrays of equal size.
-
-    Examples
-    --------
-    >>> x = np.arange(8.0)
-    >>> np.array_split(x, 3)
-        [array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.])]
-
-    >>> x = np.arange(7.0)
-    >>> np.array_split(x, 3)
-        [array([0.,  1.,  2.]), array([3.,  4.]), array([5.,  6.])]
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "
-========================
-Random Number Generation
-========================
-
-Use ``default_rng()`` to create a `Generator` and call its methods.
-
-=============== =========================================================
-Generator
---------------- ---------------------------------------------------------
-Generator       Class implementing all of the random number distributions
-default_rng     Default constructor for ``Generator``
-=============== =========================================================
-
-============================================= ===
-BitGenerator Streams that work with Generator
---------------------------------------------- ---
-MT19937
-PCG64
-Philox
-SFC64
-============================================= ===
-
-============================================= ===
-Getting entropy to initialize a BitGenerator
---------------------------------------------- ---
-SeedSequence
-============================================= ===
-
-
-Legacy
-------
-
-For backwards compatibility with previous versions of numpy before 1.17, the
-various aliases to the global `RandomState` methods are left alone and do not
-use the new `Generator` API.
-
-==================== =========================================================
-Utility functions
--------------------- ---------------------------------------------------------
-random               Uniformly distributed floats over ``[0, 1)``
-bytes                Uniformly distributed random bytes.
-permutation          Randomly permute a sequence / generate a random sequence.
-shuffle              Randomly permute a sequence in place.
-choice               Random sample from 1-D array.
-==================== =========================================================
-
-==================== =========================================================
-Compatibility
-functions - removed
-in the new API
--------------------- ---------------------------------------------------------
-rand                 Uniformly distributed values.
-randn                Normally distributed values.
-ranf                 Uniformly distributed floating point numbers.
-random_integers      Uniformly distributed integers in a given range.
-                     (deprecated, use ``integers(..., closed=True)`` instead)
-random_sample        Alias for `random_sample`
-randint              Uniformly distributed integers in a given range
-seed                 Seed the legacy random number generator.
-==================== =========================================================
-
-==================== =========================================================
-Univariate
-distributions
--------------------- ---------------------------------------------------------
-beta                 Beta distribution over ``[0, 1]``.
-binomial             Binomial distribution.
-chisquare            :math:`\\chi^2` distribution.
-exponential          Exponential distribution.
-f                    F (Fisher-Snedecor) distribution.
-gamma                Gamma distribution.
-geometric            Geometric distribution.
-gumbel               Gumbel distribution.
-hypergeometric       Hypergeometric distribution.
-laplace              Laplace distribution.
-logistic             Logistic distribution.
-lognormal            Log-normal distribution.
-logseries            Logarithmic series distribution.
-negative_binomial    Negative binomial distribution.
-noncentral_chisquare Non-central chi-square distribution.
-noncentral_f         Non-central F distribution.
-normal               Normal / Gaussian distribution.
-pareto               Pareto distribution.
-poisson              Poisson distribution.
-power                Power distribution.
-rayleigh             Rayleigh distribution.
-triangular           Triangular distribution.
-uniform              Uniform distribution.
-vonmises             Von Mises circular distribution.
-wald                 Wald (inverse Gaussian) distribution.
-weibull              Weibull distribution.
-zipf                 Zipf's distribution over ranked data.
-==================== =========================================================
-
-==================== ==========================================================
-Multivariate
-distributions
--------------------- ----------------------------------------------------------
-dirichlet            Multivariate generalization of Beta distribution.
-multinomial          Multivariate generalization of the binomial distribution.
-multivariate_normal  Multivariate generalization of the normal distribution.
-==================== ==========================================================
-
-==================== =========================================================
-Standard
-distributions
--------------------- ---------------------------------------------------------
-standard_cauchy      Standard Cauchy-Lorentz distribution.
-standard_exponential Standard exponential distribution.
-standard_gamma       Standard Gamma distribution.
-standard_normal      Standard normal distribution.
-standard_t           Standard Student's t-distribution.
-==================== =========================================================
-
-==================== =========================================================
-Internal functions
--------------------- ---------------------------------------------------------
-get_state            Get tuple representing internal state of generator.
-set_state            Set state of generator.
-==================== =========================================================
-
-
-"} random (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "random"))))
-
-(def get_include (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "get_include"))))
-(alter-meta! #'get_include assoc :doc "
-    Return the directory that contains the NumPy \\*.h header files.
-
-    Extension modules that need to compile against NumPy should use this
-    function to locate the appropriate include directory.
-
-    Notes
-    -----
-    When using ``distutils``, for example in ``setup.py``.
-    ::
-
-        import numpy as np
-        ...
-        Extension('extension_name', ...
-                include_dirs=[np.get_include()])
-        ...
-
-    " :arglists '[[]])
-
-(def ^{:doc ""} MAY_SHARE_BOUNDS (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "MAY_SHARE_BOUNDS"))))
-
-(def ^{:doc ""} UFUNC_BUFSIZE_DEFAULT (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "UFUNC_BUFSIZE_DEFAULT"))))
-
-(def ^{:doc ""} __config__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__config__"))))
-
-(def alen (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "alen"))))
-(alter-meta! #'alen assoc :doc "
-    Return the length of the first dimension of the input array.
-
-    Parameters
-    ----------
-    a : array_like
-       Input array.
-
-    Returns
-    -------
-    alen : int
-       Length of the first dimension of `a`.
-
-    See Also
-    --------
-    shape, size
-
-    Examples
-    --------
-    >>> a = np.zeros((7,4,5))
-    >>> a.shape[0]
-    7
-    >>> np.alen(a)
-    7
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def save (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "save"))))
-(alter-meta! #'save assoc :doc "
-    Save an array to a binary file in NumPy ``.npy`` format.
-
-    Parameters
-    ----------
-    file : file, str, or pathlib.Path
-        File or filename to which the data is saved.  If file is a file-object,
-        then the filename is unchanged.  If file is a string or Path, a ``.npy``
-        extension will be appended to the filename if it does not already
-        have one.
-    arr : array_like
-        Array data to be saved.
-    allow_pickle : bool, optional
-        Allow saving object arrays using Python pickles. Reasons for disallowing
-        pickles include security (loading pickled data can execute arbitrary
-        code) and portability (pickled objects may not be loadable on different
-        Python installations, for example if the stored objects require libraries
-        that are not available, and not all pickled data is compatible between
-        Python 2 and Python 3).
-        Default: True
-    fix_imports : bool, optional
-        Only useful in forcing objects in object arrays on Python 3 to be
-        pickled in a Python 2 compatible way. If `fix_imports` is True, pickle
-        will try to map the new Python 3 names to the old module names used in
-        Python 2, so that the pickle data stream is readable with Python 2.
-
-    See Also
-    --------
-    savez : Save several arrays into a ``.npz`` archive
-    savetxt, load
-
-    Notes
-    -----
-    For a description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.
-
-    Any data saved to the file is appended to the end of the file.
-
-    Examples
-    --------
-    >>> from tempfile import TemporaryFile
-    >>> outfile = TemporaryFile()
-
-    >>> x = np.arange(10)
-    >>> np.save(outfile, x)
-
-    >>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file
-    >>> np.load(outfile)
-    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-
-
-    >>> with open('test.npy', 'wb') as f:
-    ...     np.save(f, np.array([1, 2]))
-    ...     np.save(f, np.array([1, 3]))
-    >>> with open('test.npy', 'rb') as f:
-    ...     a = np.load(f)
-    ...     b = np.load(f)
-    >>> print(a, b)
-    # [1 2] [1 3]
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def cosh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cosh"))))
-(alter-meta! #'cosh assoc :doc "cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Hyperbolic cosine, element-wise.
-
-Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Output array of same shape as `x`.
-    This is a scalar if `x` is a scalar.
-
-Examples
---------
->>> np.cosh(0)
-1.0
-
-The hyperbolic cosine describes the shape of a hanging cable:
-
->>> import matplotlib.pyplot as plt
->>> x = np.linspace(-4, 4, 1000)
->>> plt.plot(x, np.cosh(x))
->>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ix_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ix_"))))
-(alter-meta! #'ix_ assoc :doc "
-    Construct an open mesh from multiple sequences.
-
-    This function takes N 1-D sequences and returns N outputs with N
-    dimensions each, such that the shape is 1 in all but one dimension
-    and the dimension with the non-unit shape value cycles through all
-    N dimensions.
-
-    Using `ix_` one can quickly construct index arrays that will index
-    the cross product. ``a[np.ix_([1,3],[2,5])]`` returns the array
-    ``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``.
-
-    Parameters
-    ----------
-    args : 1-D sequences
-        Each sequence should be of integer or boolean type.
-        Boolean sequences will be interpreted as boolean masks for the
-        corresponding dimension (equivalent to passing in
-        ``np.nonzero(boolean_sequence)``).
-
-    Returns
-    -------
-    out : tuple of ndarrays
-        N arrays with N dimensions each, with N the number of input
-        sequences. Together these arrays form an open mesh.
-
-    See Also
-    --------
-    ogrid, mgrid, meshgrid
-
-    Examples
-    --------
-    >>> a = np.arange(10).reshape(2, 5)
-    >>> a
-    array([[0, 1, 2, 3, 4],
-           [5, 6, 7, 8, 9]])
-    >>> ixgrid = np.ix_([0, 1], [2, 4])
-    >>> ixgrid
-    (array([[0],
-           [1]]), array([[2, 4]]))
-    >>> ixgrid[0].shape, ixgrid[1].shape
-    ((2, 1), (1, 2))
-    >>> a[ixgrid]
-    array([[2, 4],
-           [7, 9]])
-
-    >>> ixgrid = np.ix_([True, True], [2, 4])
-    >>> a[ixgrid]
-    array([[2, 4],
-           [7, 9]])
-    >>> ixgrid = np.ix_([True, True], [False, False, True, False, True])
-    >>> a[ixgrid]
-    array([[2, 4],
-           [7, 9]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} NINF (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "NINF"))))
-
-(def int_asbuffer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int_asbuffer"))))
-(alter-meta! #'int_asbuffer assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ufunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ufunc"))))
-(alter-meta! #'ufunc assoc :doc "Functions that operate element by element on whole arrays.
-
-    To see the documentation for a specific ufunc, use `info`.  For
-    example, ``np.info(np.sin)``.  Because ufuncs are written in C
-    (for speed) and linked into Python with NumPy's ufunc facility,
-    Python's help() function finds this page whenever help() is called
-    on a ufunc.
-
-    A detailed explanation of ufuncs can be found in the docs for :ref:`ufuncs`.
-
-    Calling ufuncs:
-    ===============
-
-    op(*x[, out], where=True, **kwargs)
-    Apply `op` to the arguments `*x` elementwise, broadcasting the arguments.
-
-    The broadcasting rules are:
-
-    * Dimensions of length 1 may be prepended to either array.
-    * Arrays may be repeated along dimensions of length 1.
-
-    Parameters
-    ----------
-    *x : array_like
-        Input arrays.
-    out : ndarray, None, or tuple of ndarray and None, optional
-        Alternate array object(s) in which to put the result; if provided, it
-        must have a shape that the inputs broadcast to. A tuple of arrays
-        (possible only as a keyword argument) must have length equal to the
-        number of outputs; use None for uninitialized outputs to be
-        allocated by the ufunc.
-    where : array_like, optional
-        This condition is broadcast over the input. At locations where the
-        condition is True, the `out` array will be set to the ufunc result.
-        Elsewhere, the `out` array will retain its original value.
-        Note that if an uninitialized `out` array is created via the default
-        ``out=None``, locations within it where the condition is False will
-        remain uninitialized.
-    **kwargs
-        For other keyword-only arguments, see the :ref:`ufunc docs <ufuncs.kwargs>`.
-
-    Returns
-    -------
-    r : ndarray or tuple of ndarray
-        `r` will have the shape that the arrays in `x` broadcast to; if `out` is
-        provided, it will be returned. If not, `r` will be allocated and
-        may contain uninitialized values. If the function has more than one
-        output, then the result will be a tuple of arrays." :arglists '[[self & [args {:as kwargs}]]])
-
-(def TooHardError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "TooHardError"))))
-(alter-meta! #'TooHardError assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def sctype2char (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sctype2char"))))
-(alter-meta! #'sctype2char assoc :doc "
-    Return the string representation of a scalar dtype.
-
-    Parameters
-    ----------
-    sctype : scalar dtype or object
-        If a scalar dtype, the corresponding string character is
-        returned. If an object, `sctype2char` tries to infer its scalar type
-        and then return the corresponding string character.
-
-    Returns
-    -------
-    typechar : str
-        The string character corresponding to the scalar type.
-
-    Raises
-    ------
-    ValueError
-        If `sctype` is an object for which the type can not be inferred.
-
-    See Also
-    --------
-    obj2sctype, issctype, issubsctype, mintypecode
-
-    Examples
-    --------
-    >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]:
-    ...     print(np.sctype2char(sctype))
-    l # may vary
-    d
-    D
-    S
-    O
-
-    >>> x = np.array([1., 2-1.j])
-    >>> np.sctype2char(x)
-    'D'
-    >>> np.sctype2char(list)
-    'O'
-
-    " :arglists '[[sctype]])
-
-(def unique (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unique"))))
-(alter-meta! #'unique assoc :doc "
-    Find the unique elements of an array.
-
-    Returns the sorted unique elements of an array. There are three optional
-    outputs in addition to the unique elements:
-
-    * the indices of the input array that give the unique values
-    * the indices of the unique array that reconstruct the input array
-    * the number of times each unique value comes up in the input array
-
-    Parameters
-    ----------
-    ar : array_like
-        Input array. Unless `axis` is specified, this will be flattened if it
-        is not already 1-D.
-    return_index : bool, optional
-        If True, also return the indices of `ar` (along the specified axis,
-        if provided, or in the flattened array) that result in the unique array.
-    return_inverse : bool, optional
-        If True, also return the indices of the unique array (for the specified
-        axis, if provided) that can be used to reconstruct `ar`.
-    return_counts : bool, optional
-        If True, also return the number of times each unique item appears
-        in `ar`.
-
-        .. versionadded:: 1.9.0
-
-    axis : int or None, optional
-        The axis to operate on. If None, `ar` will be flattened. If an integer,
-        the subarrays indexed by the given axis will be flattened and treated
-        as the elements of a 1-D array with the dimension of the given axis,
-        see the notes for more details.  Object arrays or structured arrays
-        that contain objects are not supported if the `axis` kwarg is used. The
-        default is None.
-
-        .. versionadded:: 1.13.0
-
-    Returns
-    -------
-    unique : ndarray
-        The sorted unique values.
-    unique_indices : ndarray, optional
-        The indices of the first occurrences of the unique values in the
-        original array. Only provided if `return_index` is True.
-    unique_inverse : ndarray, optional
-        The indices to reconstruct the original array from the
-        unique array. Only provided if `return_inverse` is True.
-    unique_counts : ndarray, optional
-        The number of times each of the unique values comes up in the
-        original array. Only provided if `return_counts` is True.
-
-        .. versionadded:: 1.9.0
-
-    See Also
-    --------
-    numpy.lib.arraysetops : Module with a number of other functions for
-                            performing set operations on arrays.
-
-    Notes
-    -----
-    When an axis is specified the subarrays indexed by the axis are sorted.
-    This is done by making the specified axis the first dimension of the array
-    (move the axis to the first dimension to keep the order of the other axes)
-    and then flattening the subarrays in C order. The flattened subarrays are
-    then viewed as a structured type with each element given a label, with the
-    effect that we end up with a 1-D array of structured types that can be
-    treated in the same way as any other 1-D array. The result is that the
-    flattened subarrays are sorted in lexicographic order starting with the
-    first element.
-
-    Examples
-    --------
-    >>> np.unique([1, 1, 2, 2, 3, 3])
-    array([1, 2, 3])
-    >>> a = np.array([[1, 1], [2, 3]])
-    >>> np.unique(a)
-    array([1, 2, 3])
-
-    Return the unique rows of a 2D array
-
-    >>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
-    >>> np.unique(a, axis=0)
-    array([[1, 0, 0], [2, 3, 4]])
-
-    Return the indices of the original array that give the unique values:
-
-    >>> a = np.array(['a', 'b', 'b', 'c', 'a'])
-    >>> u, indices = np.unique(a, return_index=True)
-    >>> u
-    array(['a', 'b', 'c'], dtype='<U1')
-    >>> indices
-    array([0, 1, 3])
-    >>> a[indices]
-    array(['a', 'b', 'c'], dtype='<U1')
-
-    Reconstruct the input array from the unique values:
-
-    >>> a = np.array([1, 2, 6, 4, 2, 3, 2])
-    >>> u, indices = np.unique(a, return_inverse=True)
-    >>> u
-    array([1, 2, 3, 4, 6])
-    >>> indices
-    array([0, 1, 4, ..., 1, 2, 1])
-    >>> u[indices]
-    array([1, 2, 6, ..., 2, 3, 2])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def min (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "min"))))
-(alter-meta! #'min assoc :doc "
-    Return the minimum of an array or minimum along an axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which to operate.  By default, flattened input is
-        used.
-
-        .. versionadded:: 1.7.0
-
-        If this is a tuple of ints, the minimum is selected over multiple axes,
-        instead of a single axis or all the axes as before.
-    out : ndarray, optional
-        Alternative output array in which to place the result.  Must
-        be of the same shape and buffer length as the expected output.
-        See `ufuncs-output-type` for more details.
-
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `amin` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-
-    initial : scalar, optional
-        The maximum value of an output element. Must be present to allow
-        computation on empty slice. See `~numpy.ufunc.reduce` for details.
-
-        .. versionadded:: 1.15.0
-
-    where : array_like of bool, optional
-        Elements to compare for the minimum. See `~numpy.ufunc.reduce`
-        for details.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    amin : ndarray or scalar
-        Minimum of `a`. If `axis` is None, the result is a scalar value.
-        If `axis` is given, the result is an array of dimension
-        ``a.ndim - 1``.
-
-    See Also
-    --------
-    amax :
-        The maximum value of an array along a given axis, propagating any NaNs.
-    nanmin :
-        The minimum value of an array along a given axis, ignoring any NaNs.
-    minimum :
-        Element-wise minimum of two arrays, propagating any NaNs.
-    fmin :
-        Element-wise minimum of two arrays, ignoring any NaNs.
-    argmin :
-        Return the indices of the minimum values.
-
-    nanmax, maximum, fmax
-
-    Notes
-    -----
-    NaN values are propagated, that is if at least one item is NaN, the
-    corresponding min value will be NaN as well. To ignore NaN values
-    (MATLAB behavior), please use nanmin.
-
-    Don't use `amin` for element-wise comparison of 2 arrays; when
-    ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than
-    ``amin(a, axis=0)``.
-
-    Examples
-    --------
-    >>> a = np.arange(4).reshape((2,2))
-    >>> a
-    array([[0, 1],
-           [2, 3]])
-    >>> np.amin(a)           # Minimum of the flattened array
-    0
-    >>> np.amin(a, axis=0)   # Minima along the first axis
-    array([0, 1])
-    >>> np.amin(a, axis=1)   # Minima along the second axis
-    array([0, 2])
-    >>> np.amin(a, where=[False, True], initial=10, axis=0)
-    array([10,  1])
-
-    >>> b = np.arange(5, dtype=float)
-    >>> b[2] = np.NaN
-    >>> np.amin(b)
-    nan
-    >>> np.amin(b, where=~np.isnan(b), initial=10)
-    0.0
-    >>> np.nanmin(b)
-    0.0
-
-    >>> np.min([[-50], [10]], axis=-1, initial=0)
-    array([-50,   0])
-
-    Notice that the initial value is used as one of the elements for which the
-    minimum is determined, unlike for the default argument Python's max
-    function, which is only used for empty iterables.
-
-    Notice that this isn't the same as Python's ``default`` argument.
-
-    >>> np.min([6], initial=5)
-    5
-    >>> min([6], default=5)
-    6
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def histogram2d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogram2d"))))
-(alter-meta! #'histogram2d assoc :doc "
-    Compute the bi-dimensional histogram of two data samples.
-
-    Parameters
-    ----------
-    x : array_like, shape (N,)
-        An array containing the x coordinates of the points to be
-        histogrammed.
-    y : array_like, shape (N,)
-        An array containing the y coordinates of the points to be
-        histogrammed.
-    bins : int or array_like or [int, int] or [array, array], optional
-        The bin specification:
-
-          * If int, the number of bins for the two dimensions (nx=ny=bins).
-          * If array_like, the bin edges for the two dimensions
-            (x_edges=y_edges=bins).
-          * If [int, int], the number of bins in each dimension
-            (nx, ny = bins).
-          * If [array, array], the bin edges in each dimension
-            (x_edges, y_edges = bins).
-          * A combination [int, array] or [array, int], where int
-            is the number of bins and array is the bin edges.
-
-    range : array_like, shape(2,2), optional
-        The leftmost and rightmost edges of the bins along each dimension
-        (if not specified explicitly in the `bins` parameters):
-        ``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range
-        will be considered outliers and not tallied in the histogram.
-    density : bool, optional
-        If False, the default, returns the number of samples in each bin.
-        If True, returns the probability *density* function at the bin,
-        ``bin_count / sample_count / bin_area``.
-    normed : bool, optional
-        An alias for the density argument that behaves identically. To avoid
-        confusion with the broken normed argument to `histogram`, `density`
-        should be preferred.
-    weights : array_like, shape(N,), optional
-        An array of values ``w_i`` weighing each sample ``(x_i, y_i)``.
-        Weights are normalized to 1 if `normed` is True. If `normed` is
-        False, the values of the returned histogram are equal to the sum of
-        the weights belonging to the samples falling into each bin.
-
-    Returns
-    -------
-    H : ndarray, shape(nx, ny)
-        The bi-dimensional histogram of samples `x` and `y`. Values in `x`
-        are histogrammed along the first dimension and values in `y` are
-        histogrammed along the second dimension.
-    xedges : ndarray, shape(nx+1,)
-        The bin edges along the first dimension.
-    yedges : ndarray, shape(ny+1,)
-        The bin edges along the second dimension.
-
-    See Also
-    --------
-    histogram : 1D histogram
-    histogramdd : Multidimensional histogram
-
-    Notes
-    -----
-    When `normed` is True, then the returned histogram is the sample
-    density, defined such that the sum over bins of the product
-    ``bin_value * bin_area`` is 1.
-
-    Please note that the histogram does not follow the Cartesian convention
-    where `x` values are on the abscissa and `y` values on the ordinate
-    axis.  Rather, `x` is histogrammed along the first dimension of the
-    array (vertical), and `y` along the second dimension of the array
-    (horizontal).  This ensures compatibility with `histogramdd`.
-
-    Examples
-    --------
-    >>> from matplotlib.image import NonUniformImage
-    >>> import matplotlib.pyplot as plt
-
-    Construct a 2-D histogram with variable bin width. First define the bin
-    edges:
-
-    >>> xedges = [0, 1, 3, 5]
-    >>> yedges = [0, 2, 3, 4, 6]
-
-    Next we create a histogram H with random bin content:
-
-    >>> x = np.random.normal(2, 1, 100)
-    >>> y = np.random.normal(1, 1, 100)
-    >>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges))
-    >>> H = H.T  # Let each row list bins with common y range.
-
-    :func:`imshow <matplotlib.pyplot.imshow>` can only display square bins:
-
-    >>> fig = plt.figure(figsize=(7, 3))
-    >>> ax = fig.add_subplot(131, title='imshow: square bins')
-    >>> plt.imshow(H, interpolation='nearest', origin='low',
-    ...         extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])
-    <matplotlib.image.AxesImage object at 0x...>
-
-    :func:`pcolormesh <matplotlib.pyplot.pcolormesh>` can display actual edges:
-
-    >>> ax = fig.add_subplot(132, title='pcolormesh: actual edges',
-    ...         aspect='equal')
-    >>> X, Y = np.meshgrid(xedges, yedges)
-    >>> ax.pcolormesh(X, Y, H)
-    <matplotlib.collections.QuadMesh object at 0x...>
-
-    :class:`NonUniformImage <matplotlib.image.NonUniformImage>` can be used to
-    display actual bin edges with interpolation:
-
-    >>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated',
-    ...         aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])
-    >>> im = NonUniformImage(ax, interpolation='bilinear')
-    >>> xcenters = (xedges[:-1] + xedges[1:]) / 2
-    >>> ycenters = (yedges[:-1] + yedges[1:]) / 2
-    >>> im.set_data(xcenters, ycenters, H)
-    >>> ax.images.append(im)
-    >>> plt.show()
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def array_str (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_str"))))
-(alter-meta! #'array_str assoc :doc "
-    Return a string representation of the data in an array.
-
-    The data in the array is returned as a single string.  This function is
-    similar to `array_repr`, the difference being that `array_repr` also
-    returns information on the kind of array and its data type.
-
-    Parameters
-    ----------
-    a : ndarray
-        Input array.
-    max_line_width : int, optional
-        Inserts newlines if text is longer than `max_line_width`.
-        Defaults to ``numpy.get_printoptions()['linewidth']``.
-    precision : int, optional
-        Floating point precision.
-        Defaults to ``numpy.get_printoptions()['precision']``.
-    suppress_small : bool, optional
-        Represent numbers \"very close\" to zero as zero; default is False.
-        Very close is defined by precision: if the precision is 8, e.g.,
-        numbers smaller (in absolute value) than 5e-9 are represented as
-        zero.
-        Defaults to ``numpy.get_printoptions()['suppress']``.
-
-    See Also
-    --------
-    array2string, array_repr, set_printoptions
-
-    Examples
-    --------
-    >>> np.array_str(np.arange(3))
-    '[0 1 2]'
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} SHIFT_INVALID (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "SHIFT_INVALID"))))
-
-(def zeros (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "zeros"))))
-(alter-meta! #'zeros assoc :doc "zeros(shape, dtype=float, order='C')
-
-    Return a new array of given shape and type, filled with zeros.
-
-    Parameters
-    ----------
-    shape : int or tuple of ints
-        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
-    dtype : data-type, optional
-        The desired data-type for the array, e.g., `numpy.int8`.  Default is
-        `numpy.float64`.
-    order : {'C', 'F'}, optional, default: 'C'
-        Whether to store multi-dimensional data in row-major
-        (C-style) or column-major (Fortran-style) order in
-        memory.
-
-    Returns
-    -------
-    out : ndarray
-        Array of zeros with the given shape, dtype, and order.
-
-    See Also
-    --------
-    zeros_like : Return an array of zeros with shape and type of input.
-    empty : Return a new uninitialized array.
-    ones : Return a new array setting values to one.
-    full : Return a new array of given shape filled with value.
-
-    Examples
-    --------
-    >>> np.zeros(5)
-    array([ 0.,  0.,  0.,  0.,  0.])
-
-    >>> np.zeros((5,), dtype=int)
-    array([0, 0, 0, 0, 0])
-
-    >>> np.zeros((2, 1))
-    array([[ 0.],
-           [ 0.]])
-
-    >>> s = (2,2)
-    >>> np.zeros(s)
-    array([[ 0.,  0.],
-           [ 0.,  0.]])
-
-    >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
-    array([(0, 0), (0, 0)],
-          dtype=[('x', '<i4'), ('y', '<i4')])" :arglists '[[self & [args {:as kwargs}]]])
-(def ^{:doc "dict() -> new empty dictionary
-dict(mapping) -> new dictionary initialized from a mapping object's
-    (key, value) pairs
-dict(iterable) -> new dictionary initialized as if via:
-    d = {}
-    for k, v in iterable:
-        d[k] = v
-dict(**kwargs) -> new dictionary initialized with the name=value pairs
-    in the keyword argument list.  For example:  dict(one=1, two=2)"} sctypes (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "sctypes")))) 
-
-(def invert (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "invert"))))
-(alter-meta! #'invert assoc :doc "invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute bit-wise inversion, or bit-wise NOT, element-wise.
-
-Computes the bit-wise NOT of the underlying binary representation of
-the integers in the input arrays. This ufunc implements the C/Python
-operator ``~``.
-
-For signed integer inputs, the two's complement is returned.  In a
-two's-complement system negative numbers are represented by the two's
-complement of the absolute value. This is the most common method of
-representing signed integers on computers [1]_. A N-bit
-two's-complement system can represent every integer in the range
-:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
-
-Parameters
-----------
-x : array_like
-    Only integer and boolean types are handled.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Result.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-bitwise_and, bitwise_or, bitwise_xor
-logical_not
-binary_repr :
-    Return the binary representation of the input number as a string.
-
-Notes
------
-`bitwise_not` is an alias for `invert`:
-
->>> np.bitwise_not is np.invert
-True
-
-References
-----------
-.. [1] Wikipedia, \"Two's complement\",
-    https://en.wikipedia.org/wiki/Two's_complement
-
-Examples
---------
-We've seen that 13 is represented by ``00001101``.
-The invert or bit-wise NOT of 13 is then:
-
->>> x = np.invert(np.array(13, dtype=np.uint8))
->>> x
-242
->>> np.binary_repr(x, width=8)
-'11110010'
-
-The result depends on the bit-width:
-
->>> x = np.invert(np.array(13, dtype=np.uint16))
->>> x
-65522
->>> np.binary_repr(x, width=16)
-'1111111111110010'
-
-When using signed integer types the result is the two's complement of
-the result for the unsigned type:
-
->>> np.invert(np.array([13], dtype=np.int8))
-array([-14], dtype=int8)
->>> np.binary_repr(-14, width=8)
-'11110010'
-
-Booleans are accepted as well:
-
->>> np.invert(np.array([True, False]))
-array([False,  True])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def floor_divide (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "floor_divide"))))
-(alter-meta! #'floor_divide assoc :doc "floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the largest integer smaller or equal to the division of the inputs.
-It is equivalent to the Python ``//`` operator and pairs with the
-Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)``
-up to roundoff.
-
-Parameters
-----------
-x1 : array_like
-    Numerator.
-x2 : array_like
-    Denominator. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    y = floor(`x1`/`x2`)
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-remainder : Remainder complementary to floor_divide.
-divmod : Simultaneous floor division and remainder.
-divide : Standard division.
-floor : Round a number to the nearest integer toward minus infinity.
-ceil : Round a number to the nearest integer toward infinity.
-
-Examples
---------
->>> np.floor_divide(7,3)
-2
->>> np.floor_divide([1., 2., 3., 4.], 2.5)
-array([ 0.,  0.,  1.,  1.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def uint0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint0"))))
-(alter-meta! #'uint0 assoc :doc "Unsigned integer type, compatible with C ``unsigned long``.
-    Character code: ``'L'``.
-    Canonical name: ``np.uint``.
-    Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615).
-    Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc "
-============================
-``ctypes`` Utility Functions
-============================
-
-See Also
----------
-load_library : Load a C library.
-ndpointer : Array restype/argtype with verification.
-as_ctypes : Create a ctypes array from an ndarray.
-as_array : Create an ndarray from a ctypes array.
-
-References
-----------
-.. [1] \"SciPy Cookbook: ctypes\", https://scipy-cookbook.readthedocs.io/items/Ctypes.html
-
-Examples
---------
-Load the C library:
-
->>> _lib = np.ctypeslib.load_library('libmystuff', '.')     #doctest: +SKIP
-
-Our result type, an ndarray that must be of type double, be 1-dimensional
-and is C-contiguous in memory:
-
->>> array_1d_double = np.ctypeslib.ndpointer(
-...                          dtype=np.double,
-...                          ndim=1, flags='CONTIGUOUS')    #doctest: +SKIP
-
-Our C-function typically takes an array and updates its values
-in-place.  For example::
-
-    void foo_func(double* x, int length)
-    {
-        int i;
-        for (i = 0; i < length; i++) {
-            x[i] = i*i;
-        }
-    }
-
-We wrap it using:
-
->>> _lib.foo_func.restype = None                      #doctest: +SKIP
->>> _lib.foo_func.argtypes = [array_1d_double, c_int] #doctest: +SKIP
-
-Then, we're ready to call ``foo_func``:
-
->>> out = np.empty(15, dtype=np.double)
->>> _lib.foo_func(out, len(out))                #doctest: +SKIP
-
-"} ctypeslib (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ctypeslib"))))
-
-(def bool_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bool_"))))
-(alter-meta! #'bool_ assoc :doc "Boolean type (True or False), stored as a byte.
-    Character code: ``'?'``.
-    Alias: ``np.bool8``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def void0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "void0"))))
-(alter-meta! #'void0 assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def bytes_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bytes_"))))
-(alter-meta! #'bytes_ assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def seterr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "seterr"))))
-(alter-meta! #'seterr assoc :doc "
-    Set how floating-point errors are handled.
-
-    Note that operations on integer scalar types (such as `int16`) are
-    handled like floating point, and are affected by these settings.
-
-    Parameters
-    ----------
-    all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
-        Set treatment for all types of floating-point errors at once:
-
-        - ignore: Take no action when the exception occurs.
-        - warn: Print a `RuntimeWarning` (via the Python `warnings` module).
-        - raise: Raise a `FloatingPointError`.
-        - call: Call a function specified using the `seterrcall` function.
-        - print: Print a warning directly to ``stdout``.
-        - log: Record error in a Log object specified by `seterrcall`.
-
-        The default is not to change the current behavior.
-    divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
-        Treatment for division by zero.
-    over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
-        Treatment for floating-point overflow.
-    under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
-        Treatment for floating-point underflow.
-    invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
-        Treatment for invalid floating-point operation.
-
-    Returns
-    -------
-    old_settings : dict
-        Dictionary containing the old settings.
-
-    See also
-    --------
-    seterrcall : Set a callback function for the 'call' mode.
-    geterr, geterrcall, errstate
-
-    Notes
-    -----
-    The floating-point exceptions are defined in the IEEE 754 standard [1]_:
-
-    - Division by zero: infinite result obtained from finite numbers.
-    - Overflow: result too large to be expressed.
-    - Underflow: result so close to zero that some precision
-      was lost.
-    - Invalid operation: result is not an expressible number, typically
-      indicates that a NaN was produced.
-
-    .. [1] https://en.wikipedia.org/wiki/IEEE_754
-
-    Examples
-    --------
-    >>> old_settings = np.seterr(all='ignore')  #seterr to known value
-    >>> np.seterr(over='raise')
-    {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
-    >>> np.seterr(**old_settings)  # reset to default
-    {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'}
-
-    >>> np.int16(32000) * np.int16(3)
-    30464
-    >>> old_settings = np.seterr(all='warn', over='raise')
-    >>> np.int16(32000) * np.int16(3)
-    Traceback (most recent call last):
-      File \"<stdin>\", line 1, in <module>
-    FloatingPointError: overflow encountered in short_scalars
-
-    >>> from collections import OrderedDict
-    >>> old_settings = np.seterr(all='print')
-    >>> OrderedDict(np.geterr())
-    OrderedDict([('divide', 'print'), ('over', 'print'), ('under', 'print'), ('invalid', 'print')])
-    >>> np.int16(32000) * np.int16(3)
-    30464
-
-    " :arglists '[[& [{all :all, divide :divide, over :over, under :under, invalid :invalid}]] [& [{all :all, divide :divide, over :over, under :under}]] [& [{all :all, divide :divide, over :over}]] [& [{all :all, divide :divide}]] [& [{all :all}]] []])
-
-(def ^{:doc ""} ERR_CALL (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_CALL"))))
-
-(def isinf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isinf"))))
-(alter-meta! #'isinf assoc :doc "isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Test element-wise for positive or negative infinity.
-
-Returns a boolean array of the same shape as `x`, True where ``x ==
-+/-inf``, otherwise False.
-
-Parameters
-----------
-x : array_like
-    Input values
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : bool (scalar) or boolean ndarray
-    True where ``x`` is positive or negative infinity, false otherwise.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-isneginf, isposinf, isnan, isfinite
-
-Notes
------
-NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
-(IEEE 754).
-
-Errors result if the second argument is supplied when the first
-argument is a scalar, or if the first and second arguments have
-different shapes.
-
-Examples
---------
->>> np.isinf(np.inf)
-True
->>> np.isinf(np.nan)
-False
->>> np.isinf(np.NINF)
-True
->>> np.isinf([np.inf, -np.inf, 1.0, np.nan])
-array([ True,  True, False, False])
-
->>> x = np.array([-np.inf, 0., np.inf])
->>> y = np.array([2, 2, 2])
->>> np.isinf(x, y)
-array([1, 0, 1])
->>> y
-array([1, 0, 1])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def spacing (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "spacing"))))
-(alter-meta! #'spacing assoc :doc "spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the distance between x and the nearest adjacent number.
-
-Parameters
-----------
-x : array_like
-    Values to find the spacing of.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    The spacing of values of `x`.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-It can be considered as a generalization of EPS:
-``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there
-should not be any representable number between ``x + spacing(x)`` and
-x for any finite x.
-
-Spacing of +- inf and NaN is NaN.
-
-Examples
---------
->>> np.spacing(1) == np.finfo(np.float64).eps
-True" :arglists '[[self & [args {:as kwargs}]]])
-
-(def float_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float_"))))
-(alter-meta! #'float_ assoc :doc "Double-precision floating-point number type, compatible with Python `float`
-    and C ``double``.
-    Character code: ``'d'``.
-    Canonical name: ``np.double``.
-    Alias: ``np.float_``.
-    Alias *on this platform*: ``np.float64``: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
-
-(def RankWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "RankWarning"))))
-(alter-meta! #'RankWarning assoc :doc "
-    Issued by `polyfit` when the Vandermonde matrix is rank deficient.
-
-    For more information, a way to suppress the warning, and an example of
-    `RankWarning` being issued, see `polyfit`.
-
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def polyval (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyval"))))
-(alter-meta! #'polyval assoc :doc "
-    Evaluate a polynomial at specific values.
-
-    If `p` is of length N, this function returns the value:
-
-        ``p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]``
-
-    If `x` is a sequence, then `p(x)` is returned for each element of `x`.
-    If `x` is another polynomial then the composite polynomial `p(x(t))`
-    is returned.
-
-    Parameters
-    ----------
-    p : array_like or poly1d object
-       1D array of polynomial coefficients (including coefficients equal
-       to zero) from highest degree to the constant term, or an
-       instance of poly1d.
-    x : array_like or poly1d object
-       A number, an array of numbers, or an instance of poly1d, at
-       which to evaluate `p`.
-
-    Returns
-    -------
-    values : ndarray or poly1d
-       If `x` is a poly1d instance, the result is the composition of the two
-       polynomials, i.e., `x` is \"substituted\" in `p` and the simplified
-       result is returned. In addition, the type of `x` - array_like or
-       poly1d - governs the type of the output: `x` array_like => `values`
-       array_like, `x` a poly1d object => `values` is also.
-
-    See Also
-    --------
-    poly1d: A polynomial class.
-
-    Notes
-    -----
-    Horner's scheme [1]_ is used to evaluate the polynomial. Even so,
-    for polynomials of high degree the values may be inaccurate due to
-    rounding errors. Use carefully.
-
-    If `x` is a subtype of `ndarray` the return value will be of the same type.
-
-    References
-    ----------
-    .. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng.
-       trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand
-       Reinhold Co., 1985, pg. 720.
-
-    Examples
-    --------
-    >>> np.polyval([3,0,1], 5)  # 3 * 5**2 + 0 * 5**1 + 1
-    76
-    >>> np.polyval([3,0,1], np.poly1d(5))
-    poly1d([76.])
-    >>> np.polyval(np.poly1d([3,0,1]), 5)
-    76
-    >>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5))
-    poly1d([76.])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "
-    Translates slice objects to concatenation along the first axis.
-
-    This is a simple way to build up arrays quickly. There are two use cases.
-
-    1. If the index expression contains comma separated arrays, then stack
-       them along their first axis.
-    2. If the index expression contains slice notation or scalars then create
-       a 1-D array with a range indicated by the slice notation.
-
-    If slice notation is used, the syntax ``start:stop:step`` is equivalent
-    to ``np.arange(start, stop, step)`` inside of the brackets. However, if
-    ``step`` is an imaginary number (i.e. 100j) then its integer portion is
-    interpreted as a number-of-points desired and the start and stop are
-    inclusive. In other words ``start:stop:stepj`` is interpreted as
-    ``np.linspace(start, stop, step, endpoint=1)`` inside of the brackets.
-    After expansion of slice notation, all comma separated sequences are
-    concatenated together.
-
-    Optional character strings placed as the first element of the index
-    expression can be used to change the output. The strings 'r' or 'c' result
-    in matrix output. If the result is 1-D and 'r' is specified a 1 x N (row)
-    matrix is produced. If the result is 1-D and 'c' is specified, then a N x 1
-    (column) matrix is produced. If the result is 2-D then both provide the
-    same matrix result.
-
-    A string integer specifies which axis to stack multiple comma separated
-    arrays along. A string of two comma-separated integers allows indication
-    of the minimum number of dimensions to force each entry into as the
-    second integer (the axis to concatenate along is still the first integer).
-
-    A string with three comma-separated integers allows specification of the
-    axis to concatenate along, the minimum number of dimensions to force the
-    entries to, and which axis should contain the start of the arrays which
-    are less than the specified number of dimensions. In other words the third
-    integer allows you to specify where the 1's should be placed in the shape
-    of the arrays that have their shapes upgraded. By default, they are placed
-    in the front of the shape tuple. The third argument allows you to specify
-    where the start of the array should be instead. Thus, a third argument of
-    '0' would place the 1's at the end of the array shape. Negative integers
-    specify where in the new shape tuple the last dimension of upgraded arrays
-    should be placed, so the default is '-1'.
-
-    Parameters
-    ----------
-    Not a function, so takes no parameters
-
-
-    Returns
-    -------
-    A concatenated ndarray or matrix.
-
-    See Also
-    --------
-    concatenate : Join a sequence of arrays along an existing axis.
-    c_ : Translates slice objects to concatenation along the second axis.
-
-    Examples
-    --------
-    >>> np.r_[np.array([1,2,3]), 0, 0, np.array([4,5,6])]
-    array([1, 2, 3, ..., 4, 5, 6])
-    >>> np.r_[-1:1:6j, [0]*3, 5, 6]
-    array([-1. , -0.6, -0.2,  0.2,  0.6,  1. ,  0. ,  0. ,  0. ,  5. ,  6. ])
-
-    String integers specify the axis to concatenate along or the minimum
-    number of dimensions to force entries into.
-
-    >>> a = np.array([[0, 1, 2], [3, 4, 5]])
-    >>> np.r_['-1', a, a] # concatenate along last axis
-    array([[0, 1, 2, 0, 1, 2],
-           [3, 4, 5, 3, 4, 5]])
-    >>> np.r_['0,2', [1,2,3], [4,5,6]] # concatenate along first axis, dim>=2
-    array([[1, 2, 3],
-           [4, 5, 6]])
-
-    >>> np.r_['0,2,0', [1,2,3], [4,5,6]]
-    array([[1],
-           [2],
-           [3],
-           [4],
-           [5],
-           [6]])
-    >>> np.r_['1,2,0', [1,2,3], [4,5,6]]
-    array([[1, 4],
-           [2, 5],
-           [3, 6]])
-
-    Using 'r' or 'c' as a first string argument creates a matrix.
-
-    >>> np.r_['r',[1,2,3], [4,5,6]]
-    matrix([[1, 2, 3, 4, 5, 6]])
-
-    "} r_ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "r_"))))
-
-(def ndindex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndindex"))))
-(alter-meta! #'ndindex assoc :doc "
-    An N-dimensional iterator object to index arrays.
-
-    Given the shape of an array, an `ndindex` instance iterates over
-    the N-dimensional index of the array. At each iteration a tuple
-    of indices is returned, the last dimension is iterated over first.
-
-    Parameters
-    ----------
-    `*args` : ints
-      The size of each dimension of the array.
-
-    See Also
-    --------
-    ndenumerate, flatiter
-
-    Examples
-    --------
-    >>> for index in np.ndindex(3, 2, 1):
-    ...     print(index)
-    (0, 0, 0)
-    (0, 1, 0)
-    (1, 0, 0)
-    (1, 1, 0)
-    (2, 0, 0)
-    (2, 1, 0)
-
-    " :arglists '[[self & [shape]]])
-
-(def ^{:doc ""} infty (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "infty"))))
-
-(def deprecate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "deprecate"))))
-(alter-meta! #'deprecate assoc :doc "
-    Issues a DeprecationWarning, adds warning to `old_name`'s
-    docstring, rebinds ``old_name.__name__`` and returns the new
-    function object.
-
-    This function may also be used as a decorator.
-
-    Parameters
-    ----------
-    func : function
-        The function to be deprecated.
-    old_name : str, optional
-        The name of the function to be deprecated. Default is None, in
-        which case the name of `func` is used.
-    new_name : str, optional
-        The new name for the function. Default is None, in which case the
-        deprecation message is that `old_name` is deprecated. If given, the
-        deprecation message is that `old_name` is deprecated and `new_name`
-        should be used instead.
-    message : str, optional
-        Additional explanation of the deprecation.  Displayed in the
-        docstring after the warning.
-
-    Returns
-    -------
-    old_func : function
-        The deprecated function.
-
-    Examples
-    --------
-    Note that ``olduint`` returns a value after printing Deprecation
-    Warning:
-
-    >>> olduint = np.deprecate(np.uint)
-    DeprecationWarning: `uint64` is deprecated! # may vary
-    >>> olduint(6)
-    6
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def set_printoptions (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "set_printoptions"))))
-(alter-meta! #'set_printoptions assoc :doc "
-    Set printing options.
-
-    These options determine the way floating point numbers, arrays and
-    other NumPy objects are displayed.
-
-    Parameters
-    ----------
-    precision : int or None, optional
-        Number of digits of precision for floating point output (default 8).
-        May be None if `floatmode` is not `fixed`, to print as many digits as
-        necessary to uniquely specify the value.
-    threshold : int, optional
-        Total number of array elements which trigger summarization
-        rather than full repr (default 1000).
-        To always use the full repr without summarization, pass `sys.maxsize`.
-    edgeitems : int, optional
-        Number of array items in summary at beginning and end of
-        each dimension (default 3).
-    linewidth : int, optional
-        The number of characters per line for the purpose of inserting
-        line breaks (default 75).
-    suppress : bool, optional
-        If True, always print floating point numbers using fixed point
-        notation, in which case numbers equal to zero in the current precision
-        will print as zero.  If False, then scientific notation is used when
-        absolute value of the smallest number is < 1e-4 or the ratio of the
-        maximum absolute value to the minimum is > 1e3. The default is False.
-    nanstr : str, optional
-        String representation of floating point not-a-number (default nan).
-    infstr : str, optional
-        String representation of floating point infinity (default inf).
-    sign : string, either '-', '+', or ' ', optional
-        Controls printing of the sign of floating-point types. If '+', always
-        print the sign of positive values. If ' ', always prints a space
-        (whitespace character) in the sign position of positive values.  If
-        '-', omit the sign character of positive values. (default '-')
-    formatter : dict of callables, optional
-        If not None, the keys should indicate the type(s) that the respective
-        formatting function applies to.  Callables should return a string.
-        Types that are not specified (by their corresponding keys) are handled
-        by the default formatters.  Individual types for which a formatter
-        can be set are:
-
-        - 'bool'
-        - 'int'
-        - 'timedelta' : a `numpy.timedelta64`
-        - 'datetime' : a `numpy.datetime64`
-        - 'float'
-        - 'longfloat' : 128-bit floats
-        - 'complexfloat'
-        - 'longcomplexfloat' : composed of two 128-bit floats
-        - 'numpystr' : types `numpy.string_` and `numpy.unicode_`
-        - 'object' : `np.object_` arrays
-        - 'str' : all other strings
-
-        Other keys that can be used to set a group of types at once are:
-
-        - 'all' : sets all types
-        - 'int_kind' : sets 'int'
-        - 'float_kind' : sets 'float' and 'longfloat'
-        - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
-        - 'str_kind' : sets 'str' and 'numpystr'
-    floatmode : str, optional
-        Controls the interpretation of the `precision` option for
-        floating-point types. Can take the following values
-        (default maxprec_equal):
-
-        * 'fixed': Always print exactly `precision` fractional digits,
-                even if this would print more or fewer digits than
-                necessary to specify the value uniquely.
-        * 'unique': Print the minimum number of fractional digits necessary
-                to represent each value uniquely. Different elements may
-                have a different number of digits. The value of the
-                `precision` option is ignored.
-        * 'maxprec': Print at most `precision` fractional digits, but if
-                an element can be uniquely represented with fewer digits
-                only print it with that many.
-        * 'maxprec_equal': Print at most `precision` fractional digits,
-                but if every element in the array can be uniquely
-                represented with an equal number of fewer digits, use that
-                many digits for all elements.
-    legacy : string or `False`, optional
-        If set to the string `'1.13'` enables 1.13 legacy printing mode. This
-        approximates numpy 1.13 print output by including a space in the sign
-        position of floats and different behavior for 0d arrays. If set to
-        `False`, disables legacy mode. Unrecognized strings will be ignored
-        with a warning for forward compatibility.
-
-        .. versionadded:: 1.14.0
-
-    See Also
-    --------
-    get_printoptions, printoptions, set_string_function, array2string
-
-    Notes
-    -----
-    `formatter` is always reset with a call to `set_printoptions`.
-
-    Use `printoptions` as a context manager to set the values temporarily.
-
-    Examples
-    --------
-    Floating point precision can be set:
-
-    >>> np.set_printoptions(precision=4)
-    >>> np.array([1.123456789])
-    [1.1235]
-
-    Long arrays can be summarised:
-
-    >>> np.set_printoptions(threshold=5)
-    >>> np.arange(10)
-    array([0, 1, 2, ..., 7, 8, 9])
-
-    Small results can be suppressed:
-
-    >>> eps = np.finfo(float).eps
-    >>> x = np.arange(4.)
-    >>> x**2 - (x + eps)**2
-    array([-4.9304e-32, -4.4409e-16,  0.0000e+00,  0.0000e+00])
-    >>> np.set_printoptions(suppress=True)
-    >>> x**2 - (x + eps)**2
-    array([-0., -0.,  0.,  0.])
-
-    A custom formatter can be used to display array elements as desired:
-
-    >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})
-    >>> x = np.arange(3)
-    >>> x
-    array([int: 0, int: -1, int: -2])
-    >>> np.set_printoptions()  # formatter gets reset
-    >>> x
-    array([0, 1, 2])
-
-    To put back the default options, you can use:
-
-    >>> np.set_printoptions(edgeitems=3, infstr='inf',
-    ... linewidth=75, nanstr='nan', precision=8,
-    ... suppress=False, threshold=1000, formatter=None)
-
-    Also to temporarily override options, use `printoptions` as a context manager:
-
-    >>> with np.printoptions(precision=2, suppress=True, threshold=5):
-    ...     np.linspace(0, 10, 10)
-    array([ 0.  ,  1.11,  2.22, ...,  7.78,  8.89, 10.  ])
-
-    " :arglists '[[& [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, sign :sign, formatter :formatter, precision :precision, floatmode :floatmode, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}]] [& [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, sign :sign, formatter :formatter, precision :precision, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}]] [& [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, formatter :formatter, precision :precision, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, nanstr :nanstr, infstr :infstr, :as kwarg}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, nanstr :nanstr, :as kwarg}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, :as kwarg}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, :as kwarg}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, :as kwarg}]] [& [{precision :precision, threshold :threshold, :as kwarg}]] [& [{precision :precision, :as kwarg}]] [& [{:as kwarg}]]])
-
-(def pad (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "pad"))))
-(alter-meta! #'pad assoc :doc "
-    Pad an array.
-
-    Parameters
-    ----------
-    array : array_like of rank N
-        The array to pad.
-    pad_width : {sequence, array_like, int}
-        Number of values padded to the edges of each axis.
-        ((before_1, after_1), ... (before_N, after_N)) unique pad widths
-        for each axis.
-        ((before, after),) yields same before and after pad for each axis.
-        (pad,) or int is a shortcut for before = after = pad width for all
-        axes.
-    mode : str or function, optional
-        One of the following string values or a user supplied function.
-
-        'constant' (default)
-            Pads with a constant value.
-        'edge'
-            Pads with the edge values of array.
-        'linear_ramp'
-            Pads with the linear ramp between end_value and the
-            array edge value.
-        'maximum'
-            Pads with the maximum value of all or part of the
-            vector along each axis.
-        'mean'
-            Pads with the mean value of all or part of the
-            vector along each axis.
-        'median'
-            Pads with the median value of all or part of the
-            vector along each axis.
-        'minimum'
-            Pads with the minimum value of all or part of the
-            vector along each axis.
-        'reflect'
-            Pads with the reflection of the vector mirrored on
-            the first and last values of the vector along each
-            axis.
-        'symmetric'
-            Pads with the reflection of the vector mirrored
-            along the edge of the array.
-        'wrap'
-            Pads with the wrap of the vector along the axis.
-            The first values are used to pad the end and the
-            end values are used to pad the beginning.
-        'empty'
-            Pads with undefined values.
-
-            .. versionadded:: 1.17
-
-        <function>
-            Padding function, see Notes.
-    stat_length : sequence or int, optional
-        Used in 'maximum', 'mean', 'median', and 'minimum'.  Number of
-        values at edge of each axis used to calculate the statistic value.
-
-        ((before_1, after_1), ... (before_N, after_N)) unique statistic
-        lengths for each axis.
-
-        ((before, after),) yields same before and after statistic lengths
-        for each axis.
-
-        (stat_length,) or int is a shortcut for before = after = statistic
-        length for all axes.
-
-        Default is ``None``, to use the entire axis.
-    constant_values : sequence or scalar, optional
-        Used in 'constant'.  The values to set the padded values for each
-        axis.
-
-        ``((before_1, after_1), ... (before_N, after_N))`` unique pad constants
-        for each axis.
-
-        ``((before, after),)`` yields same before and after constants for each
-        axis.
-
-        ``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
-        all axes.
-
-        Default is 0.
-    end_values : sequence or scalar, optional
-        Used in 'linear_ramp'.  The values used for the ending value of the
-        linear_ramp and that will form the edge of the padded array.
-
-        ``((before_1, after_1), ... (before_N, after_N))`` unique end values
-        for each axis.
-
-        ``((before, after),)`` yields same before and after end values for each
-        axis.
-
-        ``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
-        all axes.
-
-        Default is 0.
-    reflect_type : {'even', 'odd'}, optional
-        Used in 'reflect', and 'symmetric'.  The 'even' style is the
-        default with an unaltered reflection around the edge value.  For
-        the 'odd' style, the extended part of the array is created by
-        subtracting the reflected values from two times the edge value.
-
-    Returns
-    -------
-    pad : ndarray
-        Padded array of rank equal to `array` with shape increased
-        according to `pad_width`.
-
-    Notes
-    -----
-    .. versionadded:: 1.7.0
-
-    For an array with rank greater than 1, some of the padding of later
-    axes is calculated from padding of previous axes.  This is easiest to
-    think about with a rank 2 array where the corners of the padded array
-    are calculated by using padded values from the first axis.
-
-    The padding function, if used, should modify a rank 1 array in-place. It
-    has the following signature::
-
-        padding_func(vector, iaxis_pad_width, iaxis, kwargs)
-
-    where
-
-        vector : ndarray
-            A rank 1 array already padded with zeros.  Padded values are
-            vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:].
-        iaxis_pad_width : tuple
-            A 2-tuple of ints, iaxis_pad_width[0] represents the number of
-            values padded at the beginning of vector where
-            iaxis_pad_width[1] represents the number of values padded at
-            the end of vector.
-        iaxis : int
-            The axis currently being calculated.
-        kwargs : dict
-            Any keyword arguments the function requires.
-
-    Examples
-    --------
-    >>> a = [1, 2, 3, 4, 5]
-    >>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6))
-    array([4, 4, 1, ..., 6, 6, 6])
-
-    >>> np.pad(a, (2, 3), 'edge')
-    array([1, 1, 1, ..., 5, 5, 5])
-
-    >>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
-    array([ 5,  3,  1,  2,  3,  4,  5,  2, -1, -4])
-
-    >>> np.pad(a, (2,), 'maximum')
-    array([5, 5, 1, 2, 3, 4, 5, 5, 5])
-
-    >>> np.pad(a, (2,), 'mean')
-    array([3, 3, 1, 2, 3, 4, 5, 3, 3])
-
-    >>> np.pad(a, (2,), 'median')
-    array([3, 3, 1, 2, 3, 4, 5, 3, 3])
-
-    >>> a = [[1, 2], [3, 4]]
-    >>> np.pad(a, ((3, 2), (2, 3)), 'minimum')
-    array([[1, 1, 1, 2, 1, 1, 1],
-           [1, 1, 1, 2, 1, 1, 1],
-           [1, 1, 1, 2, 1, 1, 1],
-           [1, 1, 1, 2, 1, 1, 1],
-           [3, 3, 3, 4, 3, 3, 3],
-           [1, 1, 1, 2, 1, 1, 1],
-           [1, 1, 1, 2, 1, 1, 1]])
-
-    >>> a = [1, 2, 3, 4, 5]
-    >>> np.pad(a, (2, 3), 'reflect')
-    array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
-
-    >>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')
-    array([-1,  0,  1,  2,  3,  4,  5,  6,  7,  8])
-
-    >>> np.pad(a, (2, 3), 'symmetric')
-    array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
-
-    >>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
-    array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
-
-    >>> np.pad(a, (2, 3), 'wrap')
-    array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])
-
-    >>> def pad_with(vector, pad_width, iaxis, kwargs):
-    ...     pad_value = kwargs.get('padder', 10)
-    ...     vector[:pad_width[0]] = pad_value
-    ...     vector[-pad_width[1]:] = pad_value
-    >>> a = np.arange(6)
-    >>> a = a.reshape((2, 3))
-    >>> np.pad(a, 2, pad_with)
-    array([[10, 10, 10, 10, 10, 10, 10],
-           [10, 10, 10, 10, 10, 10, 10],
-           [10, 10,  0,  1,  2, 10, 10],
-           [10, 10,  3,  4,  5, 10, 10],
-           [10, 10, 10, 10, 10, 10, 10],
-           [10, 10, 10, 10, 10, 10, 10]])
-    >>> np.pad(a, 2, pad_with, padder=100)
-    array([[100, 100, 100, 100, 100, 100, 100],
-           [100, 100, 100, 100, 100, 100, 100],
-           [100, 100,   0,   1,   2, 100, 100],
-           [100, 100,   3,   4,   5, 100, 100],
-           [100, 100, 100, 100, 100, 100, 100],
-           [100, 100, 100, 100, 100, 100, 100]])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} typeNA (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "typeNA"))))
-
-(def who (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "who"))))
-(alter-meta! #'who assoc :doc "
-    Print the NumPy arrays in the given dictionary.
-
-    If there is no dictionary passed in or `vardict` is None then returns
-    NumPy arrays in the globals() dictionary (all NumPy arrays in the
-    namespace).
-
-    Parameters
-    ----------
-    vardict : dict, optional
-        A dictionary possibly containing ndarrays.  Default is globals().
-
-    Returns
-    -------
-    out : None
-        Returns 'None'.
-
-    Notes
-    -----
-    Prints out the name, shape, bytes and type of all of the ndarrays
-    present in `vardict`.
-
-    Examples
-    --------
-    >>> a = np.arange(10)
-    >>> b = np.ones(20)
-    >>> np.who()
-    Name            Shape            Bytes            Type
-    ===========================================================
-    a               10               80               int64
-    b               20               160              float64
-    Upper bound on total bytes  =       240
-
-    >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',
-    ... 'idx':5}
-    >>> np.who(d)
-    Name            Shape            Bytes            Type
-    ===========================================================
-    x               2                16               float64
-    y               3                24               float64
-    Upper bound on total bytes  =       40
-
-    " :arglists '[[& [{vardict :vardict}]] []])
-
-(def histogram_bin_edges (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogram_bin_edges"))))
-(alter-meta! #'histogram_bin_edges assoc :doc "
-    Function to calculate only the edges of the bins used by the `histogram`
-    function.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data. The histogram is computed over the flattened array.
-    bins : int or sequence of scalars or str, optional
-        If `bins` is an int, it defines the number of equal-width
-        bins in the given range (10, by default). If `bins` is a
-        sequence, it defines the bin edges, including the rightmost
-        edge, allowing for non-uniform bin widths.
-
-        If `bins` is a string from the list below, `histogram_bin_edges` will use
-        the method chosen to calculate the optimal bin width and
-        consequently the number of bins (see `Notes` for more detail on
-        the estimators) from the data that falls within the requested
-        range. While the bin width will be optimal for the actual data
-        in the range, the number of bins will be computed to fill the
-        entire range, including the empty portions. For visualisation,
-        using the 'auto' option is suggested. Weighted data is not
-        supported for automated bin size selection.
-
-        'auto'
-            Maximum of the 'sturges' and 'fd' estimators. Provides good
-            all around performance.
-
-        'fd' (Freedman Diaconis Estimator)
-            Robust (resilient to outliers) estimator that takes into
-            account data variability and data size.
-
-        'doane'
-            An improved version of Sturges' estimator that works better
-            with non-normal datasets.
-
-        'scott'
-            Less robust estimator that that takes into account data
-            variability and data size.
-
-        'stone'
-            Estimator based on leave-one-out cross-validation estimate of
-            the integrated squared error. Can be regarded as a generalization
-            of Scott's rule.
-
-        'rice'
-            Estimator does not take variability into account, only data
-            size. Commonly overestimates number of bins required.
-
-        'sturges'
-            R's default method, only accounts for data size. Only
-            optimal for gaussian data and underestimates number of bins
-            for large non-gaussian datasets.
-
-        'sqrt'
-            Square root (of data size) estimator, used by Excel and
-            other programs for its speed and simplicity.
-
-    range : (float, float), optional
-        The lower and upper range of the bins.  If not provided, range
-        is simply ``(a.min(), a.max())``.  Values outside the range are
-        ignored. The first element of the range must be less than or
-        equal to the second. `range` affects the automatic bin
-        computation as well. While bin width is computed to be optimal
-        based on the actual data within `range`, the bin count will fill
-        the entire range including portions containing no data.
-
-    weights : array_like, optional
-        An array of weights, of the same shape as `a`.  Each value in
-        `a` only contributes its associated weight towards the bin count
-        (instead of 1). This is currently not used by any of the bin estimators,
-        but may be in the future.
-
-    Returns
-    -------
-    bin_edges : array of dtype float
-        The edges to pass into `histogram`
-
-    See Also
-    --------
-    histogram
-
-    Notes
-    -----
-    The methods to estimate the optimal number of bins are well founded
-    in literature, and are inspired by the choices R provides for
-    histogram visualisation. Note that having the number of bins
-    proportional to :math:`n^{1/3}` is asymptotically optimal, which is
-    why it appears in most estimators. These are simply plug-in methods
-    that give good starting points for number of bins. In the equations
-    below, :math:`h` is the binwidth and :math:`n_h` is the number of
-    bins. All estimators that compute bin counts are recast to bin width
-    using the `ptp` of the data. The final bin count is obtained from
-    ``np.round(np.ceil(range / h))``.
-
-    'auto' (maximum of the 'sturges' and 'fd' estimators)
-        A compromise to get a good value. For small datasets the Sturges
-        value will usually be chosen, while larger datasets will usually
-        default to FD.  Avoids the overly conservative behaviour of FD
-        and Sturges for small and large datasets respectively.
-        Switchover point is usually :math:`a.size \\approx 1000`.
-
-    'fd' (Freedman Diaconis Estimator)
-        .. math:: h = 2 \\frac{IQR}{n^{1/3}}
-
-        The binwidth is proportional to the interquartile range (IQR)
-        and inversely proportional to cube root of a.size. Can be too
-        conservative for small datasets, but is quite good for large
-        datasets. The IQR is very robust to outliers.
-
-    'scott'
-        .. math:: h = \\sigma \\sqrt[3]{\\frac{24 * \\sqrt{\\pi}}{n}}
-
-        The binwidth is proportional to the standard deviation of the
-        data and inversely proportional to cube root of ``x.size``. Can
-        be too conservative for small datasets, but is quite good for
-        large datasets. The standard deviation is not very robust to
-        outliers. Values are very similar to the Freedman-Diaconis
-        estimator in the absence of outliers.
-
-    'rice'
-        .. math:: n_h = 2n^{1/3}
-
-        The number of bins is only proportional to cube root of
-        ``a.size``. It tends to overestimate the number of bins and it
-        does not take into account data variability.
-
-    'sturges'
-        .. math:: n_h = \\log _{2}n+1
-
-        The number of bins is the base 2 log of ``a.size``.  This
-        estimator assumes normality of data and is too conservative for
-        larger, non-normal datasets. This is the default method in R's
-        ``hist`` method.
-
-    'doane'
-        .. math:: n_h = 1 + \\log_{2}(n) +
-                        \\log_{2}(1 + \\frac{|g_1|}{\\sigma_{g_1}})
-
-            g_1 = mean[(\\frac{x - \\mu}{\\sigma})^3]
-
-            \\sigma_{g_1} = \\sqrt{\\frac{6(n - 2)}{(n + 1)(n + 3)}}
-
-        An improved version of Sturges' formula that produces better
-        estimates for non-normal datasets. This estimator attempts to
-        account for the skew of the data.
-
-    'sqrt'
-        .. math:: n_h = \\sqrt n
-
-        The simplest and fastest estimator. Only takes into account the
-        data size.
-
-    Examples
-    --------
-    >>> arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5])
-    >>> np.histogram_bin_edges(arr, bins='auto', range=(0, 1))
-    array([0.  , 0.25, 0.5 , 0.75, 1.  ])
-    >>> np.histogram_bin_edges(arr, bins=2)
-    array([0. , 2.5, 5. ])
-
-    For consistency with histogram, an array of pre-computed bins is
-    passed through unmodified:
-
-    >>> np.histogram_bin_edges(arr, [1, 2])
-    array([1, 2])
-
-    This function allows one set of bins to be computed, and reused across
-    multiple histograms:
-
-    >>> shared_bins = np.histogram_bin_edges(arr, bins='auto')
-    >>> shared_bins
-    array([0., 1., 2., 3., 4., 5.])
-
-    >>> group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1])
-    >>> hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins)
-    >>> hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins)
-
-    >>> hist_0; hist_1
-    array([1, 1, 0, 1, 0])
-    array([2, 0, 1, 1, 2])
-
-    Which gives more easily comparable results than using separate bins for
-    each histogram:
-
-    >>> hist_0, bins_0 = np.histogram(arr[group_id == 0], bins='auto')
-    >>> hist_1, bins_1 = np.histogram(arr[group_id == 1], bins='auto')
-    >>> hist_0; hist_1
-    array([1, 1, 1])
-    array([2, 1, 1, 2])
-    >>> bins_0; bins_1
-    array([0., 1., 2., 3.])
-    array([0.  , 1.25, 2.5 , 3.75, 5.  ])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def std (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "std"))))
-(alter-meta! #'std assoc :doc "
-    Compute the standard deviation along the specified axis.
-
-    Returns the standard deviation, a measure of the spread of a distribution,
-    of the array elements. The standard deviation is computed for the
-    flattened array by default, otherwise over the specified axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Calculate the standard deviation of these values.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which the standard deviation is computed. The
-        default is to compute the standard deviation of the flattened array.
-
-        .. versionadded:: 1.7.0
-
-        If this is a tuple of ints, a standard deviation is performed over
-        multiple axes, instead of a single axis or all the axes as before.
-    dtype : dtype, optional
-        Type to use in computing the standard deviation. For arrays of
-        integer type the default is float64, for arrays of float types it is
-        the same as the array type.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must have
-        the same shape as the expected output but the type (of the calculated
-        values) will be cast if necessary.
-    ddof : int, optional
-        Means Delta Degrees of Freedom.  The divisor used in calculations
-        is ``N - ddof``, where ``N`` represents the number of elements.
-        By default `ddof` is zero.
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `std` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-
-    Returns
-    -------
-    standard_deviation : ndarray, see dtype parameter above.
-        If `out` is None, return a new array containing the standard deviation,
-        otherwise return a reference to the output array.
-
-    See Also
-    --------
-    var, mean, nanmean, nanstd, nanvar
-    ufuncs-output-type
-
-    Notes
-    -----
-    The standard deviation is the square root of the average of the squared
-    deviations from the mean, i.e., ``std = sqrt(mean(abs(x - x.mean())**2))``.
-
-    The average squared deviation is normally calculated as
-    ``x.sum() / N``, where ``N = len(x)``.  If, however, `ddof` is specified,
-    the divisor ``N - ddof`` is used instead. In standard statistical
-    practice, ``ddof=1`` provides an unbiased estimator of the variance
-    of the infinite population. ``ddof=0`` provides a maximum likelihood
-    estimate of the variance for normally distributed variables. The
-    standard deviation computed in this function is the square root of
-    the estimated variance, so even with ``ddof=1``, it will not be an
-    unbiased estimate of the standard deviation per se.
-
-    Note that, for complex numbers, `std` takes the absolute
-    value before squaring, so that the result is always real and nonnegative.
-
-    For floating-point input, the *std* is computed using the same
-    precision the input has. Depending on the input data, this can cause
-    the results to be inaccurate, especially for float32 (see example below).
-    Specifying a higher-accuracy accumulator using the `dtype` keyword can
-    alleviate this issue.
-
-    Examples
-    --------
-    >>> a = np.array([[1, 2], [3, 4]])
-    >>> np.std(a)
-    1.1180339887498949 # may vary
-    >>> np.std(a, axis=0)
-    array([1.,  1.])
-    >>> np.std(a, axis=1)
-    array([0.5,  0.5])
-
-    In single precision, std() can be inaccurate:
-
-    >>> a = np.zeros((2, 512*512), dtype=np.float32)
-    >>> a[0, :] = 1.0
-    >>> a[1, :] = 0.1
-    >>> np.std(a)
-    0.45000005
-
-    Computing the standard deviation in float64 is more accurate:
-
-    >>> np.std(a, dtype=np.float64)
-    0.44999999925494177 # may vary
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def isneginf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isneginf"))))
-(alter-meta! #'isneginf assoc :doc "
-    Test element-wise for negative infinity, return result as bool array.
-
-    Parameters
-    ----------
-    x : array_like
-        The input array.
-    out : array_like, optional
-        A boolean array with the same shape and type as `x` to store the
-        result.
-
-    Returns
-    -------
-    out : ndarray
-        A boolean array with the same dimensions as the input.
-        If second argument is not supplied then a numpy boolean array is
-        returned with values True where the corresponding element of the
-        input is negative infinity and values False where the element of
-        the input is not negative infinity.
-
-        If a second argument is supplied the result is stored there. If the
-        type of that array is a numeric type the result is represented as
-        zeros and ones, if the type is boolean then as False and True. The
-        return value `out` is then a reference to that array.
-
-    See Also
-    --------
-    isinf, isposinf, isnan, isfinite
-
-    Notes
-    -----
-    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
-    (IEEE 754).
-
-    Errors result if the second argument is also supplied when x is a scalar
-    input, if first and second arguments have different shapes, or if the
-    first argument has complex values.
-
-    Examples
-    --------
-    >>> np.isneginf(np.NINF)
-    True
-    >>> np.isneginf(np.inf)
-    False
-    >>> np.isneginf(np.PINF)
-    False
-    >>> np.isneginf([-np.inf, 0., np.inf])
-    array([ True, False, False])
-
-    >>> x = np.array([-np.inf, 0., np.inf])
-    >>> y = np.array([2, 2, 2])
-    >>> np.isneginf(x, y)
-    array([1, 0, 0])
-    >>> y
-    array([1, 0, 0])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def fix (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fix"))))
-(alter-meta! #'fix assoc :doc "
-    Round to nearest integer towards zero.
-
-    Round an array of floats element-wise to nearest integer towards zero.
-    The rounded values are returned as floats.
-
-    Parameters
-    ----------
-    x : array_like
-        An array of floats to be rounded
-    y : ndarray, optional
-        Output array
-
-    Returns
-    -------
-    out : ndarray of floats
-        The array of rounded numbers
-
-    See Also
-    --------
-    trunc, floor, ceil
-    around : Round to given number of decimals
-
-    Examples
-    --------
-    >>> np.fix(3.14)
-    3.0
-    >>> np.fix(3)
-    3.0
-    >>> np.fix([2.1, 2.9, -2.1, -2.9])
-    array([ 2.,  2., -2., -2.])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ones (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ones"))))
-(alter-meta! #'ones assoc :doc "
-    Return a new array of given shape and type, filled with ones.
-
-    Parameters
-    ----------
-    shape : int or sequence of ints
-        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
-    dtype : data-type, optional
-        The desired data-type for the array, e.g., `numpy.int8`.  Default is
-        `numpy.float64`.
-    order : {'C', 'F'}, optional, default: C
-        Whether to store multi-dimensional data in row-major
-        (C-style) or column-major (Fortran-style) order in
-        memory.
-
-    Returns
-    -------
-    out : ndarray
-        Array of ones with the given shape, dtype, and order.
-
-    See Also
-    --------
-    ones_like : Return an array of ones with shape and type of input.
-    empty : Return a new uninitialized array.
-    zeros : Return a new array setting values to zero.
-    full : Return a new array of given shape filled with value.
-
-
-    Examples
-    --------
-    >>> np.ones(5)
-    array([1., 1., 1., 1., 1.])
-
-    >>> np.ones((5,), dtype=int)
-    array([1, 1, 1, 1, 1])
-
-    >>> np.ones((2, 1))
-    array([[1.],
-           [1.]])
-
-    >>> s = (2,2)
-    >>> np.ones(s)
-    array([[1.,  1.],
-           [1.,  1.]])
-
-    " :arglists '[[shape & [{dtype :dtype, order :order}]] [shape & [{dtype :dtype}]] [shape]])
-
-(def squeeze (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "squeeze"))))
-(alter-meta! #'squeeze assoc :doc "
-    Remove single-dimensional entries from the shape of an array.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-    axis : None or int or tuple of ints, optional
-        .. versionadded:: 1.7.0
-
-        Selects a subset of the single-dimensional entries in the
-        shape. If an axis is selected with shape entry greater than
-        one, an error is raised.
-
-    Returns
-    -------
-    squeezed : ndarray
-        The input array, but with all or a subset of the
-        dimensions of length 1 removed. This is always `a` itself
-        or a view into `a`.
-
-    Raises
-    ------
-    ValueError
-        If `axis` is not None, and an axis being squeezed is not of length 1
-
-    See Also
-    --------
-    expand_dims : The inverse operation, adding singleton dimensions
-    reshape : Insert, remove, and combine dimensions, and resize existing ones
-
-    Examples
-    --------
-    >>> x = np.array([[[0], [1], [2]]])
-    >>> x.shape
-    (1, 3, 1)
-    >>> np.squeeze(x).shape
-    (3,)
-    >>> np.squeeze(x, axis=0).shape
-    (3, 1)
-    >>> np.squeeze(x, axis=1).shape
-    Traceback (most recent call last):
-    ...
-    ValueError: cannot select an axis to squeeze out which has size not equal to one
-    >>> np.squeeze(x, axis=2).shape
-    (1, 3)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def format_parser (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "format_parser"))))
-(alter-meta! #'format_parser assoc :doc "
-    Class to convert formats, names, titles description to a dtype.
-
-    After constructing the format_parser object, the dtype attribute is
-    the converted data-type:
-    ``dtype = format_parser(formats, names, titles).dtype``
-
-    Attributes
-    ----------
-    dtype : dtype
-        The converted data-type.
-
-    Parameters
-    ----------
-    formats : str or list of str
-        The format description, either specified as a string with
-        comma-separated format descriptions in the form ``'f8, i4, a5'``, or
-        a list of format description strings  in the form
-        ``['f8', 'i4', 'a5']``.
-    names : str or list/tuple of str
-        The field names, either specified as a comma-separated string in the
-        form ``'col1, col2, col3'``, or as a list or tuple of strings in the
-        form ``['col1', 'col2', 'col3']``.
-        An empty list can be used, in that case default field names
-        ('f0', 'f1', ...) are used.
-    titles : sequence
-        Sequence of title strings. An empty list can be used to leave titles
-        out.
-    aligned : bool, optional
-        If True, align the fields by padding as the C-compiler would.
-        Default is False.
-    byteorder : str, optional
-        If specified, all the fields will be changed to the
-        provided byte-order.  Otherwise, the default byte-order is
-        used. For all available string specifiers, see `dtype.newbyteorder`.
-
-    See Also
-    --------
-    dtype, typename, sctype2char
-
-    Examples
-    --------
-    >>> np.format_parser(['<f8', '<i4', '<a5'], ['col1', 'col2', 'col3'],
-    ...                  ['T1', 'T2', 'T3']).dtype
-    dtype([(('T1', 'col1'), '<f8'), (('T2', 'col2'), '<i4'), (('T3', 'col3'), 'S5')])
-
-    `names` and/or `titles` can be empty lists. If `titles` is an empty list,
-    titles will simply not appear. If `names` is empty, default field names
-    will be used.
-
-    >>> np.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'],
-    ...                  []).dtype
-    dtype([('col1', '<f8'), ('col2', '<i4'), ('col3', '<S5')])
-    >>> np.format_parser(['<f8', '<i4', '<a5'], [], []).dtype
-    dtype([('f0', '<f8'), ('f1', '<i4'), ('f2', 'S5')])
-
-    " :arglists '[[self formats names titles & [{aligned :aligned, byteorder :byteorder}]] [self formats names titles & [{aligned :aligned}]] [self formats names titles]])
-
-(def add_newdoc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add_newdoc"))))
-(alter-meta! #'add_newdoc assoc :doc "
-    Add documentation to an existing object, typically one defined in C
-
-    The purpose is to allow easier editing of the docstrings without requiring
-    a re-compile. This exists primarily for internal use within numpy itself.
-
-    Parameters
-    ----------
-    place : str
-        The absolute name of the module to import from
-    obj : str
-        The name of the object to add documentation to, typically a class or
-        function name
-    doc : {str, Tuple[str, str], List[Tuple[str, str]]}
-        If a string, the documentation to apply to `obj`
-
-        If a tuple, then the first element is interpreted as an attribute of
-        `obj` and the second as the docstring to apply - ``(method, docstring)``
-
-        If a list, then each element of the list should be a tuple of length
-        two - ``[(method1, docstring1), (method2, docstring2), ...]``
-    warn_on_python : bool
-        If True, the default, emit `UserWarning` if this is used to attach
-        documentation to a pure-python object.
-
-    Notes
-    -----
-    This routine never raises an error if the docstring can't be written, but
-    will raise an error if the object being documented does not exist.
-
-    This routine cannot modify read-only docstrings, as appear
-    in new-style classes or built-in functions. Because this
-    routine never raises an error the caller must check manually
-    that the docstrings were changed.
-
-    Since this function grabs the ``char *`` from a c-level str object and puts
-    it into the ``tp_doc`` slot of the type of `obj`, it violates a number of
-    C-API best-practices, by:
-
-    - modifying a `PyTypeObject` after calling `PyType_Ready`
-    - calling `Py_INCREF` on the str and losing the reference, so the str
-      will never be released
-
-    If possible it should be avoided.
-    " :arglists '[[place obj doc & [{warn_on_python :warn_on_python}]] [place obj doc]])
-
-(def ^{:doc ""} absolute_import (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "absolute_import"))))
-
-(def ^{:doc "Sub-package containing the matrix class and related functions.
-
-"} _mat (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_mat"))))
-
-(def float32 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float32"))))
-(alter-meta! #'float32 assoc :doc "Single-precision floating-point number type, compatible with C ``float``.
-    Character code: ``'f'``.
-    Canonical name: ``np.single``.
-    Alias *on this platform*: ``np.float32``: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
-
-(def gradient (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "gradient"))))
-(alter-meta! #'gradient assoc :doc "
-    Return the gradient of an N-dimensional array.
-
-    The gradient is computed using second order accurate central differences
-    in the interior points and either first or second order accurate one-sides
-    (forward or backwards) differences at the boundaries.
-    The returned gradient hence has the same shape as the input array.
-
-    Parameters
-    ----------
-    f : array_like
-        An N-dimensional array containing samples of a scalar function.
-    varargs : list of scalar or array, optional
-        Spacing between f values. Default unitary spacing for all dimensions.
-        Spacing can be specified using:
-
-        1. single scalar to specify a sample distance for all dimensions.
-        2. N scalars to specify a constant sample distance for each dimension.
-           i.e. `dx`, `dy`, `dz`, ...
-        3. N arrays to specify the coordinates of the values along each
-           dimension of F. The length of the array must match the size of
-           the corresponding dimension
-        4. Any combination of N scalars/arrays with the meaning of 2. and 3.
-
-        If `axis` is given, the number of varargs must equal the number of axes.
-        Default: 1.
-
-    edge_order : {1, 2}, optional
-        Gradient is calculated using N-th order accurate differences
-        at the boundaries. Default: 1.
-
-        .. versionadded:: 1.9.1
-
-    axis : None or int or tuple of ints, optional
-        Gradient is calculated only along the given axis or axes
-        The default (axis = None) is to calculate the gradient for all the axes
-        of the input array. axis may be negative, in which case it counts from
-        the last to the first axis.
-
-        .. versionadded:: 1.11.0
-
-    Returns
-    -------
-    gradient : ndarray or list of ndarray
-        A set of ndarrays (or a single ndarray if there is only one dimension)
-        corresponding to the derivatives of f with respect to each dimension.
-        Each derivative has the same shape as f.
-
-    Examples
-    --------
-    >>> f = np.array([1, 2, 4, 7, 11, 16], dtype=float)
-    >>> np.gradient(f)
-    array([1. , 1.5, 2.5, 3.5, 4.5, 5. ])
-    >>> np.gradient(f, 2)
-    array([0.5 ,  0.75,  1.25,  1.75,  2.25,  2.5 ])
-
-    Spacing can be also specified with an array that represents the coordinates
-    of the values F along the dimensions.
-    For instance a uniform spacing:
-
-    >>> x = np.arange(f.size)
-    >>> np.gradient(f, x)
-    array([1. ,  1.5,  2.5,  3.5,  4.5,  5. ])
-
-    Or a non uniform one:
-
-    >>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float)
-    >>> np.gradient(f, x)
-    array([1. ,  3. ,  3.5,  6.7,  6.9,  2.5])
-
-    For two dimensional arrays, the return will be two arrays ordered by
-    axis. In this example the first array stands for the gradient in
-    rows and the second one in columns direction:
-
-    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float))
-    [array([[ 2.,  2., -1.],
-           [ 2.,  2., -1.]]), array([[1. , 2.5, 4. ],
-           [1. , 1. , 1. ]])]
-
-    In this example the spacing is also specified:
-    uniform for axis=0 and non uniform for axis=1
-
-    >>> dx = 2.
-    >>> y = [1., 1.5, 3.5]
-    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y)
-    [array([[ 1. ,  1. , -0.5],
-           [ 1. ,  1. , -0.5]]), array([[2. , 2. , 2. ],
-           [2. , 1.7, 0.5]])]
-
-    It is possible to specify how boundaries are treated using `edge_order`
-
-    >>> x = np.array([0, 1, 2, 3, 4])
-    >>> f = x**2
-    >>> np.gradient(f, edge_order=1)
-    array([1.,  2.,  4.,  6.,  7.])
-    >>> np.gradient(f, edge_order=2)
-    array([0., 2., 4., 6., 8.])
-
-    The `axis` keyword can be used to specify a subset of axes of which the
-    gradient is calculated
-
-    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0)
-    array([[ 2.,  2., -1.],
-           [ 2.,  2., -1.]])
-
-    Notes
-    -----
-    Assuming that :math:`f\\in C^{3}` (i.e., :math:`f` has at least 3 continuous
-    derivatives) and let :math:`h_{*}` be a non-homogeneous stepsize, we
-    minimize the \"consistency error\" :math:`\\eta_{i}` between the true gradient
-    and its estimate from a linear combination of the neighboring grid-points:
-
-    .. math::
-
-        \\eta_{i} = f_{i}^{\\left(1\\right)} -
-                    \\left[ \\alpha f\\left(x_{i}\\right) +
-                            \\beta f\\left(x_{i} + h_{d}\\right) +
-                            \\gamma f\\left(x_{i}-h_{s}\\right)
-                    \\right]
-
-    By substituting :math:`f(x_{i} + h_{d})` and :math:`f(x_{i} - h_{s})`
-    with their Taylor series expansion, this translates into solving
-    the following the linear system:
-
-    .. math::
-
-        \\left\\{
-            \\begin{array}{r}
-                \\alpha+\\beta+\\gamma=0 \\\\
-                \\beta h_{d}-\\gamma h_{s}=1 \\\\
-                \\beta h_{d}^{2}+\\gamma h_{s}^{2}=0
-            \\end{array}
-        \\right.
-
-    The resulting approximation of :math:`f_{i}^{(1)}` is the following:
-
-    .. math::
-
-        \\hat f_{i}^{(1)} =
-            \\frac{
-                h_{s}^{2}f\\left(x_{i} + h_{d}\\right)
-                + \\left(h_{d}^{2} - h_{s}^{2}\\right)f\\left(x_{i}\\right)
-                - h_{d}^{2}f\\left(x_{i}-h_{s}\\right)}
-                { h_{s}h_{d}\\left(h_{d} + h_{s}\\right)}
-            + \\mathcal{O}\\left(\\frac{h_{d}h_{s}^{2}
-                                + h_{s}h_{d}^{2}}{h_{d}
-                                + h_{s}}\\right)
-
-    It is worth noting that if :math:`h_{s}=h_{d}`
-    (i.e., data are evenly spaced)
-    we find the standard second order approximation:
-
-    .. math::
-
-        \\hat f_{i}^{(1)}=
-            \\frac{f\\left(x_{i+1}\\right) - f\\left(x_{i-1}\\right)}{2h}
-            + \\mathcal{O}\\left(h^{2}\\right)
-
-    With a similar procedure the forward/backward approximations used for
-    boundaries can be derived.
-
-    References
-    ----------
-    .. [1]  Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics
-            (Texts in Applied Mathematics). New York: Springer.
-    .. [2]  Durran D. R. (1999) Numerical Methods for Wave Equations
-            in Geophysical Fluid Dynamics. New York: Springer.
-    .. [3]  Fornberg B. (1988) Generation of Finite Difference Formulas on
-            Arbitrarily Spaced Grids,
-            Mathematics of Computation 51, no. 184 : 699-706.
-            `PDF <http://www.ams.org/journals/mcom/1988-51-184/
-            S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_.
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def obj2sctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "obj2sctype"))))
-(alter-meta! #'obj2sctype assoc :doc "
-    Return the scalar dtype or NumPy equivalent of Python type of an object.
-
-    Parameters
-    ----------
-    rep : any
-        The object of which the type is returned.
-    default : any, optional
-        If given, this is returned for objects whose types can not be
-        determined. If not given, None is returned for those objects.
-
-    Returns
-    -------
-    dtype : dtype or Python type
-        The data type of `rep`.
-
-    See Also
-    --------
-    sctype2char, issctype, issubsctype, issubdtype, maximum_sctype
-
-    Examples
-    --------
-    >>> np.obj2sctype(np.int32)
-    <class 'numpy.int32'>
-    >>> np.obj2sctype(np.array([1., 2.]))
-    <class 'numpy.float64'>
-    >>> np.obj2sctype(np.array([1.j]))
-    <class 'numpy.complex128'>
-
-    >>> np.obj2sctype(dict)
-    <class 'numpy.object_'>
-    >>> np.obj2sctype('string')
-
-    >>> np.obj2sctype(1, default=list)
-    <class 'list'>
-
-    " :arglists '[[rep & [{default :default}]] [rep]])
-
-(def ^{:doc "
-    Base object for a dictionary for look-up with any alias for an array dtype.
-
-    Instances of `_typedict` can not be used as dictionaries directly,
-    first they have to be populated.
-
-    "} cast (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "cast"))))
-
-(def find_common_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "find_common_type"))))
-(alter-meta! #'find_common_type assoc :doc "
-    Determine common type following standard coercion rules.
-
-    Parameters
-    ----------
-    array_types : sequence
-        A list of dtypes or dtype convertible objects representing arrays.
-    scalar_types : sequence
-        A list of dtypes or dtype convertible objects representing scalars.
-
-    Returns
-    -------
-    datatype : dtype
-        The common data type, which is the maximum of `array_types` ignoring
-        `scalar_types`, unless the maximum of `scalar_types` is of a
-        different kind (`dtype.kind`). If the kind is not understood, then
-        None is returned.
-
-    See Also
-    --------
-    dtype, common_type, can_cast, mintypecode
-
-    Examples
-    --------
-    >>> np.find_common_type([], [np.int64, np.float32, complex])
-    dtype('complex128')
-    >>> np.find_common_type([np.int64, np.float32], [])
-    dtype('float64')
-
-    The standard casting rules ensure that a scalar cannot up-cast an
-    array unless the scalar is of a fundamentally different kind of data
-    (i.e. under a different hierarchy in the data type hierarchy) then
-    the array:
-
-    >>> np.find_common_type([np.float32], [np.int64, np.float64])
-    dtype('float32')
-
-    Complex is of a different type, so it up-casts the float in the
-    `array_types` argument:
-
-    >>> np.find_common_type([np.float32], [complex])
-    dtype('complex128')
-
-    Type specifier strings are convertible to dtypes and can therefore
-    be used instead of dtypes:
-
-    >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8'])
-    dtype('complex128')
-
-    " :arglists '[[array_types scalar_types]])
-
-(def intp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "intp"))))
-(alter-meta! #'intp assoc :doc "Signed integer type, compatible with Python `int` anc C ``long``.
-    Character code: ``'l'``.
-    Canonical name: ``np.int_``.
-    Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807).
-    Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def poly (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "poly"))))
-(alter-meta! #'poly assoc :doc "
-    Find the coefficients of a polynomial with the given sequence of roots.
-
-    Returns the coefficients of the polynomial whose leading coefficient
-    is one for the given sequence of zeros (multiple roots must be included
-    in the sequence as many times as their multiplicity; see Examples).
-    A square matrix (or array, which will be treated as a matrix) can also
-    be given, in which case the coefficients of the characteristic polynomial
-    of the matrix are returned.
-
-    Parameters
-    ----------
-    seq_of_zeros : array_like, shape (N,) or (N, N)
-        A sequence of polynomial roots, or a square array or matrix object.
-
-    Returns
-    -------
-    c : ndarray
-        1D array of polynomial coefficients from highest to lowest degree:
-
-        ``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]``
-        where c[0] always equals 1.
-
-    Raises
-    ------
-    ValueError
-        If input is the wrong shape (the input must be a 1-D or square
-        2-D array).
-
-    See Also
-    --------
-    polyval : Compute polynomial values.
-    roots : Return the roots of a polynomial.
-    polyfit : Least squares polynomial fit.
-    poly1d : A one-dimensional polynomial class.
-
-    Notes
-    -----
-    Specifying the roots of a polynomial still leaves one degree of
-    freedom, typically represented by an undetermined leading
-    coefficient. [1]_ In the case of this function, that coefficient -
-    the first one in the returned array - is always taken as one. (If
-    for some reason you have one other point, the only automatic way
-    presently to leverage that information is to use ``polyfit``.)
-
-    The characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n`
-    matrix **A** is given by
-
-        :math:`p_a(t) = \\mathrm{det}(t\\, \\mathbf{I} - \\mathbf{A})`,
-
-    where **I** is the `n`-by-`n` identity matrix. [2]_
-
-    References
-    ----------
-    .. [1] M. Sullivan and M. Sullivan, III, \"Algebra and Trignometry,
-       Enhanced With Graphing Utilities,\" Prentice-Hall, pg. 318, 1996.
-
-    .. [2] G. Strang, \"Linear Algebra and Its Applications, 2nd Edition,\"
-       Academic Press, pg. 182, 1980.
-
-    Examples
-    --------
-    Given a sequence of a polynomial's zeros:
-
-    >>> np.poly((0, 0, 0)) # Multiple root example
-    array([1., 0., 0., 0.])
-
-    The line above represents z**3 + 0*z**2 + 0*z + 0.
-
-    >>> np.poly((-1./2, 0, 1./2))
-    array([ 1.  ,  0.  , -0.25,  0.  ])
-
-    The line above represents z**3 - z/4
-
-    >>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0]))
-    array([ 1.        , -0.77086955,  0.08618131,  0.        ]) # random
-
-    Given a square array object:
-
-    >>> P = np.array([[0, 1./3], [-1./2, 0]])
-    >>> np.poly(P)
-    array([1.        , 0.        , 0.16666667])
-
-    Note how in all cases the leading coefficient is always 1.
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def maximum_sctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "maximum_sctype"))))
-(alter-meta! #'maximum_sctype assoc :doc "
-    Return the scalar type of highest precision of the same kind as the input.
-
-    Parameters
-    ----------
-    t : dtype or dtype specifier
-        The input data type. This can be a `dtype` object or an object that
-        is convertible to a `dtype`.
-
-    Returns
-    -------
-    out : dtype
-        The highest precision data type of the same kind (`dtype.kind`) as `t`.
-
-    See Also
-    --------
-    obj2sctype, mintypecode, sctype2char
-    dtype
-
-    Examples
-    --------
-    >>> np.maximum_sctype(int)
-    <class 'numpy.int64'>
-    >>> np.maximum_sctype(np.uint8)
-    <class 'numpy.uint64'>
-    >>> np.maximum_sctype(complex)
-    <class 'numpy.complex256'> # may vary
-
-    >>> np.maximum_sctype(str)
-    <class 'numpy.str_'>
-
-    >>> np.maximum_sctype('i2')
-    <class 'numpy.int64'>
-    >>> np.maximum_sctype('f4')
-    <class 'numpy.float128'> # may vary
-
-    " :arglists '[[t]])
-
-(def bmat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bmat"))))
-(alter-meta! #'bmat assoc :doc "
-    Build a matrix object from a string, nested sequence, or array.
-
-    Parameters
-    ----------
-    obj : str or array_like
-        Input data. If a string, variables in the current scope may be
-        referenced by name.
-    ldict : dict, optional
-        A dictionary that replaces local operands in current frame.
-        Ignored if `obj` is not a string or `gdict` is None.
-    gdict : dict, optional
-        A dictionary that replaces global operands in current frame.
-        Ignored if `obj` is not a string.
-
-    Returns
-    -------
-    out : matrix
-        Returns a matrix object, which is a specialized 2-D array.
-
-    See Also
-    --------
-    block :
-        A generalization of this function for N-d arrays, that returns normal
-        ndarrays.
-
-    Examples
-    --------
-    >>> A = np.mat('1 1; 1 1')
-    >>> B = np.mat('2 2; 2 2')
-    >>> C = np.mat('3 4; 5 6')
-    >>> D = np.mat('7 8; 9 0')
-
-    All the following expressions construct the same block matrix:
-
-    >>> np.bmat([[A, B], [C, D]])
-    matrix([[1, 1, 2, 2],
-            [1, 1, 2, 2],
-            [3, 4, 7, 8],
-            [5, 6, 9, 0]])
-    >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]])
-    matrix([[1, 1, 2, 2],
-            [1, 1, 2, 2],
-            [3, 4, 7, 8],
-            [5, 6, 9, 0]])
-    >>> np.bmat('A,B; C,D')
-    matrix([[1, 1, 2, 2],
-            [1, 1, 2, 2],
-            [3, 4, 7, 8],
-            [5, 6, 9, 0]])
-
-    " :arglists '[[obj & [{ldict :ldict, gdict :gdict}]] [obj & [{ldict :ldict}]] [obj]])
-
-(def put_along_axis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "put_along_axis"))))
-(alter-meta! #'put_along_axis assoc :doc "
-    Put values into the destination array by matching 1d index and data slices.
-
-    This iterates over matching 1d slices oriented along the specified axis in
-    the index and data arrays, and uses the former to place values into the
-    latter. These slices can be different lengths.
-
-    Functions returning an index along an axis, like `argsort` and
-    `argpartition`, produce suitable indices for this function.
-
-    .. versionadded:: 1.15.0
-
-    Parameters
-    ----------
-    arr: ndarray (Ni..., M, Nk...)
-        Destination array.
-    indices: ndarray (Ni..., J, Nk...)
-        Indices to change along each 1d slice of `arr`. This must match the
-        dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast
-        against `arr`.
-    values: array_like (Ni..., J, Nk...)
-        values to insert at those indices. Its shape and dimension are
-        broadcast to match that of `indices`.
-    axis: int
-        The axis to take 1d slices along. If axis is None, the destination
-        array is treated as if a flattened 1d view had been created of it.
-
-    Notes
-    -----
-    This is equivalent to (but faster than) the following use of `ndindex` and
-    `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::
-
-        Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
-        J = indices.shape[axis]  # Need not equal M
-
-        for ii in ndindex(Ni):
-            for kk in ndindex(Nk):
-                a_1d       = a      [ii + s_[:,] + kk]
-                indices_1d = indices[ii + s_[:,] + kk]
-                values_1d  = values [ii + s_[:,] + kk]
-                for j in range(J):
-                    a_1d[indices_1d[j]] = values_1d[j]
-
-    Equivalently, eliminating the inner loop, the last two lines would be::
-
-                a_1d[indices_1d] = values_1d
-
-    See Also
-    --------
-    take_along_axis :
-        Take values from the input array by matching 1d index and data slices
-
-    Examples
-    --------
-
-    For this sample array
-
-    >>> a = np.array([[10, 30, 20], [60, 40, 50]])
-
-    We can replace the maximum values with:
-
-    >>> ai = np.expand_dims(np.argmax(a, axis=1), axis=1)
-    >>> ai
-    array([[1],
-           [0]])
-    >>> np.put_along_axis(a, ai, 99, axis=1)
-    >>> a
-    array([[10, 99, 20],
-           [99, 40, 50]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def logical_or (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_or"))))
-(alter-meta! #'logical_or assoc :doc "logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute the truth value of x1 OR x2 element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    Logical OR is applied to the elements of `x1` and `x2`.
-    If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or bool
-    Boolean result of the logical OR operation applied to the elements
-    of `x1` and `x2`; the shape is determined by broadcasting.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-logical_and, logical_not, logical_xor
-bitwise_or
-
-Examples
---------
->>> np.logical_or(True, False)
-True
->>> np.logical_or([True, False], [False, False])
-array([ True, False])
-
->>> x = np.arange(5)
->>> np.logical_or(x < 1, x > 3)
-array([ True, False, False, False,  True])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def void (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "void"))))
-(alter-meta! #'void assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} e (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "e"))))
-
-(def positive (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "positive"))))
-(alter-meta! #'positive assoc :doc "positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Numerical positive, element-wise.
-
-.. versionadded:: 1.13.0
-
-Parameters
-----------
-x : array_like or scalar
-    Input array.
-
-Returns
--------
-y : ndarray or scalar
-    Returned array or scalar: `y = +x`.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-Equivalent to `x.copy()`, but only defined for types that support
-arithmetic." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} inf (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "inf"))))
-
-(def nditer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nditer"))))
-(alter-meta! #'nditer assoc :doc "Efficient multi-dimensional iterator object to iterate over arrays.
-    To get started using this object, see the
-    :ref:`introductory guide to array iteration <arrays.nditer>`.
-
-    Parameters
-    ----------
-    op : ndarray or sequence of array_like
-        The array(s) to iterate over.
-
-    flags : sequence of str, optional
-          Flags to control the behavior of the iterator.
-
-          * ``buffered`` enables buffering when required.
-          * ``c_index`` causes a C-order index to be tracked.
-          * ``f_index`` causes a Fortran-order index to be tracked.
-          * ``multi_index`` causes a multi-index, or a tuple of indices
-            with one per iteration dimension, to be tracked.
-          * ``common_dtype`` causes all the operands to be converted to
-            a common data type, with copying or buffering as necessary.
-          * ``copy_if_overlap`` causes the iterator to determine if read
-            operands have overlap with write operands, and make temporary
-            copies as necessary to avoid overlap. False positives (needless
-            copying) are possible in some cases.
-          * ``delay_bufalloc`` delays allocation of the buffers until
-            a reset() call is made. Allows ``allocate`` operands to
-            be initialized before their values are copied into the buffers.
-          * ``external_loop`` causes the ``values`` given to be
-            one-dimensional arrays with multiple values instead of
-            zero-dimensional arrays.
-          * ``grow_inner`` allows the ``value`` array sizes to be made
-            larger than the buffer size when both ``buffered`` and
-            ``external_loop`` is used.
-          * ``ranged`` allows the iterator to be restricted to a sub-range
-            of the iterindex values.
-          * ``refs_ok`` enables iteration of reference types, such as
-            object arrays.
-          * ``reduce_ok`` enables iteration of ``readwrite`` operands
-            which are broadcasted, also known as reduction operands.
-          * ``zerosize_ok`` allows `itersize` to be zero.
-    op_flags : list of list of str, optional
-          This is a list of flags for each operand. At minimum, one of
-          ``readonly``, ``readwrite``, or ``writeonly`` must be specified.
-
-          * ``readonly`` indicates the operand will only be read from.
-          * ``readwrite`` indicates the operand will be read from and written to.
-          * ``writeonly`` indicates the operand will only be written to.
-          * ``no_broadcast`` prevents the operand from being broadcasted.
-          * ``contig`` forces the operand data to be contiguous.
-          * ``aligned`` forces the operand data to be aligned.
-          * ``nbo`` forces the operand data to be in native byte order.
-          * ``copy`` allows a temporary read-only copy if required.
-          * ``updateifcopy`` allows a temporary read-write copy if required.
-          * ``allocate`` causes the array to be allocated if it is None
-            in the ``op`` parameter.
-          * ``no_subtype`` prevents an ``allocate`` operand from using a subtype.
-          * ``arraymask`` indicates that this operand is the mask to use
-            for selecting elements when writing to operands with the
-            'writemasked' flag set. The iterator does not enforce this,
-            but when writing from a buffer back to the array, it only
-            copies those elements indicated by this mask.
-          * ``writemasked`` indicates that only elements where the chosen
-            ``arraymask`` operand is True will be written to.
-          * ``overlap_assume_elementwise`` can be used to mark operands that are
-            accessed only in the iterator order, to allow less conservative
-            copying when ``copy_if_overlap`` is present.
-    op_dtypes : dtype or tuple of dtype(s), optional
-        The required data type(s) of the operands. If copying or buffering
-        is enabled, the data will be converted to/from their original types.
-    order : {'C', 'F', 'A', 'K'}, optional
-        Controls the iteration order. 'C' means C order, 'F' means
-        Fortran order, 'A' means 'F' order if all the arrays are Fortran
-        contiguous, 'C' order otherwise, and 'K' means as close to the
-        order the array elements appear in memory as possible. This also
-        affects the element memory order of ``allocate`` operands, as they
-        are allocated to be compatible with iteration order.
-        Default is 'K'.
-    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
-        Controls what kind of data casting may occur when making a copy
-        or buffering.  Setting this to 'unsafe' is not recommended,
-        as it can adversely affect accumulations.
-
-        * 'no' means the data types should not be cast at all.
-        * 'equiv' means only byte-order changes are allowed.
-        * 'safe' means only casts which can preserve values are allowed.
-        * 'same_kind' means only safe casts or casts within a kind,
-          like float64 to float32, are allowed.
-        * 'unsafe' means any data conversions may be done.
-    op_axes : list of list of ints, optional
-        If provided, is a list of ints or None for each operands.
-        The list of axes for an operand is a mapping from the dimensions
-        of the iterator to the dimensions of the operand. A value of
-        -1 can be placed for entries, causing that dimension to be
-        treated as `newaxis`.
-    itershape : tuple of ints, optional
-        The desired shape of the iterator. This allows ``allocate`` operands
-        with a dimension mapped by op_axes not corresponding to a dimension
-        of a different operand to get a value not equal to 1 for that
-        dimension.
-    buffersize : int, optional
-        When buffering is enabled, controls the size of the temporary
-        buffers. Set to 0 for the default value.
-
-    Attributes
-    ----------
-    dtypes : tuple of dtype(s)
-        The data types of the values provided in `value`. This may be
-        different from the operand data types if buffering is enabled.
-        Valid only before the iterator is closed.
-    finished : bool
-        Whether the iteration over the operands is finished or not.
-    has_delayed_bufalloc : bool
-        If True, the iterator was created with the ``delay_bufalloc`` flag,
-        and no reset() function was called on it yet.
-    has_index : bool
-        If True, the iterator was created with either the ``c_index`` or
-        the ``f_index`` flag, and the property `index` can be used to
-        retrieve it.
-    has_multi_index : bool
-        If True, the iterator was created with the ``multi_index`` flag,
-        and the property `multi_index` can be used to retrieve it.
-    index
-        When the ``c_index`` or ``f_index`` flag was used, this property
-        provides access to the index. Raises a ValueError if accessed
-        and ``has_index`` is False.
-    iterationneedsapi : bool
-        Whether iteration requires access to the Python API, for example
-        if one of the operands is an object array.
-    iterindex : int
-        An index which matches the order of iteration.
-    itersize : int
-        Size of the iterator.
-    itviews
-        Structured view(s) of `operands` in memory, matching the reordered
-        and optimized iterator access pattern. Valid only before the iterator
-        is closed.
-    multi_index
-        When the ``multi_index`` flag was used, this property
-        provides access to the index. Raises a ValueError if accessed
-        accessed and ``has_multi_index`` is False.
-    ndim : int
-        The dimensions of the iterator.
-    nop : int
-        The number of iterator operands.
-    operands : tuple of operand(s)
-        The array(s) to be iterated over. Valid only before the iterator is
-        closed.
-    shape : tuple of ints
-        Shape tuple, the shape of the iterator.
-    value
-        Value of ``operands`` at current iteration. Normally, this is a
-        tuple of array scalars, but if the flag ``external_loop`` is used,
-        it is a tuple of one dimensional arrays.
-
-    Notes
-    -----
-    `nditer` supersedes `flatiter`.  The iterator implementation behind
-    `nditer` is also exposed by the NumPy C API.
-
-    The Python exposure supplies two iteration interfaces, one which follows
-    the Python iterator protocol, and another which mirrors the C-style
-    do-while pattern.  The native Python approach is better in most cases, but
-    if you need the coordinates or index of an iterator, use the C-style pattern.
-
-    Examples
-    --------
-    Here is how we might write an ``iter_add`` function, using the
-    Python iterator protocol:
-
-    >>> def iter_add_py(x, y, out=None):
-    ...     addop = np.add
-    ...     it = np.nditer([x, y, out], [],
-    ...                 [['readonly'], ['readonly'], ['writeonly','allocate']])
-    ...     with it:
-    ...         for (a, b, c) in it:
-    ...             addop(a, b, out=c)
-    ...     return it.operands[2]
-
-    Here is the same function, but following the C-style pattern:
-
-    >>> def iter_add(x, y, out=None):
-    ...    addop = np.add
-    ...    it = np.nditer([x, y, out], [],
-    ...                [['readonly'], ['readonly'], ['writeonly','allocate']])
-    ...    with it:
-    ...        while not it.finished:
-    ...            addop(it[0], it[1], out=it[2])
-    ...            it.iternext()
-    ...        return it.operands[2]
-
-    Here is an example outer product function:
-
-    >>> def outer_it(x, y, out=None):
-    ...     mulop = np.multiply
-    ...     it = np.nditer([x, y, out], ['external_loop'],
-    ...             [['readonly'], ['readonly'], ['writeonly', 'allocate']],
-    ...             op_axes=[list(range(x.ndim)) + [-1] * y.ndim,
-    ...                      [-1] * x.ndim + list(range(y.ndim)),
-    ...                      None])
-    ...     with it:
-    ...         for (a, b, c) in it:
-    ...             mulop(a, b, out=c)
-    ...         return it.operands[2]
-
-    >>> a = np.arange(2)+1
-    >>> b = np.arange(3)+1
-    >>> outer_it(a,b)
-    array([[1, 2, 3],
-           [2, 4, 6]])
-
-    Here is an example function which operates like a \"lambda\" ufunc:
-
-    >>> def luf(lamdaexpr, *args, **kwargs):
-    ...    '''luf(lambdaexpr, op1, ..., opn, out=None, order='K', casting='safe', buffersize=0)'''
-    ...    nargs = len(args)
-    ...    op = (kwargs.get('out',None),) + args
-    ...    it = np.nditer(op, ['buffered','external_loop'],
-    ...            [['writeonly','allocate','no_broadcast']] +
-    ...                            [['readonly','nbo','aligned']]*nargs,
-    ...            order=kwargs.get('order','K'),
-    ...            casting=kwargs.get('casting','safe'),
-    ...            buffersize=kwargs.get('buffersize',0))
-    ...    while not it.finished:
-    ...        it[0] = lamdaexpr(*it[1:])
-    ...        it.iternext()
-    ...        return it.operands[0]
-
-    >>> a = np.arange(5)
-    >>> b = np.ones(5)
-    >>> luf(lambda i,j:i*i + j/2, a, b)
-    array([  0.5,   1.5,   4.5,   9.5,  16.5])
-
-    If operand flags `\"writeonly\"` or `\"readwrite\"` are used the
-    operands may be views into the original data with the
-    `WRITEBACKIFCOPY` flag. In this case `nditer` must be used as a
-    context manager or the `nditer.close` method must be called before
-    using the result. The temporary data will be written back to the
-    original data when the `__exit__` function is called but not before:
-
-    >>> a = np.arange(6, dtype='i4')[::-2]
-    >>> with np.nditer(a, [],
-    ...        [['writeonly', 'updateifcopy']],
-    ...        casting='unsafe',
-    ...        op_dtypes=[np.dtype('f4')]) as i:
-    ...    x = i.operands[0]
-    ...    x[:] = [-1, -2, -3]
-    ...    # a still unchanged here
-    >>> a, x
-    (array([-1, -2, -3], dtype=int32), array([-1., -2., -3.], dtype=float32))
-
-    It is important to note that once the iterator is exited, dangling
-    references (like `x` in the example) may or may not share data with
-    the original data `a`. If writeback semantics were active, i.e. if
-    `x.base.flags.writebackifcopy` is `True`, then exiting the iterator
-    will sever the connection between `x` and `a`, writing to `x` will
-    no longer write to `a`. If writeback semantics are not active, then
-    `x.data` will still point at some part of `a.data`, and writing to
-    one will affect the other.
-
-    Context management and the `close` method appeared in version 1.15.0." :arglists '[[self & [args {:as kwargs}]]])
-
-(def nansum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nansum"))))
-(alter-meta! #'nansum assoc :doc "
-    Return the sum of array elements over a given axis treating Not a
-    Numbers (NaNs) as zero.
-
-    In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or
-    empty. In later versions zero is returned.
-
-    Parameters
-    ----------
-    a : array_like
-        Array containing numbers whose sum is desired. If `a` is not an
-        array, a conversion is attempted.
-    axis : {int, tuple of int, None}, optional
-        Axis or axes along which the sum is computed. The default is to compute the
-        sum of the flattened array.
-    dtype : data-type, optional
-        The type of the returned array and of the accumulator in which the
-        elements are summed.  By default, the dtype of `a` is used.  An
-        exception is when `a` has an integer type with less precision than
-        the platform (u)intp. In that case, the default will be either
-        (u)int32 or (u)int64 depending on whether the platform is 32 or 64
-        bits. For inexact inputs, dtype must be inexact.
-
-        .. versionadded:: 1.8.0
-    out : ndarray, optional
-        Alternate output array in which to place the result.  The default
-        is ``None``. If provided, it must have the same shape as the
-        expected output, but the type will be cast if necessary.  See
-        `ufuncs-output-type` for more details. The casting of NaN to integer
-        can yield unexpected results.
-
-        .. versionadded:: 1.8.0
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the original `a`.
-
-
-        If the value is anything but the default, then
-        `keepdims` will be passed through to the `mean` or `sum` methods
-        of sub-classes of `ndarray`.  If the sub-classes methods
-        does not implement `keepdims` any exceptions will be raised.
-
-        .. versionadded:: 1.8.0
-
-    Returns
-    -------
-    nansum : ndarray.
-        A new array holding the result is returned unless `out` is
-        specified, in which it is returned. The result has the same
-        size as `a`, and the same shape as `a` if `axis` is not None
-        or `a` is a 1-d array.
-
-    See Also
-    --------
-    numpy.sum : Sum across array propagating NaNs.
-    isnan : Show which elements are NaN.
-    isfinite: Show which elements are not NaN or +/-inf.
-
-    Notes
-    -----
-    If both positive and negative infinity are present, the sum will be Not
-    A Number (NaN).
-
-    Examples
-    --------
-    >>> np.nansum(1)
-    1
-    >>> np.nansum([1])
-    1
-    >>> np.nansum([1, np.nan])
-    1.0
-    >>> a = np.array([[1, 1], [1, np.nan]])
-    >>> np.nansum(a)
-    3.0
-    >>> np.nansum(a, axis=0)
-    array([2.,  1.])
-    >>> np.nansum([1, np.nan, np.inf])
-    inf
-    >>> np.nansum([1, np.nan, np.NINF])
-    -inf
-    >>> from numpy.testing import suppress_warnings
-    >>> with suppress_warnings() as sup:
-    ...     sup.filter(RuntimeWarning)
-    ...     np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present
-    nan
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def nanprod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanprod"))))
-(alter-meta! #'nanprod assoc :doc "
-    Return the product of array elements over a given axis treating Not a
-    Numbers (NaNs) as ones.
-
-    One is returned for slices that are all-NaN or empty.
-
-    .. versionadded:: 1.10.0
-
-    Parameters
-    ----------
-    a : array_like
-        Array containing numbers whose product is desired. If `a` is not an
-        array, a conversion is attempted.
-    axis : {int, tuple of int, None}, optional
-        Axis or axes along which the product is computed. The default is to compute
-        the product of the flattened array.
-    dtype : data-type, optional
-        The type of the returned array and of the accumulator in which the
-        elements are summed.  By default, the dtype of `a` is used.  An
-        exception is when `a` has an integer type with less precision than
-        the platform (u)intp. In that case, the default will be either
-        (u)int32 or (u)int64 depending on whether the platform is 32 or 64
-        bits. For inexact inputs, dtype must be inexact.
-    out : ndarray, optional
-        Alternate output array in which to place the result.  The default
-        is ``None``. If provided, it must have the same shape as the
-        expected output, but the type will be cast if necessary. See
-        `ufuncs-output-type` for more details. The casting of NaN to integer
-        can yield unexpected results.
-    keepdims : bool, optional
-        If True, the axes which are reduced are left in the result as
-        dimensions with size one. With this option, the result will
-        broadcast correctly against the original `arr`.
-
-    Returns
-    -------
-    nanprod : ndarray
-        A new array holding the result is returned unless `out` is
-        specified, in which case it is returned.
-
-    See Also
-    --------
-    numpy.prod : Product across array propagating NaNs.
-    isnan : Show which elements are NaN.
-
-    Examples
-    --------
-    >>> np.nanprod(1)
-    1
-    >>> np.nanprod([1])
-    1
-    >>> np.nanprod([1, np.nan])
-    1.0
-    >>> a = np.array([[1, 2], [3, np.nan]])
-    >>> np.nanprod(a)
-    6.0
-    >>> np.nanprod(a, axis=0)
-    array([3., 2.])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def setxor1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "setxor1d"))))
-(alter-meta! #'setxor1d assoc :doc "
-    Find the set exclusive-or of two arrays.
-
-    Return the sorted, unique values that are in only one (not both) of the
-    input arrays.
-
-    Parameters
-    ----------
-    ar1, ar2 : array_like
-        Input arrays.
-    assume_unique : bool
-        If True, the input arrays are both assumed to be unique, which
-        can speed up the calculation.  Default is False.
-
-    Returns
-    -------
-    setxor1d : ndarray
-        Sorted 1D array of unique values that are in only one of the input
-        arrays.
-
-    Examples
-    --------
-    >>> a = np.array([1, 2, 3, 2, 4])
-    >>> b = np.array([2, 3, 5, 7, 5])
-    >>> np.setxor1d(a,b)
-    array([1, 4, 5, 7])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def copy (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "copy"))))
-(alter-meta! #'copy assoc :doc "
-    Return an array copy of the given object.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-    order : {'C', 'F', 'A', 'K'}, optional
-        Controls the memory layout of the copy. 'C' means C-order,
-        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
-        'C' otherwise. 'K' means match the layout of `a` as closely
-        as possible. (Note that this function and :meth:`ndarray.copy` are very
-        similar, but have different default values for their order=
-        arguments.)
-
-    Returns
-    -------
-    arr : ndarray
-        Array interpretation of `a`.
-
-    Notes
-    -----
-    This is equivalent to:
-
-    >>> np.array(a, copy=True)  #doctest: +SKIP
-
-    Examples
-    --------
-    Create an array x, with a reference y and a copy z:
-
-    >>> x = np.array([1, 2, 3])
-    >>> y = x
-    >>> z = np.copy(x)
-
-    Note that, when we modify x, y changes, but not z:
-
-    >>> x[0] = 10
-    >>> x[0] == y[0]
-    True
-    >>> x[0] == z[0]
-    False
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def in1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "in1d"))))
-(alter-meta! #'in1d assoc :doc "
-    Test whether each element of a 1-D array is also present in a second array.
-
-    Returns a boolean array the same length as `ar1` that is True
-    where an element of `ar1` is in `ar2` and False otherwise.
-
-    We recommend using :func:`isin` instead of `in1d` for new code.
-
-    Parameters
-    ----------
-    ar1 : (M,) array_like
-        Input array.
-    ar2 : array_like
-        The values against which to test each value of `ar1`.
-    assume_unique : bool, optional
-        If True, the input arrays are both assumed to be unique, which
-        can speed up the calculation.  Default is False.
-    invert : bool, optional
-        If True, the values in the returned array are inverted (that is,
-        False where an element of `ar1` is in `ar2` and True otherwise).
-        Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
-        to (but is faster than) ``np.invert(in1d(a, b))``.
-
-        .. versionadded:: 1.8.0
-
-    Returns
-    -------
-    in1d : (M,) ndarray, bool
-        The values `ar1[in1d]` are in `ar2`.
-
-    See Also
-    --------
-    isin                  : Version of this function that preserves the
-                            shape of ar1.
-    numpy.lib.arraysetops : Module with a number of other functions for
-                            performing set operations on arrays.
-
-    Notes
-    -----
-    `in1d` can be considered as an element-wise function version of the
-    python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
-    equivalent to ``np.array([item in b for item in a])``.
-    However, this idea fails if `ar2` is a set, or similar (non-sequence)
-    container:  As ``ar2`` is converted to an array, in those cases
-    ``asarray(ar2)`` is an object array rather than the expected array of
-    contained values.
-
-    .. versionadded:: 1.4.0
-
-    Examples
-    --------
-    >>> test = np.array([0, 1, 2, 5, 0])
-    >>> states = [0, 2]
-    >>> mask = np.in1d(test, states)
-    >>> mask
-    array([ True, False,  True, False,  True])
-    >>> test[mask]
-    array([0, 2, 0])
-    >>> mask = np.in1d(test, states, invert=True)
-    >>> mask
-    array([False,  True, False,  True, False])
-    >>> test[mask]
-    array([1, 5])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def complex_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex_"))))
-(alter-meta! #'complex_ assoc :doc "Complex number type composed of two double-precision floating-point
-    numbers, compatible with Python `complex`.
-    Character code: ``'D'``.
-    Canonical name: ``np.cdouble``.
-    Alias: ``np.cfloat``.
-    Alias: ``np.complex_``.
-    Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc "
-    Translates slice objects to concatenation along the second axis.
-
-    This is short-hand for ``np.r_['-1,2,0', index expression]``, which is
-    useful because of its common occurrence. In particular, arrays will be
-    stacked along their last axis after being upgraded to at least 2-D with
-    1's post-pended to the shape (column vectors made out of 1-D arrays).
-    
-    See Also
-    --------
-    column_stack : Stack 1-D arrays as columns into a 2-D array.
-    r_ : For more detailed documentation.
-
-    Examples
-    --------
-    >>> np.c_[np.array([1,2,3]), np.array([4,5,6])]
-    array([[1, 4],
-           [2, 5],
-           [3, 6]])
-    >>> np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]
-    array([[1, 2, 3, ..., 4, 5, 6]])
-
-    "} c_ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "c_"))))
-
-(def ^{:doc "
-    `nd_grid` instance which returns a dense multi-dimensional \"meshgrid\".
-
-    An instance of `numpy.lib.index_tricks.nd_grid` which returns an dense
-    (or fleshed out) mesh-grid when indexed, so that each returned argument
-    has the same shape.  The dimensions and number of the output arrays are
-    equal to the number of indexing dimensions.  If the step length is not a
-    complex number, then the stop is not inclusive.
-
-    However, if the step length is a **complex number** (e.g. 5j), then
-    the integer part of its magnitude is interpreted as specifying the
-    number of points to create between the start and stop values, where
-    the stop value **is inclusive**.
-
-    Returns
-    ----------
-    mesh-grid `ndarrays` all of the same dimensions
-
-    See Also
-    --------
-    numpy.lib.index_tricks.nd_grid : class of `ogrid` and `mgrid` objects
-    ogrid : like mgrid but returns open (not fleshed out) mesh grids
-    r_ : array concatenator
-
-    Examples
-    --------
-    >>> np.mgrid[0:5,0:5]
-    array([[[0, 0, 0, 0, 0],
-            [1, 1, 1, 1, 1],
-            [2, 2, 2, 2, 2],
-            [3, 3, 3, 3, 3],
-            [4, 4, 4, 4, 4]],
-           [[0, 1, 2, 3, 4],
-            [0, 1, 2, 3, 4],
-            [0, 1, 2, 3, 4],
-            [0, 1, 2, 3, 4],
-            [0, 1, 2, 3, 4]]])
-    >>> np.mgrid[-1:1:5j]
-    array([-1. , -0.5,  0. ,  0.5,  1. ])
-
-    "} mgrid (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "mgrid"))))
-
-(def trapz (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trapz"))))
-(alter-meta! #'trapz assoc :doc "
-    Integrate along the given axis using the composite trapezoidal rule.
-
-    Integrate `y` (`x`) along given axis.
-
-    Parameters
-    ----------
-    y : array_like
-        Input array to integrate.
-    x : array_like, optional
-        The sample points corresponding to the `y` values. If `x` is None,
-        the sample points are assumed to be evenly spaced `dx` apart. The
-        default is None.
-    dx : scalar, optional
-        The spacing between sample points when `x` is None. The default is 1.
-    axis : int, optional
-        The axis along which to integrate.
-
-    Returns
-    -------
-    trapz : float
-        Definite integral as approximated by trapezoidal rule.
-
-    See Also
-    --------
-    sum, cumsum
-
-    Notes
-    -----
-    Image [2]_ illustrates trapezoidal rule -- y-axis locations of points
-    will be taken from `y` array, by default x-axis distances between
-    points will be 1.0, alternatively they can be provided with `x` array
-    or with `dx` scalar.  Return value will be equal to combined area under
-    the red lines.
-
-
-    References
-    ----------
-    .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule
-
-    .. [2] Illustration image:
-           https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png
-
-    Examples
-    --------
-    >>> np.trapz([1,2,3])
-    4.0
-    >>> np.trapz([1,2,3], x=[4,6,8])
-    8.0
-    >>> np.trapz([1,2,3], dx=2)
-    8.0
-    >>> a = np.arange(6).reshape(2, 3)
-    >>> a
-    array([[0, 1, 2],
-           [3, 4, 5]])
-    >>> np.trapz(a, axis=0)
-    array([1.5, 2.5, 3.5])
-    >>> np.trapz(a, axis=1)
-    array([2.,  8.])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def float64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float64"))))
-(alter-meta! #'float64 assoc :doc "Double-precision floating-point number type, compatible with Python `float`
-    and C ``double``.
-    Character code: ``'d'``.
-    Canonical name: ``np.double``.
-    Alias: ``np.float_``.
-    Alias *on this platform*: ``np.float64``: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
-
-(def histogramdd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogramdd"))))
-(alter-meta! #'histogramdd assoc :doc "
-    Compute the multidimensional histogram of some data.
-
-    Parameters
-    ----------
-    sample : (N, D) array, or (D, N) array_like
-        The data to be histogrammed.
-
-        Note the unusual interpretation of sample when an array_like:
-
-        * When an array, each row is a coordinate in a D-dimensional space -
-          such as ``histogramgramdd(np.array([p1, p2, p3]))``.
-        * When an array_like, each element is the list of values for single
-          coordinate - such as ``histogramgramdd((X, Y, Z))``.
-
-        The first form should be preferred.
-
-    bins : sequence or int, optional
-        The bin specification:
-
-        * A sequence of arrays describing the monotonically increasing bin
-          edges along each dimension.
-        * The number of bins for each dimension (nx, ny, ... =bins)
-        * The number of bins for all dimensions (nx=ny=...=bins).
-
-    range : sequence, optional
-        A sequence of length D, each an optional (lower, upper) tuple giving
-        the outer bin edges to be used if the edges are not given explicitly in
-        `bins`.
-        An entry of None in the sequence results in the minimum and maximum
-        values being used for the corresponding dimension.
-        The default, None, is equivalent to passing a tuple of D None values.
-    density : bool, optional
-        If False, the default, returns the number of samples in each bin.
-        If True, returns the probability *density* function at the bin,
-        ``bin_count / sample_count / bin_volume``.
-    normed : bool, optional
-        An alias for the density argument that behaves identically. To avoid
-        confusion with the broken normed argument to `histogram`, `density`
-        should be preferred.
-    weights : (N,) array_like, optional
-        An array of values `w_i` weighing each sample `(x_i, y_i, z_i, ...)`.
-        Weights are normalized to 1 if normed is True. If normed is False,
-        the values of the returned histogram are equal to the sum of the
-        weights belonging to the samples falling into each bin.
-
-    Returns
-    -------
-    H : ndarray
-        The multidimensional histogram of sample x. See normed and weights
-        for the different possible semantics.
-    edges : list
-        A list of D arrays describing the bin edges for each dimension.
-
-    See Also
-    --------
-    histogram: 1-D histogram
-    histogram2d: 2-D histogram
-
-    Examples
-    --------
-    >>> r = np.random.randn(100,3)
-    >>> H, edges = np.histogramdd(r, bins = (5, 8, 4))
-    >>> H.shape, edges[0].size, edges[1].size, edges[2].size
-    ((5, 8, 4), 6, 9, 5)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def average (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "average"))))
-(alter-meta! #'average assoc :doc "
-    Compute the weighted average along the specified axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Array containing data to be averaged. If `a` is not an array, a
-        conversion is attempted.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which to average `a`.  The default,
-        axis=None, will average over all of the elements of the input array.
-        If axis is negative it counts from the last to the first axis.
-
-        .. versionadded:: 1.7.0
-
-        If axis is a tuple of ints, averaging is performed on all of the axes
-        specified in the tuple instead of a single axis or all the axes as
-        before.
-    weights : array_like, optional
-        An array of weights associated with the values in `a`. Each value in
-        `a` contributes to the average according to its associated weight.
-        The weights array can either be 1-D (in which case its length must be
-        the size of `a` along the given axis) or of the same shape as `a`.
-        If `weights=None`, then all data in `a` are assumed to have a
-        weight equal to one.  The 1-D calculation is::
-
-            avg = sum(a * weights) / sum(weights)
-
-        The only constraint on `weights` is that `sum(weights)` must not be 0.
-    returned : bool, optional
-        Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`)
-        is returned, otherwise only the average is returned.
-        If `weights=None`, `sum_of_weights` is equivalent to the number of
-        elements over which the average is taken.
-
-    Returns
-    -------
-    retval, [sum_of_weights] : array_type or double
-        Return the average along the specified axis. When `returned` is `True`,
-        return a tuple with the average as the first element and the sum
-        of the weights as the second element. `sum_of_weights` is of the
-        same type as `retval`. The result dtype follows a genereal pattern.
-        If `weights` is None, the result dtype will be that of `a` , or ``float64``
-        if `a` is integral. Otherwise, if `weights` is not None and `a` is non-
-        integral, the result type will be the type of lowest precision capable of
-        representing values of both `a` and `weights`. If `a` happens to be
-        integral, the previous rules still applies but the result dtype will
-        at least be ``float64``.
-
-    Raises
-    ------
-    ZeroDivisionError
-        When all weights along axis are zero. See `numpy.ma.average` for a
-        version robust to this type of error.
-    TypeError
-        When the length of 1D `weights` is not the same as the shape of `a`
-        along axis.
-
-    See Also
-    --------
-    mean
-
-    ma.average : average for masked arrays -- useful if your data contains
-                 \"missing\" values
-    numpy.result_type : Returns the type that results from applying the
-                        numpy type promotion rules to the arguments.
-
-    Examples
-    --------
-    >>> data = np.arange(1, 5)
-    >>> data
-    array([1, 2, 3, 4])
-    >>> np.average(data)
-    2.5
-    >>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1))
-    4.0
-
-    >>> data = np.arange(6).reshape((3,2))
-    >>> data
-    array([[0, 1],
-           [2, 3],
-           [4, 5]])
-    >>> np.average(data, axis=1, weights=[1./4, 3./4])
-    array([0.75, 2.75, 4.75])
-    >>> np.average(data, weights=[1./4, 3./4])
-    Traceback (most recent call last):
-        ...
-    TypeError: Axis must be specified when shapes of a and weights differ.
-
-    >>> a = np.ones(5, dtype=np.float128)
-    >>> w = np.ones(5, dtype=np.complex64)
-    >>> avg = np.average(a, weights=w)
-    >>> print(avg.dtype)
-    complex256
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def iscomplexobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iscomplexobj"))))
-(alter-meta! #'iscomplexobj assoc :doc "
-    Check for a complex type or an array of complex numbers.
-
-    The type of the input is checked, not the value. Even if the input
-    has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
-
-    Parameters
-    ----------
-    x : any
-        The input can be of any type and shape.
-
-    Returns
-    -------
-    iscomplexobj : bool
-        The return value, True if `x` is of a complex type or has at least
-        one complex element.
-
-    See Also
-    --------
-    isrealobj, iscomplex
-
-    Examples
-    --------
-    >>> np.iscomplexobj(1)
-    False
-    >>> np.iscomplexobj(1+0j)
-    True
-    >>> np.iscomplexobj([3, 1+0j, True])
-    True
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def logaddexp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logaddexp"))))
-(alter-meta! #'logaddexp assoc :doc "logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Logarithm of the sum of exponentiations of the inputs.
-
-Calculates ``log(exp(x1) + exp(x2))``. This function is useful in
-statistics where the calculated probabilities of events may be so small
-as to exceed the range of normal floating point numbers.  In such cases
-the logarithm of the calculated probability is stored. This function
-allows adding probabilities stored in such a fashion.
-
-Parameters
-----------
-x1, x2 : array_like
-    Input values. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-result : ndarray
-    Logarithm of ``exp(x1) + exp(x2)``.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2.
-
-Notes
------
-.. versionadded:: 1.3.0
-
-Examples
---------
->>> prob1 = np.log(1e-50)
->>> prob2 = np.log(2.5e-50)
->>> prob12 = np.logaddexp(prob1, prob2)
->>> prob12
--113.87649168120691
->>> np.exp(prob12)
-3.5000000000000057e-50" :arglists '[[self & [args {:as kwargs}]]])
-
-(def multiply (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "multiply"))))
-(alter-meta! #'multiply assoc :doc "multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Multiply arguments element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    Input arrays to be multiplied. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The product of `x1` and `x2`, element-wise.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-Notes
------
-Equivalent to `x1` * `x2` in terms of array broadcasting.
-
-Examples
---------
->>> np.multiply(2.0, 4.0)
-8.0
-
->>> x1 = np.arange(9.0).reshape((3, 3))
->>> x2 = np.arange(3.0)
->>> np.multiply(x1, x2)
-array([[  0.,   1.,   4.],
-       [  0.,   4.,  10.],
-       [  0.,   7.,  16.]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def uint (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint"))))
-(alter-meta! #'uint assoc :doc "Unsigned integer type, compatible with C ``unsigned long``.
-    Character code: ``'L'``.
-    Canonical name: ``np.uint``.
-    Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615).
-    Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def nanpercentile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanpercentile"))))
-(alter-meta! #'nanpercentile assoc :doc "
-    Compute the qth percentile of the data along the specified axis,
-    while ignoring nan values.
-
-    Returns the qth percentile(s) of the array elements.
-
-    .. versionadded:: 1.9.0
-
-    Parameters
-    ----------
-    a : array_like
-        Input array or object that can be converted to an array, containing
-        nan values to be ignored.
-    q : array_like of float
-        Percentile or sequence of percentiles to compute, which must be between
-        0 and 100 inclusive.
-    axis : {int, tuple of int, None}, optional
-        Axis or axes along which the percentiles are computed. The
-        default is to compute the percentile(s) along a flattened
-        version of the array.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must
-        have the same shape and buffer length as the expected output,
-        but the type (of the output) will be cast if necessary.
-    overwrite_input : bool, optional
-        If True, then allow the input array `a` to be modified by intermediate
-        calculations, to save memory. In this case, the contents of the input
-        `a` after this function completes is undefined.
-    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
-        This optional parameter specifies the interpolation method to
-        use when the desired percentile lies between two data points
-        ``i < j``:
-
-        * 'linear': ``i + (j - i) * fraction``, where ``fraction``
-          is the fractional part of the index surrounded by ``i``
-          and ``j``.
-        * 'lower': ``i``.
-        * 'higher': ``j``.
-        * 'nearest': ``i`` or ``j``, whichever is nearest.
-        * 'midpoint': ``(i + j) / 2``.
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left in
-        the result as dimensions with size one. With this option, the
-        result will broadcast correctly against the original array `a`.
-
-        If this is anything but the default value it will be passed
-        through (in the special case of an empty array) to the
-        `mean` function of the underlying array.  If the array is
-        a sub-class and `mean` does not have the kwarg `keepdims` this
-        will raise a RuntimeError.
-
-    Returns
-    -------
-    percentile : scalar or ndarray
-        If `q` is a single percentile and `axis=None`, then the result
-        is a scalar. If multiple percentiles are given, first axis of
-        the result corresponds to the percentiles. The other axes are
-        the axes that remain after the reduction of `a`. If the input
-        contains integers or floats smaller than ``float64``, the output
-        data-type is ``float64``. Otherwise, the output data-type is the
-        same as that of the input. If `out` is specified, that array is
-        returned instead.
-
-    See Also
-    --------
-    nanmean
-    nanmedian : equivalent to ``nanpercentile(..., 50)``
-    percentile, median, mean
-    nanquantile : equivalent to nanpercentile, but with q in the range [0, 1].
-
-    Notes
-    -----
-    Given a vector ``V`` of length ``N``, the ``q``-th percentile of
-    ``V`` is the value ``q/100`` of the way from the minimum to the
-    maximum in a sorted copy of ``V``. The values and distances of
-    the two nearest neighbors as well as the `interpolation` parameter
-    will determine the percentile if the normalized ranking does not
-    match the location of ``q`` exactly. This function is the same as
-    the median if ``q=50``, the same as the minimum if ``q=0`` and the
-    same as the maximum if ``q=100``.
-
-    Examples
-    --------
-    >>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
-    >>> a[0][1] = np.nan
-    >>> a
-    array([[10.,  nan,   4.],
-          [ 3.,   2.,   1.]])
-    >>> np.percentile(a, 50)
-    nan
-    >>> np.nanpercentile(a, 50)
-    3.0
-    >>> np.nanpercentile(a, 50, axis=0)
-    array([6.5, 2. , 2.5])
-    >>> np.nanpercentile(a, 50, axis=1, keepdims=True)
-    array([[7.],
-           [2.]])
-    >>> m = np.nanpercentile(a, 50, axis=0)
-    >>> out = np.zeros_like(m)
-    >>> np.nanpercentile(a, 50, axis=0, out=out)
-    array([6.5, 2. , 2.5])
-    >>> m
-    array([6.5,  2. ,  2.5])
-
-    >>> b = a.copy()
-    >>> np.nanpercentile(b, 50, axis=1, overwrite_input=True)
-    array([7., 2.])
-    >>> assert not np.all(a==b)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def intc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "intc"))))
-(alter-meta! #'intc assoc :doc "Signed integer type, compatible with C ``int``.
-    Character code: ``'i'``.
-    Canonical name: ``np.intc``.
-    Alias *on this platform*: ``np.int32``: 32-bit signed integer (-2147483648 to 2147483647)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def int32 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int32"))))
-(alter-meta! #'int32 assoc :doc "Signed integer type, compatible with C ``int``.
-    Character code: ``'i'``.
-    Canonical name: ``np.intc``.
-    Alias *on this platform*: ``np.int32``: 32-bit signed integer (-2147483648 to 2147483647)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def place (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "place"))))
-(alter-meta! #'place assoc :doc "
-    Change elements of an array based on conditional and input values.
-
-    Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that
-    `place` uses the first N elements of `vals`, where N is the number of
-    True values in `mask`, while `copyto` uses the elements where `mask`
-    is True.
-
-    Note that `extract` does the exact opposite of `place`.
-
-    Parameters
-    ----------
-    arr : ndarray
-        Array to put data into.
-    mask : array_like
-        Boolean mask array. Must have the same size as `a`.
-    vals : 1-D sequence
-        Values to put into `a`. Only the first N elements are used, where
-        N is the number of True values in `mask`. If `vals` is smaller
-        than N, it will be repeated, and if elements of `a` are to be masked,
-        this sequence must be non-empty.
-
-    See Also
-    --------
-    copyto, put, take, extract
-
-    Examples
-    --------
-    >>> arr = np.arange(6).reshape(2, 3)
-    >>> np.place(arr, arr>2, [44, 55])
-    >>> arr
-    array([[ 0,  1,  2],
-           [44, 55, 44]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def shape (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "shape"))))
-(alter-meta! #'shape assoc :doc "
-    Return the shape of an array.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-
-    Returns
-    -------
-    shape : tuple of ints
-        The elements of the shape tuple give the lengths of the
-        corresponding array dimensions.
-
-    See Also
-    --------
-    alen
-    ndarray.shape : Equivalent array method.
-
-    Examples
-    --------
-    >>> np.shape(np.eye(3))
-    (3, 3)
-    >>> np.shape([[1, 2]])
-    (1, 2)
-    >>> np.shape([0])
-    (1,)
-    >>> np.shape(0)
-    ()
-
-    >>> a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
-    >>> np.shape(a)
-    (2,)
-    >>> a.shape
-    (2,)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "Sub-package containing the matrix class and related functions.
-
-"} matrixlib (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "matrixlib"))))
-
-(def lcm (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "lcm"))))
-(alter-meta! #'lcm assoc :doc "lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Returns the lowest common multiple of ``|x1|`` and ``|x2|``
-
-Parameters
-----------
-x1, x2 : array_like, int
-    Arrays of values. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-
-Returns
--------
-y : ndarray or scalar
-    The lowest common multiple of the absolute value of the inputs
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-gcd : The greatest common divisor
-
-Examples
---------
->>> np.lcm(12, 20)
-60
->>> np.lcm.reduce([3, 12, 20])
-60
->>> np.lcm.reduce([40, 12, 20])
-120
->>> np.lcm(np.arange(6), 20)
-array([ 0, 20, 20, 60, 20, 20])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def copysign (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "copysign"))))
-(alter-meta! #'copysign assoc :doc "copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Change the sign of x1 to that of x2, element-wise.
-
-If `x2` is a scalar, its sign will be copied to all elements of `x1`.
-
-Parameters
-----------
-x1 : array_like
-    Values to change the sign of.
-x2 : array_like
-    The sign of `x2` is copied to `x1`. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    The values of `x1` with the sign of `x2`.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-Examples
---------
->>> np.copysign(1.3, -1)
--1.3
->>> 1/np.copysign(0, 1)
-inf
->>> 1/np.copysign(0, -1)
--inf
-
->>> np.copysign([-1, 0, 1], -1.1)
-array([-1., -0., -1.])
->>> np.copysign([-1, 0, 1], np.arange(3)-1)
-array([-1.,  0.,  1.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def uint16 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint16"))))
-(alter-meta! #'uint16 assoc :doc "Unsigned integer type, compatible with C ``unsigned short``.
-    Character code: ``'H'``.
-    Canonical name: ``np.ushort``.
-    Alias *on this platform*: ``np.uint16``: 16-bit unsigned integer (0 to 65535)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def delete (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "delete"))))
-(alter-meta! #'delete assoc :doc "
-    Return a new array with sub-arrays along an axis deleted. For a one
-    dimensional array, this returns those entries not returned by
-    `arr[obj]`.
-
-    Parameters
-    ----------
-    arr : array_like
-      Input array.
-    obj : slice, int or array of ints
-      Indicate indices of sub-arrays to remove along the specified axis.
-    axis : int, optional
-      The axis along which to delete the subarray defined by `obj`.
-      If `axis` is None, `obj` is applied to the flattened array.
-
-    Returns
-    -------
-    out : ndarray
-        A copy of `arr` with the elements specified by `obj` removed. Note
-        that `delete` does not occur in-place. If `axis` is None, `out` is
-        a flattened array.
-
-    See Also
-    --------
-    insert : Insert elements into an array.
-    append : Append elements at the end of an array.
-
-    Notes
-    -----
-    Often it is preferable to use a boolean mask. For example:
-
-    >>> arr = np.arange(12) + 1
-    >>> mask = np.ones(len(arr), dtype=bool)
-    >>> mask[[0,2,4]] = False
-    >>> result = arr[mask,...]
-
-    Is equivalent to `np.delete(arr, [0,2,4], axis=0)`, but allows further
-    use of `mask`.
-
-    Examples
-    --------
-    >>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
-    >>> arr
-    array([[ 1,  2,  3,  4],
-           [ 5,  6,  7,  8],
-           [ 9, 10, 11, 12]])
-    >>> np.delete(arr, 1, 0)
-    array([[ 1,  2,  3,  4],
-           [ 9, 10, 11, 12]])
-
-    >>> np.delete(arr, np.s_[::2], 1)
-    array([[ 2,  4],
-           [ 6,  8],
-           [10, 12]])
-    >>> np.delete(arr, [1,3,5], None)
-    array([ 1,  3,  5,  7,  8,  9, 10, 11, 12])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def is_busday (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "is_busday"))))
-(alter-meta! #'is_busday assoc :doc "
-    is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)
-
-    Calculates which of the given dates are valid days, and which are not.
-
-    .. versionadded:: 1.7.0
-
-    Parameters
-    ----------
-    dates : array_like of datetime64[D]
-        The array of dates to process.
-    weekmask : str or array_like of bool, optional
-        A seven-element array indicating which of Monday through Sunday are
-        valid days. May be specified as a length-seven list or array, like
-        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
-        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
-        weekdays, optionally separated by white space. Valid abbreviations
-        are: Mon Tue Wed Thu Fri Sat Sun
-    holidays : array_like of datetime64[D], optional
-        An array of dates to consider as invalid dates.  They may be
-        specified in any order, and NaT (not-a-time) dates are ignored.
-        This list is saved in a normalized form that is suited for
-        fast calculations of valid days.
-    busdaycal : busdaycalendar, optional
-        A `busdaycalendar` object which specifies the valid days. If this
-        parameter is provided, neither weekmask nor holidays may be
-        provided.
-    out : array of bool, optional
-        If provided, this array is filled with the result.
-
-    Returns
-    -------
-    out : array of bool
-        An array with the same shape as ``dates``, containing True for
-        each valid day, and False for each invalid day.
-
-    See Also
-    --------
-    busdaycalendar: An object that specifies a custom set of valid days.
-    busday_offset : Applies an offset counted in valid days.
-    busday_count : Counts how many valid days are in a half-open date range.
-
-    Examples
-    --------
-    >>> # The weekdays are Friday, Saturday, and Monday
-    ... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'],
-    ...                 holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
-    array([False, False,  True])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def savez_compressed (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "savez_compressed"))))
-(alter-meta! #'savez_compressed assoc :doc "
-    Save several arrays into a single file in compressed ``.npz`` format.
-
-    If keyword arguments are given, then filenames are taken from the keywords.
-    If arguments are passed in with no keywords, then stored filenames are
-    arr_0, arr_1, etc.
-
-    Parameters
-    ----------
-    file : str or file
-        Either the filename (string) or an open file (file-like object)
-        where the data will be saved. If file is a string or a Path, the
-        ``.npz`` extension will be appended to the filename if it is not
-        already there.
-    args : Arguments, optional
-        Arrays to save to the file. Since it is not possible for Python to
-        know the names of the arrays outside `savez`, the arrays will be saved
-        with names \"arr_0\", \"arr_1\", and so on. These arguments can be any
-        expression.
-    kwds : Keyword arguments, optional
-        Arrays to save to the file. Arrays will be saved in the file with the
-        keyword names.
-
-    Returns
-    -------
-    None
-
-    See Also
-    --------
-    numpy.save : Save a single array to a binary file in NumPy format.
-    numpy.savetxt : Save an array to a file as plain text.
-    numpy.savez : Save several arrays into an uncompressed ``.npz`` file format
-    numpy.load : Load the files created by savez_compressed.
-
-    Notes
-    -----
-    The ``.npz`` file format is a zipped archive of files named after the
-    variables they contain.  The archive is compressed with
-    ``zipfile.ZIP_DEFLATED`` and each file in the archive contains one variable
-    in ``.npy`` format. For a description of the ``.npy`` format, see 
-    :py:mod:`numpy.lib.format`.
-
-
-    When opening the saved ``.npz`` file with `load` a `NpzFile` object is
-    returned. This is a dictionary-like object which can be queried for
-    its list of arrays (with the ``.files`` attribute), and for the arrays
-    themselves.
-
-    Examples
-    --------
-    >>> test_array = np.random.rand(3, 2)
-    >>> test_vector = np.random.rand(4)
-    >>> np.savez_compressed('/tmp/123', a=test_array, b=test_vector)
-    >>> loaded = np.load('/tmp/123.npz')
-    >>> print(np.array_equal(test_array, loaded['a']))
-    True
-    >>> print(np.array_equal(test_vector, loaded['b']))
-    True
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ediff1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ediff1d"))))
-(alter-meta! #'ediff1d assoc :doc "
-    The differences between consecutive elements of an array.
-
-    Parameters
-    ----------
-    ary : array_like
-        If necessary, will be flattened before the differences are taken.
-    to_end : array_like, optional
-        Number(s) to append at the end of the returned differences.
-    to_begin : array_like, optional
-        Number(s) to prepend at the beginning of the returned differences.
-
-    Returns
-    -------
-    ediff1d : ndarray
-        The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.
-
-    See Also
-    --------
-    diff, gradient
-
-    Notes
-    -----
-    When applied to masked arrays, this function drops the mask information
-    if the `to_begin` and/or `to_end` parameters are used.
-
-    Examples
-    --------
-    >>> x = np.array([1, 2, 4, 7, 0])
-    >>> np.ediff1d(x)
-    array([ 1,  2,  3, -7])
-
-    >>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))
-    array([-99,   1,   2, ...,  -7,  88,  99])
-
-    The returned array is always 1D.
-
-    >>> y = [[1, 2, 4], [1, 6, 24]]
-    >>> np.ediff1d(y)
-    array([ 1,  2, -3,  5, 18])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def fromfile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromfile"))))
-(alter-meta! #'fromfile assoc :doc "fromfile(file, dtype=float, count=-1, sep='', offset=0)
-
-    Construct an array from data in a text or binary file.
-
-    A highly efficient way of reading binary data with a known data-type,
-    as well as parsing simply formatted text files.  Data written using the
-    `tofile` method can be read using this function.
-
-    Parameters
-    ----------
-    file : file or str or Path
-        Open file object or filename.
-
-        .. versionchanged:: 1.17.0
-            `pathlib.Path` objects are now accepted.
-
-    dtype : data-type
-        Data type of the returned array.
-        For binary files, it is used to determine the size and byte-order
-        of the items in the file.
-        Most builtin numeric types are supported and extension types may be supported.
-
-        .. versionadded:: 1.18.0
-            Complex dtypes.
-
-    count : int
-        Number of items to read. ``-1`` means all items (i.e., the complete
-        file).
-    sep : str
-        Separator between items if file is a text file.
-        Empty (\"\") separator means the file should be treated as binary.
-        Spaces (\" \") in the separator match zero or more whitespace characters.
-        A separator consisting only of spaces must match at least one
-        whitespace.
-    offset : int
-        The offset (in bytes) from the file's current position. Defaults to 0.
-        Only permitted for binary files.
-
-        .. versionadded:: 1.17.0
-
-    See also
-    --------
-    load, save
-    ndarray.tofile
-    loadtxt : More flexible way of loading data from a text file.
-
-    Notes
-    -----
-    Do not rely on the combination of `tofile` and `fromfile` for
-    data storage, as the binary files generated are not platform
-    independent.  In particular, no byte-order or data-type information is
-    saved.  Data can be stored in the platform independent ``.npy`` format
-    using `save` and `load` instead.
-
-    Examples
-    --------
-    Construct an ndarray:
-
-    >>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]),
-    ...                ('temp', float)])
-    >>> x = np.zeros((1,), dtype=dt)
-    >>> x['time']['min'] = 10; x['temp'] = 98.25
-    >>> x
-    array([((10, 0), 98.25)],
-          dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])
-
-    Save the raw data to disk:
-
-    >>> import tempfile
-    >>> fname = tempfile.mkstemp()[1]
-    >>> x.tofile(fname)
-
-    Read the raw data from disk:
-
-    >>> np.fromfile(fname, dtype=dt)
-    array([((10, 0), 98.25)],
-          dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])
-
-    The recommended way to store and load data:
-
-    >>> np.save(fname, x)
-    >>> np.load(fname + '.npy')
-    array([((10, 0), 98.25)],
-          dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def put (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "put"))))
-(alter-meta! #'put assoc :doc "
-    Replaces specified elements of an array with given values.
-
-    The indexing works on the flattened target array. `put` is roughly
-    equivalent to:
-
-    ::
-
-        a.flat[ind] = v
-
-    Parameters
-    ----------
-    a : ndarray
-        Target array.
-    ind : array_like
-        Target indices, interpreted as integers.
-    v : array_like
-        Values to place in `a` at target indices. If `v` is shorter than
-        `ind` it will be repeated as necessary.
-    mode : {'raise', 'wrap', 'clip'}, optional
-        Specifies how out-of-bounds indices will behave.
-
-        * 'raise' -- raise an error (default)
-        * 'wrap' -- wrap around
-        * 'clip' -- clip to the range
-
-        'clip' mode means that all indices that are too large are replaced
-        by the index that addresses the last element along that axis. Note
-        that this disables indexing with negative numbers. In 'raise' mode,
-        if an exception occurs the target array may still be modified.
-
-    See Also
-    --------
-    putmask, place
-    put_along_axis : Put elements by matching the array and the index arrays
-
-    Examples
-    --------
-    >>> a = np.arange(5)
-    >>> np.put(a, [0, 2], [-44, -55])
-    >>> a
-    array([-44,   1, -55,   3,   4])
-
-    >>> a = np.arange(5)
-    >>> np.put(a, 22, -5, mode='clip')
-    >>> a
-    array([ 0,  1,  2,  3, -5])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def not_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "not_equal"))))
-(alter-meta! #'not_equal assoc :doc "not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return (x1 != x2) element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    Input arrays.  If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Output array, element-wise comparison of `x1` and `x2`.
-    Typically of type bool, unless ``dtype=object`` is passed.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-equal, greater, greater_equal, less, less_equal
-
-Examples
---------
->>> np.not_equal([1.,2.], [1., 3.])
-array([False,  True])
->>> np.not_equal([1, 2], [[1, 3],[1, 4]])
-array([[False,  True],
-       [False,  True]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def corrcoef (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "corrcoef"))))
-(alter-meta! #'corrcoef assoc :doc "
-    Return Pearson product-moment correlation coefficients.
-
-    Please refer to the documentation for `cov` for more detail.  The
-    relationship between the correlation coefficient matrix, `R`, and the
-    covariance matrix, `C`, is
-
-    .. math:: R_{ij} = \\frac{ C_{ij} } { \\sqrt{ C_{ii} * C_{jj} } }
-
-    The values of `R` are between -1 and 1, inclusive.
-
-    Parameters
-    ----------
-    x : array_like
-        A 1-D or 2-D array containing multiple variables and observations.
-        Each row of `x` represents a variable, and each column a single
-        observation of all those variables. Also see `rowvar` below.
-    y : array_like, optional
-        An additional set of variables and observations. `y` has the same
-        shape as `x`.
-    rowvar : bool, optional
-        If `rowvar` is True (default), then each row represents a
-        variable, with observations in the columns. Otherwise, the relationship
-        is transposed: each column represents a variable, while the rows
-        contain observations.
-    bias : _NoValue, optional
-        Has no effect, do not use.
-
-        .. deprecated:: 1.10.0
-    ddof : _NoValue, optional
-        Has no effect, do not use.
-
-        .. deprecated:: 1.10.0
-
-    Returns
-    -------
-    R : ndarray
-        The correlation coefficient matrix of the variables.
-
-    See Also
-    --------
-    cov : Covariance matrix
-
-    Notes
-    -----
-    Due to floating point rounding the resulting array may not be Hermitian,
-    the diagonal elements may not be 1, and the elements may not satisfy the
-    inequality abs(a) <= 1. The real and imaginary parts are clipped to the
-    interval [-1,  1] in an attempt to improve on that situation but is not
-    much help in the complex case.
-
-    This function accepts but discards arguments `bias` and `ddof`.  This is
-    for backwards compatibility with previous versions of this function.  These
-    arguments had no effect on the return values of the function and can be
-    safely ignored in this and previous versions of numpy.
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def msort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "msort"))))
-(alter-meta! #'msort assoc :doc "
-    Return a copy of an array sorted along the first axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Array to be sorted.
-
-    Returns
-    -------
-    sorted_array : ndarray
-        Array of the same type and shape as `a`.
-
-    See Also
-    --------
-    sort
-
-    Notes
-    -----
-    ``np.msort(a)`` is equivalent to  ``np.sort(a, axis=0)``.
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def csingle (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "csingle"))))
-(alter-meta! #'csingle assoc :doc "Complex number type composed of two single-precision floating-point
-    numbers.
-    Character code: ``'F'``.
-    Canonical name: ``np.csingle``.
-    Alias: ``np.singlecomplex``.
-    Alias *on this platform*: ``np.complex64``: Complex number type composed of 2 32-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def bitwise_or (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_or"))))
-(alter-meta! #'bitwise_or assoc :doc "bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute the bit-wise OR of two arrays element-wise.
-
-Computes the bit-wise OR of the underlying binary representation of
-the integers in the input arrays. This ufunc implements the C/Python
-operator ``|``.
-
-Parameters
-----------
-x1, x2 : array_like
-    Only integer and boolean types are handled. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Result.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-logical_or
-bitwise_and
-bitwise_xor
-binary_repr :
-    Return the binary representation of the input number as a string.
-
-Examples
---------
-The number 13 has the binaray representation ``00001101``. Likewise,
-16 is represented by ``00010000``.  The bit-wise OR of 13 and 16 is
-then ``000111011``, or 29:
-
->>> np.bitwise_or(13, 16)
-29
->>> np.binary_repr(29)
-'11101'
-
->>> np.bitwise_or(32, 2)
-34
->>> np.bitwise_or([33, 4], 1)
-array([33,  5])
->>> np.bitwise_or([33, 4], [1, 2])
-array([33,  6])
-
->>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4]))
-array([  6,   5, 255])
->>> np.array([2, 5, 255]) | np.array([4, 4, 4])
-array([  6,   5, 255])
->>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32),
-...               np.array([4, 4, 4, 2147483647], dtype=np.int32))
-array([         6,          5,        255, 2147483647])
->>> np.bitwise_or([True, True], [False, True])
-array([ True,  True])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def rad2deg (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rad2deg"))))
-(alter-meta! #'rad2deg assoc :doc "rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Convert angles from radians to degrees.
-
-Parameters
-----------
-x : array_like
-    Angle in radians.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The corresponding angle in degrees.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-deg2rad : Convert angles from degrees to radians.
-unwrap : Remove large jumps in angle by wrapping.
-
-Notes
------
-.. versionadded:: 1.3.0
-
-rad2deg(x) is ``180 * x / pi``.
-
-Examples
---------
->>> np.rad2deg(np.pi/2)
-90.0" :arglists '[[self & [args {:as kwargs}]]])
-
-(def deprecate_with_doc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "deprecate_with_doc"))))
-(alter-meta! #'deprecate_with_doc assoc :doc "" :arglists '[[msg]])
-
-(def real_if_close (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "real_if_close"))))
-(alter-meta! #'real_if_close assoc :doc "
-    If complex input returns a real array if complex parts are close to zero.
-
-    \"Close to zero\" is defined as `tol` * (machine epsilon of the type for
-    `a`).
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    tol : float
-        Tolerance in machine epsilons for the complex part of the elements
-        in the array.
-
-    Returns
-    -------
-    out : ndarray
-        If `a` is real, the type of `a` is used for the output.  If `a`
-        has complex elements, the returned type is float.
-
-    See Also
-    --------
-    real, imag, angle
-
-    Notes
-    -----
-    Machine epsilon varies from machine to machine and between data types
-    but Python floats on most platforms have a machine epsilon equal to
-    2.2204460492503131e-16.  You can use 'np.finfo(float).eps' to print
-    out the machine epsilon for floats.
-
-    Examples
-    --------
-    >>> np.finfo(float).eps
-    2.2204460492503131e-16 # may vary
-
-    >>> np.real_if_close([2.1 + 4e-14j], tol=1000)
-    array([2.1])
-    >>> np.real_if_close([2.1 + 4e-13j], tol=1000)
-    array([2.1+4.e-13j])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def fromregex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromregex"))))
-(alter-meta! #'fromregex assoc :doc "
-    Construct an array from a text file, using regular expression parsing.
-
-    The returned array is always a structured array, and is constructed from
-    all matches of the regular expression in the file. Groups in the regular
-    expression are converted to fields of the structured array.
-
-    Parameters
-    ----------
-    file : str or file
-        Filename or file object to read.
-    regexp : str or regexp
-        Regular expression used to parse the file.
-        Groups in the regular expression correspond to fields in the dtype.
-    dtype : dtype or list of dtypes
-        Dtype for the structured array.
-    encoding : str, optional
-        Encoding used to decode the inputfile. Does not apply to input streams.
-
-        .. versionadded:: 1.14.0
-
-    Returns
-    -------
-    output : ndarray
-        The output array, containing the part of the content of `file` that
-        was matched by `regexp`. `output` is always a structured array.
-
-    Raises
-    ------
-    TypeError
-        When `dtype` is not a valid dtype for a structured array.
-
-    See Also
-    --------
-    fromstring, loadtxt
-
-    Notes
-    -----
-    Dtypes for structured arrays can be specified in several forms, but all
-    forms specify at least the data type and field name. For details see
-    `doc.structured_arrays`.
-
-    Examples
-    --------
-    >>> f = open('test.dat', 'w')
-    >>> _ = f.write(\"1312 foo\\n1534  bar\\n444   qux\")
-    >>> f.close()
-
-    >>> regexp = r\"(\\d+)\\s+(...)\"  # match [digits, whitespace, anything]
-    >>> output = np.fromregex('test.dat', regexp,
-    ...                       [('num', np.int64), ('key', 'S3')])
-    >>> output
-    array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')],
-          dtype=[('num', '<i8'), ('key', 'S3')])
-    >>> output['num']
-    array([1312, 1534,  444])
-
-    " :arglists '[[file regexp dtype & [{encoding :encoding}]] [file regexp dtype]])
-
-(def ^{:doc ""} FLOATING_POINT_SUPPORT (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "FLOATING_POINT_SUPPORT"))))
-
-(def clip (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "clip"))))
-(alter-meta! #'clip assoc :doc "
-    Clip (limit) the values in an array.
-
-    Given an interval, values outside the interval are clipped to
-    the interval edges.  For example, if an interval of ``[0, 1]``
-    is specified, values smaller than 0 become 0, and values larger
-    than 1 become 1.
-
-    Equivalent to but faster than ``np.maximum(a_min, np.minimum(a, a_max))``.
-    No check is performed to ensure ``a_min < a_max``.
-
-    Parameters
-    ----------
-    a : array_like
-        Array containing elements to clip.
-    a_min : scalar or array_like or None
-        Minimum value. If None, clipping is not performed on lower
-        interval edge. Not more than one of `a_min` and `a_max` may be
-        None.
-    a_max : scalar or array_like or None
-        Maximum value. If None, clipping is not performed on upper
-        interval edge. Not more than one of `a_min` and `a_max` may be
-        None. If `a_min` or `a_max` are array_like, then the three
-        arrays will be broadcasted to match their shapes.
-    out : ndarray, optional
-        The results will be placed in this array. It may be the input
-        array for in-place clipping.  `out` must be of the right shape
-        to hold the output.  Its type is preserved.
-    **kwargs
-        For other keyword-only arguments, see the
-        :ref:`ufunc docs <ufuncs.kwargs>`.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    clipped_array : ndarray
-        An array with the elements of `a`, but where values
-        < `a_min` are replaced with `a_min`, and those > `a_max`
-        with `a_max`.
-
-    See Also
-    --------
-    ufuncs-output-type
-
-    Examples
-    --------
-    >>> a = np.arange(10)
-    >>> np.clip(a, 1, 8)
-    array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
-    >>> a
-    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-    >>> np.clip(a, 3, 6, out=a)
-    array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
-    >>> a = np.arange(10)
-    >>> a
-    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-    >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
-    array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def longdouble (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longdouble"))))
-(alter-meta! #'longdouble assoc :doc "Extended-precision floating-point number type, compatible with C
-    ``long double`` but not necessarily with IEEE 754 quadruple-precision.
-    Character code: ``'g'``.
-    Canonical name: ``np.longdouble``.
-    Alias: ``np.longfloat``.
-    Alias *on this platform*: ``np.float128``: 128-bit extended-precision floating-point number type." :arglists '[[self & [args {:as kwargs}]]])
-
-(def record (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "record"))))
-(alter-meta! #'record assoc :doc "A data-type scalar that allows field access as attribute lookup.
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def argmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argmax"))))
-(alter-meta! #'argmax assoc :doc "
-    Returns the indices of the maximum values along an axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    axis : int, optional
-        By default, the index is into the flattened array, otherwise
-        along the specified axis.
-    out : array, optional
-        If provided, the result will be inserted into this array. It should
-        be of the appropriate shape and dtype.
-
-    Returns
-    -------
-    index_array : ndarray of ints
-        Array of indices into the array. It has the same shape as `a.shape`
-        with the dimension along `axis` removed.
-
-    See Also
-    --------
-    ndarray.argmax, argmin
-    amax : The maximum value along a given axis.
-    unravel_index : Convert a flat index into an index tuple.
-    take_along_axis : Apply ``np.expand_dims(index_array, axis)`` 
-                      from argmax to an array as if by calling max.
-
-    Notes
-    -----
-    In case of multiple occurrences of the maximum values, the indices
-    corresponding to the first occurrence are returned.
-
-    Examples
-    --------
-    >>> a = np.arange(6).reshape(2,3) + 10
-    >>> a
-    array([[10, 11, 12],
-           [13, 14, 15]])
-    >>> np.argmax(a)
-    5
-    >>> np.argmax(a, axis=0)
-    array([1, 1, 1])
-    >>> np.argmax(a, axis=1)
-    array([2, 2])
-
-    Indexes of the maximal elements of a N-dimensional array:
-
-    >>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape)
-    >>> ind
-    (1, 2)
-    >>> a[ind]
-    15
-
-    >>> b = np.arange(6)
-    >>> b[1] = 5
-    >>> b
-    array([0, 5, 2, 3, 4, 5])
-    >>> np.argmax(b)  # Only the first occurrence is returned.
-    1
-
-    >>> x = np.array([[4,2,3], [1,0,3]])
-    >>> index_array = np.argmax(x, axis=-1)
-    >>> # Same as np.max(x, axis=-1, keepdims=True)
-    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
-    array([[4],
-           [3]])
-    >>> # Same as np.max(x, axis=-1)
-    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1)
-    array([4, 3])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def frexp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "frexp"))))
-(alter-meta! #'frexp assoc :doc "frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Decompose the elements of x into mantissa and twos exponent.
-
-Returns (`mantissa`, `exponent`), where `x = mantissa * 2**exponent``.
-The mantissa is lies in the open interval(-1, 1), while the twos
-exponent is a signed integer.
-
-Parameters
-----------
-x : array_like
-    Array of numbers to be decomposed.
-out1 : ndarray, optional
-    Output array for the mantissa. Must have the same shape as `x`.
-out2 : ndarray, optional
-    Output array for the exponent. Must have the same shape as `x`.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-mantissa : ndarray
-    Floating values between -1 and 1.
-    This is a scalar if `x` is a scalar.
-exponent : ndarray
-    Integer exponents of 2.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`.
-
-Notes
------
-Complex dtypes are not supported, they will raise a TypeError.
-
-Examples
---------
->>> x = np.arange(9)
->>> y1, y2 = np.frexp(x)
->>> y1
-array([ 0.   ,  0.5  ,  0.5  ,  0.75 ,  0.5  ,  0.625,  0.75 ,  0.875,
-        0.5  ])
->>> y2
-array([0, 1, 2, 2, 3, 3, 3, 3, 4])
->>> y1 * 2**y2
-array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def asmatrix (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asmatrix"))))
-(alter-meta! #'asmatrix assoc :doc "
-    Interpret the input as a matrix.
-
-    Unlike `matrix`, `asmatrix` does not make a copy if the input is already
-    a matrix or an ndarray.  Equivalent to ``matrix(data, copy=False)``.
-
-    Parameters
-    ----------
-    data : array_like
-        Input data.
-    dtype : data-type
-       Data-type of the output matrix.
-
-    Returns
-    -------
-    mat : matrix
-        `data` interpreted as a matrix.
-
-    Examples
-    --------
-    >>> x = np.array([[1, 2], [3, 4]])
-
-    >>> m = np.asmatrix(x)
-
-    >>> x[0,0] = 5
-
-    >>> m
-    matrix([[5, 2],
-            [3, 4]])
-
-    " :arglists '[[data & [{dtype :dtype}]] [data]])
-
-(def matmul (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "matmul"))))
-(alter-meta! #'matmul assoc :doc "matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Matrix product of two arrays.
-
-Parameters
-----------
-x1, x2 : array_like
-    Input arrays, scalars not allowed.
-out : ndarray, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not
-    provided or None, a freshly-allocated array is returned.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-    .. versionadded:: 1.16
-       Now handles ufunc kwargs
-
-Returns
--------
-y : ndarray
-    The matrix product of the inputs.
-    This is a scalar only when both x1, x2 are 1-d vectors.
-
-Raises
-------
-ValueError
-    If the last dimension of `a` is not the same size as
-    the second-to-last dimension of `b`.
-
-    If a scalar value is passed in.
-
-See Also
---------
-vdot : Complex-conjugating dot product.
-tensordot : Sum products over arbitrary axes.
-einsum : Einstein summation convention.
-dot : alternative matrix product with different broadcasting rules.
-
-Notes
------
-
-The behavior depends on the arguments in the following way.
-
-- If both arguments are 2-D they are multiplied like conventional
-  matrices.
-- If either argument is N-D, N > 2, it is treated as a stack of
-  matrices residing in the last two indexes and broadcast accordingly.
-- If the first argument is 1-D, it is promoted to a matrix by
-  prepending a 1 to its dimensions. After matrix multiplication
-  the prepended 1 is removed.
-- If the second argument is 1-D, it is promoted to a matrix by
-  appending a 1 to its dimensions. After matrix multiplication
-  the appended 1 is removed.
-
-``matmul`` differs from ``dot`` in two important ways:
-
-- Multiplication by scalars is not allowed, use ``*`` instead.
-- Stacks of matrices are broadcast together as if the matrices
-  were elements, respecting the signature ``(n,k),(k,m)->(n,m)``:
-
-  >>> a = np.ones([9, 5, 7, 4])
-  >>> c = np.ones([9, 5, 4, 3])
-  >>> np.dot(a, c).shape
-  (9, 5, 7, 9, 5, 3)
-  >>> np.matmul(a, c).shape
-  (9, 5, 7, 3)
-  >>> # n is 7, k is 4, m is 3
-
-The matmul function implements the semantics of the `@` operator introduced
-in Python 3.5 following PEP465.
-
-Examples
---------
-For 2-D arrays it is the matrix product:
-
->>> a = np.array([[1, 0],
-...               [0, 1]])
->>> b = np.array([[4, 1],
-...               [2, 2]])
->>> np.matmul(a, b)
-array([[4, 1],
-       [2, 2]])
-
-For 2-D mixed with 1-D, the result is the usual.
-
->>> a = np.array([[1, 0],
-...               [0, 1]])
->>> b = np.array([1, 2])
->>> np.matmul(a, b)
-array([1, 2])
->>> np.matmul(b, a)
-array([1, 2])
-
-
-Broadcasting is conventional for stacks of arrays
-
->>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4))
->>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2))
->>> np.matmul(a,b).shape
-(2, 2, 2)
->>> np.matmul(a, b)[0, 1, 1]
-98
->>> sum(a[0, 1, :] * b[0 , :, 1])
-98
-
-Vector, vector returns the scalar inner product, but neither argument
-is complex-conjugated:
-
->>> np.matmul([2j, 3j], [2j, 3j])
-(-13+0j)
-
-Scalar multiplication raises an error.
-
->>> np.matmul([1,2], 3)
-Traceback (most recent call last):
-...
-ValueError: matmul: Input operand 1 does not have enough dimensions ...
-
-.. versionadded:: 1.10.0" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc "
-Wrapper functions to more user-friendly calling of certain math functions
-whose output data-type is different than the input data-type in certain
-domains of the input.
-
-For example, for functions like `log` with branch cuts, the versions in this
-module provide the mathematically valid answers in the complex plane::
-
-  >>> import math
-  >>> from numpy.lib import scimath
-  >>> scimath.log(-math.exp(1)) == (1+1j*math.pi)
-  True
-
-Similarly, `sqrt`, other base logarithms, `power` and trig functions are
-correctly handled.  See their respective docstrings for specific examples.
-
-"} emath (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "emath"))))
-
-(def mean (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mean"))))
-(alter-meta! #'mean assoc :doc "
-    Compute the arithmetic mean along the specified axis.
-
-    Returns the average of the array elements.  The average is taken over
-    the flattened array by default, otherwise over the specified axis.
-    `float64` intermediate and return values are used for integer inputs.
-
-    Parameters
-    ----------
-    a : array_like
-        Array containing numbers whose mean is desired. If `a` is not an
-        array, a conversion is attempted.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which the means are computed. The default is to
-        compute the mean of the flattened array.
-
-        .. versionadded:: 1.7.0
-
-        If this is a tuple of ints, a mean is performed over multiple axes,
-        instead of a single axis or all the axes as before.
-    dtype : data-type, optional
-        Type to use in computing the mean.  For integer inputs, the default
-        is `float64`; for floating point inputs, it is the same as the
-        input dtype.
-    out : ndarray, optional
-        Alternate output array in which to place the result.  The default
-        is ``None``; if provided, it must have the same shape as the
-        expected output, but the type will be cast if necessary.
-        See `ufuncs-output-type` for more details.
-
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `mean` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-
-    Returns
-    -------
-    m : ndarray, see dtype parameter above
-        If `out=None`, returns a new array containing the mean values,
-        otherwise a reference to the output array is returned.
-
-    See Also
-    --------
-    average : Weighted average
-    std, var, nanmean, nanstd, nanvar
-
-    Notes
-    -----
-    The arithmetic mean is the sum of the elements along the axis divided
-    by the number of elements.
-
-    Note that for floating-point input, the mean is computed using the
-    same precision the input has.  Depending on the input data, this can
-    cause the results to be inaccurate, especially for `float32` (see
-    example below).  Specifying a higher-precision accumulator using the
-    `dtype` keyword can alleviate this issue.
-
-    By default, `float16` results are computed using `float32` intermediates
-    for extra precision.
-
-    Examples
-    --------
-    >>> a = np.array([[1, 2], [3, 4]])
-    >>> np.mean(a)
-    2.5
-    >>> np.mean(a, axis=0)
-    array([2., 3.])
-    >>> np.mean(a, axis=1)
-    array([1.5, 3.5])
-
-    In single precision, `mean` can be inaccurate:
-
-    >>> a = np.zeros((2, 512*512), dtype=np.float32)
-    >>> a[0, :] = 1.0
-    >>> a[1, :] = 0.1
-    >>> np.mean(a)
-    0.54999924
-
-    Computing the mean in float64 is more accurate:
-
-    >>> np.mean(a, dtype=np.float64)
-    0.55000000074505806 # may vary
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def uint32 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint32"))))
-(alter-meta! #'uint32 assoc :doc "Unsigned integer type, compatible with C ``unsigned int``.
-    Character code: ``'I'``.
-    Canonical name: ``np.uintc``.
-    Alias *on this platform*: ``np.uint32``: 32-bit unsigned integer (0 to 4294967295)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def alltrue (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "alltrue"))))
-(alter-meta! #'alltrue assoc :doc "
-    Check if all elements of input array are true.
-
-    See Also
-    --------
-    numpy.all : Equivalent function; see for details.
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def get_array_wrap (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "get_array_wrap"))))
-(alter-meta! #'get_array_wrap assoc :doc "Find the wrapper for the array with the highest priority.
-
-    In case of ties, leftmost wins. If no wrapper is found, return None
-    " :arglists '[[& [args]]])
-
-(def loadtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "loadtxt"))))
-(alter-meta! #'loadtxt assoc :doc "
-    Load data from a text file.
-
-    Each row in the text file must have the same number of values.
-
-    Parameters
-    ----------
-    fname : file, str, or pathlib.Path
-        File, filename, or generator to read.  If the filename extension is
-        ``.gz`` or ``.bz2``, the file is first decompressed. Note that
-        generators should return byte strings.
-    dtype : data-type, optional
-        Data-type of the resulting array; default: float.  If this is a
-        structured data-type, the resulting array will be 1-dimensional, and
-        each row will be interpreted as an element of the array.  In this
-        case, the number of columns used must match the number of fields in
-        the data-type.
-    comments : str or sequence of str, optional
-        The characters or list of characters used to indicate the start of a
-        comment. None implies no comments. For backwards compatibility, byte
-        strings will be decoded as 'latin1'. The default is '#'.
-    delimiter : str, optional
-        The string used to separate values. For backwards compatibility, byte
-        strings will be decoded as 'latin1'. The default is whitespace.
-    converters : dict, optional
-        A dictionary mapping column number to a function that will parse the
-        column string into the desired value.  E.g., if column 0 is a date
-        string: ``converters = {0: datestr2num}``.  Converters can also be
-        used to provide a default value for missing data (but see also
-        `genfromtxt`): ``converters = {3: lambda s: float(s.strip() or 0)}``.
-        Default: None.
-    skiprows : int, optional
-        Skip the first `skiprows` lines, including comments; default: 0.
-    usecols : int or sequence, optional
-        Which columns to read, with 0 being the first. For example,
-        ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns.
-        The default, None, results in all columns being read.
-
-        .. versionchanged:: 1.11.0
-            When a single column has to be read it is possible to use
-            an integer instead of a tuple. E.g ``usecols = 3`` reads the
-            fourth column the same way as ``usecols = (3,)`` would.
-    unpack : bool, optional
-        If True, the returned array is transposed, so that arguments may be
-        unpacked using ``x, y, z = loadtxt(...)``.  When used with a structured
-        data-type, arrays are returned for each field.  Default is False.
-    ndmin : int, optional
-        The returned array will have at least `ndmin` dimensions.
-        Otherwise mono-dimensional axes will be squeezed.
-        Legal values: 0 (default), 1 or 2.
-
-        .. versionadded:: 1.6.0
-    encoding : str, optional
-        Encoding used to decode the inputfile. Does not apply to input streams.
-        The special value 'bytes' enables backward compatibility workarounds
-        that ensures you receive byte arrays as results if possible and passes
-        'latin1' encoded strings to converters. Override this value to receive
-        unicode arrays and pass strings as input to converters.  If set to None
-        the system default is used. The default value is 'bytes'.
-
-        .. versionadded:: 1.14.0
-    max_rows : int, optional
-        Read `max_rows` lines of content after `skiprows` lines. The default
-        is to read all the lines.
-
-        .. versionadded:: 1.16.0
-
-    Returns
-    -------
-    out : ndarray
-        Data read from the text file.
-
-    See Also
-    --------
-    load, fromstring, fromregex
-    genfromtxt : Load data with missing values handled as specified.
-    scipy.io.loadmat : reads MATLAB data files
-
-    Notes
-    -----
-    This function aims to be a fast reader for simply formatted files.  The
-    `genfromtxt` function provides more sophisticated handling of, e.g.,
-    lines with missing values.
-
-    .. versionadded:: 1.10.0
-
-    The strings produced by the Python float.hex method can be used as
-    input for floats.
-
-    Examples
-    --------
-    >>> from io import StringIO   # StringIO behaves like a file object
-    >>> c = StringIO(u\"0 1\\n2 3\")
-    >>> np.loadtxt(c)
-    array([[0., 1.],
-           [2., 3.]])
-
-    >>> d = StringIO(u\"M 21 72\\nF 35 58\")
-    >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),
-    ...                      'formats': ('S1', 'i4', 'f4')})
-    array([(b'M', 21, 72.), (b'F', 35, 58.)],
-          dtype=[('gender', 'S1'), ('age', '<i4'), ('weight', '<f4')])
-
-    >>> c = StringIO(u\"1,0,2\\n3,0,4\")
-    >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)
-    >>> x
-    array([1., 3.])
-    >>> y
-    array([2., 4.])
-
-    " :arglists '[[fname & [{max_rows :max_rows, encoding :encoding, ndmin :ndmin, dtype :dtype, comments :comments, unpack :unpack, converters :converters, delimiter :delimiter, skiprows :skiprows, usecols :usecols}]] [fname & [{encoding :encoding, ndmin :ndmin, dtype :dtype, comments :comments, unpack :unpack, converters :converters, delimiter :delimiter, skiprows :skiprows, usecols :usecols}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols, unpack :unpack, ndmin :ndmin}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols, unpack :unpack}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter}]] [fname & [{dtype :dtype, comments :comments}]] [fname & [{dtype :dtype}]] [fname]])
-
-(def var (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "var"))))
-(alter-meta! #'var assoc :doc "
-    Compute the variance along the specified axis.
-
-    Returns the variance of the array elements, a measure of the spread of a
-    distribution.  The variance is computed for the flattened array by
-    default, otherwise over the specified axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Array containing numbers whose variance is desired.  If `a` is not an
-        array, a conversion is attempted.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which the variance is computed.  The default is to
-        compute the variance of the flattened array.
-
-        .. versionadded:: 1.7.0
-
-        If this is a tuple of ints, a variance is performed over multiple axes,
-        instead of a single axis or all the axes as before.
-    dtype : data-type, optional
-        Type to use in computing the variance.  For arrays of integer type
-        the default is `float64`; for arrays of float types it is the same as
-        the array type.
-    out : ndarray, optional
-        Alternate output array in which to place the result.  It must have
-        the same shape as the expected output, but the type is cast if
-        necessary.
-    ddof : int, optional
-        \"Delta Degrees of Freedom\": the divisor used in the calculation is
-        ``N - ddof``, where ``N`` represents the number of elements. By
-        default `ddof` is zero.
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `var` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-
-    Returns
-    -------
-    variance : ndarray, see dtype parameter above
-        If ``out=None``, returns a new array containing the variance;
-        otherwise, a reference to the output array is returned.
-
-    See Also
-    --------
-    std, mean, nanmean, nanstd, nanvar
-    ufuncs-output-type
-
-    Notes
-    -----
-    The variance is the average of the squared deviations from the mean,
-    i.e.,  ``var = mean(abs(x - x.mean())**2)``.
-
-    The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``.
-    If, however, `ddof` is specified, the divisor ``N - ddof`` is used
-    instead.  In standard statistical practice, ``ddof=1`` provides an
-    unbiased estimator of the variance of a hypothetical infinite population.
-    ``ddof=0`` provides a maximum likelihood estimate of the variance for
-    normally distributed variables.
-
-    Note that for complex numbers, the absolute value is taken before
-    squaring, so that the result is always real and nonnegative.
-
-    For floating-point input, the variance is computed using the same
-    precision the input has.  Depending on the input data, this can cause
-    the results to be inaccurate, especially for `float32` (see example
-    below).  Specifying a higher-accuracy accumulator using the ``dtype``
-    keyword can alleviate this issue.
-
-    Examples
-    --------
-    >>> a = np.array([[1, 2], [3, 4]])
-    >>> np.var(a)
-    1.25
-    >>> np.var(a, axis=0)
-    array([1.,  1.])
-    >>> np.var(a, axis=1)
-    array([0.25,  0.25])
-
-    In single precision, var() can be inaccurate:
-
-    >>> a = np.zeros((2, 512*512), dtype=np.float32)
-    >>> a[0, :] = 1.0
-    >>> a[1, :] = 0.1
-    >>> np.var(a)
-    0.20250003
-
-    Computing the variance in float64 is more accurate:
-
-    >>> np.var(a, dtype=np.float64)
-    0.20249999932944759 # may vary
-    >>> ((1-0.55)**2 + (0.1-0.55)**2)/2
-    0.2025
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def take_along_axis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "take_along_axis"))))
-(alter-meta! #'take_along_axis assoc :doc "
-    Take values from the input array by matching 1d index and data slices.
-
-    This iterates over matching 1d slices oriented along the specified axis in
-    the index and data arrays, and uses the former to look up values in the
-    latter. These slices can be different lengths.
-
-    Functions returning an index along an axis, like `argsort` and
-    `argpartition`, produce suitable indices for this function.
-
-    .. versionadded:: 1.15.0
-
-    Parameters
-    ----------
-    arr: ndarray (Ni..., M, Nk...)
-        Source array
-    indices: ndarray (Ni..., J, Nk...)
-        Indices to take along each 1d slice of `arr`. This must match the
-        dimension of arr, but dimensions Ni and Nj only need to broadcast
-        against `arr`.
-    axis: int
-        The axis to take 1d slices along. If axis is None, the input array is
-        treated as if it had first been flattened to 1d, for consistency with
-        `sort` and `argsort`.
-
-    Returns
-    -------
-    out: ndarray (Ni..., J, Nk...)
-        The indexed result.
-
-    Notes
-    -----
-    This is equivalent to (but faster than) the following use of `ndindex` and
-    `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::
-
-        Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
-        J = indices.shape[axis]  # Need not equal M
-        out = np.empty(Ni + (J,) + Nk)
-
-        for ii in ndindex(Ni):
-            for kk in ndindex(Nk):
-                a_1d       = a      [ii + s_[:,] + kk]
-                indices_1d = indices[ii + s_[:,] + kk]
-                out_1d     = out    [ii + s_[:,] + kk]
-                for j in range(J):
-                    out_1d[j] = a_1d[indices_1d[j]]
-
-    Equivalently, eliminating the inner loop, the last two lines would be::
-
-                out_1d[:] = a_1d[indices_1d]
-
-    See Also
-    --------
-    take : Take along an axis, using the same indices for every 1d slice
-    put_along_axis :
-        Put values into the destination array by matching 1d index and data slices
-
-    Examples
-    --------
-
-    For this sample array
-
-    >>> a = np.array([[10, 30, 20], [60, 40, 50]])
-
-    We can sort either by using sort directly, or argsort and this function
-
-    >>> np.sort(a, axis=1)
-    array([[10, 20, 30],
-           [40, 50, 60]])
-    >>> ai = np.argsort(a, axis=1); ai
-    array([[0, 2, 1],
-           [1, 2, 0]])
-    >>> np.take_along_axis(a, ai, axis=1)
-    array([[10, 20, 30],
-           [40, 50, 60]])
-
-    The same works for max and min, if you expand the dimensions:
-
-    >>> np.expand_dims(np.max(a, axis=1), axis=1)
-    array([[30],
-           [60]])
-    >>> ai = np.expand_dims(np.argmax(a, axis=1), axis=1)
-    >>> ai
-    array([[1],
-           [0]])
-    >>> np.take_along_axis(a, ai, axis=1)
-    array([[30],
-           [60]])
-
-    If we want to get the max and min at the same time, we can stack the
-    indices first
-
-    >>> ai_min = np.expand_dims(np.argmin(a, axis=1), axis=1)
-    >>> ai_max = np.expand_dims(np.argmax(a, axis=1), axis=1)
-    >>> ai = np.concatenate([ai_min, ai_max], axis=1)
-    >>> ai
-    array([[0, 1],
-           [1, 0]])
-    >>> np.take_along_axis(a, ai, axis=1)
-    array([[10, 30],
-           [40, 60]])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def prod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "prod"))))
-(alter-meta! #'prod assoc :doc "
-    Return the product of array elements over a given axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which a product is performed.  The default,
-        axis=None, will calculate the product of all the elements in the
-        input array. If axis is negative it counts from the last to the
-        first axis.
-
-        .. versionadded:: 1.7.0
-
-        If axis is a tuple of ints, a product is performed on all of the
-        axes specified in the tuple instead of a single axis or all the
-        axes as before.
-    dtype : dtype, optional
-        The type of the returned array, as well as of the accumulator in
-        which the elements are multiplied.  The dtype of `a` is used by
-        default unless `a` has an integer dtype of less precision than the
-        default platform integer.  In that case, if `a` is signed then the
-        platform integer is used while if `a` is unsigned then an unsigned
-        integer of the same precision as the platform integer is used.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must have
-        the same shape as the expected output, but the type of the output
-        values will be cast if necessary.
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left in the
-        result as dimensions with size one. With this option, the result
-        will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `prod` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-    initial : scalar, optional
-        The starting value for this product. See `~numpy.ufunc.reduce` for details.
-
-        .. versionadded:: 1.15.0
-
-    where : array_like of bool, optional
-        Elements to include in the product. See `~numpy.ufunc.reduce` for details.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    product_along_axis : ndarray, see `dtype` parameter above.
-        An array shaped as `a` but with the specified axis removed.
-        Returns a reference to `out` if specified.
-
-    See Also
-    --------
-    ndarray.prod : equivalent method
-    ufuncs-output-type
-
-    Notes
-    -----
-    Arithmetic is modular when using integer types, and no error is
-    raised on overflow.  That means that, on a 32-bit platform:
-
-    >>> x = np.array([536870910, 536870910, 536870910, 536870910])
-    >>> np.prod(x)
-    16 # may vary
-
-    The product of an empty array is the neutral element 1:
-
-    >>> np.prod([])
-    1.0
-
-    Examples
-    --------
-    By default, calculate the product of all elements:
-
-    >>> np.prod([1.,2.])
-    2.0
-
-    Even when the input array is two-dimensional:
-
-    >>> np.prod([[1.,2.],[3.,4.]])
-    24.0
-
-    But we can also specify the axis over which to multiply:
-
-    >>> np.prod([[1.,2.],[3.,4.]], axis=1)
-    array([  2.,  12.])
-
-    Or select specific elements to include:
-
-    >>> np.prod([1., np.nan, 3.], where=[True, False, True])
-    3.0
-
-    If the type of `x` is unsigned, then the output type is
-    the unsigned platform integer:
-
-    >>> x = np.array([1, 2, 3], dtype=np.uint8)
-    >>> np.prod(x).dtype == np.uint
-    True
-
-    If `x` is of a signed integer type, then the output type
-    is the default platform integer:
-
-    >>> x = np.array([1, 2, 3], dtype=np.int8)
-    >>> np.prod(x).dtype == int
-    True
-
-    You can also start the product with a value other than one:
-
-    >>> np.prod([1, 2], initial=5)
-    10
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def load (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "load"))))
-(alter-meta! #'load assoc :doc "
-    Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.
-
-    .. warning:: Loading files that contain object arrays uses the ``pickle``
-                 module, which is not secure against erroneous or maliciously
-                 constructed data. Consider passing ``allow_pickle=False`` to
-                 load data that is known not to contain object arrays for the
-                 safer handling of untrusted sources.
-
-    Parameters
-    ----------
-    file : file-like object, string, or pathlib.Path
-        The file to read. File-like objects must support the
-        ``seek()`` and ``read()`` methods. Pickled files require that the
-        file-like object support the ``readline()`` method as well.
-    mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional
-        If not None, then memory-map the file, using the given mode (see
-        `numpy.memmap` for a detailed description of the modes).  A
-        memory-mapped array is kept on disk. However, it can be accessed
-        and sliced like any ndarray.  Memory mapping is especially useful
-        for accessing small fragments of large files without reading the
-        entire file into memory.
-    allow_pickle : bool, optional
-        Allow loading pickled object arrays stored in npy files. Reasons for
-        disallowing pickles include security, as loading pickled data can
-        execute arbitrary code. If pickles are disallowed, loading object
-        arrays will fail. Default: False
-
-        .. versionchanged:: 1.16.3
-            Made default False in response to CVE-2019-6446.
-
-    fix_imports : bool, optional
-        Only useful when loading Python 2 generated pickled files on Python 3,
-        which includes npy/npz files containing object arrays. If `fix_imports`
-        is True, pickle will try to map the old Python 2 names to the new names
-        used in Python 3.
-    encoding : str, optional
-        What encoding to use when reading Python 2 strings. Only useful when
-        loading Python 2 generated pickled files in Python 3, which includes
-        npy/npz files containing object arrays. Values other than 'latin1',
-        'ASCII', and 'bytes' are not allowed, as they can corrupt numerical
-        data. Default: 'ASCII'
-
-    Returns
-    -------
-    result : array, tuple, dict, etc.
-        Data stored in the file. For ``.npz`` files, the returned instance
-        of NpzFile class must be closed to avoid leaking file descriptors.
-
-    Raises
-    ------
-    IOError
-        If the input file does not exist or cannot be read.
-    ValueError
-        The file contains an object array, but allow_pickle=False given.
-
-    See Also
-    --------
-    save, savez, savez_compressed, loadtxt
-    memmap : Create a memory-map to an array stored in a file on disk.
-    lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.
-
-    Notes
-    -----
-    - If the file contains pickle data, then whatever object is stored
-      in the pickle is returned.
-    - If the file is a ``.npy`` file, then a single array is returned.
-    - If the file is a ``.npz`` file, then a dictionary-like object is
-      returned, containing ``{filename: array}`` key-value pairs, one for
-      each file in the archive.
-    - If the file is a ``.npz`` file, the returned value supports the
-      context manager protocol in a similar fashion to the open function::
-
-        with load('foo.npz') as data:
-            a = data['a']
-
-      The underlying file descriptor is closed when exiting the 'with'
-      block.
-
-    Examples
-    --------
-    Store data to disk, and load it again:
-
-    >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]]))
-    >>> np.load('/tmp/123.npy')
-    array([[1, 2, 3],
-           [4, 5, 6]])
-
-    Store compressed data to disk, and load it again:
-
-    >>> a=np.array([[1, 2, 3], [4, 5, 6]])
-    >>> b=np.array([1, 2])
-    >>> np.savez('/tmp/123.npz', a=a, b=b)
-    >>> data = np.load('/tmp/123.npz')
-    >>> data['a']
-    array([[1, 2, 3],
-           [4, 5, 6]])
-    >>> data['b']
-    array([1, 2])
-    >>> data.close()
-
-    Mem-map the stored array, and then access the second row
-    directly from disk:
-
-    >>> X = np.load('/tmp/123.npy', mmap_mode='r')
-    >>> X[1, :]
-    memmap([4, 5, 6])
-
-    " :arglists '[[file & [{mmap_mode :mmap_mode, allow_pickle :allow_pickle, fix_imports :fix_imports, encoding :encoding}]] [file & [{mmap_mode :mmap_mode, allow_pickle :allow_pickle, fix_imports :fix_imports}]] [file & [{mmap_mode :mmap_mode, allow_pickle :allow_pickle}]] [file & [{mmap_mode :mmap_mode}]] [file]])
-
-(def sum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sum"))))
-(alter-meta! #'sum assoc :doc "
-    Sum of array elements over a given axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Elements to sum.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which a sum is performed.  The default,
-        axis=None, will sum all of the elements of the input array.  If
-        axis is negative it counts from the last to the first axis.
-
-        .. versionadded:: 1.7.0
-
-        If axis is a tuple of ints, a sum is performed on all of the axes
-        specified in the tuple instead of a single axis or all the axes as
-        before.
-    dtype : dtype, optional
-        The type of the returned array and of the accumulator in which the
-        elements are summed.  The dtype of `a` is used by default unless `a`
-        has an integer dtype of less precision than the default platform
-        integer.  In that case, if `a` is signed then the platform integer
-        is used while if `a` is unsigned then an unsigned integer of the
-        same precision as the platform integer is used.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must have
-        the same shape as the expected output, but the type of the output
-        values will be cast if necessary.
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `sum` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-    initial : scalar, optional
-        Starting value for the sum. See `~numpy.ufunc.reduce` for details.
-
-        .. versionadded:: 1.15.0
-
-    where : array_like of bool, optional
-        Elements to include in the sum. See `~numpy.ufunc.reduce` for details.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    sum_along_axis : ndarray
-        An array with the same shape as `a`, with the specified
-        axis removed.   If `a` is a 0-d array, or if `axis` is None, a scalar
-        is returned.  If an output array is specified, a reference to
-        `out` is returned.
-
-    See Also
-    --------
-    ndarray.sum : Equivalent method.
-
-    add.reduce : Equivalent functionality of `add`.
-
-    cumsum : Cumulative sum of array elements.
-
-    trapz : Integration of array values using the composite trapezoidal rule.
-
-    mean, average
-
-    Notes
-    -----
-    Arithmetic is modular when using integer types, and no error is
-    raised on overflow.
-
-    The sum of an empty array is the neutral element 0:
-
-    >>> np.sum([])
-    0.0
-
-    For floating point numbers the numerical precision of sum (and
-    ``np.add.reduce``) is in general limited by directly adding each number
-    individually to the result causing rounding errors in every step.
-    However, often numpy will use a  numerically better approach (partial
-    pairwise summation) leading to improved precision in many use-cases.
-    This improved precision is always provided when no ``axis`` is given.
-    When ``axis`` is given, it will depend on which axis is summed.
-    Technically, to provide the best speed possible, the improved precision
-    is only used when the summation is along the fast axis in memory.
-    Note that the exact precision may vary depending on other parameters.
-    In contrast to NumPy, Python's ``math.fsum`` function uses a slower but
-    more precise approach to summation.
-    Especially when summing a large number of lower precision floating point
-    numbers, such as ``float32``, numerical errors can become significant.
-    In such cases it can be advisable to use `dtype=\"float64\"` to use a higher
-    precision for the output.
-
-    Examples
-    --------
-    >>> np.sum([0.5, 1.5])
-    2.0
-    >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)
-    1
-    >>> np.sum([[0, 1], [0, 5]])
-    6
-    >>> np.sum([[0, 1], [0, 5]], axis=0)
-    array([0, 6])
-    >>> np.sum([[0, 1], [0, 5]], axis=1)
-    array([1, 5])
-    >>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1)
-    array([1., 5.])
-
-    If the accumulator is too small, overflow occurs:
-
-    >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8)
-    -128
-
-    You can also start the sum with a value other than zero:
-
-    >>> np.sum([10], initial=5)
-    15
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def str (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "str"))))
-(alter-meta! #'str assoc :doc "str(object='') -> str
-str(bytes_or_buffer[, encoding[, errors]]) -> str
-
-Create a new string object from the given object. If encoding or
-errors is specified, then the object must expose a data buffer
-that will be decoded using the given encoding and error handler.
-Otherwise, returns the result of object.__str__() (if defined)
-or repr(object).
-encoding defaults to sys.getdefaultencoding().
-errors defaults to 'strict'." :arglists '[[self & [args {:as kwargs}]]])
-
-(def int64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int64"))))
-(alter-meta! #'int64 assoc :doc "Signed integer type, compatible with Python `int` anc C ``long``.
-    Character code: ``'l'``.
-    Canonical name: ``np.int_``.
-    Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807).
-    Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def nper (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nper"))))
-(alter-meta! #'nper assoc :doc "
-    Compute the number of periodic payments.
-
-    .. deprecated:: 1.18
-
-       `nper` is deprecated; for details, see NEP 32 [1]_.
-       Use the corresponding function in the numpy-financial library,
-       https://pypi.org/project/numpy-financial.
-
-    :class:`decimal.Decimal` type is not supported.
-
-    Parameters
-    ----------
-    rate : array_like
-        Rate of interest (per period)
-    pmt : array_like
-        Payment
-    pv : array_like
-        Present value
-    fv : array_like, optional
-        Future value
-    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
-        When payments are due ('begin' (1) or 'end' (0))
-
-    Notes
-    -----
-    The number of periods ``nper`` is computed by solving the equation::
-
-     fv + pv*(1+rate)**nper + pmt*(1+rate*when)/rate*((1+rate)**nper-1) = 0
-
-    but if ``rate = 0`` then::
-
-     fv + pv + pmt*nper = 0
-
-    References
-    ----------
-    .. [1] NumPy Enhancement Proposal (NEP) 32,
-       https://numpy.org/neps/nep-0032-remove-financial-functions.html
-
-    Examples
-    --------
-    If you only had $150/month to pay towards the loan, how long would it take
-    to pay-off a loan of $8,000 at 7% annual interest?
-
-    >>> print(np.round(np.nper(0.07/12, -150, 8000), 5))
-    64.07335
-
-    So, over 64 months would be required to pay off the loan.
-
-    The same analysis could be done with several different interest rates
-    and/or payments and/or total amounts to produce an entire table.
-
-    >>> np.nper(*(np.ogrid[0.07/12: 0.08/12: 0.01/12,
-    ...                    -150   : -99     : 50    ,
-    ...                    8000   : 9001    : 1000]))
-    array([[[ 64.07334877,  74.06368256],
-            [108.07548412, 127.99022654]],
-           [[ 66.12443902,  76.87897353],
-            [114.70165583, 137.90124779]]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def issubclass_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issubclass_"))))
-(alter-meta! #'issubclass_ assoc :doc "
-    Determine if a class is a subclass of a second class.
-
-    `issubclass_` is equivalent to the Python built-in ``issubclass``,
-    except that it returns False instead of raising a TypeError if one
-    of the arguments is not a class.
-
-    Parameters
-    ----------
-    arg1 : class
-        Input class. True is returned if `arg1` is a subclass of `arg2`.
-    arg2 : class or tuple of classes.
-        Input class. If a tuple of classes, True is returned if `arg1` is a
-        subclass of any of the tuple elements.
-
-    Returns
-    -------
-    out : bool
-        Whether `arg1` is a subclass of `arg2` or not.
-
-    See Also
-    --------
-    issubsctype, issubdtype, issctype
-
-    Examples
-    --------
-    >>> np.issubclass_(np.int32, int)
-    False # True on Python 2.7
-    >>> np.issubclass_(np.int32, float)
-    False
-
-    " :arglists '[[arg1 arg2]])
-
-(def long (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "long"))))
-(alter-meta! #'long assoc :doc "int([x]) -> integer
-int(x, base=10) -> integer
-
-Convert a number or string to an integer, or return 0 if no arguments
-are given.  If x is a number, return x.__int__().  For floating point
-numbers, this truncates towards zero.
-
-If x is not a number or if base is given, then x must be a string,
-bytes, or bytearray instance representing an integer literal in the
-given base.  The literal can be preceded by '+' or '-' and be surrounded
-by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
-Base 0 means to interpret the base from the string as an integer literal.
->>> int('0b100', base=0)
-4" :arglists '[[self & [args {:as kwargs}]]])
-
-(def longcomplex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longcomplex"))))
-(alter-meta! #'longcomplex assoc :doc "Complex number type composed of two extended-precision floating-point
-    numbers.
-    Character code: ``'G'``.
-    Canonical name: ``np.clongdouble``.
-    Alias: ``np.clongfloat``.
-    Alias: ``np.longcomplex``.
-    Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def dot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dot"))))
-(alter-meta! #'dot assoc :doc "
-    dot(a, b, out=None)
-
-    Dot product of two arrays. Specifically,
-
-    - If both `a` and `b` are 1-D arrays, it is inner product of vectors
-      (without complex conjugation).
-
-    - If both `a` and `b` are 2-D arrays, it is matrix multiplication,
-      but using :func:`matmul` or ``a @ b`` is preferred.
-
-    - If either `a` or `b` is 0-D (scalar), it is equivalent to :func:`multiply`
-      and using ``numpy.multiply(a, b)`` or ``a * b`` is preferred.
-
-    - If `a` is an N-D array and `b` is a 1-D array, it is a sum product over
-      the last axis of `a` and `b`.
-
-    - If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a
-      sum product over the last axis of `a` and the second-to-last axis of `b`::
-
-        dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
-
-    Parameters
-    ----------
-    a : array_like
-        First argument.
-    b : array_like
-        Second argument.
-    out : ndarray, optional
-        Output argument. This must have the exact kind that would be returned
-        if it was not used. In particular, it must have the right type, must be
-        C-contiguous, and its dtype must be the dtype that would be returned
-        for `dot(a,b)`. This is a performance feature. Therefore, if these
-        conditions are not met, an exception is raised, instead of attempting
-        to be flexible.
-
-    Returns
-    -------
-    output : ndarray
-        Returns the dot product of `a` and `b`.  If `a` and `b` are both
-        scalars or both 1-D arrays then a scalar is returned; otherwise
-        an array is returned.
-        If `out` is given, then it is returned.
-
-    Raises
-    ------
-    ValueError
-        If the last dimension of `a` is not the same size as
-        the second-to-last dimension of `b`.
-
-    See Also
-    --------
-    vdot : Complex-conjugating dot product.
-    tensordot : Sum products over arbitrary axes.
-    einsum : Einstein summation convention.
-    matmul : '@' operator as method with out parameter.
-
-    Examples
-    --------
-    >>> np.dot(3, 4)
-    12
-
-    Neither argument is complex-conjugated:
-
-    >>> np.dot([2j, 3j], [2j, 3j])
-    (-13+0j)
-
-    For 2-D arrays it is the matrix product:
-
-    >>> a = [[1, 0], [0, 1]]
-    >>> b = [[4, 1], [2, 2]]
-    >>> np.dot(a, b)
-    array([[4, 1],
-           [2, 2]])
-
-    >>> a = np.arange(3*4*5*6).reshape((3,4,5,6))
-    >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
-    >>> np.dot(a, b)[2,3,2,1,2,2]
-    499128
-    >>> sum(a[2,3,2,:] * b[1,2,:,2])
-    499128
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def fv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fv"))))
-(alter-meta! #'fv assoc :doc "
-    Compute the future value.
-
-    .. deprecated:: 1.18
-
-       `fv` is deprecated; for details, see NEP 32 [1]_.
-       Use the corresponding function in the numpy-financial library,
-       https://pypi.org/project/numpy-financial.
-
-    Given:
-     * a present value, `pv`
-     * an interest `rate` compounded once per period, of which
-       there are
-     * `nper` total
-     * a (fixed) payment, `pmt`, paid either
-     * at the beginning (`when` = {'begin', 1}) or the end
-       (`when` = {'end', 0}) of each period
-
-    Return:
-       the value at the end of the `nper` periods
-
-    Parameters
-    ----------
-    rate : scalar or array_like of shape(M, )
-        Rate of interest as decimal (not per cent) per period
-    nper : scalar or array_like of shape(M, )
-        Number of compounding periods
-    pmt : scalar or array_like of shape(M, )
-        Payment
-    pv : scalar or array_like of shape(M, )
-        Present value
-    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
-        When payments are due ('begin' (1) or 'end' (0)).
-        Defaults to {'end', 0}.
-
-    Returns
-    -------
-    out : ndarray
-        Future values.  If all input is scalar, returns a scalar float.  If
-        any input is array_like, returns future values for each input element.
-        If multiple inputs are array_like, they all must have the same shape.
-
-    Notes
-    -----
-    The future value is computed by solving the equation::
-
-     fv +
-     pv*(1+rate)**nper +
-     pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) == 0
-
-    or, when ``rate == 0``::
-
-     fv + pv + pmt * nper == 0
-
-    References
-    ----------
-    .. [1] NumPy Enhancement Proposal (NEP) 32,
-       https://numpy.org/neps/nep-0032-remove-financial-functions.html
-    .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).
-       Open Document Format for Office Applications (OpenDocument)v1.2,
-       Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,
-       Pre-Draft 12. Organization for the Advancement of Structured Information
-       Standards (OASIS). Billerica, MA, USA. [ODT Document].
-       Available:
-       http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula
-       OpenDocument-formula-20090508.odt
-
-
-    Examples
-    --------
-    What is the future value after 10 years of saving $100 now, with
-    an additional monthly savings of $100.  Assume the interest rate is
-    5% (annually) compounded monthly?
-
-    >>> np.fv(0.05/12, 10*12, -100, -100)
-    15692.928894335748
-
-    By convention, the negative sign represents cash flow out (i.e. money not
-    available today).  Thus, saving $100 a month at 5% annual interest leads
-    to $15,692.93 available to spend in 10 years.
-
-    If any input is array_like, returns an array of equal shape.  Let's
-    compare different interest rates from the example above.
-
-    >>> a = np.array((0.05, 0.06, 0.07))/12
-    >>> np.fv(a, 10*12, -100, -100)
-    array([ 15692.92889434,  16569.87435405,  17509.44688102]) # may vary
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def trace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trace"))))
-(alter-meta! #'trace assoc :doc "
-    Return the sum along diagonals of the array.
-
-    If `a` is 2-D, the sum along its diagonal with the given offset
-    is returned, i.e., the sum of elements ``a[i,i+offset]`` for all i.
-
-    If `a` has more than two dimensions, then the axes specified by axis1 and
-    axis2 are used to determine the 2-D sub-arrays whose traces are returned.
-    The shape of the resulting array is the same as that of `a` with `axis1`
-    and `axis2` removed.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array, from which the diagonals are taken.
-    offset : int, optional
-        Offset of the diagonal from the main diagonal. Can be both positive
-        and negative. Defaults to 0.
-    axis1, axis2 : int, optional
-        Axes to be used as the first and second axis of the 2-D sub-arrays
-        from which the diagonals should be taken. Defaults are the first two
-        axes of `a`.
-    dtype : dtype, optional
-        Determines the data-type of the returned array and of the accumulator
-        where the elements are summed. If dtype has the value None and `a` is
-        of integer type of precision less than the default integer
-        precision, then the default integer precision is used. Otherwise,
-        the precision is the same as that of `a`.
-    out : ndarray, optional
-        Array into which the output is placed. Its type is preserved and
-        it must be of the right shape to hold the output.
-
-    Returns
-    -------
-    sum_along_diagonals : ndarray
-        If `a` is 2-D, the sum along the diagonal is returned.  If `a` has
-        larger dimensions, then an array of sums along diagonals is returned.
-
-    See Also
-    --------
-    diag, diagonal, diagflat
-
-    Examples
-    --------
-    >>> np.trace(np.eye(3))
-    3.0
-    >>> a = np.arange(8).reshape((2,2,2))
-    >>> np.trace(a)
-    array([6, 8])
-
-    >>> a = np.arange(24).reshape((2,2,2,3))
-    >>> np.trace(a).shape
-    (2, 3)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} BUFSIZE (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "BUFSIZE"))))
-
-(def nanargmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanargmin"))))
-(alter-meta! #'nanargmin assoc :doc "
-    Return the indices of the minimum values in the specified axis ignoring
-    NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the results
-    cannot be trusted if a slice contains only NaNs and Infs.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-    axis : int, optional
-        Axis along which to operate.  By default flattened input is used.
-
-    Returns
-    -------
-    index_array : ndarray
-        An array of indices or a single index value.
-
-    See Also
-    --------
-    argmin, nanargmax
-
-    Examples
-    --------
-    >>> a = np.array([[np.nan, 4], [2, 3]])
-    >>> np.argmin(a)
-    0
-    >>> np.nanargmin(a)
-    2
-    >>> np.nanargmin(a, axis=0)
-    array([1, 1])
-    >>> np.nanargmin(a, axis=1)
-    array([1, 0])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def cbrt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cbrt"))))
-(alter-meta! #'cbrt assoc :doc "cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the cube-root of an array, element-wise.
-
-.. versionadded:: 1.10.0
-
-Parameters
-----------
-x : array_like
-    The values whose cube-roots are required.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    An array of the same shape as `x`, containing the cube
-    cube-root of each element in `x`.
-    If `out` was provided, `y` is a reference to it.
-    This is a scalar if `x` is a scalar.
-
-
-Examples
---------
->>> np.cbrt([1,8,27])
-array([ 1.,  2.,  3.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def min_scalar_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "min_scalar_type"))))
-(alter-meta! #'min_scalar_type assoc :doc "
-    min_scalar_type(a)
-
-    For scalar ``a``, returns the data type with the smallest size
-    and smallest scalar kind which can hold its value.  For non-scalar
-    array ``a``, returns the vector's dtype unmodified.
-
-    Floating point values are not demoted to integers,
-    and complex values are not demoted to floats.
-
-    Parameters
-    ----------
-    a : scalar or array_like
-        The value whose minimal data type is to be found.
-
-    Returns
-    -------
-    out : dtype
-        The minimal data type.
-
-    Notes
-    -----
-    .. versionadded:: 1.6.0
-
-    See Also
-    --------
-    result_type, promote_types, dtype, can_cast
-
-    Examples
-    --------
-    >>> np.min_scalar_type(10)
-    dtype('uint8')
-
-    >>> np.min_scalar_type(-260)
-    dtype('int16')
-
-    >>> np.min_scalar_type(3.1)
-    dtype('float16')
-
-    >>> np.min_scalar_type(1e50)
-    dtype('float64')
-
-    >>> np.min_scalar_type(np.arange(4,dtype='f8'))
-    dtype('float64')
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def cross (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cross"))))
-(alter-meta! #'cross assoc :doc "
-    Return the cross product of two (arrays of) vectors.
-
-    The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular
-    to both `a` and `b`.  If `a` and `b` are arrays of vectors, the vectors
-    are defined by the last axis of `a` and `b` by default, and these axes
-    can have dimensions 2 or 3.  Where the dimension of either `a` or `b` is
-    2, the third component of the input vector is assumed to be zero and the
-    cross product calculated accordingly.  In cases where both input vectors
-    have dimension 2, the z-component of the cross product is returned.
-
-    Parameters
-    ----------
-    a : array_like
-        Components of the first vector(s).
-    b : array_like
-        Components of the second vector(s).
-    axisa : int, optional
-        Axis of `a` that defines the vector(s).  By default, the last axis.
-    axisb : int, optional
-        Axis of `b` that defines the vector(s).  By default, the last axis.
-    axisc : int, optional
-        Axis of `c` containing the cross product vector(s).  Ignored if
-        both input vectors have dimension 2, as the return is scalar.
-        By default, the last axis.
-    axis : int, optional
-        If defined, the axis of `a`, `b` and `c` that defines the vector(s)
-        and cross product(s).  Overrides `axisa`, `axisb` and `axisc`.
-
-    Returns
-    -------
-    c : ndarray
-        Vector cross product(s).
-
-    Raises
-    ------
-    ValueError
-        When the dimension of the vector(s) in `a` and/or `b` does not
-        equal 2 or 3.
-
-    See Also
-    --------
-    inner : Inner product
-    outer : Outer product.
-    ix_ : Construct index arrays.
-
-    Notes
-    -----
-    .. versionadded:: 1.9.0
-
-    Supports full broadcasting of the inputs.
-
-    Examples
-    --------
-    Vector cross-product.
-
-    >>> x = [1, 2, 3]
-    >>> y = [4, 5, 6]
-    >>> np.cross(x, y)
-    array([-3,  6, -3])
-
-    One vector with dimension 2.
-
-    >>> x = [1, 2]
-    >>> y = [4, 5, 6]
-    >>> np.cross(x, y)
-    array([12, -6, -3])
-
-    Equivalently:
-
-    >>> x = [1, 2, 0]
-    >>> y = [4, 5, 6]
-    >>> np.cross(x, y)
-    array([12, -6, -3])
-
-    Both vectors with dimension 2.
-
-    >>> x = [1,2]
-    >>> y = [4,5]
-    >>> np.cross(x, y)
-    array(-3)
-
-    Multiple vector cross-products. Note that the direction of the cross
-    product vector is defined by the `right-hand rule`.
-
-    >>> x = np.array([[1,2,3], [4,5,6]])
-    >>> y = np.array([[4,5,6], [1,2,3]])
-    >>> np.cross(x, y)
-    array([[-3,  6, -3],
-           [ 3, -6,  3]])
-
-    The orientation of `c` can be changed using the `axisc` keyword.
-
-    >>> np.cross(x, y, axisc=0)
-    array([[-3,  3],
-           [ 6, -6],
-           [-3,  3]])
-
-    Change the vector definition of `x` and `y` using `axisa` and `axisb`.
-
-    >>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]])
-    >>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]])
-    >>> np.cross(x, y)
-    array([[ -6,  12,  -6],
-           [  0,   0,   0],
-           [  6, -12,   6]])
-    >>> np.cross(x, y, axisa=0, axisb=0)
-    array([[-24,  48, -24],
-           [-30,  60, -30],
-           [-36,  72, -36]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "Capsule objects let you wrap a C \"void *\" pointer in a Python
-object.  They're a way of passing data through the Python interpreter
-without creating your own custom type.
-
-Capsules are used for communication between extension modules.
-They provide a way for an extension module to export a C interface
-to other extension modules, so that extension modules can use the
-Python import mechanism to link to one another.
-"} _UFUNC_API (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_UFUNC_API"))))
-
-(def mintypecode (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mintypecode"))))
-(alter-meta! #'mintypecode assoc :doc "
-    Return the character for the minimum-size type to which given types can
-    be safely cast.
-
-    The returned type character must represent the smallest size dtype such
-    that an array of the returned type can handle the data from an array of
-    all types in `typechars` (or if `typechars` is an array, then its
-    dtype.char).
-
-    Parameters
-    ----------
-    typechars : list of str or array_like
-        If a list of strings, each string should represent a dtype.
-        If array_like, the character representation of the array dtype is used.
-    typeset : str or list of str, optional
-        The set of characters that the returned character is chosen from.
-        The default set is 'GDFgdf'.
-    default : str, optional
-        The default character, this is returned if none of the characters in
-        `typechars` matches a character in `typeset`.
-
-    Returns
-    -------
-    typechar : str
-        The character representing the minimum-size type that was found.
-
-    See Also
-    --------
-    dtype, sctype2char, maximum_sctype
-
-    Examples
-    --------
-    >>> np.mintypecode(['d', 'f', 'S'])
-    'd'
-    >>> x = np.array([1.1, 2-3.j])
-    >>> np.mintypecode(x)
-    'D'
-
-    >>> np.mintypecode('abceh', default='G')
-    'G'
-
-    " :arglists '[[typechars & [{typeset :typeset, default :default}]] [typechars & [{typeset :typeset}]] [typechars]])
-
-(def cumprod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cumprod"))))
-(alter-meta! #'cumprod assoc :doc "
-    Return the cumulative product of elements along a given axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    axis : int, optional
-        Axis along which the cumulative product is computed.  By default
-        the input is flattened.
-    dtype : dtype, optional
-        Type of the returned array, as well as of the accumulator in which
-        the elements are multiplied.  If *dtype* is not specified, it
-        defaults to the dtype of `a`, unless `a` has an integer dtype with
-        a precision less than that of the default platform integer.  In
-        that case, the default platform integer is used instead.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must
-        have the same shape and buffer length as the expected output
-        but the type of the resulting values will be cast if necessary.
-
-    Returns
-    -------
-    cumprod : ndarray
-        A new array holding the result is returned unless `out` is
-        specified, in which case a reference to out is returned.
-
-    See Also
-    --------
-    ufuncs-output-type
-
-    Notes
-    -----
-    Arithmetic is modular when using integer types, and no error is
-    raised on overflow.
-
-    Examples
-    --------
-    >>> a = np.array([1,2,3])
-    >>> np.cumprod(a) # intermediate results 1, 1*2
-    ...               # total product 1*2*3 = 6
-    array([1, 2, 6])
-    >>> a = np.array([[1, 2, 3], [4, 5, 6]])
-    >>> np.cumprod(a, dtype=float) # specify type of output
-    array([   1.,    2.,    6.,   24.,  120.,  720.])
-
-    The cumulative product for each column (i.e., over the rows) of `a`:
-
-    >>> np.cumprod(a, axis=0)
-    array([[ 1,  2,  3],
-           [ 4, 10, 18]])
-
-    The cumulative product for each row (i.e. over the columns) of `a`:
-
-    >>> np.cumprod(a,axis=1)
-    array([[  1,   2,   6],
-           [  4,  20, 120]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def repeat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "repeat"))))
-(alter-meta! #'repeat assoc :doc "
-    Repeat elements of an array.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    repeats : int or array of ints
-        The number of repetitions for each element.  `repeats` is broadcasted
-        to fit the shape of the given axis.
-    axis : int, optional
-        The axis along which to repeat values.  By default, use the
-        flattened input array, and return a flat output array.
-
-    Returns
-    -------
-    repeated_array : ndarray
-        Output array which has the same shape as `a`, except along
-        the given axis.
-
-    See Also
-    --------
-    tile : Tile an array.
-
-    Examples
-    --------
-    >>> np.repeat(3, 4)
-    array([3, 3, 3, 3])
-    >>> x = np.array([[1,2],[3,4]])
-    >>> np.repeat(x, 2)
-    array([1, 1, 2, 2, 3, 3, 4, 4])
-    >>> np.repeat(x, 3, axis=1)
-    array([[1, 1, 1, 2, 2, 2],
-           [3, 3, 3, 4, 4, 4]])
-    >>> np.repeat(x, [1, 2], axis=0)
-    array([[1, 2],
-           [3, 4],
-           [3, 4]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def matrix (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "matrix"))))
-(alter-meta! #'matrix assoc :doc "
-    matrix(data, dtype=None, copy=True)
-
-    .. note:: It is no longer recommended to use this class, even for linear
-              algebra. Instead use regular arrays. The class may be removed
-              in the future.
-
-    Returns a matrix from an array-like object, or from a string of data.
-    A matrix is a specialized 2-D array that retains its 2-D nature
-    through operations.  It has certain special operators, such as ``*``
-    (matrix multiplication) and ``**`` (matrix power).
-
-    Parameters
-    ----------
-    data : array_like or string
-       If `data` is a string, it is interpreted as a matrix with commas
-       or spaces separating columns, and semicolons separating rows.
-    dtype : data-type
-       Data-type of the output matrix.
-    copy : bool
-       If `data` is already an `ndarray`, then this flag determines
-       whether the data is copied (the default), or whether a view is
-       constructed.
-
-    See Also
-    --------
-    array
-
-    Examples
-    --------
-    >>> a = np.matrix('1 2; 3 4')
-    >>> a
-    matrix([[1, 2],
-            [3, 4]])
-
-    >>> np.matrix([[1, 2], [3, 4]])
-    matrix([[1, 2],
-            [3, 4]])
-
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def less_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "less_equal"))))
-(alter-meta! #'less_equal assoc :doc "less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the truth value of (x1 =< x2) element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Output array, element-wise comparison of `x1` and `x2`.
-    Typically of type bool, unless ``dtype=object`` is passed.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-greater, less, greater_equal, equal, not_equal
-
-Examples
---------
->>> np.less_equal([4, 2, 1], [2, 2, 2])
-array([False,  True,  True])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def kaiser (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "kaiser"))))
-(alter-meta! #'kaiser assoc :doc "
-    Return the Kaiser window.
-
-    The Kaiser window is a taper formed by using a Bessel function.
-
-    Parameters
-    ----------
-    M : int
-        Number of points in the output window. If zero or less, an
-        empty array is returned.
-    beta : float
-        Shape parameter for window.
-
-    Returns
-    -------
-    out : array
-        The window, with the maximum value normalized to one (the value
-        one appears only if the number of samples is odd).
-
-    See Also
-    --------
-    bartlett, blackman, hamming, hanning
-
-    Notes
-    -----
-    The Kaiser window is defined as
-
-    .. math::  w(n) = I_0\\left( \\beta \\sqrt{1-\\frac{4n^2}{(M-1)^2}}
-               \\right)/I_0(\\beta)
-
-    with
-
-    .. math:: \\quad -\\frac{M-1}{2} \\leq n \\leq \\frac{M-1}{2},
-
-    where :math:`I_0` is the modified zeroth-order Bessel function.
-
-    The Kaiser was named for Jim Kaiser, who discovered a simple
-    approximation to the DPSS window based on Bessel functions.  The Kaiser
-    window is a very good approximation to the Digital Prolate Spheroidal
-    Sequence, or Slepian window, which is the transform which maximizes the
-    energy in the main lobe of the window relative to total energy.
-
-    The Kaiser can approximate many other windows by varying the beta
-    parameter.
-
-    ====  =======================
-    beta  Window shape
-    ====  =======================
-    0     Rectangular
-    5     Similar to a Hamming
-    6     Similar to a Hanning
-    8.6   Similar to a Blackman
-    ====  =======================
-
-    A beta value of 14 is probably a good starting point. Note that as beta
-    gets large, the window narrows, and so the number of samples needs to be
-    large enough to sample the increasingly narrow spike, otherwise NaNs will
-    get returned.
-
-    Most references to the Kaiser window come from the signal processing
-    literature, where it is used as one of many windowing functions for
-    smoothing values.  It is also known as an apodization (which means
-    \"removing the foot\", i.e. smoothing discontinuities at the beginning
-    and end of the sampled signal) or tapering function.
-
-    References
-    ----------
-    .. [1] J. F. Kaiser, \"Digital Filters\" - Ch 7 in \"Systems analysis by
-           digital computer\", Editors: F.F. Kuo and J.F. Kaiser, p 218-285.
-           John Wiley and Sons, New York, (1966).
-    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\", The
-           University of Alberta Press, 1975, pp. 177-178.
-    .. [3] Wikipedia, \"Window function\",
-           https://en.wikipedia.org/wiki/Window_function
-
-    Examples
-    --------
-    >>> import matplotlib.pyplot as plt
-    >>> np.kaiser(12, 14)
-     array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary
-            2.29737120e-01, 5.99885316e-01, 9.45674898e-01,
-            9.45674898e-01, 5.99885316e-01, 2.29737120e-01,
-            4.65200189e-02, 3.46009194e-03, 7.72686684e-06])
-
-
-    Plot the window and the frequency response:
-
-    >>> from numpy.fft import fft, fftshift
-    >>> window = np.kaiser(51, 14)
-    >>> plt.plot(window)
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.title(\"Kaiser window\")
-    Text(0.5, 1.0, 'Kaiser window')
-    >>> plt.ylabel(\"Amplitude\")
-    Text(0, 0.5, 'Amplitude')
-    >>> plt.xlabel(\"Sample\")
-    Text(0.5, 0, 'Sample')
-    >>> plt.show()
-
-    >>> plt.figure()
-    <Figure size 640x480 with 0 Axes>
-    >>> A = fft(window, 2048) / 25.5
-    >>> mag = np.abs(fftshift(A))
-    >>> freq = np.linspace(-0.5, 0.5, len(A))
-    >>> response = 20 * np.log10(mag)
-    >>> response = np.clip(response, -100, 100)
-    >>> plt.plot(freq, response)
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.title(\"Frequency response of Kaiser window\")
-    Text(0.5, 1.0, 'Frequency response of Kaiser window')
-    >>> plt.ylabel(\"Magnitude [dB]\")
-    Text(0, 0.5, 'Magnitude [dB]')
-    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
-    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
-    >>> plt.axis('tight')
-    (-0.5, 0.5, -100.0, ...) # may vary
-    >>> plt.show()
-
-    " :arglists '[[M beta]])
-
-(def add_newdoc_ufunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add_newdoc_ufunc"))))
-(alter-meta! #'add_newdoc_ufunc assoc :doc "add_ufunc_docstring(ufunc, new_docstring)
-
-    Replace the docstring for a ufunc with new_docstring.
-    This method will only work if the current docstring for
-    the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)
-
-    Parameters
-    ----------
-    ufunc : numpy.ufunc
-        A ufunc whose current doc is NULL.
-    new_docstring : string
-        The new docstring for the ufunc.
-
-    Notes
-    -----
-    This method allocates memory for new_docstring on
-    the heap. Technically this creates a mempory leak, since this
-    memory will not be reclaimed until the end of the program
-    even if the ufunc itself is removed. However this will only
-    be a problem if the user is repeatedly creating ufuncs with
-    no documentation, adding documentation via add_newdoc_ufunc,
-    and then throwing away the ufunc." :arglists '[[self & [args {:as kwargs}]]])
-
-(def memmap (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "memmap"))))
-(alter-meta! #'memmap assoc :doc "Create a memory-map to an array stored in a *binary* file on disk.
-
-    Memory-mapped files are used for accessing small segments of large files
-    on disk, without reading the entire file into memory.  NumPy's
-    memmap's are array-like objects.  This differs from Python's ``mmap``
-    module, which uses file-like objects.
-
-    This subclass of ndarray has some unpleasant interactions with
-    some operations, because it doesn't quite fit properly as a subclass.
-    An alternative to using this subclass is to create the ``mmap``
-    object yourself, then create an ndarray with ndarray.__new__ directly,
-    passing the object created in its 'buffer=' parameter.
-
-    This class may at some point be turned into a factory function
-    which returns a view into an mmap buffer.
-
-    Delete the memmap instance to close the memmap file.
-
-
-    Parameters
-    ----------
-    filename : str, file-like object, or pathlib.Path instance
-        The file name or file object to be used as the array data buffer.
-    dtype : data-type, optional
-        The data-type used to interpret the file contents.
-        Default is `uint8`.
-    mode : {'r+', 'r', 'w+', 'c'}, optional
-        The file is opened in this mode:
-
-        +------+-------------------------------------------------------------+
-        | 'r'  | Open existing file for reading only.                        |
-        +------+-------------------------------------------------------------+
-        | 'r+' | Open existing file for reading and writing.                 |
-        +------+-------------------------------------------------------------+
-        | 'w+' | Create or overwrite existing file for reading and writing.  |
-        +------+-------------------------------------------------------------+
-        | 'c'  | Copy-on-write: assignments affect data in memory, but       |
-        |      | changes are not saved to disk.  The file on disk is         |
-        |      | read-only.                                                  |
-        +------+-------------------------------------------------------------+
-
-        Default is 'r+'.
-    offset : int, optional
-        In the file, array data starts at this offset. Since `offset` is
-        measured in bytes, it should normally be a multiple of the byte-size
-        of `dtype`. When ``mode != 'r'``, even positive offsets beyond end of
-        file are valid; The file will be extended to accommodate the
-        additional data. By default, ``memmap`` will start at the beginning of
-        the file, even if ``filename`` is a file pointer ``fp`` and
-        ``fp.tell() != 0``.
-    shape : tuple, optional
-        The desired shape of the array. If ``mode == 'r'`` and the number
-        of remaining bytes after `offset` is not a multiple of the byte-size
-        of `dtype`, you must specify `shape`. By default, the returned array
-        will be 1-D with the number of elements determined by file size
-        and data-type.
-    order : {'C', 'F'}, optional
-        Specify the order of the ndarray memory layout:
-        :term:`row-major`, C-style or :term:`column-major`,
-        Fortran-style.  This only has an effect if the shape is
-        greater than 1-D.  The default order is 'C'.
-
-    Attributes
-    ----------
-    filename : str or pathlib.Path instance
-        Path to the mapped file.
-    offset : int
-        Offset position in the file.
-    mode : str
-        File mode.
-
-    Methods
-    -------
-    flush
-        Flush any changes in memory to file on disk.
-        When you delete a memmap object, flush is called first to write
-        changes to disk before removing the object.
-
-
-    See also
-    --------
-    lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.
-
-    Notes
-    -----
-    The memmap object can be used anywhere an ndarray is accepted.
-    Given a memmap ``fp``, ``isinstance(fp, numpy.ndarray)`` returns
-    ``True``.
-    
-    Memory-mapped files cannot be larger than 2GB on 32-bit systems.
-
-    When a memmap causes a file to be created or extended beyond its
-    current size in the filesystem, the contents of the new part are
-    unspecified. On systems with POSIX filesystem semantics, the extended
-    part will be filled with zero bytes.
-
-    Examples
-    --------
-    >>> data = np.arange(12, dtype='float32')
-    >>> data.resize((3,4))
-
-    This example uses a temporary file so that doctest doesn't write
-    files to your directory. You would use a 'normal' filename.
-
-    >>> from tempfile import mkdtemp
-    >>> import os.path as path
-    >>> filename = path.join(mkdtemp(), 'newfile.dat')
-
-    Create a memmap with dtype and shape that matches our data:
-
-    >>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4))
-    >>> fp
-    memmap([[0., 0., 0., 0.],
-            [0., 0., 0., 0.],
-            [0., 0., 0., 0.]], dtype=float32)
-
-    Write data to memmap array:
-
-    >>> fp[:] = data[:]
-    >>> fp
-    memmap([[  0.,   1.,   2.,   3.],
-            [  4.,   5.,   6.,   7.],
-            [  8.,   9.,  10.,  11.]], dtype=float32)
-
-    >>> fp.filename == path.abspath(filename)
-    True
-
-    Deletion flushes memory changes to disk before removing the object:
-
-    >>> del fp
-
-    Load the memmap and verify data was stored:
-
-    >>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
-    >>> newfp
-    memmap([[  0.,   1.,   2.,   3.],
-            [  4.,   5.,   6.,   7.],
-            [  8.,   9.,  10.,  11.]], dtype=float32)
-
-    Read-only memmap:
-
-    >>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
-    >>> fpr.flags.writeable
-    False
-
-    Copy-on-write memmap:
-
-    >>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4))
-    >>> fpc.flags.writeable
-    True
-
-    It's possible to assign to copy-on-write array, but values are only
-    written into the memory copy of the array, and not written to disk:
-
-    >>> fpc
-    memmap([[  0.,   1.,   2.,   3.],
-            [  4.,   5.,   6.,   7.],
-            [  8.,   9.,  10.,  11.]], dtype=float32)
-    >>> fpc[0,:] = 0
-    >>> fpc
-    memmap([[  0.,   0.,   0.,   0.],
-            [  4.,   5.,   6.,   7.],
-            [  8.,   9.,  10.,  11.]], dtype=float32)
-
-    File on disk is unchanged:
-
-    >>> fpr
-    memmap([[  0.,   1.,   2.,   3.],
-            [  4.,   5.,   6.,   7.],
-            [  8.,   9.,  10.,  11.]], dtype=float32)
-
-    Offset into a memmap:
-
-    >>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16)
-    >>> fpo
-    memmap([  4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.], dtype=float32)
-
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} RAISE (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "RAISE"))))
-
-(def nonzero (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nonzero"))))
-(alter-meta! #'nonzero assoc :doc "
-    Return the indices of the elements that are non-zero.
-
-    Returns a tuple of arrays, one for each dimension of `a`,
-    containing the indices of the non-zero elements in that
-    dimension. The values in `a` are always tested and returned in
-    row-major, C-style order.
-
-    To group the indices by element, rather than dimension, use `argwhere`,
-    which returns a row for each non-zero element.
-
-    .. note::
-
-       When called on a zero-d array or scalar, ``nonzero(a)`` is treated
-       as ``nonzero(atleast1d(a))``.
-
-       .. deprecated:: 1.17.0
-
-          Use `atleast1d` explicitly if this behavior is deliberate.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-
-    Returns
-    -------
-    tuple_of_arrays : tuple
-        Indices of elements that are non-zero.
-
-    See Also
-    --------
-    flatnonzero :
-        Return indices that are non-zero in the flattened version of the input
-        array.
-    ndarray.nonzero :
-        Equivalent ndarray method.
-    count_nonzero :
-        Counts the number of non-zero elements in the input array.
-
-    Notes
-    -----
-    While the nonzero values can be obtained with ``a[nonzero(a)]``, it is
-    recommended to use ``x[x.astype(bool)]`` or ``x[x != 0]`` instead, which
-    will correctly handle 0-d arrays.
-
-    Examples
-    --------
-    >>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
-    >>> x
-    array([[3, 0, 0],
-           [0, 4, 0],
-           [5, 6, 0]])
-    >>> np.nonzero(x)
-    (array([0, 1, 2, 2]), array([0, 1, 0, 1]))
-
-    >>> x[np.nonzero(x)]
-    array([3, 4, 5, 6])
-    >>> np.transpose(np.nonzero(x))
-    array([[0, 0],
-           [1, 1],
-           [2, 0],
-           [2, 1]])
-
-    A common use for ``nonzero`` is to find the indices of an array, where
-    a condition is True.  Given an array `a`, the condition `a` > 3 is a
-    boolean array and since False is interpreted as 0, np.nonzero(a > 3)
-    yields the indices of the `a` where the condition is true.
-
-    >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-    >>> a > 3
-    array([[False, False, False],
-           [ True,  True,  True],
-           [ True,  True,  True]])
-    >>> np.nonzero(a > 3)
-    (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
-
-    Using this result to index `a` is equivalent to using the mask directly:
-
-    >>> a[np.nonzero(a > 3)]
-    array([4, 5, 6, 7, 8, 9])
-    >>> a[a > 3]  # prefer this spelling
-    array([4, 5, 6, 7, 8, 9])
-
-    ``nonzero`` can also be called as a method of the array.
-
-    >>> (a > 3).nonzero()
-    (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "Concrete implementation of SourceLoader using the file system."} __loader__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__loader__"))))
-
-(def rollaxis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rollaxis"))))
-(alter-meta! #'rollaxis assoc :doc "
-    Roll the specified axis backwards, until it lies in a given position.
-
-    This function continues to be supported for backward compatibility, but you
-    should prefer `moveaxis`. The `moveaxis` function was added in NumPy
-    1.11.
-
-    Parameters
-    ----------
-    a : ndarray
-        Input array.
-    axis : int
-        The axis to roll backwards.  The positions of the other axes do not
-        change relative to one another.
-    start : int, optional
-        The axis is rolled until it lies before this position.  The default,
-        0, results in a \"complete\" roll.
-
-    Returns
-    -------
-    res : ndarray
-        For NumPy >= 1.10.0 a view of `a` is always returned. For earlier
-        NumPy versions a view of `a` is returned only if the order of the
-        axes is changed, otherwise the input array is returned.
-
-    See Also
-    --------
-    moveaxis : Move array axes to new positions.
-    roll : Roll the elements of an array by a number of positions along a
-        given axis.
-
-    Examples
-    --------
-    >>> a = np.ones((3,4,5,6))
-    >>> np.rollaxis(a, 3, 1).shape
-    (3, 6, 4, 5)
-    >>> np.rollaxis(a, 2).shape
-    (5, 3, 4, 6)
-    >>> np.rollaxis(a, 1, 4).shape
-    (3, 5, 6, 4)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ppmt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ppmt"))))
-(alter-meta! #'ppmt assoc :doc "
-    Compute the payment against loan principal.
-
-    .. deprecated:: 1.18
-
-       `ppmt` is deprecated; for details, see NEP 32 [1]_.
-       Use the corresponding function in the numpy-financial library,
-       https://pypi.org/project/numpy-financial.
-
-    Parameters
-    ----------
-    rate : array_like
-        Rate of interest (per period)
-    per : array_like, int
-        Amount paid against the loan changes.  The `per` is the period of
-        interest.
-    nper : array_like
-        Number of compounding periods
-    pv : array_like
-        Present value
-    fv : array_like, optional
-        Future value
-    when : {{'begin', 1}, {'end', 0}}, {string, int}
-        When payments are due ('begin' (1) or 'end' (0))
-
-    See Also
-    --------
-    pmt, pv, ipmt
-
-    References
-    ----------
-    .. [1] NumPy Enhancement Proposal (NEP) 32,
-       https://numpy.org/neps/nep-0032-remove-financial-functions.html
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} ERR_RAISE (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_RAISE"))))
-
-(def isnat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isnat"))))
-(alter-meta! #'isnat assoc :doc "isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Test element-wise for NaT (not a time) and return result as a boolean array.
-
-.. versionadded:: 1.13.0
-
-Parameters
-----------
-x : array_like
-    Input array with datetime or timedelta data type.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or bool
-    True where ``x`` is NaT, false otherwise.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-isnan, isinf, isneginf, isposinf, isfinite
-
-Examples
---------
->>> np.isnat(np.datetime64(\"NaT\"))
-True
->>> np.isnat(np.datetime64(\"2016-01-01\"))
-False
->>> np.isnat(np.array([\"NaT\", \"2016-01-01\"], dtype=\"datetime64[ns]\"))
-array([ True, False])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def roots (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "roots"))))
-(alter-meta! #'roots assoc :doc "
-    Return the roots of a polynomial with coefficients given in p.
-
-    The values in the rank-1 array `p` are coefficients of a polynomial.
-    If the length of `p` is n+1 then the polynomial is described by::
-
-      p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n]
-
-    Parameters
-    ----------
-    p : array_like
-        Rank-1 array of polynomial coefficients.
-
-    Returns
-    -------
-    out : ndarray
-        An array containing the roots of the polynomial.
-
-    Raises
-    ------
-    ValueError
-        When `p` cannot be converted to a rank-1 array.
-
-    See also
-    --------
-    poly : Find the coefficients of a polynomial with a given sequence
-           of roots.
-    polyval : Compute polynomial values.
-    polyfit : Least squares polynomial fit.
-    poly1d : A one-dimensional polynomial class.
-
-    Notes
-    -----
-    The algorithm relies on computing the eigenvalues of the
-    companion matrix [1]_.
-
-    References
-    ----------
-    .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*.  Cambridge, UK:
-        Cambridge University Press, 1999, pp. 146-7.
-
-    Examples
-    --------
-    >>> coeff = [3.2, 2, 1]
-    >>> np.roots(coeff)
-    array([-0.3125+0.46351241j, -0.3125-0.46351241j])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def max (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "max"))))
-(alter-meta! #'max assoc :doc "
-    Return the maximum of an array or maximum along an axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which to operate.  By default, flattened input is
-        used.
-
-        .. versionadded:: 1.7.0
-
-        If this is a tuple of ints, the maximum is selected over multiple axes,
-        instead of a single axis or all the axes as before.
-    out : ndarray, optional
-        Alternative output array in which to place the result.  Must
-        be of the same shape and buffer length as the expected output.
-        See `ufuncs-output-type` for more details.
-
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `amax` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-
-    initial : scalar, optional
-        The minimum value of an output element. Must be present to allow
-        computation on empty slice. See `~numpy.ufunc.reduce` for details.
-
-        .. versionadded:: 1.15.0
-
-    where : array_like of bool, optional
-        Elements to compare for the maximum. See `~numpy.ufunc.reduce`
-        for details.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    amax : ndarray or scalar
-        Maximum of `a`. If `axis` is None, the result is a scalar value.
-        If `axis` is given, the result is an array of dimension
-        ``a.ndim - 1``.
-
-    See Also
-    --------
-    amin :
-        The minimum value of an array along a given axis, propagating any NaNs.
-    nanmax :
-        The maximum value of an array along a given axis, ignoring any NaNs.
-    maximum :
-        Element-wise maximum of two arrays, propagating any NaNs.
-    fmax :
-        Element-wise maximum of two arrays, ignoring any NaNs.
-    argmax :
-        Return the indices of the maximum values.
-
-    nanmin, minimum, fmin
-
-    Notes
-    -----
-    NaN values are propagated, that is if at least one item is NaN, the
-    corresponding max value will be NaN as well. To ignore NaN values
-    (MATLAB behavior), please use nanmax.
-
-    Don't use `amax` for element-wise comparison of 2 arrays; when
-    ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
-    ``amax(a, axis=0)``.
-
-    Examples
-    --------
-    >>> a = np.arange(4).reshape((2,2))
-    >>> a
-    array([[0, 1],
-           [2, 3]])
-    >>> np.amax(a)           # Maximum of the flattened array
-    3
-    >>> np.amax(a, axis=0)   # Maxima along the first axis
-    array([2, 3])
-    >>> np.amax(a, axis=1)   # Maxima along the second axis
-    array([1, 3])
-    >>> np.amax(a, where=[False, True], initial=-1, axis=0)
-    array([-1,  3])
-    >>> b = np.arange(5, dtype=float)
-    >>> b[2] = np.NaN
-    >>> np.amax(b)
-    nan
-    >>> np.amax(b, where=~np.isnan(b), initial=-1)
-    4.0
-    >>> np.nanmax(b)
-    4.0
-
-    You can use an initial value to compute the maximum of an empty slice, or
-    to initialize it to a different value:
-
-    >>> np.max([[-50], [10]], axis=-1, initial=0)
-    array([ 0, 10])
-
-    Notice that the initial value is used as one of the elements for which the
-    maximum is determined, unlike for the default argument Python's max
-    function, which is only used for empty iterables.
-
-    >>> np.max([5], initial=6)
-    6
-    >>> max([5], default=6)
-    5
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def info (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "info"))))
-(alter-meta! #'info assoc :doc "
-    Get help information for a function, class, or module.
-
-    Parameters
-    ----------
-    object : object or str, optional
-        Input object or name to get information about. If `object` is a
-        numpy object, its docstring is given. If it is a string, available
-        modules are searched for matching objects.  If None, information
-        about `info` itself is returned.
-    maxwidth : int, optional
-        Printing width.
-    output : file like object, optional
-        File like object that the output is written to, default is
-        ``stdout``.  The object has to be opened in 'w' or 'a' mode.
-    toplevel : str, optional
-        Start search at this level.
-
-    See Also
-    --------
-    source, lookfor
-
-    Notes
-    -----
-    When used interactively with an object, ``np.info(obj)`` is equivalent
-    to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython
-    prompt.
-
-    Examples
-    --------
-    >>> np.info(np.polyval) # doctest: +SKIP
-       polyval(p, x)
-         Evaluate the polynomial p at x.
-         ...
-
-    When using a string for `object` it is possible to get multiple results.
-
-    >>> np.info('fft') # doctest: +SKIP
-         *** Found in numpy ***
-    Core FFT routines
-    ...
-         *** Found in numpy.fft ***
-     fft(a, n=None, axis=-1)
-    ...
-         *** Repeat reference found in numpy.fft.fftpack ***
-         *** Total of 3 references found. ***
-
-    " :arglists '[[& [{object :object, maxwidth :maxwidth, output :output, toplevel :toplevel}]] [& [{object :object, maxwidth :maxwidth, output :output}]] [& [{object :object, maxwidth :maxwidth}]] [& [{object :object}]] []])
-
-(def ^{:doc "
-Compatibility module.
-
-This module contains duplicated code from Python itself or 3rd party
-extensions, which may be included for the following reasons:
-
-  * compatibility
-  * we may only need a small subset of the copied library/module
-
-"} compat (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "compat"))))
-
-(def vsplit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vsplit"))))
-(alter-meta! #'vsplit assoc :doc "
-    Split an array into multiple sub-arrays vertically (row-wise).
-
-    Please refer to the ``split`` documentation.  ``vsplit`` is equivalent
-    to ``split`` with `axis=0` (default), the array is always split along the
-    first axis regardless of the array dimension.
-
-    See Also
-    --------
-    split : Split an array into multiple sub-arrays of equal size.
-
-    Examples
-    --------
-    >>> x = np.arange(16.0).reshape(4, 4)
-    >>> x
-    array([[ 0.,   1.,   2.,   3.],
-           [ 4.,   5.,   6.,   7.],
-           [ 8.,   9.,  10.,  11.],
-           [12.,  13.,  14.,  15.]])
-    >>> np.vsplit(x, 2)
-    [array([[0., 1., 2., 3.],
-           [4., 5., 6., 7.]]), array([[ 8.,  9., 10., 11.],
-           [12., 13., 14., 15.]])]
-    >>> np.vsplit(x, np.array([3, 6]))
-    [array([[ 0.,  1.,  2.,  3.],
-           [ 4.,  5.,  6.,  7.],
-           [ 8.,  9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([], shape=(0, 4), dtype=float64)]
-
-    With a higher dimensional array the split is still along the first axis.
-
-    >>> x = np.arange(8.0).reshape(2, 2, 2)
-    >>> x
-    array([[[0.,  1.],
-            [2.,  3.]],
-           [[4.,  5.],
-            [6.,  7.]]])
-    >>> np.vsplit(x, 2)
-    [array([[[0., 1.],
-            [2., 3.]]]), array([[[4., 5.],
-            [6., 7.]]])]
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def polysub (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polysub"))))
-(alter-meta! #'polysub assoc :doc "
-    Difference (subtraction) of two polynomials.
-
-    Given two polynomials `a1` and `a2`, returns ``a1 - a2``.
-    `a1` and `a2` can be either array_like sequences of the polynomials'
-    coefficients (including coefficients equal to zero), or `poly1d` objects.
-
-    Parameters
-    ----------
-    a1, a2 : array_like or poly1d
-        Minuend and subtrahend polynomials, respectively.
-
-    Returns
-    -------
-    out : ndarray or poly1d
-        Array or `poly1d` object of the difference polynomial's coefficients.
-
-    See Also
-    --------
-    polyval, polydiv, polymul, polyadd
-
-    Examples
-    --------
-    .. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2)
-
-    >>> np.polysub([2, 10, -2], [3, 10, -4])
-    array([-1,  0,  2])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def array_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_equal"))))
-(alter-meta! #'array_equal assoc :doc "
-    True if two arrays have the same shape and elements, False otherwise.
-
-    Parameters
-    ----------
-    a1, a2 : array_like
-        Input arrays.
-
-    Returns
-    -------
-    b : bool
-        Returns True if the arrays are equal.
-
-    See Also
-    --------
-    allclose: Returns True if two arrays are element-wise equal within a
-              tolerance.
-    array_equiv: Returns True if input arrays are shape consistent and all
-                 elements equal.
-
-    Examples
-    --------
-    >>> np.array_equal([1, 2], [1, 2])
-    True
-    >>> np.array_equal(np.array([1, 2]), np.array([1, 2]))
-    True
-    >>> np.array_equal([1, 2], [1, 2, 3])
-    False
-    >>> np.array_equal([1, 2], [1, 4])
-    False
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def linspace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "linspace"))))
-(alter-meta! #'linspace assoc :doc "
-    Return evenly spaced numbers over a specified interval.
-
-    Returns `num` evenly spaced samples, calculated over the
-    interval [`start`, `stop`].
-
-    The endpoint of the interval can optionally be excluded.
-
-    .. versionchanged:: 1.16.0
-        Non-scalar `start` and `stop` are now supported.
-
-    Parameters
-    ----------
-    start : array_like
-        The starting value of the sequence.
-    stop : array_like
-        The end value of the sequence, unless `endpoint` is set to False.
-        In that case, the sequence consists of all but the last of ``num + 1``
-        evenly spaced samples, so that `stop` is excluded.  Note that the step
-        size changes when `endpoint` is False.
-    num : int, optional
-        Number of samples to generate. Default is 50. Must be non-negative.
-    endpoint : bool, optional
-        If True, `stop` is the last sample. Otherwise, it is not included.
-        Default is True.
-    retstep : bool, optional
-        If True, return (`samples`, `step`), where `step` is the spacing
-        between samples.
-    dtype : dtype, optional
-        The type of the output array.  If `dtype` is not given, infer the data
-        type from the other input arguments.
-
-        .. versionadded:: 1.9.0
-
-    axis : int, optional
-        The axis in the result to store the samples.  Relevant only if start
-        or stop are array-like.  By default (0), the samples will be along a
-        new axis inserted at the beginning. Use -1 to get an axis at the end.
-
-        .. versionadded:: 1.16.0
-
-    Returns
-    -------
-    samples : ndarray
-        There are `num` equally spaced samples in the closed interval
-        ``[start, stop]`` or the half-open interval ``[start, stop)``
-        (depending on whether `endpoint` is True or False).
-    step : float, optional
-        Only returned if `retstep` is True
-
-        Size of spacing between samples.
-
-
-    See Also
-    --------
-    arange : Similar to `linspace`, but uses a step size (instead of the
-             number of samples).
-    geomspace : Similar to `linspace`, but with numbers spaced evenly on a log
-                scale (a geometric progression).
-    logspace : Similar to `geomspace`, but with the end points specified as
-               logarithms.
-
-    Examples
-    --------
-    >>> np.linspace(2.0, 3.0, num=5)
-    array([2.  , 2.25, 2.5 , 2.75, 3.  ])
-    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)
-    array([2. ,  2.2,  2.4,  2.6,  2.8])
-    >>> np.linspace(2.0, 3.0, num=5, retstep=True)
-    (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)
-
-    Graphical illustration:
-
-    >>> import matplotlib.pyplot as plt
-    >>> N = 8
-    >>> y = np.zeros(N)
-    >>> x1 = np.linspace(0, 10, N, endpoint=True)
-    >>> x2 = np.linspace(0, 10, N, endpoint=False)
-    >>> plt.plot(x1, y, 'o')
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.plot(x2, y + 0.5, 'o')
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.ylim([-0.5, 1])
-    (-0.5, 1)
-    >>> plt.show()
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def mat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mat"))))
-(alter-meta! #'mat assoc :doc "
-    Interpret the input as a matrix.
-
-    Unlike `matrix`, `asmatrix` does not make a copy if the input is already
-    a matrix or an ndarray.  Equivalent to ``matrix(data, copy=False)``.
-
-    Parameters
-    ----------
-    data : array_like
-        Input data.
-    dtype : data-type
-       Data-type of the output matrix.
-
-    Returns
-    -------
-    mat : matrix
-        `data` interpreted as a matrix.
-
-    Examples
-    --------
-    >>> x = np.array([[1, 2], [3, 4]])
-
-    >>> m = np.asmatrix(x)
-
-    >>> x[0,0] = 5
-
-    >>> m
-    matrix([[5, 2],
-            [3, 4]])
-
-    " :arglists '[[data & [{dtype :dtype}]] [data]])
-
-(def frombuffer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "frombuffer"))))
-(alter-meta! #'frombuffer assoc :doc "frombuffer(buffer, dtype=float, count=-1, offset=0)
-
-    Interpret a buffer as a 1-dimensional array.
-
-    Parameters
-    ----------
-    buffer : buffer_like
-        An object that exposes the buffer interface.
-    dtype : data-type, optional
-        Data-type of the returned array; default: float.
-    count : int, optional
-        Number of items to read. ``-1`` means all data in the buffer.
-    offset : int, optional
-        Start reading the buffer from this offset (in bytes); default: 0.
-
-    Notes
-    -----
-    If the buffer has data that is not in machine byte-order, this should
-    be specified as part of the data-type, e.g.::
-
-      >>> dt = np.dtype(int)
-      >>> dt = dt.newbyteorder('>')
-      >>> np.frombuffer(buf, dtype=dt) # doctest: +SKIP
-
-    The data of the resulting array will not be byteswapped, but will be
-    interpreted correctly.
-
-    Examples
-    --------
-    >>> s = b'hello world'
-    >>> np.frombuffer(s, dtype='S1', count=5, offset=6)
-    array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1')
-
-    >>> np.frombuffer(b'\\x01\\x02', dtype=np.uint8)
-    array([1, 2], dtype=uint8)
-    >>> np.frombuffer(b'\\x01\\x02\\x03\\x04\\x05', dtype=np.uint8, count=3)
-    array([1, 2, 3], dtype=uint8)" :arglists '[[self & [args {:as kwargs}]]])
-
-(def flatiter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flatiter"))))
-(alter-meta! #'flatiter assoc :doc "Flat iterator object to iterate over arrays.
-
-    A `flatiter` iterator is returned by ``x.flat`` for any array `x`.
-    It allows iterating over the array as if it were a 1-D array,
-    either in a for-loop or by calling its `next` method.
-
-    Iteration is done in row-major, C-style order (the last
-    index varying the fastest). The iterator can also be indexed using
-    basic slicing or advanced indexing.
-
-    See Also
-    --------
-    ndarray.flat : Return a flat iterator over an array.
-    ndarray.flatten : Returns a flattened copy of an array.
-
-    Notes
-    -----
-    A `flatiter` iterator can not be constructed directly from Python code
-    by calling the `flatiter` constructor.
-
-    Examples
-    --------
-    >>> x = np.arange(6).reshape(2, 3)
-    >>> fl = x.flat
-    >>> type(fl)
-    <class 'numpy.flatiter'>
-    >>> for item in fl:
-    ...     print(item)
-    ...
-    0
-    1
-    2
-    3
-    4
-    5
-
-    >>> fl[2:4]
-    array([2, 3])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def setbufsize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "setbufsize"))))
-(alter-meta! #'setbufsize assoc :doc "
-    Set the size of the buffer used in ufuncs.
-
-    Parameters
-    ----------
-    size : int
-        Size of buffer.
-
-    " :arglists '[[size]])
-
-(def ^{:doc ""} PZERO (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "PZERO"))))
-
-(def ^{:doc "Built-in mutable sequence.
-
-If no argument is given, the constructor creates a new empty list.
-The argument must be an iterable if specified."} __all__ (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* "__all__")))) 
-
-(def busday_count (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "busday_count"))))
-(alter-meta! #'busday_count assoc :doc "
-    busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None)
-
-    Counts the number of valid days between `begindates` and
-    `enddates`, not including the day of `enddates`.
-
-    If ``enddates`` specifies a date value that is earlier than the
-    corresponding ``begindates`` date value, the count will be negative.
-
-    .. versionadded:: 1.7.0
-
-    Parameters
-    ----------
-    begindates : array_like of datetime64[D]
-        The array of the first dates for counting.
-    enddates : array_like of datetime64[D]
-        The array of the end dates for counting, which are excluded
-        from the count themselves.
-    weekmask : str or array_like of bool, optional
-        A seven-element array indicating which of Monday through Sunday are
-        valid days. May be specified as a length-seven list or array, like
-        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
-        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
-        weekdays, optionally separated by white space. Valid abbreviations
-        are: Mon Tue Wed Thu Fri Sat Sun
-    holidays : array_like of datetime64[D], optional
-        An array of dates to consider as invalid dates.  They may be
-        specified in any order, and NaT (not-a-time) dates are ignored.
-        This list is saved in a normalized form that is suited for
-        fast calculations of valid days.
-    busdaycal : busdaycalendar, optional
-        A `busdaycalendar` object which specifies the valid days. If this
-        parameter is provided, neither weekmask nor holidays may be
-        provided.
-    out : array of int, optional
-        If provided, this array is filled with the result.
-
-    Returns
-    -------
-    out : array of int
-        An array with a shape from broadcasting ``begindates`` and ``enddates``
-        together, containing the number of valid days between
-        the begin and end dates.
-
-    See Also
-    --------
-    busdaycalendar: An object that specifies a custom set of valid days.
-    is_busday : Returns a boolean array indicating valid days.
-    busday_offset : Applies an offset counted in valid days.
-
-    Examples
-    --------
-    >>> # Number of weekdays in January 2011
-    ... np.busday_count('2011-01', '2011-02')
-    21
-    >>> # Number of weekdays in 2011
-    >>> np.busday_count('2011', '2012')
-    260
-    >>> # Number of Saturdays in 2011
-    ... np.busday_count('2011', '2012', weekmask='Sat')
-    53
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def polyint (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyint"))))
-(alter-meta! #'polyint assoc :doc "
-    Return an antiderivative (indefinite integral) of a polynomial.
-
-    The returned order `m` antiderivative `P` of polynomial `p` satisfies
-    :math:`\\frac{d^m}{dx^m}P(x) = p(x)` and is defined up to `m - 1`
-    integration constants `k`. The constants determine the low-order
-    polynomial part
-
-    .. math:: \\frac{k_{m-1}}{0!} x^0 + \\ldots + \\frac{k_0}{(m-1)!}x^{m-1}
-
-    of `P` so that :math:`P^{(j)}(0) = k_{m-j-1}`.
-
-    Parameters
-    ----------
-    p : array_like or poly1d
-        Polynomial to integrate.
-        A sequence is interpreted as polynomial coefficients, see `poly1d`.
-    m : int, optional
-        Order of the antiderivative. (Default: 1)
-    k : list of `m` scalars or scalar, optional
-        Integration constants. They are given in the order of integration:
-        those corresponding to highest-order terms come first.
-
-        If ``None`` (default), all constants are assumed to be zero.
-        If `m = 1`, a single scalar can be given instead of a list.
-
-    See Also
-    --------
-    polyder : derivative of a polynomial
-    poly1d.integ : equivalent method
-
-    Examples
-    --------
-    The defining property of the antiderivative:
-
-    >>> p = np.poly1d([1,1,1])
-    >>> P = np.polyint(p)
-    >>> P
-     poly1d([ 0.33333333,  0.5       ,  1.        ,  0.        ]) # may vary
-    >>> np.polyder(P) == p
-    True
-
-    The integration constants default to zero, but can be specified:
-
-    >>> P = np.polyint(p, 3)
-    >>> P(0)
-    0.0
-    >>> np.polyder(P)(0)
-    0.0
-    >>> np.polyder(P, 2)(0)
-    0.0
-    >>> P = np.polyint(p, 3, k=[6,5,3])
-    >>> P
-    poly1d([ 0.01666667,  0.04166667,  0.16666667,  3. ,  5. ,  3. ]) # may vary
-
-    Note that 3 = 6 / 2!, and that the constants are given in the order of
-    integrations. Constant of the highest-order polynomial term comes first:
-
-    >>> np.polyder(P, 2)(0)
-    6.0
-    >>> np.polyder(P, 1)(0)
-    5.0
-    >>> P(0)
-    3.0
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def maximum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "maximum"))))
-(alter-meta! #'maximum assoc :doc "maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Element-wise maximum of array elements.
-
-Compare two arrays and returns a new array containing the element-wise
-maxima. If one of the elements being compared is a NaN, then that
-element is returned. If both elements are NaNs then the first is
-returned. The latter distinction is important for complex NaNs, which
-are defined as at least one of the real or imaginary parts being a NaN.
-The net effect is that NaNs are propagated.
-
-Parameters
-----------
-x1, x2 : array_like
-    The arrays holding the elements to be compared. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or scalar
-    The maximum of `x1` and `x2`, element-wise.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-minimum :
-    Element-wise minimum of two arrays, propagates NaNs.
-fmax :
-    Element-wise maximum of two arrays, ignores NaNs.
-amax :
-    The maximum value of an array along a given axis, propagates NaNs.
-nanmax :
-    The maximum value of an array along a given axis, ignores NaNs.
-
-fmin, amin, nanmin
-
-Notes
------
-The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when
-neither x1 nor x2 are nans, but it is faster and does proper
-broadcasting.
-
-Examples
---------
->>> np.maximum([2, 3, 4], [1, 5, 2])
-array([2, 5, 4])
-
->>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting
-array([[ 1. ,  2. ],
-       [ 0.5,  2. ]])
-
->>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan])
-array([nan, nan, nan])
->>> np.maximum(np.Inf, 1)
-inf" :arglists '[[self & [args {:as kwargs}]]])
-
-(def negative (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "negative"))))
-(alter-meta! #'negative assoc :doc "negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Numerical negative, element-wise.
-
-Parameters
-----------
-x : array_like or scalar
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or scalar
-    Returned array or scalar: `y = -x`.
-    This is a scalar if `x` is a scalar.
-
-Examples
---------
->>> np.negative([1.,-1.])
-array([-1.,  1.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def diagonal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diagonal"))))
-(alter-meta! #'diagonal assoc :doc "
-    Return specified diagonals.
-
-    If `a` is 2-D, returns the diagonal of `a` with the given offset,
-    i.e., the collection of elements of the form ``a[i, i+offset]``.  If
-    `a` has more than two dimensions, then the axes specified by `axis1`
-    and `axis2` are used to determine the 2-D sub-array whose diagonal is
-    returned.  The shape of the resulting array can be determined by
-    removing `axis1` and `axis2` and appending an index to the right equal
-    to the size of the resulting diagonals.
-
-    In versions of NumPy prior to 1.7, this function always returned a new,
-    independent array containing a copy of the values in the diagonal.
-
-    In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal,
-    but depending on this fact is deprecated. Writing to the resulting
-    array continues to work as it used to, but a FutureWarning is issued.
-
-    Starting in NumPy 1.9 it returns a read-only view on the original array.
-    Attempting to write to the resulting array will produce an error.
-
-    In some future release, it will return a read/write view and writing to
-    the returned array will alter your original array.  The returned array
-    will have the same type as the input array.
-
-    If you don't write to the array returned by this function, then you can
-    just ignore all of the above.
-
-    If you depend on the current behavior, then we suggest copying the
-    returned array explicitly, i.e., use ``np.diagonal(a).copy()`` instead
-    of just ``np.diagonal(a)``. This will work with both past and future
-    versions of NumPy.
-
-    Parameters
-    ----------
-    a : array_like
-        Array from which the diagonals are taken.
-    offset : int, optional
-        Offset of the diagonal from the main diagonal.  Can be positive or
-        negative.  Defaults to main diagonal (0).
-    axis1 : int, optional
-        Axis to be used as the first axis of the 2-D sub-arrays from which
-        the diagonals should be taken.  Defaults to first axis (0).
-    axis2 : int, optional
-        Axis to be used as the second axis of the 2-D sub-arrays from
-        which the diagonals should be taken. Defaults to second axis (1).
-
-    Returns
-    -------
-    array_of_diagonals : ndarray
-        If `a` is 2-D, then a 1-D array containing the diagonal and of the
-        same type as `a` is returned unless `a` is a `matrix`, in which case
-        a 1-D array rather than a (2-D) `matrix` is returned in order to
-        maintain backward compatibility.
-
-        If ``a.ndim > 2``, then the dimensions specified by `axis1` and `axis2`
-        are removed, and a new axis inserted at the end corresponding to the
-        diagonal.
-
-    Raises
-    ------
-    ValueError
-        If the dimension of `a` is less than 2.
-
-    See Also
-    --------
-    diag : MATLAB work-a-like for 1-D and 2-D arrays.
-    diagflat : Create diagonal arrays.
-    trace : Sum along diagonals.
-
-    Examples
-    --------
-    >>> a = np.arange(4).reshape(2,2)
-    >>> a
-    array([[0, 1],
-           [2, 3]])
-    >>> a.diagonal()
-    array([0, 3])
-    >>> a.diagonal(1)
-    array([1])
-
-    A 3-D example:
-
-    >>> a = np.arange(8).reshape(2,2,2); a
-    array([[[0, 1],
-            [2, 3]],
-           [[4, 5],
-            [6, 7]]])
-    >>> a.diagonal(0,  # Main diagonals of two arrays created by skipping
-    ...            0,  # across the outer(left)-most axis last and
-    ...            1)  # the \"middle\" (row) axis first.
-    array([[0, 6],
-           [1, 7]])
-
-    The sub-arrays whose main diagonals we just obtained; note that each
-    corresponds to fixing the right-most (column) axis, and that the
-    diagonals are \"packed\" in rows.
-
-    >>> a[:,:,0]  # main diagonal is [0 6]
-    array([[0, 2],
-           [4, 6]])
-    >>> a[:,:,1]  # main diagonal is [1 7]
-    array([[1, 3],
-           [5, 7]])
-
-    The anti-diagonal can be obtained by reversing the order of elements
-    using either `numpy.flipud` or `numpy.fliplr`.
-
-    >>> a = np.arange(9).reshape(3, 3)
-    >>> a
-    array([[0, 1, 2],
-           [3, 4, 5],
-           [6, 7, 8]])
-    >>> np.fliplr(a).diagonal()  # Horizontal flip
-    array([2, 4, 6])
-    >>> np.flipud(a).diagonal()  # Vertical flip
-    array([6, 4, 2])
-
-    Note that the order in which the diagonal is retrieved varies depending
-    on the flip function.
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ipmt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ipmt"))))
-(alter-meta! #'ipmt assoc :doc "
-    Compute the interest portion of a payment.
-
-    .. deprecated:: 1.18
-
-       `ipmt` is deprecated; for details, see NEP 32 [1]_.
-       Use the corresponding function in the numpy-financial library,
-       https://pypi.org/project/numpy-financial.
-
-    Parameters
-    ----------
-    rate : scalar or array_like of shape(M, )
-        Rate of interest as decimal (not per cent) per period
-    per : scalar or array_like of shape(M, )
-        Interest paid against the loan changes during the life or the loan.
-        The `per` is the payment period to calculate the interest amount.
-    nper : scalar or array_like of shape(M, )
-        Number of compounding periods
-    pv : scalar or array_like of shape(M, )
-        Present value
-    fv : scalar or array_like of shape(M, ), optional
-        Future value
-    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
-        When payments are due ('begin' (1) or 'end' (0)).
-        Defaults to {'end', 0}.
-
-    Returns
-    -------
-    out : ndarray
-        Interest portion of payment.  If all input is scalar, returns a scalar
-        float.  If any input is array_like, returns interest payment for each
-        input element. If multiple inputs are array_like, they all must have
-        the same shape.
-
-    See Also
-    --------
-    ppmt, pmt, pv
-
-    Notes
-    -----
-    The total payment is made up of payment against principal plus interest.
-
-    ``pmt = ppmt + ipmt``
-
-    References
-    ----------
-    .. [1] NumPy Enhancement Proposal (NEP) 32,
-       https://numpy.org/neps/nep-0032-remove-financial-functions.html
-
-    Examples
-    --------
-    What is the amortization schedule for a 1 year loan of $2500 at
-    8.24% interest per year compounded monthly?
-
-    >>> principal = 2500.00
-
-    The 'per' variable represents the periods of the loan.  Remember that
-    financial equations start the period count at 1!
-
-    >>> per = np.arange(1*12) + 1
-    >>> ipmt = np.ipmt(0.0824/12, per, 1*12, principal)
-    >>> ppmt = np.ppmt(0.0824/12, per, 1*12, principal)
-
-    Each element of the sum of the 'ipmt' and 'ppmt' arrays should equal
-    'pmt'.
-
-    >>> pmt = np.pmt(0.0824/12, 1*12, principal)
-    >>> np.allclose(ipmt + ppmt, pmt)
-    True
-
-    >>> fmt = '{0:2d} {1:8.2f} {2:8.2f} {3:8.2f}'
-    >>> for payment in per:
-    ...     index = payment - 1
-    ...     principal = principal + ppmt[index]
-    ...     print(fmt.format(payment, ppmt[index], ipmt[index], principal))
-     1  -200.58   -17.17  2299.42
-     2  -201.96   -15.79  2097.46
-     3  -203.35   -14.40  1894.11
-     4  -204.74   -13.01  1689.37
-     5  -206.15   -11.60  1483.22
-     6  -207.56   -10.18  1275.66
-     7  -208.99    -8.76  1066.67
-     8  -210.42    -7.32   856.25
-     9  -211.87    -5.88   644.38
-    10  -213.32    -4.42   431.05
-    11  -214.79    -2.96   216.26
-    12  -216.26    -1.49    -0.00
-
-    >>> interestpd = np.sum(ipmt)
-    >>> np.round(interestpd, 2)
-    -112.98
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def einsum_path (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "einsum_path"))))
-(alter-meta! #'einsum_path assoc :doc "
-    einsum_path(subscripts, *operands, optimize='greedy')
-
-    Evaluates the lowest cost contraction order for an einsum expression by
-    considering the creation of intermediate arrays.
-
-    Parameters
-    ----------
-    subscripts : str
-        Specifies the subscripts for summation.
-    *operands : list of array_like
-        These are the arrays for the operation.
-    optimize : {bool, list, tuple, 'greedy', 'optimal'}
-        Choose the type of path. If a tuple is provided, the second argument is
-        assumed to be the maximum intermediate size created. If only a single
-        argument is provided the largest input or output array size is used
-        as a maximum intermediate size.
-
-        * if a list is given that starts with ``einsum_path``, uses this as the
-          contraction path
-        * if False no optimization is taken
-        * if True defaults to the 'greedy' algorithm
-        * 'optimal' An algorithm that combinatorially explores all possible
-          ways of contracting the listed tensors and choosest the least costly
-          path. Scales exponentially with the number of terms in the
-          contraction.
-        * 'greedy' An algorithm that chooses the best pair contraction
-          at each step. Effectively, this algorithm searches the largest inner,
-          Hadamard, and then outer products at each step. Scales cubically with
-          the number of terms in the contraction. Equivalent to the 'optimal'
-          path for most contractions.
-
-        Default is 'greedy'.
-
-    Returns
-    -------
-    path : list of tuples
-        A list representation of the einsum path.
-    string_repr : str
-        A printable representation of the einsum path.
-
-    Notes
-    -----
-    The resulting path indicates which terms of the input contraction should be
-    contracted first, the result of this contraction is then appended to the
-    end of the contraction list. This list can then be iterated over until all
-    intermediate contractions are complete.
-
-    See Also
-    --------
-    einsum, linalg.multi_dot
-
-    Examples
-    --------
-
-    We can begin with a chain dot example. In this case, it is optimal to
-    contract the ``b`` and ``c`` tensors first as represented by the first
-    element of the path ``(1, 2)``. The resulting tensor is added to the end
-    of the contraction and the remaining contraction ``(0, 1)`` is then
-    completed.
-
-    >>> np.random.seed(123)
-    >>> a = np.random.rand(2, 2)
-    >>> b = np.random.rand(2, 5)
-    >>> c = np.random.rand(5, 2)
-    >>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy')
-    >>> print(path_info[0])
-    ['einsum_path', (1, 2), (0, 1)]
-    >>> print(path_info[1])
-      Complete contraction:  ij,jk,kl->il # may vary
-             Naive scaling:  4
-         Optimized scaling:  3
-          Naive FLOP count:  1.600e+02
-      Optimized FLOP count:  5.600e+01
-       Theoretical speedup:  2.857
-      Largest intermediate:  4.000e+00 elements
-    -------------------------------------------------------------------------
-    scaling                  current                                remaining
-    -------------------------------------------------------------------------
-       3                   kl,jk->jl                                ij,jl->il
-       3                   jl,ij->il                                   il->il
-
-
-    A more complex index transformation example.
-
-    >>> I = np.random.rand(10, 10, 10, 10)
-    >>> C = np.random.rand(10, 10)
-    >>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C,
-    ...                            optimize='greedy')
-
-    >>> print(path_info[0])
-    ['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)]
-    >>> print(path_info[1]) 
-      Complete contraction:  ea,fb,abcd,gc,hd->efgh # may vary
-             Naive scaling:  8
-         Optimized scaling:  5
-          Naive FLOP count:  8.000e+08
-      Optimized FLOP count:  8.000e+05
-       Theoretical speedup:  1000.000
-      Largest intermediate:  1.000e+04 elements
-    --------------------------------------------------------------------------
-    scaling                  current                                remaining
-    --------------------------------------------------------------------------
-       5               abcd,ea->bcde                      fb,gc,hd,bcde->efgh
-       5               bcde,fb->cdef                         gc,hd,cdef->efgh
-       5               cdef,gc->defg                            hd,defg->efgh
-       5               defg,hd->efgh                               efgh->efgh
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} FPE_DIVIDEBYZERO (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "FPE_DIVIDEBYZERO"))))
-
-(def require (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "require"))))
-(alter-meta! #'require assoc :doc "
-    Return an ndarray of the provided type that satisfies requirements.
-
-    This function is useful to be sure that an array with the correct flags
-    is returned for passing to compiled code (perhaps through ctypes).
-
-    Parameters
-    ----------
-    a : array_like
-       The object to be converted to a type-and-requirement-satisfying array.
-    dtype : data-type
-       The required data-type. If None preserve the current dtype. If your
-       application requires the data to be in native byteorder, include
-       a byteorder specification as a part of the dtype specification.
-    requirements : str or list of str
-       The requirements list can be any of the following
-
-       * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array
-       * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array
-       * 'ALIGNED' ('A')      - ensure a data-type aligned array
-       * 'WRITEABLE' ('W')    - ensure a writable array
-       * 'OWNDATA' ('O')      - ensure an array that owns its own data
-       * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass
-
-    Returns
-    -------
-    out : ndarray
-        Array with specified requirements and type if given.
-
-    See Also
-    --------
-    asarray : Convert input to an ndarray.
-    asanyarray : Convert to an ndarray, but pass through ndarray subclasses.
-    ascontiguousarray : Convert input to a contiguous array.
-    asfortranarray : Convert input to an ndarray with column-major
-                     memory order.
-    ndarray.flags : Information about the memory layout of the array.
-
-    Notes
-    -----
-    The returned array will be guaranteed to have the listed requirements
-    by making a copy if needed.
-
-    Examples
-    --------
-    >>> x = np.arange(6).reshape(2,3)
-    >>> x.flags
-      C_CONTIGUOUS : True
-      F_CONTIGUOUS : False
-      OWNDATA : False
-      WRITEABLE : True
-      ALIGNED : True
-      WRITEBACKIFCOPY : False
-      UPDATEIFCOPY : False
-
-    >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])
-    >>> y.flags
-      C_CONTIGUOUS : False
-      F_CONTIGUOUS : True
-      OWNDATA : True
-      WRITEABLE : True
-      ALIGNED : True
-      WRITEBACKIFCOPY : False
-      UPDATEIFCOPY : False
-
-    " :arglists '[[a & [{dtype :dtype, requirements :requirements}]] [a & [{dtype :dtype}]] [a]])
-
-(def nancumsum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nancumsum"))))
-(alter-meta! #'nancumsum assoc :doc "
-    Return the cumulative sum of array elements over a given axis treating Not a
-    Numbers (NaNs) as zero.  The cumulative sum does not change when NaNs are
-    encountered and leading NaNs are replaced by zeros.
-
-    Zeros are returned for slices that are all-NaN or empty.
-
-    .. versionadded:: 1.12.0
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    axis : int, optional
-        Axis along which the cumulative sum is computed. The default
-        (None) is to compute the cumsum over the flattened array.
-    dtype : dtype, optional
-        Type of the returned array and of the accumulator in which the
-        elements are summed.  If `dtype` is not specified, it defaults
-        to the dtype of `a`, unless `a` has an integer dtype with a
-        precision less than that of the default platform integer.  In
-        that case, the default platform integer is used.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must
-        have the same shape and buffer length as the expected output
-        but the type will be cast if necessary. See `ufuncs-output-type` for
-        more details.
-
-    Returns
-    -------
-    nancumsum : ndarray.
-        A new array holding the result is returned unless `out` is
-        specified, in which it is returned. The result has the same
-        size as `a`, and the same shape as `a` if `axis` is not None
-        or `a` is a 1-d array.
-
-    See Also
-    --------
-    numpy.cumsum : Cumulative sum across array propagating NaNs.
-    isnan : Show which elements are NaN.
-
-    Examples
-    --------
-    >>> np.nancumsum(1)
-    array([1])
-    >>> np.nancumsum([1])
-    array([1])
-    >>> np.nancumsum([1, np.nan])
-    array([1.,  1.])
-    >>> a = np.array([[1, 2], [3, np.nan]])
-    >>> np.nancumsum(a)
-    array([1.,  3.,  6.,  6.])
-    >>> np.nancumsum(a, axis=0)
-    array([[1.,  2.],
-           [4.,  2.]])
-    >>> np.nancumsum(a, axis=1)
-    array([[1.,  3.],
-           [3.,  3.]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def clongfloat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "clongfloat"))))
-(alter-meta! #'clongfloat assoc :doc "Complex number type composed of two extended-precision floating-point
-    numbers.
-    Character code: ``'G'``.
-    Canonical name: ``np.clongdouble``.
-    Alias: ``np.clongfloat``.
-    Alias: ``np.longcomplex``.
-    Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def isnan (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isnan"))))
-(alter-meta! #'isnan assoc :doc "isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Test element-wise for NaN and return result as a boolean array.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or bool
-    True where ``x`` is NaN, false otherwise.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-isinf, isneginf, isposinf, isfinite, isnat
-
-Notes
------
-NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
-(IEEE 754). This means that Not a Number is not equivalent to infinity.
-
-Examples
---------
->>> np.isnan(np.nan)
-True
->>> np.isnan(np.inf)
-False
->>> np.isnan([np.log(-1.),1.,np.log(0)])
-array([ True, False, False])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def reciprocal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "reciprocal"))))
-(alter-meta! #'reciprocal assoc :doc "reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the reciprocal of the argument, element-wise.
-
-Calculates ``1/x``.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    Return array.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-.. note::
-    This function is not designed to work with integers.
-
-For integer arguments with absolute value larger than 1 the result is
-always zero because of the way Python handles integer division.  For
-integer zero the result is an overflow.
-
-Examples
---------
->>> np.reciprocal(2.)
-0.5
->>> np.reciprocal([1, 2., 3.33])
-array([ 1.       ,  0.5      ,  0.3003003])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def partition (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "partition"))))
-(alter-meta! #'partition assoc :doc "
-    Return a partitioned copy of an array.
-
-    Creates a copy of the array with its elements rearranged in such a
-    way that the value of the element in k-th position is in the
-    position it would be in a sorted array. All elements smaller than
-    the k-th element are moved before this element and all equal or
-    greater are moved behind it. The ordering of the elements in the two
-    partitions is undefined.
-
-    .. versionadded:: 1.8.0
-
-    Parameters
-    ----------
-    a : array_like
-        Array to be sorted.
-    kth : int or sequence of ints
-        Element index to partition by. The k-th value of the element
-        will be in its final sorted position and all smaller elements
-        will be moved before it and all equal or greater elements behind
-        it. The order of all elements in the partitions is undefined. If
-        provided with a sequence of k-th it will partition all elements
-        indexed by k-th  of them into their sorted position at once.
-    axis : int or None, optional
-        Axis along which to sort. If None, the array is flattened before
-        sorting. The default is -1, which sorts along the last axis.
-    kind : {'introselect'}, optional
-        Selection algorithm. Default is 'introselect'.
-    order : str or list of str, optional
-        When `a` is an array with fields defined, this argument
-        specifies which fields to compare first, second, etc.  A single
-        field can be specified as a string.  Not all fields need be
-        specified, but unspecified fields will still be used, in the
-        order in which they come up in the dtype, to break ties.
-
-    Returns
-    -------
-    partitioned_array : ndarray
-        Array of the same type and shape as `a`.
-
-    See Also
-    --------
-    ndarray.partition : Method to sort an array in-place.
-    argpartition : Indirect partition.
-    sort : Full sorting
-
-    Notes
-    -----
-    The various selection algorithms are characterized by their average
-    speed, worst case performance, work space size, and whether they are
-    stable. A stable sort keeps items with the same key in the same
-    relative order. The available algorithms have the following
-    properties:
-
-    ================= ======= ============= ============ =======
-       kind            speed   worst case    work space  stable
-    ================= ======= ============= ============ =======
-    'introselect'        1        O(n)           0         no
-    ================= ======= ============= ============ =======
-
-    All the partition algorithms make temporary copies of the data when
-    partitioning along any but the last axis.  Consequently,
-    partitioning along the last axis is faster and uses less space than
-    partitioning along any other axis.
-
-    The sort order for complex numbers is lexicographic. If both the
-    real and imaginary parts are non-nan then the order is determined by
-    the real parts except when they are equal, in which case the order
-    is determined by the imaginary parts.
-
-    Examples
-    --------
-    >>> a = np.array([3, 4, 2, 1])
-    >>> np.partition(a, 3)
-    array([2, 1, 3, 4])
-
-    >>> np.partition(a, (1, 3))
-    array([1, 2, 3, 4])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def where (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "where"))))
-(alter-meta! #'where assoc :doc "
-    where(condition, [x, y])
-
-    Return elements chosen from `x` or `y` depending on `condition`.
-
-    .. note::
-        When only `condition` is provided, this function is a shorthand for
-        ``np.asarray(condition).nonzero()``. Using `nonzero` directly should be
-        preferred, as it behaves correctly for subclasses. The rest of this
-        documentation covers only the case where all three arguments are
-        provided.
-
-    Parameters
-    ----------
-    condition : array_like, bool
-        Where True, yield `x`, otherwise yield `y`.
-    x, y : array_like
-        Values from which to choose. `x`, `y` and `condition` need to be
-        broadcastable to some shape.
-
-    Returns
-    -------
-    out : ndarray
-        An array with elements from `x` where `condition` is True, and elements
-        from `y` elsewhere.
-
-    See Also
-    --------
-    choose
-    nonzero : The function that is called when x and y are omitted
-
-    Notes
-    -----
-    If all the arrays are 1-D, `where` is equivalent to::
-
-        [xv if c else yv
-         for c, xv, yv in zip(condition, x, y)]
-
-    Examples
-    --------
-    >>> a = np.arange(10)
-    >>> a
-    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-    >>> np.where(a < 5, a, 10*a)
-    array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])
-
-    This can be used on multidimensional arrays too:
-
-    >>> np.where([[True, False], [True, True]],
-    ...          [[1, 2], [3, 4]],
-    ...          [[9, 8], [7, 6]])
-    array([[1, 8],
-           [3, 4]])
-
-    The shapes of x, y, and the condition are broadcast together:
-
-    >>> x, y = np.ogrid[:3, :4]
-    >>> np.where(x < y, x, 10 + y)  # both x and 10+y are broadcast
-    array([[10,  0,  0,  0],
-           [10, 11,  1,  1],
-           [10, 11, 12,  2]])
-
-    >>> a = np.array([[0, 1, 2],
-    ...               [0, 2, 4],
-    ...               [0, 3, 6]])
-    >>> np.where(a < 4, a, -1)  # -1 is broadcast
-    array([[ 0,  1,  2],
-           [ 0,  2, -1],
-           [ 0,  3, -1]])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def minimum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "minimum"))))
-(alter-meta! #'minimum assoc :doc "minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Element-wise minimum of array elements.
-
-Compare two arrays and returns a new array containing the element-wise
-minima. If one of the elements being compared is a NaN, then that
-element is returned. If both elements are NaNs then the first is
-returned. The latter distinction is important for complex NaNs, which
-are defined as at least one of the real or imaginary parts being a NaN.
-The net effect is that NaNs are propagated.
-
-Parameters
-----------
-x1, x2 : array_like
-    The arrays holding the elements to be compared. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or scalar
-    The minimum of `x1` and `x2`, element-wise.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-maximum :
-    Element-wise maximum of two arrays, propagates NaNs.
-fmin :
-    Element-wise minimum of two arrays, ignores NaNs.
-amin :
-    The minimum value of an array along a given axis, propagates NaNs.
-nanmin :
-    The minimum value of an array along a given axis, ignores NaNs.
-
-fmax, amax, nanmax
-
-Notes
------
-The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when
-neither x1 nor x2 are NaNs, but it is faster and does proper
-broadcasting.
-
-Examples
---------
->>> np.minimum([2, 3, 4], [1, 5, 2])
-array([1, 3, 2])
-
->>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting
-array([[ 0.5,  0. ],
-       [ 0. ,  1. ]])
-
->>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan])
-array([nan, nan, nan])
->>> np.minimum(-np.Inf, 1)
--inf" :arglists '[[self & [args {:as kwargs}]]])
-
-(def interp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "interp"))))
-(alter-meta! #'interp assoc :doc "
-    One-dimensional linear interpolation.
-
-    Returns the one-dimensional piecewise linear interpolant to a function
-    with given discrete data points (`xp`, `fp`), evaluated at `x`.
-
-    Parameters
-    ----------
-    x : array_like
-        The x-coordinates at which to evaluate the interpolated values.
-
-    xp : 1-D sequence of floats
-        The x-coordinates of the data points, must be increasing if argument
-        `period` is not specified. Otherwise, `xp` is internally sorted after
-        normalizing the periodic boundaries with ``xp = xp % period``.
-
-    fp : 1-D sequence of float or complex
-        The y-coordinates of the data points, same length as `xp`.
-
-    left : optional float or complex corresponding to fp
-        Value to return for `x < xp[0]`, default is `fp[0]`.
-
-    right : optional float or complex corresponding to fp
-        Value to return for `x > xp[-1]`, default is `fp[-1]`.
-
-    period : None or float, optional
-        A period for the x-coordinates. This parameter allows the proper
-        interpolation of angular x-coordinates. Parameters `left` and `right`
-        are ignored if `period` is specified.
-
-        .. versionadded:: 1.10.0
-
-    Returns
-    -------
-    y : float or complex (corresponding to fp) or ndarray
-        The interpolated values, same shape as `x`.
-
-    Raises
-    ------
-    ValueError
-        If `xp` and `fp` have different length
-        If `xp` or `fp` are not 1-D sequences
-        If `period == 0`
-
-    Notes
-    -----
-    The x-coordinate sequence is expected to be increasing, but this is not
-    explicitly enforced.  However, if the sequence `xp` is non-increasing,
-    interpolation results are meaningless.
-
-    Note that, since NaN is unsortable, `xp` also cannot contain NaNs.
-
-    A simple check for `xp` being strictly increasing is::
-
-        np.all(np.diff(xp) > 0)
-
-    Examples
-    --------
-    >>> xp = [1, 2, 3]
-    >>> fp = [3, 2, 0]
-    >>> np.interp(2.5, xp, fp)
-    1.0
-    >>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp)
-    array([3.  , 3.  , 2.5 , 0.56, 0.  ])
-    >>> UNDEF = -99.0
-    >>> np.interp(3.14, xp, fp, right=UNDEF)
-    -99.0
-
-    Plot an interpolant to the sine function:
-
-    >>> x = np.linspace(0, 2*np.pi, 10)
-    >>> y = np.sin(x)
-    >>> xvals = np.linspace(0, 2*np.pi, 50)
-    >>> yinterp = np.interp(xvals, x, y)
-    >>> import matplotlib.pyplot as plt
-    >>> plt.plot(x, y, 'o')
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.plot(xvals, yinterp, '-x')
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.show()
-
-    Interpolation with periodic x-coordinates:
-
-    >>> x = [-180, -170, -185, 185, -10, -5, 0, 365]
-    >>> xp = [190, -190, 350, -350]
-    >>> fp = [5, 10, 3, 4]
-    >>> np.interp(x, xp, fp, period=360)
-    array([7.5 , 5.  , 8.75, 6.25, 3.  , 3.25, 3.5 , 3.75])
-
-    Complex interpolation:
-
-    >>> x = [1.5, 4.0]
-    >>> xp = [2,3,5]
-    >>> fp = [1.0j, 0, 2+3j]
-    >>> np.interp(x, xp, fp)
-    array([0.+1.j , 1.+1.5j])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def genfromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "genfromtxt"))))
-(alter-meta! #'genfromtxt assoc :doc "
-    Load data from a text file, with missing values handled as specified.
-
-    Each line past the first `skip_header` lines is split at the `delimiter`
-    character, and characters following the `comments` character are discarded.
-
-    Parameters
-    ----------
-    fname : file, str, pathlib.Path, list of str, generator
-        File, filename, list, or generator to read.  If the filename
-        extension is `.gz` or `.bz2`, the file is first decompressed. Note
-        that generators must return byte strings. The strings
-        in a list or produced by a generator are treated as lines.
-    dtype : dtype, optional
-        Data type of the resulting array.
-        If None, the dtypes will be determined by the contents of each
-        column, individually.
-    comments : str, optional
-        The character used to indicate the start of a comment.
-        All the characters occurring on a line after a comment are discarded
-    delimiter : str, int, or sequence, optional
-        The string used to separate values.  By default, any consecutive
-        whitespaces act as delimiter.  An integer or sequence of integers
-        can also be provided as width(s) of each field.
-    skiprows : int, optional
-        `skiprows` was removed in numpy 1.10. Please use `skip_header` instead.
-    skip_header : int, optional
-        The number of lines to skip at the beginning of the file.
-    skip_footer : int, optional
-        The number of lines to skip at the end of the file.
-    converters : variable, optional
-        The set of functions that convert the data of a column to a value.
-        The converters can also be used to provide a default value
-        for missing data: ``converters = {3: lambda s: float(s or 0)}``.
-    missing : variable, optional
-        `missing` was removed in numpy 1.10. Please use `missing_values`
-        instead.
-    missing_values : variable, optional
-        The set of strings corresponding to missing data.
-    filling_values : variable, optional
-        The set of values to be used as default when the data are missing.
-    usecols : sequence, optional
-        Which columns to read, with 0 being the first.  For example,
-        ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.
-    names : {None, True, str, sequence}, optional
-        If `names` is True, the field names are read from the first line after
-        the first `skip_header` lines.  This line can optionally be proceeded
-        by a comment delimiter. If `names` is a sequence or a single-string of
-        comma-separated names, the names will be used to define the field names
-        in a structured dtype. If `names` is None, the names of the dtype
-        fields will be used, if any.
-    excludelist : sequence, optional
-        A list of names to exclude. This list is appended to the default list
-        ['return','file','print']. Excluded names are appended an underscore:
-        for example, `file` would become `file_`.
-    deletechars : str, optional
-        A string combining invalid characters that must be deleted from the
-        names.
-    defaultfmt : str, optional
-        A format used to define default field names, such as \"f%i\" or \"f_%02i\".
-    autostrip : bool, optional
-        Whether to automatically strip white spaces from the variables.
-    replace_space : char, optional
-        Character(s) used in replacement of white spaces in the variables
-        names. By default, use a '_'.
-    case_sensitive : {True, False, 'upper', 'lower'}, optional
-        If True, field names are case sensitive.
-        If False or 'upper', field names are converted to upper case.
-        If 'lower', field names are converted to lower case.
-    unpack : bool, optional
-        If True, the returned array is transposed, so that arguments may be
-        unpacked using ``x, y, z = loadtxt(...)``
-    usemask : bool, optional
-        If True, return a masked array.
-        If False, return a regular array.
-    loose : bool, optional
-        If True, do not raise errors for invalid values.
-    invalid_raise : bool, optional
-        If True, an exception is raised if an inconsistency is detected in the
-        number of columns.
-        If False, a warning is emitted and the offending lines are skipped.
-    max_rows : int,  optional
-        The maximum number of rows to read. Must not be used with skip_footer
-        at the same time.  If given, the value must be at least 1. Default is
-        to read the entire file.
-
-        .. versionadded:: 1.10.0
-    encoding : str, optional
-        Encoding used to decode the inputfile. Does not apply when `fname` is
-        a file object.  The special value 'bytes' enables backward compatibility
-        workarounds that ensure that you receive byte arrays when possible
-        and passes latin1 encoded strings to converters. Override this value to
-        receive unicode arrays and pass strings as input to converters.  If set
-        to None the system default is used. The default value is 'bytes'.
-
-        .. versionadded:: 1.14.0
-
-    Returns
-    -------
-    out : ndarray
-        Data read from the text file. If `usemask` is True, this is a
-        masked array.
-
-    See Also
-    --------
-    numpy.loadtxt : equivalent function when no data is missing.
-
-    Notes
-    -----
-    * When spaces are used as delimiters, or when no delimiter has been given
-      as input, there should not be any missing data between two fields.
-    * When the variables are named (either by a flexible dtype or with `names`,
-      there must not be any header in the file (else a ValueError
-      exception is raised).
-    * Individual values are not stripped of spaces by default.
-      When using a custom converter, make sure the function does remove spaces.
-
-    References
-    ----------
-    .. [1] NumPy User Guide, section `I/O with NumPy
-           <https://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html>`_.
-
-    Examples
-    ---------
-    >>> from io import StringIO
-    >>> import numpy as np
-
-    Comma delimited file with mixed dtype
-
-    >>> s = StringIO(u\"1,1.3,abcde\")
-    >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),
-    ... ('mystring','S5')], delimiter=\",\")
-    >>> data
-    array((1, 1.3, b'abcde'),
-          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
-
-    Using dtype = None
-
-    >>> _ = s.seek(0) # needed for StringIO example only
-    >>> data = np.genfromtxt(s, dtype=None,
-    ... names = ['myint','myfloat','mystring'], delimiter=\",\")
-    >>> data
-    array((1, 1.3, b'abcde'),
-          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
-
-    Specifying dtype and names
-
-    >>> _ = s.seek(0)
-    >>> data = np.genfromtxt(s, dtype=\"i8,f8,S5\",
-    ... names=['myint','myfloat','mystring'], delimiter=\",\")
-    >>> data
-    array((1, 1.3, b'abcde'),
-          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
-
-    An example with fixed-width columns
-
-    >>> s = StringIO(u\"11.3abcde\")
-    >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],
-    ...     delimiter=[1,3,5])
-    >>> data
-    array((1, 1.3, b'abcde'),
-          dtype=[('intvar', '<i8'), ('fltvar', '<f8'), ('strvar', 'S5')])
-
-    An example to show comments
-
-    >>> f = StringIO('''
-    ... text,# of chars
-    ... hello world,11
-    ... numpy,5''')
-    >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',')
-    array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')],
-      dtype=[('f0', 'S12'), ('f1', 'S12')])
-
-    " :arglists '[[fname & [{names :names, max_rows :max_rows, encoding :encoding, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, max_rows :max_rows, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, excludelist :excludelist, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters, missing_values :missing_values, filling_values :filling_values}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters, missing_values :missing_values}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter}]] [fname & [{dtype :dtype, comments :comments}]] [fname & [{dtype :dtype}]] [fname]])
-
-(def errstate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "errstate"))))
-(alter-meta! #'errstate assoc :doc "
-    errstate(**kwargs)
-
-    Context manager for floating-point error handling.
-
-    Using an instance of `errstate` as a context manager allows statements in
-    that context to execute with a known error handling behavior. Upon entering
-    the context the error handling is set with `seterr` and `seterrcall`, and
-    upon exiting it is reset to what it was before.
-
-    ..  versionchanged:: 1.17.0
-        `errstate` is also usable as a function decorator, saving
-        a level of indentation if an entire function is wrapped.
-        See :py:class:`contextlib.ContextDecorator` for more information.
-
-    Parameters
-    ----------
-    kwargs : {divide, over, under, invalid}
-        Keyword arguments. The valid keywords are the possible floating-point
-        exceptions. Each keyword should have a string value that defines the
-        treatment for the particular error. Possible values are
-        {'ignore', 'warn', 'raise', 'call', 'print', 'log'}.
-
-    See Also
-    --------
-    seterr, geterr, seterrcall, geterrcall
-
-    Notes
-    -----
-    For complete documentation of the types of floating-point exceptions and
-    treatment options, see `seterr`.
-
-    Examples
-    --------
-    >>> from collections import OrderedDict
-    >>> olderr = np.seterr(all='ignore')  # Set error handling to known state.
-
-    >>> np.arange(3) / 0.
-    array([nan, inf, inf])
-    >>> with np.errstate(divide='warn'):
-    ...     np.arange(3) / 0.
-    array([nan, inf, inf])
-
-    >>> np.sqrt(-1)
-    nan
-    >>> with np.errstate(invalid='raise'):
-    ...     np.sqrt(-1)
-    Traceback (most recent call last):
-      File \"<stdin>\", line 2, in <module>
-    FloatingPointError: invalid value encountered in sqrt
-
-    Outside the context the error handling behavior has not changed:
-
-    >>> OrderedDict(sorted(np.geterr().items()))
-    OrderedDict([('divide', 'ignore'), ('invalid', 'ignore'), ('over', 'ignore'), ('under', 'ignore')])
-
-    " :arglists '[[self & [{:as kwargs}]]])
-
-(def set_numeric_ops (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "set_numeric_ops"))))
-(alter-meta! #'set_numeric_ops assoc :doc "set_numeric_ops(op1=func1, op2=func2, ...)
-
-    Set numerical operators for array objects.
-
-    .. deprecated:: 1.16
-
-        For the general case, use :c:func:`PyUFunc_ReplaceLoopBySignature`.
-        For ndarray subclasses, define the ``__array_ufunc__`` method and
-        override the relevant ufunc.
-
-    Parameters
-    ----------
-    op1, op2, ... : callable
-        Each ``op = func`` pair describes an operator to be replaced.
-        For example, ``add = lambda x, y: np.add(x, y) % 5`` would replace
-        addition by modulus 5 addition.
-
-    Returns
-    -------
-    saved_ops : list of callables
-        A list of all operators, stored before making replacements.
-
-    Notes
-    -----
-    .. WARNING::
-       Use with care!  Incorrect usage may lead to memory errors.
-
-    A function replacing an operator cannot make use of that operator.
-    For example, when replacing add, you may not use ``+``.  Instead,
-    directly call ufuncs.
-
-    Examples
-    --------
-    >>> def add_mod5(x, y):
-    ...     return np.add(x, y) % 5
-    ...
-    >>> old_funcs = np.set_numeric_ops(add=add_mod5)
-
-    >>> x = np.arange(12).reshape((3, 4))
-    >>> x + x
-    array([[0, 2, 4, 1],
-           [3, 0, 2, 4],
-           [1, 3, 0, 2]])
-
-    >>> ignore = np.set_numeric_ops(**old_funcs) # restore operators" :arglists '[[self & [args {:as kwargs}]]])
-
-(def degrees (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "degrees"))))
-(alter-meta! #'degrees assoc :doc "degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Convert angles from radians to degrees.
-
-Parameters
-----------
-x : array_like
-    Input array in radians.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray of floats
-    The corresponding degree values; if `out` was supplied this is a
-    reference to it.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-rad2deg : equivalent function
-
-Examples
---------
-Convert a radian array to degrees
-
->>> rad = np.arange(12.)*np.pi/6
->>> np.degrees(rad)
-array([   0.,   30.,   60.,   90.,  120.,  150.,  180.,  210.,  240.,
-        270.,  300.,  330.])
-
->>> out = np.zeros((rad.shape))
->>> r = np.degrees(rad, out)
->>> np.all(r == out)
-True" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} True_ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "True_"))))
-
-(def diff (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diff"))))
-(alter-meta! #'diff assoc :doc "
-    Calculate the n-th discrete difference along the given axis.
-
-    The first difference is given by ``out[i] = a[i+1] - a[i]`` along
-    the given axis, higher differences are calculated by using `diff`
-    recursively.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array
-    n : int, optional
-        The number of times values are differenced. If zero, the input
-        is returned as-is.
-    axis : int, optional
-        The axis along which the difference is taken, default is the
-        last axis.
-    prepend, append : array_like, optional
-        Values to prepend or append to `a` along axis prior to
-        performing the difference.  Scalar values are expanded to
-        arrays with length 1 in the direction of axis and the shape
-        of the input array in along all other axes.  Otherwise the
-        dimension and shape must match `a` except along axis.
-
-        .. versionadded:: 1.16.0
-
-    Returns
-    -------
-    diff : ndarray
-        The n-th differences. The shape of the output is the same as `a`
-        except along `axis` where the dimension is smaller by `n`. The
-        type of the output is the same as the type of the difference
-        between any two elements of `a`. This is the same as the type of
-        `a` in most cases. A notable exception is `datetime64`, which
-        results in a `timedelta64` output array.
-
-    See Also
-    --------
-    gradient, ediff1d, cumsum
-
-    Notes
-    -----
-    Type is preserved for boolean arrays, so the result will contain
-    `False` when consecutive elements are the same and `True` when they
-    differ.
-
-    For unsigned integer arrays, the results will also be unsigned. This
-    should not be surprising, as the result is consistent with
-    calculating the difference directly:
-
-    >>> u8_arr = np.array([1, 0], dtype=np.uint8)
-    >>> np.diff(u8_arr)
-    array([255], dtype=uint8)
-    >>> u8_arr[1,...] - u8_arr[0,...]
-    255
-
-    If this is not desirable, then the array should be cast to a larger
-    integer type first:
-
-    >>> i16_arr = u8_arr.astype(np.int16)
-    >>> np.diff(i16_arr)
-    array([-1], dtype=int16)
-
-    Examples
-    --------
-    >>> x = np.array([1, 2, 4, 7, 0])
-    >>> np.diff(x)
-    array([ 1,  2,  3, -7])
-    >>> np.diff(x, n=2)
-    array([  1,   1, -10])
-
-    >>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])
-    >>> np.diff(x)
-    array([[2, 3, 4],
-           [5, 1, 2]])
-    >>> np.diff(x, axis=0)
-    array([[-1,  2,  0, -2]])
-
-    >>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64)
-    >>> np.diff(x)
-    array([1, 1], dtype='timedelta64[D]')
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def isin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isin"))))
-(alter-meta! #'isin assoc :doc "
-    Calculates `element in test_elements`, broadcasting over `element` only.
-    Returns a boolean array of the same shape as `element` that is True
-    where an element of `element` is in `test_elements` and False otherwise.
-
-    Parameters
-    ----------
-    element : array_like
-        Input array.
-    test_elements : array_like
-        The values against which to test each value of `element`.
-        This argument is flattened if it is an array or array_like.
-        See notes for behavior with non-array-like parameters.
-    assume_unique : bool, optional
-        If True, the input arrays are both assumed to be unique, which
-        can speed up the calculation.  Default is False.
-    invert : bool, optional
-        If True, the values in the returned array are inverted, as if
-        calculating `element not in test_elements`. Default is False.
-        ``np.isin(a, b, invert=True)`` is equivalent to (but faster
-        than) ``np.invert(np.isin(a, b))``.
-
-    Returns
-    -------
-    isin : ndarray, bool
-        Has the same shape as `element`. The values `element[isin]`
-        are in `test_elements`.
-
-    See Also
-    --------
-    in1d                  : Flattened version of this function.
-    numpy.lib.arraysetops : Module with a number of other functions for
-                            performing set operations on arrays.
-
-    Notes
-    -----
-
-    `isin` is an element-wise function version of the python keyword `in`.
-    ``isin(a, b)`` is roughly equivalent to
-    ``np.array([item in b for item in a])`` if `a` and `b` are 1-D sequences.
-
-    `element` and `test_elements` are converted to arrays if they are not
-    already. If `test_elements` is a set (or other non-sequence collection)
-    it will be converted to an object array with one element, rather than an
-    array of the values contained in `test_elements`. This is a consequence
-    of the `array` constructor's way of handling non-sequence collections.
-    Converting the set to a list usually gives the desired behavior.
-
-    .. versionadded:: 1.13.0
-
-    Examples
-    --------
-    >>> element = 2*np.arange(4).reshape((2, 2))
-    >>> element
-    array([[0, 2],
-           [4, 6]])
-    >>> test_elements = [1, 2, 4, 8]
-    >>> mask = np.isin(element, test_elements)
-    >>> mask
-    array([[False,  True],
-           [ True, False]])
-    >>> element[mask]
-    array([2, 4])
-
-    The indices of the matched values can be obtained with `nonzero`:
-
-    >>> np.nonzero(mask)
-    (array([0, 1]), array([1, 0]))
-
-    The test can also be inverted:
-
-    >>> mask = np.isin(element, test_elements, invert=True)
-    >>> mask
-    array([[ True, False],
-           [False,  True]])
-    >>> element[mask]
-    array([0, 6])
-
-    Because of how `array` handles sets, the following does not
-    work as expected:
-
-    >>> test_set = {1, 2, 4, 8}
-    >>> np.isin(element, test_set)
-    array([[False, False],
-           [False, False]])
-
-    Casting the set to a list gives the expected result:
-
-    >>> np.isin(element, list(test_set))
-    array([[False,  True],
-           [ True, False]])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} sctypeNA (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "sctypeNA"))))
-
-(def argmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argmin"))))
-(alter-meta! #'argmin assoc :doc "
-    Returns the indices of the minimum values along an axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    axis : int, optional
-        By default, the index is into the flattened array, otherwise
-        along the specified axis.
-    out : array, optional
-        If provided, the result will be inserted into this array. It should
-        be of the appropriate shape and dtype.
-
-    Returns
-    -------
-    index_array : ndarray of ints
-        Array of indices into the array. It has the same shape as `a.shape`
-        with the dimension along `axis` removed.
-
-    See Also
-    --------
-    ndarray.argmin, argmax
-    amin : The minimum value along a given axis.
-    unravel_index : Convert a flat index into an index tuple.
-    take_along_axis : Apply ``np.expand_dims(index_array, axis)`` 
-                      from argmin to an array as if by calling min.
-
-    Notes
-    -----
-    In case of multiple occurrences of the minimum values, the indices
-    corresponding to the first occurrence are returned.
-
-    Examples
-    --------
-    >>> a = np.arange(6).reshape(2,3) + 10
-    >>> a
-    array([[10, 11, 12],
-           [13, 14, 15]])
-    >>> np.argmin(a)
-    0
-    >>> np.argmin(a, axis=0)
-    array([0, 0, 0])
-    >>> np.argmin(a, axis=1)
-    array([0, 0])
-
-    Indices of the minimum elements of a N-dimensional array:
-
-    >>> ind = np.unravel_index(np.argmin(a, axis=None), a.shape)
-    >>> ind
-    (0, 0)
-    >>> a[ind]
-    10
-
-    >>> b = np.arange(6) + 10
-    >>> b[4] = 10
-    >>> b
-    array([10, 11, 12, 13, 10, 15])
-    >>> np.argmin(b)  # Only the first occurrence is returned.
-    0
-
-    >>> x = np.array([[4,2,3], [1,0,3]])
-    >>> index_array = np.argmin(x, axis=-1)
-    >>> # Same as np.min(x, axis=-1, keepdims=True)
-    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
-    array([[2],
-           [0]])
-    >>> # Same as np.max(x, axis=-1)
-    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1)
-    array([2, 0])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def chararray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "chararray"))))
-(alter-meta! #'chararray assoc :doc "
-    chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,
-              strides=None, order=None)
-
-    Provides a convenient view on arrays of string and unicode values.
-
-    .. note::
-       The `chararray` class exists for backwards compatibility with
-       Numarray, it is not recommended for new development. Starting from numpy
-       1.4, if one needs arrays of strings, it is recommended to use arrays of
-       `dtype` `object_`, `string_` or `unicode_`, and use the free functions
-       in the `numpy.char` module for fast vectorized string operations.
-
-    Versus a regular NumPy array of type `str` or `unicode`, this
-    class adds the following functionality:
-
-      1) values automatically have whitespace removed from the end
-         when indexed
-
-      2) comparison operators automatically remove whitespace from the
-         end when comparing values
-
-      3) vectorized string operations are provided as methods
-         (e.g. `.endswith`) and infix operators (e.g. ``\"+\", \"*\", \"%\"``)
-
-    chararrays should be created using `numpy.char.array` or
-    `numpy.char.asarray`, rather than this constructor directly.
-
-    This constructor creates the array, using `buffer` (with `offset`
-    and `strides`) if it is not ``None``. If `buffer` is ``None``, then
-    constructs a new array with `strides` in \"C order\", unless both
-    ``len(shape) >= 2`` and ``order='F'``, in which case `strides`
-    is in \"Fortran order\".
-
-    Methods
-    -------
-    astype
-    argsort
-    copy
-    count
-    decode
-    dump
-    dumps
-    encode
-    endswith
-    expandtabs
-    fill
-    find
-    flatten
-    getfield
-    index
-    isalnum
-    isalpha
-    isdecimal
-    isdigit
-    islower
-    isnumeric
-    isspace
-    istitle
-    isupper
-    item
-    join
-    ljust
-    lower
-    lstrip
-    nonzero
-    put
-    ravel
-    repeat
-    replace
-    reshape
-    resize
-    rfind
-    rindex
-    rjust
-    rsplit
-    rstrip
-    searchsorted
-    setfield
-    setflags
-    sort
-    split
-    splitlines
-    squeeze
-    startswith
-    strip
-    swapaxes
-    swapcase
-    take
-    title
-    tofile
-    tolist
-    tostring
-    translate
-    transpose
-    upper
-    view
-    zfill
-
-    Parameters
-    ----------
-    shape : tuple
-        Shape of the array.
-    itemsize : int, optional
-        Length of each array element, in number of characters. Default is 1.
-    unicode : bool, optional
-        Are the array elements of type unicode (True) or string (False).
-        Default is False.
-    buffer : int, optional
-        Memory address of the start of the array data.  Default is None,
-        in which case a new array is created.
-    offset : int, optional
-        Fixed stride displacement from the beginning of an axis?
-        Default is 0. Needs to be >=0.
-    strides : array_like of ints, optional
-        Strides for the array (see `ndarray.strides` for full description).
-        Default is None.
-    order : {'C', 'F'}, optional
-        The order in which the array data is stored in memory: 'C' ->
-        \"row major\" order (the default), 'F' -> \"column major\"
-        (Fortran) order.
-
-    Examples
-    --------
-    >>> charar = np.chararray((3, 3))
-    >>> charar[:] = 'a'
-    >>> charar
-    chararray([[b'a', b'a', b'a'],
-               [b'a', b'a', b'a'],
-               [b'a', b'a', b'a']], dtype='|S1')
-
-    >>> charar = np.chararray(charar.shape, itemsize=5)
-    >>> charar[:] = 'abc'
-    >>> charar
-    chararray([[b'abc', b'abc', b'abc'],
-               [b'abc', b'abc', b'abc'],
-               [b'abc', b'abc', b'abc']], dtype='|S5')
-
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def shares_memory (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "shares_memory"))))
-(alter-meta! #'shares_memory assoc :doc "
-    shares_memory(a, b, max_work=None)
-
-    Determine if two arrays share memory
-
-    Parameters
-    ----------
-    a, b : ndarray
-        Input arrays
-    max_work : int, optional
-        Effort to spend on solving the overlap problem (maximum number
-        of candidate solutions to consider). The following special
-        values are recognized:
-
-        max_work=MAY_SHARE_EXACT  (default)
-            The problem is solved exactly. In this case, the function returns
-            True only if there is an element shared between the arrays.
-        max_work=MAY_SHARE_BOUNDS
-            Only the memory bounds of a and b are checked.
-
-    Raises
-    ------
-    numpy.TooHardError
-        Exceeded max_work.
-
-    Returns
-    -------
-    out : bool
-
-    See Also
-    --------
-    may_share_memory
-
-    Examples
-    --------
-    >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9]))
-    False
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def flip (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flip"))))
-(alter-meta! #'flip assoc :doc "
-    Reverse the order of elements in an array along the given axis.
-
-    The shape of the array is preserved, but the elements are reordered.
-
-    .. versionadded:: 1.12.0
-
-    Parameters
-    ----------
-    m : array_like
-        Input array.
-    axis : None or int or tuple of ints, optional
-         Axis or axes along which to flip over. The default,
-         axis=None, will flip over all of the axes of the input array.
-         If axis is negative it counts from the last to the first axis.
-
-         If axis is a tuple of ints, flipping is performed on all of the axes
-         specified in the tuple.
-
-         .. versionchanged:: 1.15.0
-            None and tuples of axes are supported
-
-    Returns
-    -------
-    out : array_like
-        A view of `m` with the entries of axis reversed.  Since a view is
-        returned, this operation is done in constant time.
-
-    See Also
-    --------
-    flipud : Flip an array vertically (axis=0).
-    fliplr : Flip an array horizontally (axis=1).
-
-    Notes
-    -----
-    flip(m, 0) is equivalent to flipud(m).
-
-    flip(m, 1) is equivalent to fliplr(m).
-
-    flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n.
-
-    flip(m) corresponds to ``m[::-1,::-1,...,::-1]`` with ``::-1`` at all
-    positions.
-
-    flip(m, (0, 1)) corresponds to ``m[::-1,::-1,...]`` with ``::-1`` at
-    position 0 and position 1.
-
-    Examples
-    --------
-    >>> A = np.arange(8).reshape((2,2,2))
-    >>> A
-    array([[[0, 1],
-            [2, 3]],
-           [[4, 5],
-            [6, 7]]])
-    >>> np.flip(A, 0)
-    array([[[4, 5],
-            [6, 7]],
-           [[0, 1],
-            [2, 3]]])
-    >>> np.flip(A, 1)
-    array([[[2, 3],
-            [0, 1]],
-           [[6, 7],
-            [4, 5]]])
-    >>> np.flip(A)
-    array([[[7, 6],
-            [5, 4]],
-           [[3, 2],
-            [1, 0]]])
-    >>> np.flip(A, (0, 2))
-    array([[[5, 4],
-            [7, 6]],
-           [[1, 0],
-            [3, 2]]])
-    >>> A = np.random.randn(3,4,5)
-    >>> np.all(np.flip(A,2) == A[:,:,::-1,...])
-    True
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def block (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "block"))))
-(alter-meta! #'block assoc :doc "
-    Assemble an nd-array from nested lists of blocks.
-
-    Blocks in the innermost lists are concatenated (see `concatenate`) along
-    the last dimension (-1), then these are concatenated along the
-    second-last dimension (-2), and so on until the outermost list is reached.
-
-    Blocks can be of any dimension, but will not be broadcasted using the normal
-    rules. Instead, leading axes of size 1 are inserted, to make ``block.ndim``
-    the same for all blocks. This is primarily useful for working with scalars,
-    and means that code like ``np.block([v, 1])`` is valid, where
-    ``v.ndim == 1``.
-
-    When the nested list is two levels deep, this allows block matrices to be
-    constructed from their components.
-
-    .. versionadded:: 1.13.0
-
-    Parameters
-    ----------
-    arrays : nested list of array_like or scalars (but not tuples)
-        If passed a single ndarray or scalar (a nested list of depth 0), this
-        is returned unmodified (and not copied).
-
-        Elements shapes must match along the appropriate axes (without
-        broadcasting), but leading 1s will be prepended to the shape as
-        necessary to make the dimensions match.
-
-    Returns
-    -------
-    block_array : ndarray
-        The array assembled from the given blocks.
-
-        The dimensionality of the output is equal to the greatest of:
-        * the dimensionality of all the inputs
-        * the depth to which the input list is nested
-
-    Raises
-    ------
-    ValueError
-        * If list depths are mismatched - for instance, ``[[a, b], c]`` is
-          illegal, and should be spelt ``[[a, b], [c]]``
-        * If lists are empty - for instance, ``[[a, b], []]``
-
-    See Also
-    --------
-    concatenate : Join a sequence of arrays together.
-    stack : Stack arrays in sequence along a new dimension.
-    hstack : Stack arrays in sequence horizontally (column wise).
-    vstack : Stack arrays in sequence vertically (row wise).
-    dstack : Stack arrays in sequence depth wise (along third dimension).
-    vsplit : Split array into a list of multiple sub-arrays vertically.
-
-    Notes
-    -----
-
-    When called with only scalars, ``np.block`` is equivalent to an ndarray
-    call. So ``np.block([[1, 2], [3, 4]])`` is equivalent to
-    ``np.array([[1, 2], [3, 4]])``.
-
-    This function does not enforce that the blocks lie on a fixed grid.
-    ``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form::
-
-        AAAbb
-        AAAbb
-        cccDD
-
-    But is also allowed to produce, for some ``a, b, c, d``::
-
-        AAAbb
-        AAAbb
-        cDDDD
-
-    Since concatenation happens along the last axis first, `block` is _not_
-    capable of producing the following directly::
-
-        AAAbb
-        cccbb
-        cccDD
-
-    Matlab's \"square bracket stacking\", ``[A, B, ...; p, q, ...]``, is
-    equivalent to ``np.block([[A, B, ...], [p, q, ...]])``.
-
-    Examples
-    --------
-    The most common use of this function is to build a block matrix
-
-    >>> A = np.eye(2) * 2
-    >>> B = np.eye(3) * 3
-    >>> np.block([
-    ...     [A,               np.zeros((2, 3))],
-    ...     [np.ones((3, 2)), B               ]
-    ... ])
-    array([[2., 0., 0., 0., 0.],
-           [0., 2., 0., 0., 0.],
-           [1., 1., 3., 0., 0.],
-           [1., 1., 0., 3., 0.],
-           [1., 1., 0., 0., 3.]])
-
-    With a list of depth 1, `block` can be used as `hstack`
-
-    >>> np.block([1, 2, 3])              # hstack([1, 2, 3])
-    array([1, 2, 3])
-
-    >>> a = np.array([1, 2, 3])
-    >>> b = np.array([2, 3, 4])
-    >>> np.block([a, b, 10])             # hstack([a, b, 10])
-    array([ 1,  2,  3,  2,  3,  4, 10])
-
-    >>> A = np.ones((2, 2), int)
-    >>> B = 2 * A
-    >>> np.block([A, B])                 # hstack([A, B])
-    array([[1, 1, 2, 2],
-           [1, 1, 2, 2]])
-
-    With a list of depth 2, `block` can be used in place of `vstack`:
-
-    >>> a = np.array([1, 2, 3])
-    >>> b = np.array([2, 3, 4])
-    >>> np.block([[a], [b]])             # vstack([a, b])
-    array([[1, 2, 3],
-           [2, 3, 4]])
-
-    >>> A = np.ones((2, 2), int)
-    >>> B = 2 * A
-    >>> np.block([[A], [B]])             # vstack([A, B])
-    array([[1, 1],
-           [1, 1],
-           [2, 2],
-           [2, 2]])
-
-    It can also be used in places of `atleast_1d` and `atleast_2d`
-
-    >>> a = np.array(0)
-    >>> b = np.array([1])
-    >>> np.block([a])                    # atleast_1d(a)
-    array([0])
-    >>> np.block([b])                    # atleast_1d(b)
-    array([1])
-
-    >>> np.block([[a]])                  # atleast_2d(a)
-    array([[0]])
-    >>> np.block([[b]])                  # atleast_2d(b)
-    array([[1]])
-
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def putmask (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "putmask"))))
-(alter-meta! #'putmask assoc :doc "
-    putmask(a, mask, values)
-
-    Changes elements of an array based on conditional and input values.
-
-    Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``.
-
-    If `values` is not the same size as `a` and `mask` then it will repeat.
-    This gives behavior different from ``a[mask] = values``.
-
-    Parameters
-    ----------
-    a : array_like
-        Target array.
-    mask : array_like
-        Boolean mask array. It has to be the same shape as `a`.
-    values : array_like
-        Values to put into `a` where `mask` is True. If `values` is smaller
-        than `a` it will be repeated.
-
-    See Also
-    --------
-    place, put, take, copyto
-
-    Examples
-    --------
-    >>> x = np.arange(6).reshape(2, 3)
-    >>> np.putmask(x, x>2, x**2)
-    >>> x
-    array([[ 0,  1,  2],
-           [ 9, 16, 25]])
-
-    If `values` is smaller than `a` it is repeated:
-
-    >>> x = np.arange(5)
-    >>> np.putmask(x, x>1, [-33, -44])
-    >>> x
-    array([  0,   1, -33, -44, -33])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def arctanh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arctanh"))))
-(alter-meta! #'arctanh assoc :doc "arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Inverse hyperbolic tangent element-wise.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Array of the same shape as `x`.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-emath.arctanh
-
-Notes
------
-`arctanh` is a multivalued function: for each `x` there are infinitely
-many numbers `z` such that `tanh(z) = x`. The convention is to return
-the `z` whose imaginary part lies in `[-pi/2, pi/2]`.
-
-For real-valued input data types, `arctanh` always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields ``nan`` and sets the `invalid` floating point error flag.
-
-For complex-valued input, `arctanh` is a complex analytical function
-that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from
-above on the former and from below on the latter.
-
-The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``.
-
-References
-----------
-.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
-       10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/
-.. [2] Wikipedia, \"Inverse hyperbolic function\",
-       https://en.wikipedia.org/wiki/Arctanh
-
-Examples
---------
->>> np.arctanh([0, -0.5])
-array([ 0.        , -0.54930614])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def take (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "take"))))
-(alter-meta! #'take assoc :doc "
-    Take elements from an array along an axis.
-
-    When axis is not None, this function does the same thing as \"fancy\"
-    indexing (indexing arrays using arrays); however, it can be easier to use
-    if you need elements along a given axis. A call such as
-    ``np.take(arr, indices, axis=3)`` is equivalent to
-    ``arr[:,:,:,indices,...]``.
-
-    Explained without fancy indexing, this is equivalent to the following use
-    of `ndindex`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of
-    indices::
-
-        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
-        Nj = indices.shape
-        for ii in ndindex(Ni):
-            for jj in ndindex(Nj):
-                for kk in ndindex(Nk):
-                    out[ii + jj + kk] = a[ii + (indices[jj],) + kk]
-
-    Parameters
-    ----------
-    a : array_like (Ni..., M, Nk...)
-        The source array.
-    indices : array_like (Nj...)
-        The indices of the values to extract.
-
-        .. versionadded:: 1.8.0
-
-        Also allow scalars for indices.
-    axis : int, optional
-        The axis over which to select values. By default, the flattened
-        input array is used.
-    out : ndarray, optional (Ni..., Nj..., Nk...)
-        If provided, the result will be placed in this array. It should
-        be of the appropriate shape and dtype. Note that `out` is always
-        buffered if `mode='raise'`; use other modes for better performance.
-    mode : {'raise', 'wrap', 'clip'}, optional
-        Specifies how out-of-bounds indices will behave.
-
-        * 'raise' -- raise an error (default)
-        * 'wrap' -- wrap around
-        * 'clip' -- clip to the range
-
-        'clip' mode means that all indices that are too large are replaced
-        by the index that addresses the last element along that axis. Note
-        that this disables indexing with negative numbers.
-
-    Returns
-    -------
-    out : ndarray (Ni..., Nj..., Nk...)
-        The returned array has the same type as `a`.
-
-    See Also
-    --------
-    compress : Take elements using a boolean mask
-    ndarray.take : equivalent method
-    take_along_axis : Take elements by matching the array and the index arrays
-
-    Notes
-    -----
-
-    By eliminating the inner loop in the description above, and using `s_` to
-    build simple slice objects, `take` can be expressed  in terms of applying
-    fancy indexing to each 1-d slice::
-
-        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
-        for ii in ndindex(Ni):
-            for kk in ndindex(Nj):
-                out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices]
-
-    For this reason, it is equivalent to (but faster than) the following use
-    of `apply_along_axis`::
-
-        out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a)
-
-    Examples
-    --------
-    >>> a = [4, 3, 5, 7, 6, 8]
-    >>> indices = [0, 1, 4]
-    >>> np.take(a, indices)
-    array([4, 3, 6])
-
-    In this example if `a` is an ndarray, \"fancy\" indexing can be used.
-
-    >>> a = np.array(a)
-    >>> a[indices]
-    array([4, 3, 6])
-
-    If `indices` is not one dimensional, the output also has these dimensions.
-
-    >>> np.take(a, [[0, 1], [2, 3]])
-    array([[4, 3],
-           [5, 7]])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def conjugate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "conjugate"))))
-(alter-meta! #'conjugate assoc :doc "conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the complex conjugate, element-wise.
-
-The complex conjugate of a complex number is obtained by changing the
-sign of its imaginary part.
-
-Parameters
-----------
-x : array_like
-    Input value.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The complex conjugate of `x`, with same dtype as `y`.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-`conj` is an alias for `conjugate`:
-
->>> np.conj is np.conjugate
-True
-
-Examples
---------
->>> np.conjugate(1+2j)
-(1-2j)
-
->>> x = np.eye(2) + 1j * np.eye(2)
->>> np.conjugate(x)
-array([[ 1.-1.j,  0.-0.j],
-       [ 0.-0.j,  1.-1.j]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def __getattr__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__getattr__"))))
-(alter-meta! #'__getattr__ assoc :doc "" :arglists '[[attr]])
-
-(def seterrcall (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "seterrcall"))))
-(alter-meta! #'seterrcall assoc :doc "
-    Set the floating-point error callback function or log object.
-
-    There are two ways to capture floating-point error messages.  The first
-    is to set the error-handler to 'call', using `seterr`.  Then, set
-    the function to call using this function.
-
-    The second is to set the error-handler to 'log', using `seterr`.
-    Floating-point errors then trigger a call to the 'write' method of
-    the provided object.
-
-    Parameters
-    ----------
-    func : callable f(err, flag) or object with write method
-        Function to call upon floating-point errors ('call'-mode) or
-        object whose 'write' method is used to log such message ('log'-mode).
-
-        The call function takes two arguments. The first is a string describing
-        the type of error (such as \"divide by zero\", \"overflow\", \"underflow\",
-        or \"invalid value\"), and the second is the status flag.  The flag is a
-        byte, whose four least-significant bits indicate the type of error, one
-        of \"divide\", \"over\", \"under\", \"invalid\"::
-
-          [0 0 0 0 divide over under invalid]
-
-        In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.
-
-        If an object is provided, its write method should take one argument,
-        a string.
-
-    Returns
-    -------
-    h : callable, log instance or None
-        The old error handler.
-
-    See Also
-    --------
-    seterr, geterr, geterrcall
-
-    Examples
-    --------
-    Callback upon error:
-
-    >>> def err_handler(type, flag):
-    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
-    ...
-
-    >>> saved_handler = np.seterrcall(err_handler)
-    >>> save_err = np.seterr(all='call')
-    >>> from collections import OrderedDict
-
-    >>> np.array([1, 2, 3]) / 0.0
-    Floating point error (divide by zero), with flag 1
-    array([inf, inf, inf])
-
-    >>> np.seterrcall(saved_handler)
-    <function err_handler at 0x...>
-    >>> OrderedDict(sorted(np.seterr(**save_err).items()))
-    OrderedDict([('divide', 'call'), ('invalid', 'call'), ('over', 'call'), ('under', 'call')])
-
-    Log error message:
-
-    >>> class Log(object):
-    ...     def write(self, msg):
-    ...         print(\"LOG: %s\" % msg)
-    ...
-
-    >>> log = Log()
-    >>> saved_handler = np.seterrcall(log)
-    >>> save_err = np.seterr(all='log')
-
-    >>> np.array([1, 2, 3]) / 0.0
-    LOG: Warning: divide by zero encountered in true_divide
-    array([inf, inf, inf])
-
-    >>> np.seterrcall(saved_handler)
-    <numpy.core.numeric.Log object at 0x...>
-    >>> OrderedDict(sorted(np.seterr(**save_err).items()))
-    OrderedDict([('divide', 'log'), ('invalid', 'log'), ('over', 'log'), ('under', 'log')])
-
-    " :arglists '[[func]])
-
-(def unicode (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unicode"))))
-(alter-meta! #'unicode assoc :doc "str(object='') -> str
-str(bytes_or_buffer[, encoding[, errors]]) -> str
-
-Create a new string object from the given object. If encoding or
-errors is specified, then the object must expose a data buffer
-that will be decoded using the given encoding and error handler.
-Otherwise, returns the result of object.__str__() (if defined)
-or repr(object).
-encoding defaults to sys.getdefaultencoding().
-errors defaults to 'strict'." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} SHIFT_OVERFLOW (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "SHIFT_OVERFLOW"))))
-
-(def iscomplex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iscomplex"))))
-(alter-meta! #'iscomplex assoc :doc "
-    Returns a bool array, where True if input element is complex.
-
-    What is tested is whether the input has a non-zero imaginary part, not if
-    the input type is complex.
-
-    Parameters
-    ----------
-    x : array_like
-        Input array.
-
-    Returns
-    -------
-    out : ndarray of bools
-        Output array.
-
-    See Also
-    --------
-    isreal
-    iscomplexobj : Return True if x is a complex type or an array of complex
-                   numbers.
-
-    Examples
-    --------
-    >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])
-    array([ True, False, False, False, False,  True])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ushort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ushort"))))
-(alter-meta! #'ushort assoc :doc "Unsigned integer type, compatible with C ``unsigned short``.
-    Character code: ``'H'``.
-    Canonical name: ``np.ushort``.
-    Alias *on this platform*: ``np.uint16``: 16-bit unsigned integer (0 to 65535)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def fmod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fmod"))))
-(alter-meta! #'fmod assoc :doc "fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the element-wise remainder of division.
-
-This is the NumPy implementation of the C library function fmod, the
-remainder has the same sign as the dividend `x1`. It is equivalent to
-the Matlab(TM) ``rem`` function and should not be confused with the
-Python modulus operator ``x1 % x2``.
-
-Parameters
-----------
-x1 : array_like
-    Dividend.
-x2 : array_like
-    Divisor. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : array_like
-    The remainder of the division of `x1` by `x2`.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-remainder : Equivalent to the Python ``%`` operator.
-divide
-
-Notes
------
-The result of the modulo operation for negative dividend and divisors
-is bound by conventions. For `fmod`, the sign of result is the sign of
-the dividend, while for `remainder` the sign of the result is the sign
-of the divisor. The `fmod` function is equivalent to the Matlab(TM)
-``rem`` function.
-
-Examples
---------
->>> np.fmod([-3, -2, -1, 1, 2, 3], 2)
-array([-1,  0, -1,  1,  0,  1])
->>> np.remainder([-3, -2, -1, 1, 2, 3], 2)
-array([1, 0, 1, 1, 0, 1])
-
->>> np.fmod([5, 3], [2, 2.])
-array([ 1.,  1.])
->>> a = np.arange(-3, 3).reshape(3, 2)
->>> a
-array([[-3, -2],
-       [-1,  0],
-       [ 1,  2]])
->>> np.fmod(a, [2,2])
-array([[-1,  0],
-       [-1,  0],
-       [ 1,  0]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def can_cast (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "can_cast"))))
-(alter-meta! #'can_cast assoc :doc "
-    can_cast(from_, to, casting='safe')
-
-    Returns True if cast between data types can occur according to the
-    casting rule.  If from is a scalar or array scalar, also returns
-    True if the scalar value can be cast without overflow or truncation
-    to an integer.
-
-    Parameters
-    ----------
-    from_ : dtype, dtype specifier, scalar, or array
-        Data type, scalar, or array to cast from.
-    to : dtype or dtype specifier
-        Data type to cast to.
-    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
-        Controls what kind of data casting may occur.
-
-          * 'no' means the data types should not be cast at all.
-          * 'equiv' means only byte-order changes are allowed.
-          * 'safe' means only casts which can preserve values are allowed.
-          * 'same_kind' means only safe casts or casts within a kind,
-            like float64 to float32, are allowed.
-          * 'unsafe' means any data conversions may be done.
-
-    Returns
-    -------
-    out : bool
-        True if cast can occur according to the casting rule.
-
-    Notes
-    -----
-    .. versionchanged:: 1.17.0
-       Casting between a simple data type and a structured one is possible only
-       for \"unsafe\" casting.  Casting to multiple fields is allowed, but
-       casting from multiple fields is not.
-
-    .. versionchanged:: 1.9.0
-       Casting from numeric to string types in 'safe' casting mode requires
-       that the string dtype length is long enough to store the maximum
-       integer/float value converted.
-
-    See also
-    --------
-    dtype, result_type
-
-    Examples
-    --------
-    Basic examples
-
-    >>> np.can_cast(np.int32, np.int64)
-    True
-    >>> np.can_cast(np.float64, complex)
-    True
-    >>> np.can_cast(complex, float)
-    False
-
-    >>> np.can_cast('i8', 'f8')
-    True
-    >>> np.can_cast('i8', 'f4')
-    False
-    >>> np.can_cast('i4', 'S4')
-    False
-
-    Casting scalars
-
-    >>> np.can_cast(100, 'i1')
-    True
-    >>> np.can_cast(150, 'i1')
-    False
-    >>> np.can_cast(150, 'u1')
-    True
-
-    >>> np.can_cast(3.5e100, np.float32)
-    False
-    >>> np.can_cast(1000.0, np.float32)
-    True
-
-    Array scalar checks the value, array does not
-
-    >>> np.can_cast(np.array(1000.0), np.float32)
-    True
-    >>> np.can_cast(np.array([1000.0]), np.float32)
-    False
-
-    Using the casting rules
-
-    >>> np.can_cast('i8', 'i8', 'no')
-    True
-    >>> np.can_cast('<i8', '>i8', 'no')
-    False
-
-    >>> np.can_cast('<i8', '>i8', 'equiv')
-    True
-    >>> np.can_cast('<i4', '>i8', 'equiv')
-    False
-
-    >>> np.can_cast('<i4', '>i8', 'safe')
-    True
-    >>> np.can_cast('<i8', '>i4', 'safe')
-    False
-
-    >>> np.can_cast('<i8', '>i4', 'same_kind')
-    True
-    >>> np.can_cast('<i8', '>u4', 'same_kind')
-    False
-
-    >>> np.can_cast('<i8', '>u4', 'unsafe')
-    True
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def quantile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "quantile"))))
-(alter-meta! #'quantile assoc :doc "
-    Compute the q-th quantile of the data along the specified axis.
-    
-    .. versionadded:: 1.15.0
-
-    Parameters
-    ----------
-    a : array_like
-        Input array or object that can be converted to an array.
-    q : array_like of float
-        Quantile or sequence of quantiles to compute, which must be between
-        0 and 1 inclusive.
-    axis : {int, tuple of int, None}, optional
-        Axis or axes along which the quantiles are computed. The
-        default is to compute the quantile(s) along a flattened
-        version of the array.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must
-        have the same shape and buffer length as the expected output,
-        but the type (of the output) will be cast if necessary.
-    overwrite_input : bool, optional
-        If True, then allow the input array `a` to be modified by intermediate
-        calculations, to save memory. In this case, the contents of the input
-        `a` after this function completes is undefined.
-    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
-        This optional parameter specifies the interpolation method to
-        use when the desired quantile lies between two data points
-        ``i < j``:
-
-            * linear: ``i + (j - i) * fraction``, where ``fraction``
-              is the fractional part of the index surrounded by ``i``
-              and ``j``.
-            * lower: ``i``.
-            * higher: ``j``.
-            * nearest: ``i`` or ``j``, whichever is nearest.
-            * midpoint: ``(i + j) / 2``.
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left in
-        the result as dimensions with size one. With this option, the
-        result will broadcast correctly against the original array `a`.
-
-    Returns
-    -------
-    quantile : scalar or ndarray
-        If `q` is a single quantile and `axis=None`, then the result
-        is a scalar. If multiple quantiles are given, first axis of
-        the result corresponds to the quantiles. The other axes are
-        the axes that remain after the reduction of `a`. If the input
-        contains integers or floats smaller than ``float64``, the output
-        data-type is ``float64``. Otherwise, the output data-type is the
-        same as that of the input. If `out` is specified, that array is
-        returned instead.
-
-    See Also
-    --------
-    mean
-    percentile : equivalent to quantile, but with q in the range [0, 100].
-    median : equivalent to ``quantile(..., 0.5)``
-    nanquantile
-
-    Notes
-    -----
-    Given a vector ``V`` of length ``N``, the q-th quantile of
-    ``V`` is the value ``q`` of the way from the minimum to the
-    maximum in a sorted copy of ``V``. The values and distances of
-    the two nearest neighbors as well as the `interpolation` parameter
-    will determine the quantile if the normalized ranking does not
-    match the location of ``q`` exactly. This function is the same as
-    the median if ``q=0.5``, the same as the minimum if ``q=0.0`` and the
-    same as the maximum if ``q=1.0``.
-
-    Examples
-    --------
-    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
-    >>> a
-    array([[10,  7,  4],
-           [ 3,  2,  1]])
-    >>> np.quantile(a, 0.5)
-    3.5
-    >>> np.quantile(a, 0.5, axis=0)
-    array([6.5, 4.5, 2.5])
-    >>> np.quantile(a, 0.5, axis=1)
-    array([7.,  2.])
-    >>> np.quantile(a, 0.5, axis=1, keepdims=True)
-    array([[7.],
-           [2.]])
-    >>> m = np.quantile(a, 0.5, axis=0)
-    >>> out = np.zeros_like(m)
-    >>> np.quantile(a, 0.5, axis=0, out=out)
-    array([6.5, 4.5, 2.5])
-    >>> m
-    array([6.5, 4.5, 2.5])
-    >>> b = a.copy()
-    >>> np.quantile(b, 0.5, axis=1, overwrite_input=True)
-    array([7.,  2.])
-    >>> assert not np.all(a == b)
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def unwrap (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unwrap"))))
-(alter-meta! #'unwrap assoc :doc "
-    Unwrap by changing deltas between values to 2*pi complement.
-
-    Unwrap radian phase `p` by changing absolute jumps greater than
-    `discont` to their 2*pi complement along the given axis.
-
-    Parameters
-    ----------
-    p : array_like
-        Input array.
-    discont : float, optional
-        Maximum discontinuity between values, default is ``pi``.
-    axis : int, optional
-        Axis along which unwrap will operate, default is the last axis.
-
-    Returns
-    -------
-    out : ndarray
-        Output array.
-
-    See Also
-    --------
-    rad2deg, deg2rad
-
-    Notes
-    -----
-    If the discontinuity in `p` is smaller than ``pi``, but larger than
-    `discont`, no unwrapping is done because taking the 2*pi complement
-    would only make the discontinuity larger.
-
-    Examples
-    --------
-    >>> phase = np.linspace(0, np.pi, num=5)
-    >>> phase[3:] += np.pi
-    >>> phase
-    array([ 0.        ,  0.78539816,  1.57079633,  5.49778714,  6.28318531]) # may vary
-    >>> np.unwrap(phase)
-    array([ 0.        ,  0.78539816,  1.57079633, -0.78539816,  0.        ]) # may vary
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} __file__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__file__"))))
-
-(def short (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "short"))))
-(alter-meta! #'short assoc :doc "Signed integer type, compatible with C ``short``.
-    Character code: ``'h'``.
-    Canonical name: ``np.short``.
-    Alias *on this platform*: ``np.int16``: 16-bit signed integer (-32768 to 32767)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def datetime_as_string (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "datetime_as_string"))))
-(alter-meta! #'datetime_as_string assoc :doc "
-    datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind')
-
-    Convert an array of datetimes into an array of strings.
-
-    Parameters
-    ----------
-    arr : array_like of datetime64
-        The array of UTC timestamps to format.
-    unit : str
-        One of None, 'auto', or a :ref:`datetime unit <arrays.dtypes.dateunits>`.
-    timezone : {'naive', 'UTC', 'local'} or tzinfo
-        Timezone information to use when displaying the datetime. If 'UTC', end
-        with a Z to indicate UTC time. If 'local', convert to the local timezone
-        first, and suffix with a +-#### timezone offset. If a tzinfo object,
-        then do as with 'local', but use the specified timezone.
-    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}
-        Casting to allow when changing between datetime units.
-
-    Returns
-    -------
-    str_arr : ndarray
-        An array of strings the same shape as `arr`.
-
-    Examples
-    --------
-    >>> import pytz
-    >>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]')
-    >>> d
-    array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30',
-           '2002-10-27T07:30'], dtype='datetime64[m]')
-
-    Setting the timezone to UTC shows the same information, but with a Z suffix
-
-    >>> np.datetime_as_string(d, timezone='UTC')
-    array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z',
-           '2002-10-27T07:30Z'], dtype='<U35')
-
-    Note that we picked datetimes that cross a DST boundary. Passing in a
-    ``pytz`` timezone object will print the appropriate offset
-
-    >>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern'))
-    array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400',
-           '2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='<U39')
-
-    Passing in a unit will change the precision
-
-    >>> np.datetime_as_string(d, unit='h')
-    array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'],
-          dtype='<U32')
-    >>> np.datetime_as_string(d, unit='s')
-    array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00',
-           '2002-10-27T07:30:00'], dtype='<U38')
-
-    'casting' can be used to specify whether precision can be changed
-
-    >>> np.datetime_as_string(d, unit='h', casting='safe')
-    Traceback (most recent call last):
-        ...
-    TypeError: Cannot create a datetime string as units 'h' from a NumPy
-    datetime with units 'm' according to the rule 'safe'
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def datetime_data (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "datetime_data"))))
-(alter-meta! #'datetime_data assoc :doc "datetime_data(dtype, /)
-
-    Get information about the step size of a date or time type.
-
-    The returned tuple can be passed as the second argument of `numpy.datetime64` and
-    `numpy.timedelta64`.
-
-    Parameters
-    ----------
-    dtype : dtype
-        The dtype object, which must be a `datetime64` or `timedelta64` type.
-
-    Returns
-    -------
-    unit : str
-        The :ref:`datetime unit <arrays.dtypes.dateunits>` on which this dtype
-        is based.
-    count : int
-        The number of base units in a step.
-
-    Examples
-    --------
-    >>> dt_25s = np.dtype('timedelta64[25s]')
-    >>> np.datetime_data(dt_25s)
-    ('s', 25)
-    >>> np.array(10, dt_25s).astype('timedelta64[s]')
-    array(250, dtype='timedelta64[s]')
-
-    The result can be used to construct a datetime that uses the same units
-    as a timedelta
-
-    >>> np.datetime64('2010', np.datetime_data(dt_25s))
-    numpy.datetime64('2010-01-01T00:00:00','25s')" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} nan (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "nan"))))
-
-(def imag (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "imag"))))
-(alter-meta! #'imag assoc :doc "
-    Return the imaginary part of the complex argument.
-
-    Parameters
-    ----------
-    val : array_like
-        Input array.
-
-    Returns
-    -------
-    out : ndarray or scalar
-        The imaginary component of the complex argument. If `val` is real,
-        the type of `val` is used for the output.  If `val` has complex
-        elements, the returned type is float.
-
-    See Also
-    --------
-    real, angle, real_if_close
-
-    Examples
-    --------
-    >>> a = np.array([1+2j, 3+4j, 5+6j])
-    >>> a.imag
-    array([2.,  4.,  6.])
-    >>> a.imag = np.array([8, 10, 12])
-    >>> a
-    array([1. +8.j,  3.+10.j,  5.+12.j])
-    >>> np.imag(1 + 1j)
-    1.0
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def count_nonzero (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "count_nonzero"))))
-(alter-meta! #'count_nonzero assoc :doc "
-    Counts the number of non-zero values in the array ``a``.
-
-    The word \"non-zero\" is in reference to the Python 2.x
-    built-in method ``__nonzero__()`` (renamed ``__bool__()``
-    in Python 3.x) of Python objects that tests an object's
-    \"truthfulness\". For example, any number is considered
-    truthful if it is nonzero, whereas any string is considered
-    truthful if it is not the empty string. Thus, this function
-    (recursively) counts how many elements in ``a`` (and in
-    sub-arrays thereof) have their ``__nonzero__()`` or ``__bool__()``
-    method evaluated to ``True``.
-
-    Parameters
-    ----------
-    a : array_like
-        The array for which to count non-zeros.
-    axis : int or tuple, optional
-        Axis or tuple of axes along which to count non-zeros.
-        Default is None, meaning that non-zeros will be counted
-        along a flattened version of ``a``.
-
-        .. versionadded:: 1.12.0
-
-    Returns
-    -------
-    count : int or array of int
-        Number of non-zero values in the array along a given axis.
-        Otherwise, the total number of non-zero values in the array
-        is returned.
-
-    See Also
-    --------
-    nonzero : Return the coordinates of all the non-zero values.
-
-    Examples
-    --------
-    >>> np.count_nonzero(np.eye(4))
-    4
-    >>> np.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]])
-    5
-    >>> np.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]], axis=0)
-    array([1, 1, 1, 1, 1])
-    >>> np.count_nonzero([[0,1,7,0,0],[3,0,0,2,19]], axis=1)
-    array([2, 3])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def float128 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float128"))))
-(alter-meta! #'float128 assoc :doc "Extended-precision floating-point number type, compatible with C
-    ``long double`` but not necessarily with IEEE 754 quadruple-precision.
-    Character code: ``'g'``.
-    Canonical name: ``np.longdouble``.
-    Alias: ``np.longfloat``.
-    Alias *on this platform*: ``np.float128``: 128-bit extended-precision floating-point number type." :arglists '[[self & [args {:as kwargs}]]])
-
-(def greater (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "greater"))))
-(alter-meta! #'greater assoc :doc "greater(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the truth value of (x1 > x2) element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Output array, element-wise comparison of `x1` and `x2`.
-    Typically of type bool, unless ``dtype=object`` is passed.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-
-See Also
---------
-greater_equal, less, less_equal, equal, not_equal
-
-Examples
---------
->>> np.greater([4,2],[2,2])
-array([ True, False])
-
-If the inputs are ndarrays, then np.greater is equivalent to '>'.
-
->>> a = np.array([4,2])
->>> b = np.array([2,2])
->>> a > b
-array([ True, False])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def sort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sort"))))
-(alter-meta! #'sort assoc :doc "
-    Return a sorted copy of an array.
-
-    Parameters
-    ----------
-    a : array_like
-        Array to be sorted.
-    axis : int or None, optional
-        Axis along which to sort. If None, the array is flattened before
-        sorting. The default is -1, which sorts along the last axis.
-    kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
-        Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
-        and 'mergesort' use timsort or radix sort under the covers and, in general,
-        the actual implementation will vary with data type. The 'mergesort' option
-        is retained for backwards compatibility.
-
-        .. versionchanged:: 1.15.0.
-           The 'stable' option was added.
-
-    order : str or list of str, optional
-        When `a` is an array with fields defined, this argument specifies
-        which fields to compare first, second, etc.  A single field can
-        be specified as a string, and not all fields need be specified,
-        but unspecified fields will still be used, in the order in which
-        they come up in the dtype, to break ties.
-
-    Returns
-    -------
-    sorted_array : ndarray
-        Array of the same type and shape as `a`.
-
-    See Also
-    --------
-    ndarray.sort : Method to sort an array in-place.
-    argsort : Indirect sort.
-    lexsort : Indirect stable sort on multiple keys.
-    searchsorted : Find elements in a sorted array.
-    partition : Partial sort.
-
-    Notes
-    -----
-    The various sorting algorithms are characterized by their average speed,
-    worst case performance, work space size, and whether they are stable. A
-    stable sort keeps items with the same key in the same relative
-    order. The four algorithms implemented in NumPy have the following
-    properties:
-
-    =========== ======= ============= ============ ========
-       kind      speed   worst case    work space   stable
-    =========== ======= ============= ============ ========
-    'quicksort'    1     O(n^2)            0          no
-    'heapsort'     3     O(n*log(n))       0          no
-    'mergesort'    2     O(n*log(n))      ~n/2        yes
-    'timsort'      2     O(n*log(n))      ~n/2        yes
-    =========== ======= ============= ============ ========
-
-    .. note:: The datatype determines which of 'mergesort' or 'timsort'
-       is actually used, even if 'mergesort' is specified. User selection
-       at a finer scale is not currently available.
-
-    All the sort algorithms make temporary copies of the data when
-    sorting along any but the last axis.  Consequently, sorting along
-    the last axis is faster and uses less space than sorting along
-    any other axis.
-
-    The sort order for complex numbers is lexicographic. If both the real
-    and imaginary parts are non-nan then the order is determined by the
-    real parts except when they are equal, in which case the order is
-    determined by the imaginary parts.
-
-    Previous to numpy 1.4.0 sorting real and complex arrays containing nan
-    values led to undefined behaviour. In numpy versions >= 1.4.0 nan
-    values are sorted to the end. The extended sort order is:
-
-      * Real: [R, nan]
-      * Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]
-
-    where R is a non-nan real value. Complex values with the same nan
-    placements are sorted according to the non-nan part if it exists.
-    Non-nan values are sorted as before.
-
-    .. versionadded:: 1.12.0
-
-    quicksort has been changed to `introsort <https://en.wikipedia.org/wiki/Introsort>`_.
-    When sorting does not make enough progress it switches to
-    `heapsort <https://en.wikipedia.org/wiki/Heapsort>`_.
-    This implementation makes quicksort O(n*log(n)) in the worst case.
-
-    'stable' automatically chooses the best stable sorting algorithm
-    for the data type being sorted.
-    It, along with 'mergesort' is currently mapped to
-    `timsort <https://en.wikipedia.org/wiki/Timsort>`_
-    or `radix sort <https://en.wikipedia.org/wiki/Radix_sort>`_
-    depending on the data type.
-    API forward compatibility currently limits the
-    ability to select the implementation and it is hardwired for the different
-    data types.
-
-    .. versionadded:: 1.17.0
-
-    Timsort is added for better performance on already or nearly
-    sorted data. On random data timsort is almost identical to
-    mergesort. It is now used for stable sort while quicksort is still the
-    default sort if none is chosen. For timsort details, refer to
-    `CPython listsort.txt <https://github.com/python/cpython/blob/3.7/Objects/listsort.txt>`_.
-    'mergesort' and 'stable' are mapped to radix sort for integer data types. Radix sort is an
-    O(n) sort instead of O(n log n).
-
-    .. versionchanged:: 1.17.0
-
-    NaT now sorts to the end of arrays for consistency with NaN.
-
-    Examples
-    --------
-    >>> a = np.array([[1,4],[3,1]])
-    >>> np.sort(a)                # sort along the last axis
-    array([[1, 4],
-           [1, 3]])
-    >>> np.sort(a, axis=None)     # sort the flattened array
-    array([1, 1, 3, 4])
-    >>> np.sort(a, axis=0)        # sort along the first axis
-    array([[1, 1],
-           [3, 4]])
-
-    Use the `order` keyword to specify a field to use when sorting a
-    structured array:
-
-    >>> dtype = [('name', 'S10'), ('height', float), ('age', int)]
-    >>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),
-    ...           ('Galahad', 1.7, 38)]
-    >>> a = np.array(values, dtype=dtype)       # create a structured array
-    >>> np.sort(a, order='height')                        # doctest: +SKIP
-    array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),
-           ('Lancelot', 1.8999999999999999, 38)],
-          dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])
-
-    Sort by age, then height if ages are equal:
-
-    >>> np.sort(a, order=['age', 'height'])               # doctest: +SKIP
-    array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),
-           ('Arthur', 1.8, 41)],
-          dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def poly1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "poly1d"))))
-(alter-meta! #'poly1d assoc :doc "
-    A one-dimensional polynomial class.
-
-    A convenience class, used to encapsulate \"natural\" operations on
-    polynomials so that said operations may take on their customary
-    form in code (see Examples).
-
-    Parameters
-    ----------
-    c_or_r : array_like
-        The polynomial's coefficients, in decreasing powers, or if
-        the value of the second parameter is True, the polynomial's
-        roots (values where the polynomial evaluates to 0).  For example,
-        ``poly1d([1, 2, 3])`` returns an object that represents
-        :math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns
-        one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`.
-    r : bool, optional
-        If True, `c_or_r` specifies the polynomial's roots; the default
-        is False.
-    variable : str, optional
-        Changes the variable used when printing `p` from `x` to `variable`
-        (see Examples).
-
-    Examples
-    --------
-    Construct the polynomial :math:`x^2 + 2x + 3`:
-
-    >>> p = np.poly1d([1, 2, 3])
-    >>> print(np.poly1d(p))
-       2
-    1 x + 2 x + 3
-
-    Evaluate the polynomial at :math:`x = 0.5`:
-
-    >>> p(0.5)
-    4.25
-
-    Find the roots:
-
-    >>> p.r
-    array([-1.+1.41421356j, -1.-1.41421356j])
-    >>> p(p.r)
-    array([ -4.44089210e-16+0.j,  -4.44089210e-16+0.j]) # may vary
-
-    These numbers in the previous line represent (0, 0) to machine precision
-
-    Show the coefficients:
-
-    >>> p.c
-    array([1, 2, 3])
-
-    Display the order (the leading zero-coefficients are removed):
-
-    >>> p.order
-    2
-
-    Show the coefficient of the k-th power in the polynomial
-    (which is equivalent to ``p.c[-(i+1)]``):
-
-    >>> p[1]
-    2
-
-    Polynomials can be added, subtracted, multiplied, and divided
-    (returns quotient and remainder):
-
-    >>> p * p
-    poly1d([ 1,  4, 10, 12,  9])
-
-    >>> (p**3 + 4) / p
-    (poly1d([ 1.,  4., 10., 12.,  9.]), poly1d([4.]))
-
-    ``asarray(p)`` gives the coefficient array, so polynomials can be
-    used in all functions that accept arrays:
-
-    >>> p**2 # square of polynomial
-    poly1d([ 1,  4, 10, 12,  9])
-
-    >>> np.square(p) # square of individual coefficients
-    array([1, 4, 9])
-
-    The variable used in the string representation of `p` can be modified,
-    using the `variable` parameter:
-
-    >>> p = np.poly1d([1,2,3], variable='z')
-    >>> print(p)
-       2
-    1 z + 2 z + 3
-
-    Construct a polynomial from its roots:
-
-    >>> np.poly1d([1, 2], True)
-    poly1d([ 1., -3.,  2.])
-
-    This is the same polynomial as obtained by:
-
-    >>> np.poly1d([1, -1]) * np.poly1d([1, -2])
-    poly1d([ 1, -3,  2])
-
-    " :arglists '[[self c_or_r & [{r :r, variable :variable}]] [self c_or_r & [{r :r}]] [self c_or_r]])
-
-(def isfinite (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isfinite"))))
-(alter-meta! #'isfinite assoc :doc "isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Test element-wise for finiteness (not infinity or not Not a Number).
-
-The result is returned as a boolean array.
-
-Parameters
-----------
-x : array_like
-    Input values.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray, bool
-    True where ``x`` is not positive infinity, negative infinity,
-    or NaN; false otherwise.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-isinf, isneginf, isposinf, isnan
-
-Notes
------
-Not a Number, positive infinity and negative infinity are considered
-to be non-finite.
-
-NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
-(IEEE 754). This means that Not a Number is not equivalent to infinity.
-Also that positive infinity is not equivalent to negative infinity. But
-infinity is equivalent to positive infinity.  Errors result if the
-second argument is also supplied when `x` is a scalar input, or if
-first and second arguments have different shapes.
-
-Examples
---------
->>> np.isfinite(1)
-True
->>> np.isfinite(0)
-True
->>> np.isfinite(np.nan)
-False
->>> np.isfinite(np.inf)
-False
->>> np.isfinite(np.NINF)
-False
->>> np.isfinite([np.log(-1.),1.,np.log(0)])
-array([False,  True, False])
-
->>> x = np.array([-np.inf, 0., np.inf])
->>> y = np.array([2, 2, 2])
->>> np.isfinite(x, y)
-array([0, 1, 0])
->>> y
-array([0, 1, 0])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def log (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log"))))
-(alter-meta! #'log assoc :doc "log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Natural logarithm, element-wise.
-
-The natural logarithm `log` is the inverse of the exponential function,
-so that `log(exp(x)) = x`. The natural logarithm is logarithm in base
-`e`.
-
-Parameters
-----------
-x : array_like
-    Input value.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The natural logarithm of `x`, element-wise.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-log10, log2, log1p, emath.log
-
-Notes
------
-Logarithm is a multivalued function: for each `x` there is an infinite
-number of `z` such that `exp(z) = x`. The convention is to return the
-`z` whose imaginary part lies in `[-pi, pi]`.
-
-For real-valued input data types, `log` always returns real output. For
-each value that cannot be expressed as a real number or infinity, it
-yields ``nan`` and sets the `invalid` floating point error flag.
-
-For complex-valued input, `log` is a complex analytical function that
-has a branch cut `[-inf, 0]` and is continuous from above on it. `log`
-handles the floating-point negative zero as an infinitesimal negative
-number, conforming to the C99 standard.
-
-References
-----------
-.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
-       10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/
-.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm
-
-Examples
---------
->>> np.log([1, np.e, np.e**2, 0])
-array([  0.,   1.,   2., -Inf])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def complex128 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex128"))))
-(alter-meta! #'complex128 assoc :doc "Complex number type composed of two double-precision floating-point
-    numbers, compatible with Python `complex`.
-    Character code: ``'D'``.
-    Canonical name: ``np.cdouble``.
-    Alias: ``np.cfloat``.
-    Alias: ``np.complex_``.
-    Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def fromfunction (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromfunction"))))
-(alter-meta! #'fromfunction assoc :doc "
-    Construct an array by executing a function over each coordinate.
-
-    The resulting array therefore has a value ``fn(x, y, z)`` at
-    coordinate ``(x, y, z)``.
-
-    Parameters
-    ----------
-    function : callable
-        The function is called with N parameters, where N is the rank of
-        `shape`.  Each parameter represents the coordinates of the array
-        varying along a specific axis.  For example, if `shape`
-        were ``(2, 2)``, then the parameters would be
-        ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])``
-    shape : (N,) tuple of ints
-        Shape of the output array, which also determines the shape of
-        the coordinate arrays passed to `function`.
-    dtype : data-type, optional
-        Data-type of the coordinate arrays passed to `function`.
-        By default, `dtype` is float.
-
-    Returns
-    -------
-    fromfunction : any
-        The result of the call to `function` is passed back directly.
-        Therefore the shape of `fromfunction` is completely determined by
-        `function`.  If `function` returns a scalar value, the shape of
-        `fromfunction` would not match the `shape` parameter.
-
-    See Also
-    --------
-    indices, meshgrid
-
-    Notes
-    -----
-    Keywords other than `dtype` are passed to `function`.
-
-    Examples
-    --------
-    >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
-    array([[ True, False, False],
-           [False,  True, False],
-           [False, False,  True]])
-
-    >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
-    array([[0, 1, 2],
-           [1, 2, 3],
-           [2, 3, 4]])
-
-    " :arglists '[[function shape & [{:as kwargs}]]])
-
-(def nancumprod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nancumprod"))))
-(alter-meta! #'nancumprod assoc :doc "
-    Return the cumulative product of array elements over a given axis treating Not a
-    Numbers (NaNs) as one.  The cumulative product does not change when NaNs are
-    encountered and leading NaNs are replaced by ones.
-
-    Ones are returned for slices that are all-NaN or empty.
-
-    .. versionadded:: 1.12.0
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    axis : int, optional
-        Axis along which the cumulative product is computed.  By default
-        the input is flattened.
-    dtype : dtype, optional
-        Type of the returned array, as well as of the accumulator in which
-        the elements are multiplied.  If *dtype* is not specified, it
-        defaults to the dtype of `a`, unless `a` has an integer dtype with
-        a precision less than that of the default platform integer.  In
-        that case, the default platform integer is used instead.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must
-        have the same shape and buffer length as the expected output
-        but the type of the resulting values will be cast if necessary.
-
-    Returns
-    -------
-    nancumprod : ndarray
-        A new array holding the result is returned unless `out` is
-        specified, in which case it is returned.
-
-    See Also
-    --------
-    numpy.cumprod : Cumulative product across array propagating NaNs.
-    isnan : Show which elements are NaN.
-
-    Examples
-    --------
-    >>> np.nancumprod(1)
-    array([1])
-    >>> np.nancumprod([1])
-    array([1])
-    >>> np.nancumprod([1, np.nan])
-    array([1.,  1.])
-    >>> a = np.array([[1, 2], [3, np.nan]])
-    >>> np.nancumprod(a)
-    array([1.,  2.,  6.,  6.])
-    >>> np.nancumprod(a, axis=0)
-    array([[1.,  2.],
-           [3.,  2.]])
-    >>> np.nancumprod(a, axis=1)
-    array([[1.,  2.],
-           [3.,  3.]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def divmod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "divmod"))))
-(alter-meta! #'divmod assoc :doc "divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return element-wise quotient and remainder simultaneously.
-
-.. versionadded:: 1.13.0
-
-``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster
-because it avoids redundant work. It is used to implement the Python
-built-in function ``divmod`` on NumPy arrays.
-
-Parameters
-----------
-x1 : array_like
-    Dividend array.
-x2 : array_like
-    Divisor array. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out1 : ndarray
-    Element-wise quotient resulting from floor division.
-    This is a scalar if both `x1` and `x2` are scalars.
-out2 : ndarray
-    Element-wise remainder from floor division.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-floor_divide : Equivalent to Python's ``//`` operator.
-remainder : Equivalent to Python's ``%`` operator.
-modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return
-       values switched.
-
-Examples
---------
->>> np.divmod(np.arange(5), 3)
-(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} ERR_DEFAULT (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_DEFAULT"))))
-
-(def diag_indices_from (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diag_indices_from"))))
-(alter-meta! #'diag_indices_from assoc :doc "
-    Return the indices to access the main diagonal of an n-dimensional array.
-
-    See `diag_indices` for full details.
-
-    Parameters
-    ----------
-    arr : array, at least 2-D
-
-    See Also
-    --------
-    diag_indices
-
-    Notes
-    -----
-    .. versionadded:: 1.4.0
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def savetxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "savetxt"))))
-(alter-meta! #'savetxt assoc :doc "
-    Save an array to a text file.
-
-    Parameters
-    ----------
-    fname : filename or file handle
-        If the filename ends in ``.gz``, the file is automatically saved in
-        compressed gzip format.  `loadtxt` understands gzipped files
-        transparently.
-    X : 1D or 2D array_like
-        Data to be saved to a text file.
-    fmt : str or sequence of strs, optional
-        A single format (%10.5f), a sequence of formats, or a
-        multi-format string, e.g. 'Iteration %d -- %10.5f', in which
-        case `delimiter` is ignored. For complex `X`, the legal options
-        for `fmt` are:
-
-        * a single specifier, `fmt='%.4e'`, resulting in numbers formatted
-          like `' (%s+%sj)' % (fmt, fmt)`
-        * a full string specifying every real and imaginary part, e.g.
-          `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns
-        * a list of specifiers, one per column - in this case, the real
-          and imaginary part must have separate specifiers,
-          e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns
-    delimiter : str, optional
-        String or character separating columns.
-    newline : str, optional
-        String or character separating lines.
-
-        .. versionadded:: 1.5.0
-    header : str, optional
-        String that will be written at the beginning of the file.
-
-        .. versionadded:: 1.7.0
-    footer : str, optional
-        String that will be written at the end of the file.
-
-        .. versionadded:: 1.7.0
-    comments : str, optional
-        String that will be prepended to the ``header`` and ``footer`` strings,
-        to mark them as comments. Default: '# ',  as expected by e.g.
-        ``numpy.loadtxt``.
-
-        .. versionadded:: 1.7.0
-    encoding : {None, str}, optional
-        Encoding used to encode the outputfile. Does not apply to output
-        streams. If the encoding is something other than 'bytes' or 'latin1'
-        you will not be able to load the file in NumPy versions < 1.14. Default
-        is 'latin1'.
-
-        .. versionadded:: 1.14.0
-
-
-    See Also
-    --------
-    save : Save an array to a binary file in NumPy ``.npy`` format
-    savez : Save several arrays into an uncompressed ``.npz`` archive
-    savez_compressed : Save several arrays into a compressed ``.npz`` archive
-
-    Notes
-    -----
-    Further explanation of the `fmt` parameter
-    (``%[flag]width[.precision]specifier``):
-
-    flags:
-        ``-`` : left justify
-
-        ``+`` : Forces to precede result with + or -.
-
-        ``0`` : Left pad the number with zeros instead of space (see width).
-
-    width:
-        Minimum number of characters to be printed. The value is not truncated
-        if it has more characters.
-
-    precision:
-        - For integer specifiers (eg. ``d,i,o,x``), the minimum number of
-          digits.
-        - For ``e, E`` and ``f`` specifiers, the number of digits to print
-          after the decimal point.
-        - For ``g`` and ``G``, the maximum number of significant digits.
-        - For ``s``, the maximum number of characters.
-
-    specifiers:
-        ``c`` : character
-
-        ``d`` or ``i`` : signed decimal integer
-
-        ``e`` or ``E`` : scientific notation with ``e`` or ``E``.
-
-        ``f`` : decimal floating point
-
-        ``g,G`` : use the shorter of ``e,E`` or ``f``
-
-        ``o`` : signed octal
-
-        ``s`` : string of characters
-
-        ``u`` : unsigned decimal integer
-
-        ``x,X`` : unsigned hexadecimal integer
-
-    This explanation of ``fmt`` is not complete, for an exhaustive
-    specification see [1]_.
-
-    References
-    ----------
-    .. [1] `Format Specification Mini-Language
-           <https://docs.python.org/library/string.html#format-specification-mini-language>`_,
-           Python Documentation.
-
-    Examples
-    --------
-    >>> x = y = z = np.arange(0.0,5.0,1.0)
-    >>> np.savetxt('test.out', x, delimiter=',')   # X is an array
-    >>> np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays
-    >>> np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def timedelta64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "timedelta64"))))
-(alter-meta! #'timedelta64 assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def atleast_3d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "atleast_3d"))))
-(alter-meta! #'atleast_3d assoc :doc "
-    View inputs as arrays with at least three dimensions.
-
-    Parameters
-    ----------
-    arys1, arys2, ... : array_like
-        One or more array-like sequences.  Non-array inputs are converted to
-        arrays.  Arrays that already have three or more dimensions are
-        preserved.
-
-    Returns
-    -------
-    res1, res2, ... : ndarray
-        An array, or list of arrays, each with ``a.ndim >= 3``.  Copies are
-        avoided where possible, and views with three or more dimensions are
-        returned.  For example, a 1-D array of shape ``(N,)`` becomes a view
-        of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a
-        view of shape ``(M, N, 1)``.
-
-    See Also
-    --------
-    atleast_1d, atleast_2d
-
-    Examples
-    --------
-    >>> np.atleast_3d(3.0)
-    array([[[3.]]])
-
-    >>> x = np.arange(3.0)
-    >>> np.atleast_3d(x).shape
-    (1, 3, 1)
-
-    >>> x = np.arange(12.0).reshape(4,3)
-    >>> np.atleast_3d(x).shape
-    (4, 3, 1)
-    >>> np.atleast_3d(x).base is x.base  # x is a reshape, so not base itself
-    True
-
-    >>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):
-    ...     print(arr, arr.shape) # doctest: +SKIP
-    ...
-    [[[1]
-      [2]]] (1, 2, 1)
-    [[[1]
-      [2]]] (1, 2, 1)
-    [[[1 2]]] (1, 1, 2)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} division (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "division"))))
-
-(def ndarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndarray"))))
-(alter-meta! #'ndarray assoc :doc "ndarray(shape, dtype=float, buffer=None, offset=0,
-            strides=None, order=None)
-
-    An array object represents a multidimensional, homogeneous array
-    of fixed-size items.  An associated data-type object describes the
-    format of each element in the array (its byte-order, how many bytes it
-    occupies in memory, whether it is an integer, a floating point number,
-    or something else, etc.)
-
-    Arrays should be constructed using `array`, `zeros` or `empty` (refer
-    to the See Also section below).  The parameters given here refer to
-    a low-level method (`ndarray(...)`) for instantiating an array.
-
-    For more information, refer to the `numpy` module and examine the
-    methods and attributes of an array.
-
-    Parameters
-    ----------
-    (for the __new__ method; see Notes below)
-
-    shape : tuple of ints
-        Shape of created array.
-    dtype : data-type, optional
-        Any object that can be interpreted as a numpy data type.
-    buffer : object exposing buffer interface, optional
-        Used to fill the array with data.
-    offset : int, optional
-        Offset of array data in buffer.
-    strides : tuple of ints, optional
-        Strides of data in memory.
-    order : {'C', 'F'}, optional
-        Row-major (C-style) or column-major (Fortran-style) order.
-
-    Attributes
-    ----------
-    T : ndarray
-        Transpose of the array.
-    data : buffer
-        The array's elements, in memory.
-    dtype : dtype object
-        Describes the format of the elements in the array.
-    flags : dict
-        Dictionary containing information related to memory use, e.g.,
-        'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.
-    flat : numpy.flatiter object
-        Flattened version of the array as an iterator.  The iterator
-        allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for
-        assignment examples; TODO).
-    imag : ndarray
-        Imaginary part of the array.
-    real : ndarray
-        Real part of the array.
-    size : int
-        Number of elements in the array.
-    itemsize : int
-        The memory use of each array element in bytes.
-    nbytes : int
-        The total number of bytes required to store the array data,
-        i.e., ``itemsize * size``.
-    ndim : int
-        The array's number of dimensions.
-    shape : tuple of ints
-        Shape of the array.
-    strides : tuple of ints
-        The step-size required to move from one element to the next in
-        memory. For example, a contiguous ``(3, 4)`` array of type
-        ``int16`` in C-order has strides ``(8, 2)``.  This implies that
-        to move from element to element in memory requires jumps of 2 bytes.
-        To move from row-to-row, one needs to jump 8 bytes at a time
-        (``2 * 4``).
-    ctypes : ctypes object
-        Class containing properties of the array needed for interaction
-        with ctypes.
-    base : ndarray
-        If the array is a view into another array, that array is its `base`
-        (unless that array is also a view).  The `base` array is where the
-        array data is actually stored.
-
-    See Also
-    --------
-    array : Construct an array.
-    zeros : Create an array, each element of which is zero.
-    empty : Create an array, but leave its allocated memory unchanged (i.e.,
-            it contains \"garbage\").
-    dtype : Create a data-type.
-
-    Notes
-    -----
-    There are two modes of creating an array using ``__new__``:
-
-    1. If `buffer` is None, then only `shape`, `dtype`, and `order`
-       are used.
-    2. If `buffer` is an object exposing the buffer interface, then
-       all keywords are interpreted.
-
-    No ``__init__`` method is needed because the array is fully initialized
-    after the ``__new__`` method.
-
-    Examples
-    --------
-    These examples illustrate the low-level `ndarray` constructor.  Refer
-    to the `See Also` section above for easier ways of constructing an
-    ndarray.
-
-    First mode, `buffer` is None:
-
-    >>> np.ndarray(shape=(2,2), dtype=float, order='F')
-    array([[0.0e+000, 0.0e+000], # random
-           [     nan, 2.5e-323]])
-
-    Second mode:
-
-    >>> np.ndarray((2,), buffer=np.array([1,2,3]),
-    ...            offset=np.int_().itemsize,
-    ...            dtype=int) # offset = 1*itemsize, i.e. skip first element
-    array([2, 3])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def product (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "product"))))
-(alter-meta! #'product assoc :doc "
-    Return the product of array elements over a given axis.
-
-    See Also
-    --------
-    prod : equivalent function; see for details.
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "Built-in mutable sequence.
-
-If no argument is given, the constructor creates a new empty list.
-The argument must be an iterable if specified."} __path__ (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* "__path__")))) 
-
-(def ptp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ptp"))))
-(alter-meta! #'ptp assoc :doc "
-    Range of values (maximum - minimum) along an axis.
-
-    The name of the function comes from the acronym for 'peak to peak'.
-
-    Parameters
-    ----------
-    a : array_like
-        Input values.
-    axis : None or int or tuple of ints, optional
-        Axis along which to find the peaks.  By default, flatten the
-        array.  `axis` may be negative, in
-        which case it counts from the last to the first axis.
-
-        .. versionadded:: 1.15.0
-
-        If this is a tuple of ints, a reduction is performed on multiple
-        axes, instead of a single axis or all the axes as before.
-    out : array_like
-        Alternative output array in which to place the result. It must
-        have the same shape and buffer length as the expected output,
-        but the type of the output values will be cast if necessary.
-
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `ptp` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-
-    Returns
-    -------
-    ptp : ndarray
-        A new array holding the result, unless `out` was
-        specified, in which case a reference to `out` is returned.
-
-    Examples
-    --------
-    >>> x = np.arange(4).reshape((2,2))
-    >>> x
-    array([[0, 1],
-           [2, 3]])
-
-    >>> np.ptp(x, axis=0)
-    array([2, 2])
-
-    >>> np.ptp(x, axis=1)
-    array([1, 1])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def floating (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "floating"))))
-(alter-meta! #'floating assoc :doc "Abstract base class of all floating-point scalar types." :arglists '[[self & [args {:as kwargs}]]])
-
-(def arctan (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arctan"))))
-(alter-meta! #'arctan assoc :doc "arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Trigonometric inverse tangent, element-wise.
-
-The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``.
-
-Parameters
-----------
-x : array_like
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Out has the same shape as `x`.  Its real part is in
-    ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``).
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-arctan2 : The \"four quadrant\" arctan of the angle formed by (`x`, `y`)
-    and the positive `x`-axis.
-angle : Argument of complex values.
-
-Notes
------
-`arctan` is a multi-valued function: for each `x` there are infinitely
-many numbers `z` such that tan(`z`) = `x`.  The convention is to return
-the angle `z` whose real part lies in [-pi/2, pi/2].
-
-For real-valued input data types, `arctan` always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields ``nan`` and sets the `invalid` floating point error flag.
-
-For complex-valued input, `arctan` is a complex analytic function that
-has [`1j, infj`] and [`-1j, -infj`] as branch cuts, and is continuous
-from the left on the former and from the right on the latter.
-
-The inverse tangent is also known as `atan` or tan^{-1}.
-
-References
-----------
-Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
-10th printing, New York: Dover, 1964, pp. 79.
-http://www.math.sfu.ca/~cbm/aands/
-
-Examples
---------
-We expect the arctan of 0 to be 0, and of 1 to be pi/4:
-
->>> np.arctan([0, 1])
-array([ 0.        ,  0.78539816])
-
->>> np.pi/4
-0.78539816339744828
-
-Plot arctan:
-
->>> import matplotlib.pyplot as plt
->>> x = np.linspace(-10, 10)
->>> plt.plot(x, np.arctan(x))
->>> plt.axis('tight')
->>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
-
-(def fromstring (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromstring"))))
-(alter-meta! #'fromstring assoc :doc "fromstring(string, dtype=float, count=-1, sep='')
-
-    A new 1-D array initialized from text data in a string.
-
-    Parameters
-    ----------
-    string : str
-        A string containing the data.
-    dtype : data-type, optional
-        The data type of the array; default: float.  For binary input data,
-        the data must be in exactly this format. Most builtin numeric types are 
-        supported and extension types may be supported.
-
-        .. versionadded:: 1.18.0
-            Complex dtypes.
-
-    count : int, optional
-        Read this number of `dtype` elements from the data.  If this is
-        negative (the default), the count will be determined from the
-        length of the data.
-    sep : str, optional
-        The string separating numbers in the data; extra whitespace between
-        elements is also ignored.
-
-        .. deprecated:: 1.14
-            Passing ``sep=''``, the default, is deprecated since it will
-            trigger the deprecated binary mode of this function. This mode
-            interprets `string` as binary bytes, rather than ASCII text with
-            decimal numbers, an operation which is better spelt
-            ``frombuffer(string, dtype, count)``. If `string` contains unicode
-            text, the binary mode of `fromstring` will first encode it into
-            bytes using either utf-8 (python 3) or the default encoding
-            (python 2), neither of which produce sane results.
-
-    Returns
-    -------
-    arr : ndarray
-        The constructed array.
-
-    Raises
-    ------
-    ValueError
-        If the string is not the correct size to satisfy the requested
-        `dtype` and `count`.
-
-    See Also
-    --------
-    frombuffer, fromfile, fromiter
-
-    Examples
-    --------
-    >>> np.fromstring('1 2', dtype=int, sep=' ')
-    array([1, 2])
-    >>> np.fromstring('1, 2', dtype=int, sep=',')
-    array([1, 2])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc "Special keyword value.
-
-    The instance of this class may be used as the default value assigned to a
-    deprecated keyword in order to check if it has been given a user defined
-    value.
-    "} _NoValue (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_NoValue"))))
-
-(def signedinteger (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "signedinteger"))))
-(alter-meta! #'signedinteger assoc :doc "Abstract base class of all signed integer scalar types." :arglists '[[self & [args {:as kwargs}]]])
-
-(def any (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "any"))))
-(alter-meta! #'any assoc :doc "
-    Test whether any array element along a given axis evaluates to True.
-
-    Returns single boolean unless `axis` is not ``None``
-
-    Parameters
-    ----------
-    a : array_like
-        Input array or object that can be converted to an array.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which a logical OR reduction is performed.
-        The default (``axis=None``) is to perform a logical OR over all
-        the dimensions of the input array. `axis` may be negative, in
-        which case it counts from the last to the first axis.
-
-        .. versionadded:: 1.7.0
-
-        If this is a tuple of ints, a reduction is performed on multiple
-        axes, instead of a single axis or all the axes as before.
-    out : ndarray, optional
-        Alternate output array in which to place the result.  It must have
-        the same shape as the expected output and its type is preserved
-        (e.g., if it is of type float, then it will remain so, returning
-        1.0 for True and 0.0 for False, regardless of the type of `a`).
-        See `ufuncs-output-type` for more details.
-
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `any` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-
-    Returns
-    -------
-    any : bool or ndarray
-        A new boolean or `ndarray` is returned unless `out` is specified,
-        in which case a reference to `out` is returned.
-
-    See Also
-    --------
-    ndarray.any : equivalent method
-
-    all : Test whether all elements along a given axis evaluate to True.
-
-    Notes
-    -----
-    Not a Number (NaN), positive infinity and negative infinity evaluate
-    to `True` because these are not equal to zero.
-
-    Examples
-    --------
-    >>> np.any([[True, False], [True, True]])
-    True
-
-    >>> np.any([[True, False], [False, False]], axis=0)
-    array([ True, False])
-
-    >>> np.any([-1, 0, 5])
-    True
-
-    >>> np.any(np.nan)
-    True
-
-    >>> o=np.array(False)
-    >>> z=np.any([-1, 4, 5], out=o)
-    >>> z, o
-    (array(True), array(True))
-    >>> # Check now that z is a reference to o
-    >>> z is o
-    True
-    >>> id(z), id(o) # identity of z and o              # doctest: +SKIP
-    (191614240, 191614240)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def angle (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "angle"))))
-(alter-meta! #'angle assoc :doc "
-    Return the angle of the complex argument.
-
-    Parameters
-    ----------
-    z : array_like
-        A complex number or sequence of complex numbers.
-    deg : bool, optional
-        Return angle in degrees if True, radians if False (default).
-
-    Returns
-    -------
-    angle : ndarray or scalar
-        The counterclockwise angle from the positive real axis on the complex
-        plane in the range ``(-pi, pi]``, with dtype as numpy.float64.
-
-        ..versionchanged:: 1.16.0
-            This function works on subclasses of ndarray like `ma.array`.
-
-    See Also
-    --------
-    arctan2
-    absolute
-
-    Examples
-    --------
-    >>> np.angle([1.0, 1.0j, 1+1j])               # in radians
-    array([ 0.        ,  1.57079633,  0.78539816]) # may vary
-    >>> np.angle(1+1j, deg=True)                  # in degrees
-    45.0
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def reshape (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "reshape"))))
-(alter-meta! #'reshape assoc :doc "
-    Gives a new shape to an array without changing its data.
-
-    Parameters
-    ----------
-    a : array_like
-        Array to be reshaped.
-    newshape : int or tuple of ints
-        The new shape should be compatible with the original shape. If
-        an integer, then the result will be a 1-D array of that length.
-        One shape dimension can be -1. In this case, the value is
-        inferred from the length of the array and remaining dimensions.
-    order : {'C', 'F', 'A'}, optional
-        Read the elements of `a` using this index order, and place the
-        elements into the reshaped array using this index order.  'C'
-        means to read / write the elements using C-like index order,
-        with the last axis index changing fastest, back to the first
-        axis index changing slowest. 'F' means to read / write the
-        elements using Fortran-like index order, with the first index
-        changing fastest, and the last index changing slowest. Note that
-        the 'C' and 'F' options take no account of the memory layout of
-        the underlying array, and only refer to the order of indexing.
-        'A' means to read / write the elements in Fortran-like index
-        order if `a` is Fortran *contiguous* in memory, C-like order
-        otherwise.
-
-    Returns
-    -------
-    reshaped_array : ndarray
-        This will be a new view object if possible; otherwise, it will
-        be a copy.  Note there is no guarantee of the *memory layout* (C- or
-        Fortran- contiguous) of the returned array.
-
-    See Also
-    --------
-    ndarray.reshape : Equivalent method.
-
-    Notes
-    -----
-    It is not always possible to change the shape of an array without
-    copying the data. If you want an error to be raised when the data is copied,
-    you should assign the new shape to the shape attribute of the array::
-
-     >>> a = np.zeros((10, 2))
-
-     # A transpose makes the array non-contiguous
-     >>> b = a.T
-
-     # Taking a view makes it possible to modify the shape without modifying
-     # the initial object.
-     >>> c = b.view()
-     >>> c.shape = (20)
-     Traceback (most recent call last):
-        ...
-     AttributeError: incompatible shape for a non-contiguous array
-
-    The `order` keyword gives the index ordering both for *fetching* the values
-    from `a`, and then *placing* the values into the output array.
-    For example, let's say you have an array:
-
-    >>> a = np.arange(6).reshape((3, 2))
-    >>> a
-    array([[0, 1],
-           [2, 3],
-           [4, 5]])
-
-    You can think of reshaping as first raveling the array (using the given
-    index order), then inserting the elements from the raveled array into the
-    new array using the same kind of index ordering as was used for the
-    raveling.
-
-    >>> np.reshape(a, (2, 3)) # C-like index ordering
-    array([[0, 1, 2],
-           [3, 4, 5]])
-    >>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape
-    array([[0, 1, 2],
-           [3, 4, 5]])
-    >>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering
-    array([[0, 4, 3],
-           [2, 1, 5]])
-    >>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F')
-    array([[0, 4, 3],
-           [2, 1, 5]])
-
-    Examples
-    --------
-    >>> a = np.array([[1,2,3], [4,5,6]])
-    >>> np.reshape(a, 6)
-    array([1, 2, 3, 4, 5, 6])
-    >>> np.reshape(a, 6, order='F')
-    array([1, 4, 2, 5, 3, 6])
-
-    >>> np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2
-    array([[1, 2],
-           [3, 4],
-           [5, 6]])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def i0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "i0"))))
-(alter-meta! #'i0 assoc :doc "
-    Modified Bessel function of the first kind, order 0.
-
-    Usually denoted :math:`I_0`.  This function does broadcast, but will *not*
-    \"up-cast\" int dtype arguments unless accompanied by at least one float or
-    complex dtype argument (see Raises below).
-
-    Parameters
-    ----------
-    x : array_like, dtype float or complex
-        Argument of the Bessel function.
-
-    Returns
-    -------
-    out : ndarray, shape = x.shape, dtype = x.dtype
-        The modified Bessel function evaluated at each of the elements of `x`.
-
-    Raises
-    ------
-    TypeError: array cannot be safely cast to required type
-        If argument consists exclusively of int dtypes.
-
-    See Also
-    --------
-    scipy.special.i0, scipy.special.iv, scipy.special.ive
-
-    Notes
-    -----
-    The scipy implementation is recommended over this function: it is a
-    proper ufunc written in C, and more than an order of magnitude faster.
-
-    We use the algorithm published by Clenshaw [1]_ and referenced by
-    Abramowitz and Stegun [2]_, for which the function domain is
-    partitioned into the two intervals [0,8] and (8,inf), and Chebyshev
-    polynomial expansions are employed in each interval. Relative error on
-    the domain [0,30] using IEEE arithmetic is documented [3]_ as having a
-    peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).
-
-    References
-    ----------
-    .. [1] C. W. Clenshaw, \"Chebyshev series for mathematical functions\", in
-           *National Physical Laboratory Mathematical Tables*, vol. 5, London:
-           Her Majesty's Stationery Office, 1962.
-    .. [2] M. Abramowitz and I. A. Stegun, *Handbook of Mathematical
-           Functions*, 10th printing, New York: Dover, 1964, pp. 379.
-           http://www.math.sfu.ca/~cbm/aands/page_379.htm
-    .. [3] http://kobesearch.cpan.org/htdocs/Math-Cephes/Math/Cephes.html
-
-    Examples
-    --------
-    >>> np.i0(0.)
-    array(1.0)  # may vary
-    >>> np.i0([0., 1. + 2j])
-    array([ 1.00000000+0.j        ,  0.18785373+0.64616944j])  # may vary
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ndenumerate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndenumerate"))))
-(alter-meta! #'ndenumerate assoc :doc "
-    Multidimensional index iterator.
-
-    Return an iterator yielding pairs of array coordinates and values.
-
-    Parameters
-    ----------
-    arr : ndarray
-      Input array.
-
-    See Also
-    --------
-    ndindex, flatiter
-
-    Examples
-    --------
-    >>> a = np.array([[1, 2], [3, 4]])
-    >>> for index, x in np.ndenumerate(a):
-    ...     print(index, x)
-    (0, 0) 1
-    (0, 1) 2
-    (1, 0) 3
-    (1, 1) 4
-
-    " :arglists '[[self arr]])
-
-(def hamming (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hamming"))))
-(alter-meta! #'hamming assoc :doc "
-    Return the Hamming window.
-
-    The Hamming window is a taper formed by using a weighted cosine.
-
-    Parameters
-    ----------
-    M : int
-        Number of points in the output window. If zero or less, an
-        empty array is returned.
-
-    Returns
-    -------
-    out : ndarray
-        The window, with the maximum value normalized to one (the value
-        one appears only if the number of samples is odd).
-
-    See Also
-    --------
-    bartlett, blackman, hanning, kaiser
-
-    Notes
-    -----
-    The Hamming window is defined as
-
-    .. math::  w(n) = 0.54 - 0.46cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
-               \\qquad 0 \\leq n \\leq M-1
-
-    The Hamming was named for R. W. Hamming, an associate of J. W. Tukey
-    and is described in Blackman and Tukey. It was recommended for
-    smoothing the truncated autocovariance function in the time domain.
-    Most references to the Hamming window come from the signal processing
-    literature, where it is used as one of many windowing functions for
-    smoothing values.  It is also known as an apodization (which means
-    \"removing the foot\", i.e. smoothing discontinuities at the beginning
-    and end of the sampled signal) or tapering function.
-
-    References
-    ----------
-    .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
-           spectra, Dover Publications, New York.
-    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\", The
-           University of Alberta Press, 1975, pp. 109-110.
-    .. [3] Wikipedia, \"Window function\",
-           https://en.wikipedia.org/wiki/Window_function
-    .. [4] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
-           \"Numerical Recipes\", Cambridge University Press, 1986, page 425.
-
-    Examples
-    --------
-    >>> np.hamming(12)
-    array([ 0.08      ,  0.15302337,  0.34890909,  0.60546483,  0.84123594, # may vary
-            0.98136677,  0.98136677,  0.84123594,  0.60546483,  0.34890909,
-            0.15302337,  0.08      ])
-
-    Plot the window and the frequency response:
-
-    >>> import matplotlib.pyplot as plt
-    >>> from numpy.fft import fft, fftshift
-    >>> window = np.hamming(51)
-    >>> plt.plot(window)
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.title(\"Hamming window\")
-    Text(0.5, 1.0, 'Hamming window')
-    >>> plt.ylabel(\"Amplitude\")
-    Text(0, 0.5, 'Amplitude')
-    >>> plt.xlabel(\"Sample\")
-    Text(0.5, 0, 'Sample')
-    >>> plt.show()
-
-    >>> plt.figure()
-    <Figure size 640x480 with 0 Axes>
-    >>> A = fft(window, 2048) / 25.5
-    >>> mag = np.abs(fftshift(A))
-    >>> freq = np.linspace(-0.5, 0.5, len(A))
-    >>> response = 20 * np.log10(mag)
-    >>> response = np.clip(response, -100, 100)
-    >>> plt.plot(freq, response)
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.title(\"Frequency response of Hamming window\")
-    Text(0.5, 1.0, 'Frequency response of Hamming window')
-    >>> plt.ylabel(\"Magnitude [dB]\")
-    Text(0, 0.5, 'Magnitude [dB]')
-    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
-    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
-    >>> plt.axis('tight')
-    ...
-    >>> plt.show()
-
-    " :arglists '[[M]])
-
-(def ^{:doc ""} NAN (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "NAN"))))
-
-(def ^{:doc ""} Infinity (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "Infinity"))))
-
-(def ^{:doc ""} MAY_SHARE_EXACT (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "MAY_SHARE_EXACT"))))
-
-(def array2string (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array2string"))))
-(alter-meta! #'array2string assoc :doc "
-    Return a string representation of an array.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    max_line_width : int, optional
-        Inserts newlines if text is longer than `max_line_width`.
-        Defaults to ``numpy.get_printoptions()['linewidth']``.
-    precision : int or None, optional
-        Floating point precision.
-        Defaults to ``numpy.get_printoptions()['precision']``.
-    suppress_small : bool, optional
-        Represent numbers \"very close\" to zero as zero; default is False.
-        Very close is defined by precision: if the precision is 8, e.g.,
-        numbers smaller (in absolute value) than 5e-9 are represented as
-        zero.
-        Defaults to ``numpy.get_printoptions()['suppress']``.
-    separator : str, optional
-        Inserted between elements.
-    prefix : str, optional
-    suffix: str, optional
-        The length of the prefix and suffix strings are used to respectively
-        align and wrap the output. An array is typically printed as::
-
-          prefix + array2string(a) + suffix
-
-        The output is left-padded by the length of the prefix string, and
-        wrapping is forced at the column ``max_line_width - len(suffix)``.
-        It should be noted that the content of prefix and suffix strings are
-        not included in the output.
-    style : _NoValue, optional
-        Has no effect, do not use.
-
-        .. deprecated:: 1.14.0
-    formatter : dict of callables, optional
-        If not None, the keys should indicate the type(s) that the respective
-        formatting function applies to.  Callables should return a string.
-        Types that are not specified (by their corresponding keys) are handled
-        by the default formatters.  Individual types for which a formatter
-        can be set are:
-
-        - 'bool'
-        - 'int'
-        - 'timedelta' : a `numpy.timedelta64`
-        - 'datetime' : a `numpy.datetime64`
-        - 'float'
-        - 'longfloat' : 128-bit floats
-        - 'complexfloat'
-        - 'longcomplexfloat' : composed of two 128-bit floats
-        - 'void' : type `numpy.void`
-        - 'numpystr' : types `numpy.string_` and `numpy.unicode_`
-        - 'str' : all other strings
-
-        Other keys that can be used to set a group of types at once are:
-
-        - 'all' : sets all types
-        - 'int_kind' : sets 'int'
-        - 'float_kind' : sets 'float' and 'longfloat'
-        - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
-        - 'str_kind' : sets 'str' and 'numpystr'
-    threshold : int, optional
-        Total number of array elements which trigger summarization
-        rather than full repr.
-        Defaults to ``numpy.get_printoptions()['threshold']``.
-    edgeitems : int, optional
-        Number of array items in summary at beginning and end of
-        each dimension.
-        Defaults to ``numpy.get_printoptions()['edgeitems']``.
-    sign : string, either '-', '+', or ' ', optional
-        Controls printing of the sign of floating-point types. If '+', always
-        print the sign of positive values. If ' ', always prints a space
-        (whitespace character) in the sign position of positive values.  If
-        '-', omit the sign character of positive values.
-        Defaults to ``numpy.get_printoptions()['sign']``.
-    floatmode : str, optional
-        Controls the interpretation of the `precision` option for
-        floating-point types.
-        Defaults to ``numpy.get_printoptions()['floatmode']``.
-        Can take the following values:
-
-        - 'fixed': Always print exactly `precision` fractional digits,
-          even if this would print more or fewer digits than
-          necessary to specify the value uniquely.
-        - 'unique': Print the minimum number of fractional digits necessary
-          to represent each value uniquely. Different elements may
-          have a different number of digits.  The value of the
-          `precision` option is ignored.
-        - 'maxprec': Print at most `precision` fractional digits, but if
-          an element can be uniquely represented with fewer digits
-          only print it with that many.
-        - 'maxprec_equal': Print at most `precision` fractional digits,
-          but if every element in the array can be uniquely
-          represented with an equal number of fewer digits, use that
-          many digits for all elements.
-    legacy : string or `False`, optional
-        If set to the string `'1.13'` enables 1.13 legacy printing mode. This
-        approximates numpy 1.13 print output by including a space in the sign
-        position of floats and different behavior for 0d arrays. If set to
-        `False`, disables legacy mode. Unrecognized strings will be ignored
-        with a warning for forward compatibility.
-
-        .. versionadded:: 1.14.0
-
-    Returns
-    -------
-    array_str : str
-        String representation of the array.
-
-    Raises
-    ------
-    TypeError
-        if a callable in `formatter` does not return a string.
-
-    See Also
-    --------
-    array_str, array_repr, set_printoptions, get_printoptions
-
-    Notes
-    -----
-    If a formatter is specified for a certain type, the `precision` keyword is
-    ignored for that type.
-
-    This is a very flexible function; `array_repr` and `array_str` are using
-    `array2string` internally so keywords with the same name should work
-    identically in all three functions.
-
-    Examples
-    --------
-    >>> x = np.array([1e-16,1,2,3])
-    >>> np.array2string(x, precision=2, separator=',',
-    ...                       suppress_small=True)
-    '[0.,1.,2.,3.]'
-
-    >>> x  = np.arange(3.)
-    >>> np.array2string(x, formatter={'float_kind':lambda x: \"%.2f\" % x})
-    '[0.00 1.00 2.00]'
-
-    >>> x  = np.arange(3)
-    >>> np.array2string(x, formatter={'int':lambda x: hex(x)})
-    '[0x0 0x1 0x2]'
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def disp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "disp"))))
-(alter-meta! #'disp assoc :doc "
-    Display a message on a device.
-
-    Parameters
-    ----------
-    mesg : str
-        Message to display.
-    device : object
-        Device to write message. If None, defaults to ``sys.stdout`` which is
-        very similar to ``print``. `device` needs to have ``write()`` and
-        ``flush()`` methods.
-    linefeed : bool, optional
-        Option whether to print a line feed or not. Defaults to True.
-
-    Raises
-    ------
-    AttributeError
-        If `device` does not have a ``write()`` or ``flush()`` method.
-
-    Examples
-    --------
-    Besides ``sys.stdout``, a file-like object can also be used as it has
-    both required methods:
-
-    >>> from io import StringIO
-    >>> buf = StringIO()
-    >>> np.disp(u'\"Display\" in a file', device=buf)
-    >>> buf.getvalue()
-    '\"Display\" in a file\\n'
-
-    " :arglists '[[mesg & [{device :device, linefeed :linefeed}]] [mesg & [{device :device}]] [mesg]])
-
-(def packbits (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "packbits"))))
-(alter-meta! #'packbits assoc :doc "
-    packbits(a, axis=None, bitorder='big')
-
-    Packs the elements of a binary-valued array into bits in a uint8 array.
-
-    The result is padded to full bytes by inserting zero bits at the end.
-
-    Parameters
-    ----------
-    a : array_like
-        An array of integers or booleans whose elements should be packed to
-        bits.
-    axis : int, optional
-        The dimension over which bit-packing is done.
-        ``None`` implies packing the flattened array.
-    bitorder : {'big', 'little'}, optional
-        The order of the input bits. 'big' will mimic bin(val),
-        ``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011 => ``, 'little' will
-        reverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``.
-        Defaults to 'big'.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    packed : ndarray
-        Array of type uint8 whose elements represent bits corresponding to the
-        logical (0 or nonzero) value of the input elements. The shape of
-        `packed` has the same number of dimensions as the input (unless `axis`
-        is None, in which case the output is 1-D).
-
-    See Also
-    --------
-    unpackbits: Unpacks elements of a uint8 array into a binary-valued output
-                array.
-
-    Examples
-    --------
-    >>> a = np.array([[[1,0,1],
-    ...                [0,1,0]],
-    ...               [[1,1,0],
-    ...                [0,0,1]]])
-    >>> b = np.packbits(a, axis=-1)
-    >>> b
-    array([[[160],
-            [ 64]],
-           [[192],
-            [ 32]]], dtype=uint8)
-
-    Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000,
-    and 32 = 0010 0000.
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} ERR_WARN (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_WARN"))))
-
-(def percentile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "percentile"))))
-(alter-meta! #'percentile assoc :doc "
-    Compute the q-th percentile of the data along the specified axis.
-
-    Returns the q-th percentile(s) of the array elements.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array or object that can be converted to an array.
-    q : array_like of float
-        Percentile or sequence of percentiles to compute, which must be between
-        0 and 100 inclusive.
-    axis : {int, tuple of int, None}, optional
-        Axis or axes along which the percentiles are computed. The
-        default is to compute the percentile(s) along a flattened
-        version of the array.
-
-        .. versionchanged:: 1.9.0
-            A tuple of axes is supported
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must
-        have the same shape and buffer length as the expected output,
-        but the type (of the output) will be cast if necessary.
-    overwrite_input : bool, optional
-        If True, then allow the input array `a` to be modified by intermediate
-        calculations, to save memory. In this case, the contents of the input
-        `a` after this function completes is undefined.
-
-    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
-        This optional parameter specifies the interpolation method to
-        use when the desired percentile lies between two data points
-        ``i < j``:
-
-        * 'linear': ``i + (j - i) * fraction``, where ``fraction``
-          is the fractional part of the index surrounded by ``i``
-          and ``j``.
-        * 'lower': ``i``.
-        * 'higher': ``j``.
-        * 'nearest': ``i`` or ``j``, whichever is nearest.
-        * 'midpoint': ``(i + j) / 2``.
-
-        .. versionadded:: 1.9.0
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left in
-        the result as dimensions with size one. With this option, the
-        result will broadcast correctly against the original array `a`.
-
-        .. versionadded:: 1.9.0
-
-    Returns
-    -------
-    percentile : scalar or ndarray
-        If `q` is a single percentile and `axis=None`, then the result
-        is a scalar. If multiple percentiles are given, first axis of
-        the result corresponds to the percentiles. The other axes are
-        the axes that remain after the reduction of `a`. If the input
-        contains integers or floats smaller than ``float64``, the output
-        data-type is ``float64``. Otherwise, the output data-type is the
-        same as that of the input. If `out` is specified, that array is
-        returned instead.
-
-    See Also
-    --------
-    mean
-    median : equivalent to ``percentile(..., 50)``
-    nanpercentile
-    quantile : equivalent to percentile, except with q in the range [0, 1].
-
-    Notes
-    -----
-    Given a vector ``V`` of length ``N``, the q-th percentile of
-    ``V`` is the value ``q/100`` of the way from the minimum to the
-    maximum in a sorted copy of ``V``. The values and distances of
-    the two nearest neighbors as well as the `interpolation` parameter
-    will determine the percentile if the normalized ranking does not
-    match the location of ``q`` exactly. This function is the same as
-    the median if ``q=50``, the same as the minimum if ``q=0`` and the
-    same as the maximum if ``q=100``.
-
-    Examples
-    --------
-    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
-    >>> a
-    array([[10,  7,  4],
-           [ 3,  2,  1]])
-    >>> np.percentile(a, 50)
-    3.5
-    >>> np.percentile(a, 50, axis=0)
-    array([6.5, 4.5, 2.5])
-    >>> np.percentile(a, 50, axis=1)
-    array([7.,  2.])
-    >>> np.percentile(a, 50, axis=1, keepdims=True)
-    array([[7.],
-           [2.]])
-
-    >>> m = np.percentile(a, 50, axis=0)
-    >>> out = np.zeros_like(m)
-    >>> np.percentile(a, 50, axis=0, out=out)
-    array([6.5, 4.5, 2.5])
-    >>> m
-    array([6.5, 4.5, 2.5])
-
-    >>> b = a.copy()
-    >>> np.percentile(b, 50, axis=1, overwrite_input=True)
-    array([7.,  2.])
-    >>> assert not np.all(a == b)
-
-    The different types of interpolation can be visualized graphically:
-
-    .. plot::
-
-        import matplotlib.pyplot as plt
-
-        a = np.arange(4)
-        p = np.linspace(0, 100, 6001)
-        ax = plt.gca()
-        lines = [
-            ('linear', None),
-            ('higher', '--'),
-            ('lower', '--'),
-            ('nearest', '-.'),
-            ('midpoint', '-.'),
-        ]
-        for interpolation, style in lines:
-            ax.plot(
-                p, np.percentile(a, p, interpolation=interpolation),
-                label=interpolation, linestyle=style)
-        ax.set(
-            title='Interpolation methods for list: ' + str(a),
-            xlabel='Percentile',
-            ylabel='List item returned',
-            yticks=a)
-        ax.legend()
-        plt.show()
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def nanquantile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanquantile"))))
-(alter-meta! #'nanquantile assoc :doc "
-    Compute the qth quantile of the data along the specified axis,
-    while ignoring nan values.
-    Returns the qth quantile(s) of the array elements.
-    
-    .. versionadded:: 1.15.0
-
-    Parameters
-    ----------
-    a : array_like
-        Input array or object that can be converted to an array, containing
-        nan values to be ignored
-    q : array_like of float
-        Quantile or sequence of quantiles to compute, which must be between
-        0 and 1 inclusive.
-    axis : {int, tuple of int, None}, optional
-        Axis or axes along which the quantiles are computed. The
-        default is to compute the quantile(s) along a flattened
-        version of the array.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must
-        have the same shape and buffer length as the expected output,
-        but the type (of the output) will be cast if necessary.
-    overwrite_input : bool, optional
-        If True, then allow the input array `a` to be modified by intermediate
-        calculations, to save memory. In this case, the contents of the input
-        `a` after this function completes is undefined.
-    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
-        This optional parameter specifies the interpolation method to
-        use when the desired quantile lies between two data points
-        ``i < j``:
-
-        * linear: ``i + (j - i) * fraction``, where ``fraction``
-          is the fractional part of the index surrounded by ``i``
-          and ``j``.
-        * lower: ``i``.
-        * higher: ``j``.
-        * nearest: ``i`` or ``j``, whichever is nearest.
-        * midpoint: ``(i + j) / 2``.
-
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left in
-        the result as dimensions with size one. With this option, the
-        result will broadcast correctly against the original array `a`.
-
-        If this is anything but the default value it will be passed
-        through (in the special case of an empty array) to the
-        `mean` function of the underlying array.  If the array is
-        a sub-class and `mean` does not have the kwarg `keepdims` this
-        will raise a RuntimeError.
-
-    Returns
-    -------
-    quantile : scalar or ndarray
-        If `q` is a single percentile and `axis=None`, then the result
-        is a scalar. If multiple quantiles are given, first axis of
-        the result corresponds to the quantiles. The other axes are
-        the axes that remain after the reduction of `a`. If the input
-        contains integers or floats smaller than ``float64``, the output
-        data-type is ``float64``. Otherwise, the output data-type is the
-        same as that of the input. If `out` is specified, that array is
-        returned instead.
-
-    See Also
-    --------
-    quantile
-    nanmean, nanmedian
-    nanmedian : equivalent to ``nanquantile(..., 0.5)``
-    nanpercentile : same as nanquantile, but with q in the range [0, 100].
-
-    Examples
-    --------
-    >>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
-    >>> a[0][1] = np.nan
-    >>> a
-    array([[10.,  nan,   4.],
-          [ 3.,   2.,   1.]])
-    >>> np.quantile(a, 0.5)
-    nan
-    >>> np.nanquantile(a, 0.5)
-    3.0
-    >>> np.nanquantile(a, 0.5, axis=0)
-    array([6.5, 2. , 2.5])
-    >>> np.nanquantile(a, 0.5, axis=1, keepdims=True)
-    array([[7.],
-           [2.]])
-    >>> m = np.nanquantile(a, 0.5, axis=0)
-    >>> out = np.zeros_like(m)
-    >>> np.nanquantile(a, 0.5, axis=0, out=out)
-    array([6.5, 2. , 2.5])
-    >>> m
-    array([6.5,  2. ,  2.5])
-    >>> b = a.copy()
-    >>> np.nanquantile(b, 0.5, axis=1, overwrite_input=True)
-    array([7., 2.])
-    >>> assert not np.all(a==b)
-    " :arglists '[[& [args {:as kwargs}]]])
-(def ^{:doc "dict() -> new empty dictionary
-dict(mapping) -> new dictionary initialized from a mapping object's
-    (key, value) pairs
-dict(iterable) -> new dictionary initialized as if via:
-    d = {}
-    for k, v in iterable:
-        d[k] = v
-dict(**kwargs) -> new dictionary initialized with the name=value pairs
-    in the keyword argument list.  For example:  dict(one=1, two=2)"} typecodes (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "typecodes")))) 
-
-(def tril (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tril"))))
-(alter-meta! #'tril assoc :doc "
-    Lower triangle of an array.
-
-    Return a copy of an array with elements above the `k`-th diagonal zeroed.
-
-    Parameters
-    ----------
-    m : array_like, shape (M, N)
-        Input array.
-    k : int, optional
-        Diagonal above which to zero elements.  `k = 0` (the default) is the
-        main diagonal, `k < 0` is below it and `k > 0` is above.
-
-    Returns
-    -------
-    tril : ndarray, shape (M, N)
-        Lower triangle of `m`, of same shape and data-type as `m`.
-
-    See Also
-    --------
-    triu : same thing, only for the upper triangle
-
-    Examples
-    --------
-    >>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
-    array([[ 0,  0,  0],
-           [ 4,  0,  0],
-           [ 7,  8,  0],
-           [10, 11, 12]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def sin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sin"))))
-(alter-meta! #'sin assoc :doc "sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Trigonometric sine, element-wise.
-
-Parameters
-----------
-x : array_like
-    Angle, in radians (:math:`2 \\pi` rad equals 360 degrees).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : array_like
-    The sine of each element of x.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-arcsin, sinh, cos
-
-Notes
------
-The sine is one of the fundamental functions of trigonometry (the
-mathematical study of triangles).  Consider a circle of radius 1
-centered on the origin.  A ray comes in from the :math:`+x` axis, makes
-an angle at the origin (measured counter-clockwise from that axis), and
-departs from the origin.  The :math:`y` coordinate of the outgoing
-ray's intersection with the unit circle is the sine of that angle.  It
-ranges from -1 for :math:`x=3\\pi / 2` to +1 for :math:`\\pi / 2.`  The
-function has zeroes where the angle is a multiple of :math:`\\pi`.
-Sines of angles between :math:`\\pi` and :math:`2\\pi` are negative.
-The numerous properties of the sine and related functions are included
-in any standard trigonometry text.
-
-Examples
---------
-Print sine of one angle:
-
->>> np.sin(np.pi/2.)
-1.0
-
-Print sines of an array of angles given in degrees:
-
->>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. )
-array([ 0.        ,  0.5       ,  0.70710678,  0.8660254 ,  1.        ])
-
-Plot the sine function:
-
->>> import matplotlib.pylab as plt
->>> x = np.linspace(-np.pi, np.pi, 201)
->>> plt.plot(x, np.sin(x))
->>> plt.xlabel('Angle [rad]')
->>> plt.ylabel('sin(x)')
->>> plt.axis('tight')
->>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
-
-(def flipud (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flipud"))))
-(alter-meta! #'flipud assoc :doc "
-    Flip array in the up/down direction.
-
-    Flip the entries in each column in the up/down direction.
-    Rows are preserved, but appear in a different order than before.
-
-    Parameters
-    ----------
-    m : array_like
-        Input array.
-
-    Returns
-    -------
-    out : array_like
-        A view of `m` with the rows reversed.  Since a view is
-        returned, this operation is :math:`\\mathcal O(1)`.
-
-    See Also
-    --------
-    fliplr : Flip array in the left/right direction.
-    rot90 : Rotate array counterclockwise.
-
-    Notes
-    -----
-    Equivalent to ``m[::-1,...]``.
-    Does not require the array to be two-dimensional.
-
-    Examples
-    --------
-    >>> A = np.diag([1.0, 2, 3])
-    >>> A
-    array([[1.,  0.,  0.],
-           [0.,  2.,  0.],
-           [0.,  0.,  3.]])
-    >>> np.flipud(A)
-    array([[0.,  0.,  3.],
-           [0.,  2.,  0.],
-           [1.,  0.,  0.]])
-
-    >>> A = np.random.randn(2,3,5)
-    >>> np.all(np.flipud(A) == A[::-1,...])
-    True
-
-    >>> np.flipud([1,2])
-    array([2, 1])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def power (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "power"))))
-(alter-meta! #'power assoc :doc "power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-First array elements raised to powers from second array, element-wise.
-
-Raise each base in `x1` to the positionally-corresponding power in
-`x2`.  `x1` and `x2` must be broadcastable to the same shape. Note that an
-integer type raised to a negative integer power will raise a ValueError.
-
-Parameters
-----------
-x1 : array_like
-    The bases.
-x2 : array_like
-    The exponents. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The bases in `x1` raised to the exponents in `x2`.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-float_power : power function that promotes integers to float
-
-Examples
---------
-Cube each element in a list.
-
->>> x1 = range(6)
->>> x1
-[0, 1, 2, 3, 4, 5]
->>> np.power(x1, 3)
-array([  0,   1,   8,  27,  64, 125])
-
-Raise the bases to different exponents.
-
->>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
->>> np.power(x1, x2)
-array([  0.,   1.,   8.,  27.,  16.,   5.])
-
-The effect of broadcasting.
-
->>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
->>> x2
-array([[1, 2, 3, 3, 2, 1],
-       [1, 2, 3, 3, 2, 1]])
->>> np.power(x1, x2)
-array([[ 0,  1,  8, 27, 16,  5],
-       [ 0,  1,  8, 27, 16,  5]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} pi (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "pi"))))
-
-(def ^{:doc "
-Pytest test running.
-
-This module implements the ``test()`` function for NumPy modules. The usual
-boiler plate for doing that is to put the following in the module
-``__init__.py`` file::
-
-    from numpy._pytesttester import PytestTester
-    test = PytestTester(__name__).test
-    del PytestTester
-
-
-Warnings filtering and other runtime settings should be dealt with in the
-``pytest.ini`` file in the numpy repo root. The behavior of the test depends on
-whether or not that file is found as follows:
-
-* ``pytest.ini`` is present (develop mode)
-    All warnings except those explicily filtered out are raised as error.
-* ``pytest.ini`` is absent (release mode)
-    DeprecationWarnings and PendingDeprecationWarnings are ignored, other
-    warnings are passed through.
-
-In practice, tests run from the numpy repo are run in develop mode. That
-includes the standard ``python runtests.py`` invocation.
-
-This module is imported by every numpy subpackage, so lies at the top level to
-simplify circular import issues. For the same reason, it contains no numpy
-imports at module scope, instead importing numpy within function calls.
-"} _pytesttester (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_pytesttester"))))
-
-(def fabs (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fabs"))))
-(alter-meta! #'fabs assoc :doc "fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute the absolute values element-wise.
-
-This function returns the absolute values (positive magnitude) of the
-data in `x`. Complex values are not handled, use `absolute` to find the
-absolute values of complex data.
-
-Parameters
-----------
-x : array_like
-    The array of numbers for which the absolute values are required. If
-    `x` is a scalar, the result `y` will also be a scalar.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or scalar
-    The absolute values of `x`, the returned values are always floats.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-absolute : Absolute values including `complex` types.
-
-Examples
---------
->>> np.fabs(-1)
-1.0
->>> np.fabs([-1.2, 1.2])
-array([ 1.2,  1.2])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def gcd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "gcd"))))
-(alter-meta! #'gcd assoc :doc "gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Returns the greatest common divisor of ``|x1|`` and ``|x2|``
-
-Parameters
-----------
-x1, x2 : array_like, int
-    Arrays of values. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-
-Returns
--------
-y : ndarray or scalar
-    The greatest common divisor of the absolute value of the inputs
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-lcm : The lowest common multiple
-
-Examples
---------
->>> np.gcd(12, 20)
-4
->>> np.gcd.reduce([15, 25, 35])
-5
->>> np.gcd(np.arange(6), 20)
-array([20,  1,  2,  1,  4,  5])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def hypot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hypot"))))
-(alter-meta! #'hypot assoc :doc "hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Given the \"legs\" of a right triangle, return its hypotenuse.
-
-Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise.  If `x1` or
-`x2` is scalar_like (i.e., unambiguously cast-able to a scalar type),
-it is broadcast for use with each element of the other argument.
-(See Examples)
-
-Parameters
-----------
-x1, x2 : array_like
-    Leg of the triangle(s). If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-z : ndarray
-    The hypotenuse of the triangle(s).
-    This is a scalar if both `x1` and `x2` are scalars.
-
-Examples
---------
->>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3)))
-array([[ 5.,  5.,  5.],
-       [ 5.,  5.,  5.],
-       [ 5.,  5.,  5.]])
-
-Example showing broadcast of scalar_like argument:
-
->>> np.hypot(3*np.ones((3, 3)), [4])
-array([[ 5.,  5.,  5.],
-       [ 5.,  5.,  5.],
-       [ 5.,  5.,  5.]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def unicode_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unicode_"))))
-(alter-meta! #'unicode_ assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def nested_iters (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nested_iters"))))
-(alter-meta! #'nested_iters assoc :doc "Create nditers for use in nested loops
-
-    Create a tuple of `nditer` objects which iterate in nested loops over
-    different axes of the op argument. The first iterator is used in the
-    outermost loop, the last in the innermost loop. Advancing one will change
-    the subsequent iterators to point at its new element.
-
-    Parameters
-    ----------
-    op : ndarray or sequence of array_like
-        The array(s) to iterate over.
-
-    axes : list of list of int
-        Each item is used as an \"op_axes\" argument to an nditer
-
-    flags, op_flags, op_dtypes, order, casting, buffersize (optional)
-        See `nditer` parameters of the same name
-
-    Returns
-    -------
-    iters : tuple of nditer
-        An nditer for each item in `axes`, outermost first
-
-    See Also
-    --------
-    nditer
-
-    Examples
-    --------
-
-    Basic usage. Note how y is the \"flattened\" version of
-    [a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified
-    the first iter's axes as [1]
-
-    >>> a = np.arange(12).reshape(2, 3, 2)
-    >>> i, j = np.nested_iters(a, [[1], [0, 2]], flags=[\"multi_index\"])
-    >>> for x in i:
-    ...      print(i.multi_index)
-    ...      for y in j:
-    ...          print('', j.multi_index, y)
-    (0,)
-     (0, 0) 0
-     (0, 1) 1
-     (1, 0) 6
-     (1, 1) 7
-    (1,)
-     (0, 0) 2
-     (0, 1) 3
-     (1, 0) 8
-     (1, 1) 9
-    (2,)
-     (0, 0) 4
-     (0, 1) 5
-     (1, 0) 10
-     (1, 1) 11" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc "This module provides access to the mathematical functions
-defined by the C standard."} math (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "math"))))
-
-(def ^{:doc "
-=============
-Masked Arrays
-=============
-
-Arrays sometimes contain invalid or missing data.  When doing operations
-on such arrays, we wish to suppress invalid values, which is the purpose masked
-arrays fulfill (an example of typical use is given below).
-
-For example, examine the following array:
-
->>> x = np.array([2, 1, 3, np.nan, 5, 2, 3, np.nan])
-
-When we try to calculate the mean of the data, the result is undetermined:
-
->>> np.mean(x)
-nan
-
-The mean is calculated using roughly ``np.sum(x)/len(x)``, but since
-any number added to ``NaN`` [1]_ produces ``NaN``, this doesn't work.  Enter
-masked arrays:
-
->>> m = np.ma.masked_array(x, np.isnan(x))
->>> m
-masked_array(data = [2.0 1.0 3.0 -- 5.0 2.0 3.0 --],
-      mask = [False False False  True False False False  True],
-      fill_value=1e+20)
-
-Here, we construct a masked array that suppress all ``NaN`` values.  We
-may now proceed to calculate the mean of the other values:
-
->>> np.mean(m)
-2.6666666666666665
-
-.. [1] Not-a-Number, a floating point value that is the result of an
-       invalid operation.
-
-.. moduleauthor:: Pierre Gerard-Marchant
-.. moduleauthor:: Jarrod Millman
-
-"} ma (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ma"))))
-
-(def rate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rate"))))
-(alter-meta! #'rate assoc :doc "
-    Compute the rate of interest per period.
-
-    .. deprecated:: 1.18
-
-       `rate` is deprecated; for details, see NEP 32 [1]_.
-       Use the corresponding function in the numpy-financial library,
-       https://pypi.org/project/numpy-financial.
-
-    Parameters
-    ----------
-    nper : array_like
-        Number of compounding periods
-    pmt : array_like
-        Payment
-    pv : array_like
-        Present value
-    fv : array_like
-        Future value
-    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
-        When payments are due ('begin' (1) or 'end' (0))
-    guess : Number, optional
-        Starting guess for solving the rate of interest, default 0.1
-    tol : Number, optional
-        Required tolerance for the solution, default 1e-6
-    maxiter : int, optional
-        Maximum iterations in finding the solution
-
-    Notes
-    -----
-    The rate of interest is computed by iteratively solving the
-    (non-linear) equation::
-
-     fv + pv*(1+rate)**nper + pmt*(1+rate*when)/rate * ((1+rate)**nper - 1) = 0
-
-    for ``rate``.
-
-    References
-    ----------
-    .. [1] NumPy Enhancement Proposal (NEP) 32,
-       https://numpy.org/neps/nep-0032-remove-financial-functions.html
-    .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).
-       Open Document Format for Office Applications (OpenDocument)v1.2,
-       Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,
-       Pre-Draft 12. Organization for the Advancement of Structured Information
-       Standards (OASIS). Billerica, MA, USA. [ODT Document].
-       Available:
-       http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula
-       OpenDocument-formula-20090508.odt
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ndfromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndfromtxt"))))
-(alter-meta! #'ndfromtxt assoc :doc "
-    Load ASCII data stored in a file and return it as a single array.
-
-    .. deprecated:: 1.17
-        ndfromtxt` is a deprecated alias of `genfromtxt` which
-        overwrites the ``usemask`` argument with `False` even when
-        explicitly called as ``ndfromtxt(..., usemask=True)``.
-        Use `genfromtxt` instead.
-
-    Parameters
-    ----------
-    fname, kwargs : For a description of input parameters, see `genfromtxt`.
-
-    See Also
-    --------
-    numpy.genfromtxt : generic function.
-
-    " :arglists '[[fname & [{:as kwargs}]]])
-
-(def bitwise_and (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_and"))))
-(alter-meta! #'bitwise_and assoc :doc "bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute the bit-wise AND of two arrays element-wise.
-
-Computes the bit-wise AND of the underlying binary representation of
-the integers in the input arrays. This ufunc implements the C/Python
-operator ``&``.
-
-Parameters
-----------
-x1, x2 : array_like
-    Only integer and boolean types are handled. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Result.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-logical_and
-bitwise_or
-bitwise_xor
-binary_repr :
-    Return the binary representation of the input number as a string.
-
-Examples
---------
-The number 13 is represented by ``00001101``.  Likewise, 17 is
-represented by ``00010001``.  The bit-wise AND of 13 and 17 is
-therefore ``000000001``, or 1:
-
->>> np.bitwise_and(13, 17)
-1
-
->>> np.bitwise_and(14, 13)
-12
->>> np.binary_repr(12)
-'1100'
->>> np.bitwise_and([14,3], 13)
-array([12,  1])
-
->>> np.bitwise_and([11,7], [4,25])
-array([0, 1])
->>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16]))
-array([ 2,  4, 16])
->>> np.bitwise_and([True, True], [False, True])
-array([False,  True])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def cdouble (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cdouble"))))
-(alter-meta! #'cdouble assoc :doc "Complex number type composed of two double-precision floating-point
-    numbers, compatible with Python `complex`.
-    Character code: ``'D'``.
-    Canonical name: ``np.cdouble``.
-    Alias: ``np.cfloat``.
-    Alias: ``np.complex_``.
-    Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def real (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "real"))))
-(alter-meta! #'real assoc :doc "
-    Return the real part of the complex argument.
-
-    Parameters
-    ----------
-    val : array_like
-        Input array.
-
-    Returns
-    -------
-    out : ndarray or scalar
-        The real component of the complex argument. If `val` is real, the type
-        of `val` is used for the output.  If `val` has complex elements, the
-        returned type is float.
-
-    See Also
-    --------
-    real_if_close, imag, angle
-
-    Examples
-    --------
-    >>> a = np.array([1+2j, 3+4j, 5+6j])
-    >>> a.real
-    array([1.,  3.,  5.])
-    >>> a.real = 9
-    >>> a
-    array([9.+2.j,  9.+4.j,  9.+6.j])
-    >>> a.real = np.array([9, 8, 7])
-    >>> a
-    array([9.+2.j,  8.+4.j,  7.+6.j])
-    >>> np.real(1 + 1j)
-    1.0
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def fmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fmin"))))
-(alter-meta! #'fmin assoc :doc "fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Element-wise minimum of array elements.
-
-Compare two arrays and returns a new array containing the element-wise
-minima. If one of the elements being compared is a NaN, then the
-non-nan element is returned. If both elements are NaNs then the first
-is returned.  The latter distinction is important for complex NaNs,
-which are defined as at least one of the real or imaginary parts being
-a NaN. The net effect is that NaNs are ignored when possible.
-
-Parameters
-----------
-x1, x2 : array_like
-    The arrays holding the elements to be compared. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or scalar
-    The minimum of `x1` and `x2`, element-wise.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-fmax :
-    Element-wise maximum of two arrays, ignores NaNs.
-minimum :
-    Element-wise minimum of two arrays, propagates NaNs.
-amin :
-    The minimum value of an array along a given axis, propagates NaNs.
-nanmin :
-    The minimum value of an array along a given axis, ignores NaNs.
-
-maximum, amax, nanmax
-
-Notes
------
-.. versionadded:: 1.3.0
-
-The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither
-x1 nor x2 are NaNs, but it is faster and does proper broadcasting.
-
-Examples
---------
->>> np.fmin([2, 3, 4], [1, 5, 2])
-array([1, 3, 2])
-
->>> np.fmin(np.eye(2), [0.5, 2])
-array([[ 0.5,  0. ],
-       [ 0. ,  1. ]])
-
->>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan])
-array([ 0.,  0., nan])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def format_float_positional (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "format_float_positional"))))
-(alter-meta! #'format_float_positional assoc :doc "
-    Format a floating-point scalar as a decimal string in positional notation.
-
-    Provides control over rounding, trimming and padding. Uses and assumes
-    IEEE unbiased rounding. Uses the \"Dragon4\" algorithm.
-
-    Parameters
-    ----------
-    x : python float or numpy floating scalar
-        Value to format.
-    precision : non-negative integer or None, optional
-        Maximum number of digits to print. May be None if `unique` is
-        `True`, but must be an integer if unique is `False`.
-    unique : boolean, optional
-        If `True`, use a digit-generation strategy which gives the shortest
-        representation which uniquely identifies the floating-point number from
-        other values of the same type, by judicious rounding. If `precision`
-        was omitted, print out all necessary digits, otherwise digit generation
-        is cut off after `precision` digits and the remaining value is rounded.
-        If `False`, digits are generated as if printing an infinite-precision
-        value and stopping after `precision` digits, rounding the remaining
-        value.
-    fractional : boolean, optional
-        If `True`, the cutoff of `precision` digits refers to the total number
-        of digits after the decimal point, including leading zeros.
-        If `False`, `precision` refers to the total number of significant
-        digits, before or after the decimal point, ignoring leading zeros.
-    trim : one of 'k', '.', '0', '-', optional
-        Controls post-processing trimming of trailing digits, as follows:
-
-        * 'k' : keep trailing zeros, keep decimal point (no trimming)
-        * '.' : trim all trailing zeros, leave decimal point
-        * '0' : trim all but the zero before the decimal point. Insert the
-          zero if it is missing.
-        * '-' : trim trailing zeros and any trailing decimal point
-    sign : boolean, optional
-        Whether to show the sign for positive values.
-    pad_left : non-negative integer, optional
-        Pad the left side of the string with whitespace until at least that
-        many characters are to the left of the decimal point.
-    pad_right : non-negative integer, optional
-        Pad the right side of the string with whitespace until at least that
-        many characters are to the right of the decimal point.
-
-    Returns
-    -------
-    rep : string
-        The string representation of the floating point value
-
-    See Also
-    --------
-    format_float_scientific
-
-    Examples
-    --------
-    >>> np.format_float_positional(np.float32(np.pi))
-    '3.1415927'
-    >>> np.format_float_positional(np.float16(np.pi))
-    '3.14'
-    >>> np.format_float_positional(np.float16(0.3))
-    '0.3'
-    >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10)
-    '0.3000488281'
-    " :arglists '[[x & [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign, pad_left :pad_left, pad_right :pad_right}]] [x & [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign, pad_left :pad_left}]] [x & [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign}]] [x & [{precision :precision, unique :unique, fractional :fractional, trim :trim}]] [x & [{precision :precision, unique :unique, fractional :fractional}]] [x & [{precision :precision, unique :unique}]] [x & [{precision :precision}]] [x]])
-
-(def __dir__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__dir__"))))
-(alter-meta! #'__dir__ assoc :doc "" :arglists '[[]])
-
-(def vectorize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vectorize"))))
-(alter-meta! #'vectorize assoc :doc "
-    vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False,
-              signature=None)
-
-    Generalized function class.
-
-    Define a vectorized function which takes a nested sequence of objects or
-    numpy arrays as inputs and returns a single numpy array or a tuple of numpy
-    arrays. The vectorized function evaluates `pyfunc` over successive tuples
-    of the input arrays like the python map function, except it uses the
-    broadcasting rules of numpy.
-
-    The data type of the output of `vectorized` is determined by calling
-    the function with the first element of the input.  This can be avoided
-    by specifying the `otypes` argument.
-
-    Parameters
-    ----------
-    pyfunc : callable
-        A python function or method.
-    otypes : str or list of dtypes, optional
-        The output data type. It must be specified as either a string of
-        typecode characters or a list of data type specifiers. There should
-        be one data type specifier for each output.
-    doc : str, optional
-        The docstring for the function. If None, the docstring will be the
-        ``pyfunc.__doc__``.
-    excluded : set, optional
-        Set of strings or integers representing the positional or keyword
-        arguments for which the function will not be vectorized.  These will be
-        passed directly to `pyfunc` unmodified.
-
-        .. versionadded:: 1.7.0
-
-    cache : bool, optional
-       If `True`, then cache the first function call that determines the number
-       of outputs if `otypes` is not provided.
-
-        .. versionadded:: 1.7.0
-
-    signature : string, optional
-        Generalized universal function signature, e.g., ``(m,n),(n)->(m)`` for
-        vectorized matrix-vector multiplication. If provided, ``pyfunc`` will
-        be called with (and expected to return) arrays with shapes given by the
-        size of corresponding core dimensions. By default, ``pyfunc`` is
-        assumed to take scalars as input and output.
-
-        .. versionadded:: 1.12.0
-
-    Returns
-    -------
-    vectorized : callable
-        Vectorized function.
-
-    See Also
-    --------
-    frompyfunc : Takes an arbitrary Python function and returns a ufunc
-
-    Notes
-    -----
-    The `vectorize` function is provided primarily for convenience, not for
-    performance. The implementation is essentially a for loop.
-
-    If `otypes` is not specified, then a call to the function with the
-    first argument will be used to determine the number of outputs.  The
-    results of this call will be cached if `cache` is `True` to prevent
-    calling the function twice.  However, to implement the cache, the
-    original function must be wrapped which will slow down subsequent
-    calls, so only do this if your function is expensive.
-
-    The new keyword argument interface and `excluded` argument support
-    further degrades performance.
-
-    References
-    ----------
-    .. [1] NumPy Reference, section `Generalized Universal Function API
-           <https://docs.scipy.org/doc/numpy/reference/c-api.generalized-ufuncs.html>`_.
-
-    Examples
-    --------
-    >>> def myfunc(a, b):
-    ...     \"Return a-b if a>b, otherwise return a+b\"
-    ...     if a > b:
-    ...         return a - b
-    ...     else:
-    ...         return a + b
-
-    >>> vfunc = np.vectorize(myfunc)
-    >>> vfunc([1, 2, 3, 4], 2)
-    array([3, 4, 1, 2])
-
-    The docstring is taken from the input function to `vectorize` unless it
-    is specified:
-
-    >>> vfunc.__doc__
-    'Return a-b if a>b, otherwise return a+b'
-    >>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`')
-    >>> vfunc.__doc__
-    'Vectorized `myfunc`'
-
-    The output type is determined by evaluating the first element of the input,
-    unless it is specified:
-
-    >>> out = vfunc([1, 2, 3, 4], 2)
-    >>> type(out[0])
-    <class 'numpy.int64'>
-    >>> vfunc = np.vectorize(myfunc, otypes=[float])
-    >>> out = vfunc([1, 2, 3, 4], 2)
-    >>> type(out[0])
-    <class 'numpy.float64'>
-
-    The `excluded` argument can be used to prevent vectorizing over certain
-    arguments.  This can be useful for array-like arguments of a fixed length
-    such as the coefficients for a polynomial as in `polyval`:
-
-    >>> def mypolyval(p, x):
-    ...     _p = list(p)
-    ...     res = _p.pop(0)
-    ...     while _p:
-    ...         res = res*x + _p.pop(0)
-    ...     return res
-    >>> vpolyval = np.vectorize(mypolyval, excluded=['p'])
-    >>> vpolyval(p=[1, 2, 3], x=[0, 1])
-    array([3, 6])
-
-    Positional arguments may also be excluded by specifying their position:
-
-    >>> vpolyval.excluded.add(0)
-    >>> vpolyval([1, 2, 3], x=[0, 1])
-    array([3, 6])
-
-    The `signature` argument allows for vectorizing functions that act on
-    non-scalar arrays of fixed length. For example, you can use it for a
-    vectorized calculation of Pearson correlation coefficient and its p-value:
-
-    >>> import scipy.stats
-    >>> pearsonr = np.vectorize(scipy.stats.pearsonr,
-    ...                 signature='(n),(n)->(),()')
-    >>> pearsonr([[0, 1, 2, 3]], [[1, 2, 3, 4], [4, 3, 2, 1]])
-    (array([ 1., -1.]), array([ 0.,  0.]))
-
-    Or for a vectorized convolution:
-
-    >>> convolve = np.vectorize(np.convolve, signature='(n),(m)->(k)')
-    >>> convolve(np.eye(4), [1, 2, 1])
-    array([[1., 2., 1., 0., 0., 0.],
-           [0., 1., 2., 1., 0., 0.],
-           [0., 0., 1., 2., 1., 0.],
-           [0., 0., 0., 1., 2., 1.]])
-
-    " :arglists '[[self pyfunc & [{otypes :otypes, doc :doc, excluded :excluded, cache :cache, signature :signature}]] [self pyfunc & [{otypes :otypes, doc :doc, excluded :excluded, cache :cache}]] [self pyfunc & [{otypes :otypes, doc :doc, excluded :excluded}]] [self pyfunc & [{otypes :otypes, doc :doc}]] [self pyfunc & [{otypes :otypes}]] [self pyfunc]])
-
-(def radians (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "radians"))))
-(alter-meta! #'radians assoc :doc "radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Convert angles from degrees to radians.
-
-Parameters
-----------
-x : array_like
-    Input array in degrees.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The corresponding radian values.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-deg2rad : equivalent function
-
-Examples
---------
-Convert a degree array to radians
-
->>> deg = np.arange(12.) * 30.
->>> np.radians(deg)
-array([ 0.        ,  0.52359878,  1.04719755,  1.57079633,  2.0943951 ,
-        2.61799388,  3.14159265,  3.66519143,  4.1887902 ,  4.71238898,
-        5.23598776,  5.75958653])
-
->>> out = np.zeros((deg.shape))
->>> ret = np.radians(deg, out)
->>> ret is out
-True" :arglists '[[self & [args {:as kwargs}]]])
-
-(def histogram (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogram"))))
-(alter-meta! #'histogram assoc :doc "
-    Compute the histogram of a set of data.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data. The histogram is computed over the flattened array.
-    bins : int or sequence of scalars or str, optional
-        If `bins` is an int, it defines the number of equal-width
-        bins in the given range (10, by default). If `bins` is a
-        sequence, it defines a monotonically increasing array of bin edges,
-        including the rightmost edge, allowing for non-uniform bin widths.
-
-        .. versionadded:: 1.11.0
-
-        If `bins` is a string, it defines the method used to calculate the
-        optimal bin width, as defined by `histogram_bin_edges`.
-
-    range : (float, float), optional
-        The lower and upper range of the bins.  If not provided, range
-        is simply ``(a.min(), a.max())``.  Values outside the range are
-        ignored. The first element of the range must be less than or
-        equal to the second. `range` affects the automatic bin
-        computation as well. While bin width is computed to be optimal
-        based on the actual data within `range`, the bin count will fill
-        the entire range including portions containing no data.
-    normed : bool, optional
-
-        .. deprecated:: 1.6.0
-
-        This is equivalent to the `density` argument, but produces incorrect
-        results for unequal bin widths. It should not be used.
-
-        .. versionchanged:: 1.15.0
-            DeprecationWarnings are actually emitted.
-
-    weights : array_like, optional
-        An array of weights, of the same shape as `a`.  Each value in
-        `a` only contributes its associated weight towards the bin count
-        (instead of 1). If `density` is True, the weights are
-        normalized, so that the integral of the density over the range
-        remains 1.
-    density : bool, optional
-        If ``False``, the result will contain the number of samples in
-        each bin. If ``True``, the result is the value of the
-        probability *density* function at the bin, normalized such that
-        the *integral* over the range is 1. Note that the sum of the
-        histogram values will not be equal to 1 unless bins of unity
-        width are chosen; it is not a probability *mass* function.
-
-        Overrides the ``normed`` keyword if given.
-
-    Returns
-    -------
-    hist : array
-        The values of the histogram. See `density` and `weights` for a
-        description of the possible semantics.
-    bin_edges : array of dtype float
-        Return the bin edges ``(length(hist)+1)``.
-
-
-    See Also
-    --------
-    histogramdd, bincount, searchsorted, digitize, histogram_bin_edges
-
-    Notes
-    -----
-    All but the last (righthand-most) bin is half-open.  In other words,
-    if `bins` is::
-
-      [1, 2, 3, 4]
-
-    then the first bin is ``[1, 2)`` (including 1, but excluding 2) and
-    the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which
-    *includes* 4.
-
-
-    Examples
-    --------
-    >>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3])
-    (array([0, 2, 1]), array([0, 1, 2, 3]))
-    >>> np.histogram(np.arange(4), bins=np.arange(5), density=True)
-    (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4]))
-    >>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3])
-    (array([1, 4, 1]), array([0, 1, 2, 3]))
-
-    >>> a = np.arange(5)
-    >>> hist, bin_edges = np.histogram(a, density=True)
-    >>> hist
-    array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5])
-    >>> hist.sum()
-    2.4999999999999996
-    >>> np.sum(hist * np.diff(bin_edges))
-    1.0
-
-    .. versionadded:: 1.11.0
-
-    Automated Bin Selection Methods example, using 2 peak random data
-    with 2000 points:
-
-    >>> import matplotlib.pyplot as plt
-    >>> rng = np.random.RandomState(10)  # deterministic random data
-    >>> a = np.hstack((rng.normal(size=1000),
-    ...                rng.normal(loc=5, scale=2, size=1000)))
-    >>> _ = plt.hist(a, bins='auto')  # arguments are passed to np.histogram
-    >>> plt.title(\"Histogram with 'auto' bins\")
-    Text(0.5, 1.0, \"Histogram with 'auto' bins\")
-    >>> plt.show()
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} UFUNC_PYVALS_NAME (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "UFUNC_PYVALS_NAME"))))
-
-(def isfortran (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isfortran"))))
-(alter-meta! #'isfortran assoc :doc "
-    Check if the array is Fortran contiguous but *not* C contiguous.
-
-    This function is obsolete and, because of changes due to relaxed stride
-    checking, its return value for the same array may differ for versions
-    of NumPy >= 1.10.0 and previous versions. If you only want to check if an
-    array is Fortran contiguous use ``a.flags.f_contiguous`` instead.
-
-    Parameters
-    ----------
-    a : ndarray
-        Input array.
-
-    Returns
-    -------
-    isfortran : bool
-        Returns True if the array is Fortran contiguous but *not* C contiguous.
-
-
-    Examples
-    --------
-
-    np.array allows to specify whether the array is written in C-contiguous
-    order (last index varies the fastest), or FORTRAN-contiguous order in
-    memory (first index varies the fastest).
-
-    >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
-    >>> a
-    array([[1, 2, 3],
-           [4, 5, 6]])
-    >>> np.isfortran(a)
-    False
-
-    >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F')
-    >>> b
-    array([[1, 2, 3],
-           [4, 5, 6]])
-    >>> np.isfortran(b)
-    True
-
-
-    The transpose of a C-ordered array is a FORTRAN-ordered array.
-
-    >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
-    >>> a
-    array([[1, 2, 3],
-           [4, 5, 6]])
-    >>> np.isfortran(a)
-    False
-    >>> b = a.T
-    >>> b
-    array([[1, 4],
-           [2, 5],
-           [3, 6]])
-    >>> np.isfortran(b)
-    True
-
-    C-ordered arrays evaluate as False even if they are also FORTRAN-ordered.
-
-    >>> np.isfortran(np.array([1, 2], order='F'))
-    False
-
-    " :arglists '[[a]])
-
-(def float16 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float16"))))
-(alter-meta! #'float16 assoc :doc "Half-precision floating-point number type.
-    Character code: ``'e'``.
-    Canonical name: ``np.half``.
-    Alias *on this platform*: ``np.float16``: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
-
-(def searchsorted (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "searchsorted"))))
-(alter-meta! #'searchsorted assoc :doc "
-    Find indices where elements should be inserted to maintain order.
-
-    Find the indices into a sorted array `a` such that, if the
-    corresponding elements in `v` were inserted before the indices, the
-    order of `a` would be preserved.
-
-    Assuming that `a` is sorted:
-
-    ======  ============================
-    `side`  returned index `i` satisfies
-    ======  ============================
-    left    ``a[i-1] < v <= a[i]``
-    right   ``a[i-1] <= v < a[i]``
-    ======  ============================
-
-    Parameters
-    ----------
-    a : 1-D array_like
-        Input array. If `sorter` is None, then it must be sorted in
-        ascending order, otherwise `sorter` must be an array of indices
-        that sort it.
-    v : array_like
-        Values to insert into `a`.
-    side : {'left', 'right'}, optional
-        If 'left', the index of the first suitable location found is given.
-        If 'right', return the last such index.  If there is no suitable
-        index, return either 0 or N (where N is the length of `a`).
-    sorter : 1-D array_like, optional
-        Optional array of integer indices that sort array a into ascending
-        order. They are typically the result of argsort.
-
-        .. versionadded:: 1.7.0
-
-    Returns
-    -------
-    indices : array of ints
-        Array of insertion points with the same shape as `v`.
-
-    See Also
-    --------
-    sort : Return a sorted copy of an array.
-    histogram : Produce histogram from 1-D data.
-
-    Notes
-    -----
-    Binary search is used to find the required insertion points.
-
-    As of NumPy 1.4.0 `searchsorted` works with real/complex arrays containing
-    `nan` values. The enhanced sort order is documented in `sort`.
-
-    This function uses the same algorithm as the builtin python `bisect.bisect_left`
-    (``side='left'``) and `bisect.bisect_right` (``side='right'``) functions,
-    which is also vectorized in the `v` argument.
-
-    Examples
-    --------
-    >>> np.searchsorted([1,2,3,4,5], 3)
-    2
-    >>> np.searchsorted([1,2,3,4,5], 3, side='right')
-    3
-    >>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
-    array([0, 5, 1, 2])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def fromiter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromiter"))))
-(alter-meta! #'fromiter assoc :doc "fromiter(iterable, dtype, count=-1)
-
-    Create a new 1-dimensional array from an iterable object.
-
-    Parameters
-    ----------
-    iterable : iterable object
-        An iterable object providing data for the array.
-    dtype : data-type
-        The data-type of the returned array.
-    count : int, optional
-        The number of items to read from *iterable*.  The default is -1,
-        which means all data is read.
-
-    Returns
-    -------
-    out : ndarray
-        The output array.
-
-    Notes
-    -----
-    Specify `count` to improve performance.  It allows ``fromiter`` to
-    pre-allocate the output array, instead of resizing it on demand.
-
-    Examples
-    --------
-    >>> iterable = (x*x for x in range(5))
-    >>> np.fromiter(iterable, float)
-    array([  0.,   1.,   4.,   9.,  16.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def character (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "character"))))
-(alter-meta! #'character assoc :doc "Abstract base class of all character string scalar types." :arglists '[[self & [args {:as kwargs}]]])
-
-(def uint64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint64"))))
-(alter-meta! #'uint64 assoc :doc "Unsigned integer type, compatible with C ``unsigned long``.
-    Character code: ``'L'``.
-    Canonical name: ``np.uint``.
-    Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615).
-    Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def full (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "full"))))
-(alter-meta! #'full assoc :doc "
-    Return a new array of given shape and type, filled with `fill_value`.
-
-    Parameters
-    ----------
-    shape : int or sequence of ints
-        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
-    fill_value : scalar
-        Fill value.
-    dtype : data-type, optional
-        The desired data-type for the array  The default, None, means
-         `np.array(fill_value).dtype`.
-    order : {'C', 'F'}, optional
-        Whether to store multidimensional data in C- or Fortran-contiguous
-        (row- or column-wise) order in memory.
-
-    Returns
-    -------
-    out : ndarray
-        Array of `fill_value` with the given shape, dtype, and order.
-
-    See Also
-    --------
-    full_like : Return a new array with shape of input filled with value.
-    empty : Return a new uninitialized array.
-    ones : Return a new array setting values to one.
-    zeros : Return a new array setting values to zero.
-
-    Examples
-    --------
-    >>> np.full((2, 2), np.inf)
-    array([[inf, inf],
-           [inf, inf]])
-    >>> np.full((2, 2), 10)
-    array([[10, 10],
-           [10, 10]])
-
-    " :arglists '[[shape fill_value & [{dtype :dtype, order :order}]] [shape fill_value & [{dtype :dtype}]] [shape fill_value]])
-
-(def extract (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "extract"))))
-(alter-meta! #'extract assoc :doc "
-    Return the elements of an array that satisfy some condition.
-
-    This is equivalent to ``np.compress(ravel(condition), ravel(arr))``.  If
-    `condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``.
-
-    Note that `place` does the exact opposite of `extract`.
-
-    Parameters
-    ----------
-    condition : array_like
-        An array whose nonzero or True entries indicate the elements of `arr`
-        to extract.
-    arr : array_like
-        Input array of the same size as `condition`.
-
-    Returns
-    -------
-    extract : ndarray
-        Rank 1 array of values from `arr` where `condition` is True.
-
-    See Also
-    --------
-    take, put, copyto, compress, place
-
-    Examples
-    --------
-    >>> arr = np.arange(12).reshape((3, 4))
-    >>> arr
-    array([[ 0,  1,  2,  3],
-           [ 4,  5,  6,  7],
-           [ 8,  9, 10, 11]])
-    >>> condition = np.mod(arr, 3)==0
-    >>> condition
-    array([[ True, False, False,  True],
-           [False, False,  True, False],
-           [False,  True, False, False]])
-    >>> np.extract(condition, arr)
-    array([0, 3, 6, 9])
-
-
-    If `condition` is boolean:
-
-    >>> arr[condition]
-    array([0, 3, 6, 9])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def unravel_index (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unravel_index"))))
-(alter-meta! #'unravel_index assoc :doc "
-    unravel_index(indices, shape, order='C')
-
-    Converts a flat index or array of flat indices into a tuple
-    of coordinate arrays.
-
-    Parameters
-    ----------
-    indices : array_like
-        An integer array whose elements are indices into the flattened
-        version of an array of dimensions ``shape``. Before version 1.6.0,
-        this function accepted just one index value.
-    shape : tuple of ints
-        The shape of the array to use for unraveling ``indices``.
-
-        .. versionchanged:: 1.16.0
-            Renamed from ``dims`` to ``shape``.
-
-    order : {'C', 'F'}, optional
-        Determines whether the indices should be viewed as indexing in
-        row-major (C-style) or column-major (Fortran-style) order.
-
-        .. versionadded:: 1.6.0
-
-    Returns
-    -------
-    unraveled_coords : tuple of ndarray
-        Each array in the tuple has the same shape as the ``indices``
-        array.
-
-    See Also
-    --------
-    ravel_multi_index
-
-    Examples
-    --------
-    >>> np.unravel_index([22, 41, 37], (7,6))
-    (array([3, 6, 6]), array([4, 5, 1]))
-    >>> np.unravel_index([31, 41, 13], (7,6), order='F')
-    (array([3, 6, 6]), array([4, 5, 1]))
-
-    >>> np.unravel_index(1621, (6,7,8,9))
-    (3, 1, 4, 1)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def bool (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bool"))))
-(alter-meta! #'bool assoc :doc "bool(x) -> bool
-
-Returns True when the argument x is true, False otherwise.
-The builtins True and False are the only two instances of the class bool.
-The class bool is a subclass of the class int, and cannot be subclassed." :arglists '[[self & [args {:as kwargs}]]])
-
-(def blackman (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "blackman"))))
-(alter-meta! #'blackman assoc :doc "
-    Return the Blackman window.
-
-    The Blackman window is a taper formed by using the first three
-    terms of a summation of cosines. It was designed to have close to the
-    minimal leakage possible.  It is close to optimal, only slightly worse
-    than a Kaiser window.
-
-    Parameters
-    ----------
-    M : int
-        Number of points in the output window. If zero or less, an empty
-        array is returned.
-
-    Returns
-    -------
-    out : ndarray
-        The window, with the maximum value normalized to one (the value one
-        appears only if the number of samples is odd).
-
-    See Also
-    --------
-    bartlett, hamming, hanning, kaiser
-
-    Notes
-    -----
-    The Blackman window is defined as
-
-    .. math::  w(n) = 0.42 - 0.5 \\cos(2\\pi n/M) + 0.08 \\cos(4\\pi n/M)
-
-    Most references to the Blackman window come from the signal processing
-    literature, where it is used as one of many windowing functions for
-    smoothing values.  It is also known as an apodization (which means
-    \"removing the foot\", i.e. smoothing discontinuities at the beginning
-    and end of the sampled signal) or tapering function. It is known as a
-    \"near optimal\" tapering function, almost as good (by some measures)
-    as the kaiser window.
-
-    References
-    ----------
-    Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra,
-    Dover Publications, New York.
-
-    Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing.
-    Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471.
-
-    Examples
-    --------
-    >>> import matplotlib.pyplot as plt
-    >>> np.blackman(12)
-    array([-1.38777878e-17,   3.26064346e-02,   1.59903635e-01, # may vary
-            4.14397981e-01,   7.36045180e-01,   9.67046769e-01,
-            9.67046769e-01,   7.36045180e-01,   4.14397981e-01,
-            1.59903635e-01,   3.26064346e-02,  -1.38777878e-17])
-
-    Plot the window and the frequency response:
-
-    >>> from numpy.fft import fft, fftshift
-    >>> window = np.blackman(51)
-    >>> plt.plot(window)
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.title(\"Blackman window\")
-    Text(0.5, 1.0, 'Blackman window')
-    >>> plt.ylabel(\"Amplitude\")
-    Text(0, 0.5, 'Amplitude')
-    >>> plt.xlabel(\"Sample\")
-    Text(0.5, 0, 'Sample')
-    >>> plt.show()
-
-    >>> plt.figure()
-    <Figure size 640x480 with 0 Axes>
-    >>> A = fft(window, 2048) / 25.5
-    >>> mag = np.abs(fftshift(A))
-    >>> freq = np.linspace(-0.5, 0.5, len(A))
-    >>> with np.errstate(divide='ignore', invalid='ignore'):
-    ...     response = 20 * np.log10(mag)
-    ...
-    >>> response = np.clip(response, -100, 100)
-    >>> plt.plot(freq, response)
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.title(\"Frequency response of Blackman window\")
-    Text(0.5, 1.0, 'Frequency response of Blackman window')
-    >>> plt.ylabel(\"Magnitude [dB]\")
-    Text(0, 0.5, 'Magnitude [dB]')
-    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
-    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
-    >>> _ = plt.axis('tight')
-    >>> plt.show()
-
-    " :arglists '[[M]])
-
-(def ^{:doc "
-This module contains a set of functions for vectorized string
-operations and methods.
-
-.. note::
-   The `chararray` class exists for backwards compatibility with
-   Numarray, it is not recommended for new development. Starting from numpy
-   1.4, if one needs arrays of strings, it is recommended to use arrays of
-   `dtype` `object_`, `string_` or `unicode_`, and use the free functions
-   in the `numpy.char` module for fast vectorized string operations.
-
-Some methods will only be available if the corresponding string method is
-available in your version of Python.
-
-The preferred alias for `defchararray` is `numpy.char`.
-
-"} char (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "char"))))
-
-(def tile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tile"))))
-(alter-meta! #'tile assoc :doc "
-    Construct an array by repeating A the number of times given by reps.
-
-    If `reps` has length ``d``, the result will have dimension of
-    ``max(d, A.ndim)``.
-
-    If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new
-    axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication,
-    or shape (1, 1, 3) for 3-D replication. If this is not the desired
-    behavior, promote `A` to d-dimensions manually before calling this
-    function.
-
-    If ``A.ndim > d``, `reps` is promoted to `A`.ndim by pre-pending 1's to it.
-    Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as
-    (1, 1, 2, 2).
-
-    Note : Although tile may be used for broadcasting, it is strongly
-    recommended to use numpy's broadcasting operations and functions.
-
-    Parameters
-    ----------
-    A : array_like
-        The input array.
-    reps : array_like
-        The number of repetitions of `A` along each axis.
-
-    Returns
-    -------
-    c : ndarray
-        The tiled output array.
-
-    See Also
-    --------
-    repeat : Repeat elements of an array.
-    broadcast_to : Broadcast an array to a new shape
-
-    Examples
-    --------
-    >>> a = np.array([0, 1, 2])
-    >>> np.tile(a, 2)
-    array([0, 1, 2, 0, 1, 2])
-    >>> np.tile(a, (2, 2))
-    array([[0, 1, 2, 0, 1, 2],
-           [0, 1, 2, 0, 1, 2]])
-    >>> np.tile(a, (2, 1, 2))
-    array([[[0, 1, 2, 0, 1, 2]],
-           [[0, 1, 2, 0, 1, 2]]])
-
-    >>> b = np.array([[1, 2], [3, 4]])
-    >>> np.tile(b, 2)
-    array([[1, 2, 1, 2],
-           [3, 4, 3, 4]])
-    >>> np.tile(b, (2, 1))
-    array([[1, 2],
-           [3, 4],
-           [1, 2],
-           [3, 4]])
-
-    >>> c = np.array([1,2,3,4])
-    >>> np.tile(c,(4,1))
-    array([[1, 2, 3, 4],
-           [1, 2, 3, 4],
-           [1, 2, 3, 4],
-           [1, 2, 3, 4]])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def broadcast (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "broadcast"))))
-(alter-meta! #'broadcast assoc :doc "Produce an object that mimics broadcasting.
-
-    Parameters
-    ----------
-    in1, in2, ... : array_like
-        Input parameters.
-
-    Returns
-    -------
-    b : broadcast object
-        Broadcast the input parameters against one another, and
-        return an object that encapsulates the result.
-        Amongst others, it has ``shape`` and ``nd`` properties, and
-        may be used as an iterator.
-
-    See Also
-    --------
-    broadcast_arrays
-    broadcast_to
-
-    Examples
-    --------
-
-    Manually adding two vectors, using broadcasting:
-
-    >>> x = np.array([[1], [2], [3]])
-    >>> y = np.array([4, 5, 6])
-    >>> b = np.broadcast(x, y)
-
-    >>> out = np.empty(b.shape)
-    >>> out.flat = [u+v for (u,v) in b]
-    >>> out
-    array([[5.,  6.,  7.],
-           [6.,  7.,  8.],
-           [7.,  8.,  9.]])
-
-    Compare against built-in broadcasting:
-
-    >>> x + y
-    array([[5, 6, 7],
-           [6, 7, 8],
-           [7, 8, 9]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def half (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "half"))))
-(alter-meta! #'half assoc :doc "Half-precision floating-point number type.
-    Character code: ``'e'``.
-    Canonical name: ``np.half``.
-    Alias *on this platform*: ``np.float16``: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
-
-(def setdiff1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "setdiff1d"))))
-(alter-meta! #'setdiff1d assoc :doc "
-    Find the set difference of two arrays.
-
-    Return the unique values in `ar1` that are not in `ar2`.
-
-    Parameters
-    ----------
-    ar1 : array_like
-        Input array.
-    ar2 : array_like
-        Input comparison array.
-    assume_unique : bool
-        If True, the input arrays are both assumed to be unique, which
-        can speed up the calculation.  Default is False.
-
-    Returns
-    -------
-    setdiff1d : ndarray
-        1D array of values in `ar1` that are not in `ar2`. The result
-        is sorted when `assume_unique=False`, but otherwise only sorted
-        if the input is sorted.
-
-    See Also
-    --------
-    numpy.lib.arraysetops : Module with a number of other functions for
-                            performing set operations on arrays.
-
-    Examples
-    --------
-    >>> a = np.array([1, 2, 3, 2, 4, 1])
-    >>> b = np.array([3, 4, 5, 6])
-    >>> np.setdiff1d(a, b)
-    array([1, 2])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def npv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "npv"))))
-(alter-meta! #'npv assoc :doc "
-    Returns the NPV (Net Present Value) of a cash flow series.
-
-    .. deprecated:: 1.18
-
-       `npv` is deprecated; for details, see NEP 32 [1]_.
-       Use the corresponding function in the numpy-financial library,
-       https://pypi.org/project/numpy-financial.
-
-    Parameters
-    ----------
-    rate : scalar
-        The discount rate.
-    values : array_like, shape(M, )
-        The values of the time series of cash flows.  The (fixed) time
-        interval between cash flow \"events\" must be the same as that for
-        which `rate` is given (i.e., if `rate` is per year, then precisely
-        a year is understood to elapse between each cash flow event).  By
-        convention, investments or \"deposits\" are negative, income or
-        \"withdrawals\" are positive; `values` must begin with the initial
-        investment, thus `values[0]` will typically be negative.
-
-    Returns
-    -------
-    out : float
-        The NPV of the input cash flow series `values` at the discount
-        `rate`.
-
-    Warnings
-    --------
-    ``npv`` considers a series of cashflows starting in the present (t = 0).
-    NPV can also be defined with a series of future cashflows, paid at the
-    end, rather than the start, of each period. If future cashflows are used,
-    the first cashflow `values[0]` must be zeroed and added to the net
-    present value of the future cashflows. This is demonstrated in the
-    examples.
-
-    Notes
-    -----
-    Returns the result of: [2]_
-
-    .. math :: \\sum_{t=0}^{M-1}{\\frac{values_t}{(1+rate)^{t}}}
-
-    References
-    ----------
-    .. [1] NumPy Enhancement Proposal (NEP) 32,
-       https://numpy.org/neps/nep-0032-remove-financial-functions.html
-    .. [2] L. J. Gitman, \"Principles of Managerial Finance, Brief,\" 3rd ed.,
-       Addison-Wesley, 2003, pg. 346.
-
-    Examples
-    --------
-    Consider a potential project with an initial investment of $40 000 and
-    projected cashflows of $5 000, $8 000, $12 000 and $30 000 at the end of
-    each period discounted at a rate of 8% per period. To find the project's
-    net present value:
-
-    >>> rate, cashflows = 0.08, [-40_000, 5_000, 8_000, 12_000, 30_000]
-    >>> np.npv(rate, cashflows).round(5)
-    3065.22267
-
-    It may be preferable to split the projected cashflow into an initial
-    investment and expected future cashflows. In this case, the value of
-    the initial cashflow is zero and the initial investment is later added
-    to the future cashflows net present value:
-
-    >>> initial_cashflow = cashflows[0]
-    >>> cashflows[0] = 0
-    >>> np.round(np.npv(rate, cashflows) + initial_cashflow, 5)
-    3065.22267
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def remainder (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "remainder"))))
-(alter-meta! #'remainder assoc :doc "remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return element-wise remainder of division.
-
-Computes the remainder complementary to the `floor_divide` function.  It is
-equivalent to the Python modulus operator``x1 % x2`` and has the same sign
-as the divisor `x2`. The MATLAB function equivalent to ``np.remainder``
-is ``mod``.
-
-.. warning::
-
-    This should not be confused with:
-
-    * Python 3.7's `math.remainder` and C's ``remainder``, which
-      computes the IEEE remainder, which are the complement to
-      ``round(x1 / x2)``.
-    * The MATLAB ``rem`` function and or the C ``%`` operator which is the
-      complement to ``int(x1 / x2)``.
-
-Parameters
-----------
-x1 : array_like
-    Dividend array.
-x2 : array_like
-    Divisor array. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-floor_divide : Equivalent of Python ``//`` operator.
-divmod : Simultaneous floor division and remainder.
-fmod : Equivalent of the MATLAB ``rem`` function.
-divide, floor
-
-Notes
------
-Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
-integers.
-``mod`` is an alias of ``remainder``.
-
-Examples
---------
->>> np.remainder([4, 7], [2, 3])
-array([0, 1])
->>> np.remainder(np.arange(7), 5)
-array([0, 1, 2, 3, 4, 0, 1])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} ALLOW_THREADS (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ALLOW_THREADS"))))
-
-(def exp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "exp"))))
-(alter-meta! #'exp assoc :doc "exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Calculate the exponential of all elements in the input array.
-
-Parameters
-----------
-x : array_like
-    Input values.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Output array, element-wise exponential of `x`.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-expm1 : Calculate ``exp(x) - 1`` for all elements in the array.
-exp2  : Calculate ``2**x`` for all elements in the array.
-
-Notes
------
-The irrational number ``e`` is also known as Euler's number.  It is
-approximately 2.718281, and is the base of the natural logarithm,
-``ln`` (this means that, if :math:`x = \\ln y = \\log_e y`,
-then :math:`e^x = y`. For real input, ``exp(x)`` is always positive.
-
-For complex arguments, ``x = a + ib``, we can write
-:math:`e^x = e^a e^{ib}`.  The first term, :math:`e^a`, is already
-known (it is the real argument, described above).  The second term,
-:math:`e^{ib}`, is :math:`\\cos b + i \\sin b`, a function with
-magnitude 1 and a periodic phase.
-
-References
-----------
-.. [1] Wikipedia, \"Exponential function\",
-       https://en.wikipedia.org/wiki/Exponential_function
-.. [2] M. Abramovitz and I. A. Stegun, \"Handbook of Mathematical Functions
-       with Formulas, Graphs, and Mathematical Tables,\" Dover, 1964, p. 69,
-       http://www.math.sfu.ca/~cbm/aands/page_69.htm
-
-Examples
---------
-Plot the magnitude and phase of ``exp(x)`` in the complex plane:
-
->>> import matplotlib.pyplot as plt
-
->>> x = np.linspace(-2*np.pi, 2*np.pi, 100)
->>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane
->>> out = np.exp(xx)
-
->>> plt.subplot(121)
->>> plt.imshow(np.abs(out),
-...            extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray')
->>> plt.title('Magnitude of exp(x)')
-
->>> plt.subplot(122)
->>> plt.imshow(np.angle(out),
-...            extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv')
->>> plt.title('Phase (angle) of exp(x)')
->>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
-
-(def outer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "outer"))))
-(alter-meta! #'outer assoc :doc "
-    Compute the outer product of two vectors.
-
-    Given two vectors, ``a = [a0, a1, ..., aM]`` and
-    ``b = [b0, b1, ..., bN]``,
-    the outer product [1]_ is::
-
-      [[a0*b0  a0*b1 ... a0*bN ]
-       [a1*b0    .
-       [ ...          .
-       [aM*b0            aM*bN ]]
-
-    Parameters
-    ----------
-    a : (M,) array_like
-        First input vector.  Input is flattened if
-        not already 1-dimensional.
-    b : (N,) array_like
-        Second input vector.  Input is flattened if
-        not already 1-dimensional.
-    out : (M, N) ndarray, optional
-        A location where the result is stored
-
-        .. versionadded:: 1.9.0
-
-    Returns
-    -------
-    out : (M, N) ndarray
-        ``out[i, j] = a[i] * b[j]``
-
-    See also
-    --------
-    inner
-    einsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent.
-    ufunc.outer : A generalization to N dimensions and other operations.
-                  ``np.multiply.outer(a.ravel(), b.ravel())`` is the equivalent.
-
-    References
-    ----------
-    .. [1] : G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd
-             ed., Baltimore, MD, Johns Hopkins University Press, 1996,
-             pg. 8.
-
-    Examples
-    --------
-    Make a (*very* coarse) grid for computing a Mandelbrot set:
-
-    >>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))
-    >>> rl
-    array([[-2., -1.,  0.,  1.,  2.],
-           [-2., -1.,  0.,  1.,  2.],
-           [-2., -1.,  0.,  1.,  2.],
-           [-2., -1.,  0.,  1.,  2.],
-           [-2., -1.,  0.,  1.,  2.]])
-    >>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
-    >>> im
-    array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
-           [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
-           [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
-           [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
-           [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
-    >>> grid = rl + im
-    >>> grid
-    array([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
-           [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
-           [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
-           [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
-           [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]])
-
-    An example using a \"vector\" of letters:
-
-    >>> x = np.array(['a', 'b', 'c'], dtype=object)
-    >>> np.outer(x, [1, 2, 3])
-    array([['a', 'aa', 'aaa'],
-           ['b', 'bb', 'bbb'],
-           ['c', 'cc', 'ccc']], dtype=object)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def uint8 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint8"))))
-(alter-meta! #'uint8 assoc :doc "Unsigned integer type, compatible with C ``unsigned char``.
-    Character code: ``'B'``.
-    Canonical name: ``np.ubyte``.
-    Alias *on this platform*: ``np.uint8``: 8-bit unsigned integer (0 to 255)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def atleast_2d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "atleast_2d"))))
-(alter-meta! #'atleast_2d assoc :doc "
-    View inputs as arrays with at least two dimensions.
-
-    Parameters
-    ----------
-    arys1, arys2, ... : array_like
-        One or more array-like sequences.  Non-array inputs are converted
-        to arrays.  Arrays that already have two or more dimensions are
-        preserved.
-
-    Returns
-    -------
-    res, res2, ... : ndarray
-        An array, or list of arrays, each with ``a.ndim >= 2``.
-        Copies are avoided where possible, and views with two or more
-        dimensions are returned.
-
-    See Also
-    --------
-    atleast_1d, atleast_3d
-
-    Examples
-    --------
-    >>> np.atleast_2d(3.0)
-    array([[3.]])
-
-    >>> x = np.arange(3.0)
-    >>> np.atleast_2d(x)
-    array([[0., 1., 2.]])
-    >>> np.atleast_2d(x).base is x
-    True
-
-    >>> np.atleast_2d(1, [1, 2], [[1, 2]])
-    [array([[1]]), array([[1, 2]]), array([[1, 2]])]
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} SHIFT_DIVIDEBYZERO (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "SHIFT_DIVIDEBYZERO"))))
-
-(def lexsort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "lexsort"))))
-(alter-meta! #'lexsort assoc :doc "
-    lexsort(keys, axis=-1)
-
-    Perform an indirect stable sort using a sequence of keys.
-
-    Given multiple sorting keys, which can be interpreted as columns in a
-    spreadsheet, lexsort returns an array of integer indices that describes
-    the sort order by multiple columns. The last key in the sequence is used
-    for the primary sort order, the second-to-last key for the secondary sort
-    order, and so on. The keys argument must be a sequence of objects that
-    can be converted to arrays of the same shape. If a 2D array is provided
-    for the keys argument, it's rows are interpreted as the sorting keys and
-    sorting is according to the last row, second last row etc.
-
-    Parameters
-    ----------
-    keys : (k, N) array or tuple containing k (N,)-shaped sequences
-        The `k` different \"columns\" to be sorted.  The last column (or row if
-        `keys` is a 2D array) is the primary sort key.
-    axis : int, optional
-        Axis to be indirectly sorted.  By default, sort over the last axis.
-
-    Returns
-    -------
-    indices : (N,) ndarray of ints
-        Array of indices that sort the keys along the specified axis.
-
-    See Also
-    --------
-    argsort : Indirect sort.
-    ndarray.sort : In-place sort.
-    sort : Return a sorted copy of an array.
-
-    Examples
-    --------
-    Sort names: first by surname, then by name.
-
-    >>> surnames =    ('Hertz',    'Galilei', 'Hertz')
-    >>> first_names = ('Heinrich', 'Galileo', 'Gustav')
-    >>> ind = np.lexsort((first_names, surnames))
-    >>> ind
-    array([1, 2, 0])
-
-    >>> [surnames[i] + \", \" + first_names[i] for i in ind]
-    ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich']
-
-    Sort two columns of numbers:
-
-    >>> a = [1,5,1,4,3,4,4] # First column
-    >>> b = [9,4,0,4,0,2,1] # Second column
-    >>> ind = np.lexsort((b,a)) # Sort by a, then by b
-    >>> ind
-    array([2, 0, 4, 6, 5, 3, 1])
-
-    >>> [(a[i],b[i]) for i in ind]
-    [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]
-
-    Note that sorting is first according to the elements of ``a``.
-    Secondary sorting is according to the elements of ``b``.
-
-    A normal ``argsort`` would have yielded:
-
-    >>> [(a[i],b[i]) for i in np.argsort(a)]
-    [(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)]
-
-    Structured arrays are sorted lexically by ``argsort``:
-
-    >>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)],
-    ...              dtype=np.dtype([('x', int), ('y', int)]))
-
-    >>> np.argsort(x) # or np.argsort(x, order=('x', 'y'))
-    array([2, 0, 4, 6, 5, 3, 1])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def subtract (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "subtract"))))
-(alter-meta! #'subtract assoc :doc "subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Subtract arguments, element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    The arrays to be subtracted from each other. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The difference of `x1` and `x2`, element-wise.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-Notes
------
-Equivalent to ``x1 - x2`` in terms of array broadcasting.
-
-Examples
---------
->>> np.subtract(1.0, 4.0)
--3.0
-
->>> x1 = np.arange(9.0).reshape((3, 3))
->>> x2 = np.arange(3.0)
->>> np.subtract(x1, x2)
-array([[ 0.,  0.,  0.],
-       [ 3.,  3.,  3.],
-       [ 6.,  6.,  6.]])" :arglists '[[self & [args {:as kwargs}]]])
-(def ^{:doc "dict() -> new empty dictionary
-dict(mapping) -> new dictionary initialized from a mapping object's
-    (key, value) pairs
-dict(iterable) -> new dictionary initialized as if via:
-    d = {}
-    for k, v in iterable:
-        d[k] = v
-dict(**kwargs) -> new dictionary initialized with the name=value pairs
-    in the keyword argument list.  For example:  dict(one=1, two=2)"} sctypeDict (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "sctypeDict")))) 
-
-(def ^{:doc ""} FPE_OVERFLOW (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "FPE_OVERFLOW"))))
-
-(def isreal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isreal"))))
-(alter-meta! #'isreal assoc :doc "
-    Returns a bool array, where True if input element is real.
-
-    If element has complex type with zero complex part, the return value
-    for that element is True.
-
-    Parameters
-    ----------
-    x : array_like
-        Input array.
-
-    Returns
-    -------
-    out : ndarray, bool
-        Boolean array of same shape as `x`.
-
-    See Also
-    --------
-    iscomplex
-    isrealobj : Return True if x is not a complex type.
-
-    Examples
-    --------
-    >>> np.isreal([1+1j, 1+0j, 4.5, 3, 2, 2j])
-    array([False,  True,  True,  True,  True, False])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def asscalar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asscalar"))))
-(alter-meta! #'asscalar assoc :doc "
-    Convert an array of size 1 to its scalar equivalent.
-
-    .. deprecated:: 1.16
-
-        Deprecated, use `numpy.ndarray.item()` instead.
-
-    Parameters
-    ----------
-    a : ndarray
-        Input array of size 1.
-
-    Returns
-    -------
-    out : scalar
-        Scalar representation of `a`. The output data type is the same type
-        returned by the input's `item` method.
-
-    Examples
-    --------
-    >>> np.asscalar(np.array([24]))
-    24
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def select (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "select"))))
-(alter-meta! #'select assoc :doc "
-    Return an array drawn from elements in choicelist, depending on conditions.
-
-    Parameters
-    ----------
-    condlist : list of bool ndarrays
-        The list of conditions which determine from which array in `choicelist`
-        the output elements are taken. When multiple conditions are satisfied,
-        the first one encountered in `condlist` is used.
-    choicelist : list of ndarrays
-        The list of arrays from which the output elements are taken. It has
-        to be of the same length as `condlist`.
-    default : scalar, optional
-        The element inserted in `output` when all conditions evaluate to False.
-
-    Returns
-    -------
-    output : ndarray
-        The output at position m is the m-th element of the array in
-        `choicelist` where the m-th element of the corresponding array in
-        `condlist` is True.
-
-    See Also
-    --------
-    where : Return elements from one of two arrays depending on condition.
-    take, choose, compress, diag, diagonal
-
-    Examples
-    --------
-    >>> x = np.arange(10)
-    >>> condlist = [x<3, x>5]
-    >>> choicelist = [x, x**2]
-    >>> np.select(condlist, choicelist)
-    array([ 0,  1,  2, ..., 49, 64, 81])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def identity (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "identity"))))
-(alter-meta! #'identity assoc :doc "
-    Return the identity array.
-
-    The identity array is a square array with ones on
-    the main diagonal.
-
-    Parameters
-    ----------
-    n : int
-        Number of rows (and columns) in `n` x `n` output.
-    dtype : data-type, optional
-        Data-type of the output.  Defaults to ``float``.
-
-    Returns
-    -------
-    out : ndarray
-        `n` x `n` array with its main diagonal set to one,
-        and all other elements 0.
-
-    Examples
-    --------
-    >>> np.identity(3)
-    array([[1.,  0.,  0.],
-           [0.,  1.,  0.],
-           [0.,  0.,  1.]])
-
-    " :arglists '[[n & [{dtype :dtype}]] [n]])
-
-(def geterr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geterr"))))
-(alter-meta! #'geterr assoc :doc "
-    Get the current way of handling floating-point errors.
-
-    Returns
-    -------
-    res : dict
-        A dictionary with keys \"divide\", \"over\", \"under\", and \"invalid\",
-        whose values are from the strings \"ignore\", \"print\", \"log\", \"warn\",
-        \"raise\", and \"call\". The keys represent possible floating-point
-        exceptions, and the values define how these exceptions are handled.
-
-    See Also
-    --------
-    geterrcall, seterr, seterrcall
-
-    Notes
-    -----
-    For complete documentation of the types of floating-point exceptions and
-    treatment options, see `seterr`.
-
-    Examples
-    --------
-    >>> from collections import OrderedDict
-    >>> sorted(np.geterr().items())
-    [('divide', 'warn'), ('invalid', 'warn'), ('over', 'warn'), ('under', 'ignore')]
-    >>> np.arange(3.) / np.arange(3.)
-    array([nan,  1.,  1.])
-
-    >>> oldsettings = np.seterr(all='warn', over='raise')
-    >>> OrderedDict(sorted(np.geterr().items()))
-    OrderedDict([('divide', 'warn'), ('invalid', 'warn'), ('over', 'raise'), ('under', 'warn')])
-    >>> np.arange(3.) / np.arange(3.)
-    array([nan,  1.,  1.])
-
-    " :arglists '[[]])
-
-(def eye (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "eye"))))
-(alter-meta! #'eye assoc :doc "
-    Return a 2-D array with ones on the diagonal and zeros elsewhere.
-
-    Parameters
-    ----------
-    N : int
-      Number of rows in the output.
-    M : int, optional
-      Number of columns in the output. If None, defaults to `N`.
-    k : int, optional
-      Index of the diagonal: 0 (the default) refers to the main diagonal,
-      a positive value refers to an upper diagonal, and a negative value
-      to a lower diagonal.
-    dtype : data-type, optional
-      Data-type of the returned array.
-    order : {'C', 'F'}, optional
-        Whether the output should be stored in row-major (C-style) or
-        column-major (Fortran-style) order in memory.
-
-        .. versionadded:: 1.14.0
-
-    Returns
-    -------
-    I : ndarray of shape (N,M)
-      An array where all elements are equal to zero, except for the `k`-th
-      diagonal, whose values are equal to one.
-
-    See Also
-    --------
-    identity : (almost) equivalent function
-    diag : diagonal 2-D array from a 1-D array specified by the user.
-
-    Examples
-    --------
-    >>> np.eye(2, dtype=int)
-    array([[1, 0],
-           [0, 1]])
-    >>> np.eye(3, k=1)
-    array([[0.,  1.,  0.],
-           [0.,  0.,  1.],
-           [0.,  0.,  0.]])
-
-    " :arglists '[[N & [{M :M, k :k, dtype :dtype, order :order}]] [N & [{M :M, k :k, dtype :dtype}]] [N & [{M :M, k :k}]] [N & [{M :M}]] [N]])
-
-(def heaviside (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "heaviside"))))
-(alter-meta! #'heaviside assoc :doc "heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute the Heaviside step function.
-
-The Heaviside step function is defined as::
-
-                          0   if x1 < 0
-    heaviside(x1, x2) =  x2   if x1 == 0
-                          1   if x1 > 0
-
-where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used.
-
-Parameters
-----------
-x1 : array_like
-    Input values.
-x2 : array_like
-    The value of the function when x1 is 0. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    The output array, element-wise Heaviside step function of `x1`.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-Notes
------
-.. versionadded:: 1.13.0
-
-References
-----------
-.. Wikipedia, \"Heaviside step function\",
-   https://en.wikipedia.org/wiki/Heaviside_step_function
-
-Examples
---------
->>> np.heaviside([-1.5, 0, 2.0], 0.5)
-array([ 0. ,  0.5,  1. ])
->>> np.heaviside([-1.5, 0, 2.0], 1)
-array([ 0.,  1.,  1.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def busday_offset (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "busday_offset"))))
-(alter-meta! #'busday_offset assoc :doc "
-    busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)
-
-    First adjusts the date to fall on a valid day according to
-    the ``roll`` rule, then applies offsets to the given dates
-    counted in valid days.
-
-    .. versionadded:: 1.7.0
-
-    Parameters
-    ----------
-    dates : array_like of datetime64[D]
-        The array of dates to process.
-    offsets : array_like of int
-        The array of offsets, which is broadcast with ``dates``.
-    roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'}, optional
-        How to treat dates that do not fall on a valid day. The default
-        is 'raise'.
-
-          * 'raise' means to raise an exception for an invalid day.
-          * 'nat' means to return a NaT (not-a-time) for an invalid day.
-          * 'forward' and 'following' mean to take the first valid day
-            later in time.
-          * 'backward' and 'preceding' mean to take the first valid day
-            earlier in time.
-          * 'modifiedfollowing' means to take the first valid day
-            later in time unless it is across a Month boundary, in which
-            case to take the first valid day earlier in time.
-          * 'modifiedpreceding' means to take the first valid day
-            earlier in time unless it is across a Month boundary, in which
-            case to take the first valid day later in time.
-    weekmask : str or array_like of bool, optional
-        A seven-element array indicating which of Monday through Sunday are
-        valid days. May be specified as a length-seven list or array, like
-        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
-        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
-        weekdays, optionally separated by white space. Valid abbreviations
-        are: Mon Tue Wed Thu Fri Sat Sun
-    holidays : array_like of datetime64[D], optional
-        An array of dates to consider as invalid dates.  They may be
-        specified in any order, and NaT (not-a-time) dates are ignored.
-        This list is saved in a normalized form that is suited for
-        fast calculations of valid days.
-    busdaycal : busdaycalendar, optional
-        A `busdaycalendar` object which specifies the valid days. If this
-        parameter is provided, neither weekmask nor holidays may be
-        provided.
-    out : array of datetime64[D], optional
-        If provided, this array is filled with the result.
-
-    Returns
-    -------
-    out : array of datetime64[D]
-        An array with a shape from broadcasting ``dates`` and ``offsets``
-        together, containing the dates with offsets applied.
-
-    See Also
-    --------
-    busdaycalendar: An object that specifies a custom set of valid days.
-    is_busday : Returns a boolean array indicating valid days.
-    busday_count : Counts how many valid days are in a half-open date range.
-
-    Examples
-    --------
-    >>> # First business day in October 2011 (not accounting for holidays)
-    ... np.busday_offset('2011-10', 0, roll='forward')
-    numpy.datetime64('2011-10-03')
-    >>> # Last business day in February 2012 (not accounting for holidays)
-    ... np.busday_offset('2012-03', -1, roll='forward')
-    numpy.datetime64('2012-02-29')
-    >>> # Third Wednesday in January 2011
-    ... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed')
-    numpy.datetime64('2011-01-19')
-    >>> # 2012 Mother's Day in Canada and the U.S.
-    ... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun')
-    numpy.datetime64('2012-05-13')
-
-    >>> # First business day on or after a date
-    ... np.busday_offset('2011-03-20', 0, roll='forward')
-    numpy.datetime64('2011-03-21')
-    >>> np.busday_offset('2011-03-22', 0, roll='forward')
-    numpy.datetime64('2011-03-22')
-    >>> # First business day after a date
-    ... np.busday_offset('2011-03-20', 1, roll='backward')
-    numpy.datetime64('2011-03-21')
-    >>> np.busday_offset('2011-03-22', 1, roll='backward')
-    numpy.datetime64('2011-03-23')
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def greater_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "greater_equal"))))
-(alter-meta! #'greater_equal assoc :doc "greater_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the truth value of (x1 >= x2) element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : bool or ndarray of bool
-    Output array, element-wise comparison of `x1` and `x2`.
-    Typically of type bool, unless ``dtype=object`` is passed.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-greater, less, less_equal, equal, not_equal
-
-Examples
---------
->>> np.greater_equal([4, 2, 1], [2, 2, 2])
-array([ True, True, False])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} ERR_IGNORE (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_IGNORE"))))
-
-(def ulonglong (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ulonglong"))))
-(alter-meta! #'ulonglong assoc :doc "Signed integer type, compatible with C ``unsigned long long``.
-    Character code: ``'Q'``." :arglists '[[self & [args {:as kwargs}]]])
-(def ^{:doc "dict() -> new empty dictionary
-dict(mapping) -> new dictionary initialized from a mapping object's
-    (key, value) pairs
-dict(iterable) -> new dictionary initialized as if via:
-    d = {}
-    for k, v in iterable:
-        d[k] = v
-dict(**kwargs) -> new dictionary initialized with the name=value pairs
-    in the keyword argument list.  For example:  dict(one=1, two=2)"} typeDict (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "typeDict")))) 
-
-(def split (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "split"))))
-(alter-meta! #'split assoc :doc "
-    Split an array into multiple sub-arrays as views into `ary`.
-
-    Parameters
-    ----------
-    ary : ndarray
-        Array to be divided into sub-arrays.
-    indices_or_sections : int or 1-D array
-        If `indices_or_sections` is an integer, N, the array will be divided
-        into N equal arrays along `axis`.  If such a split is not possible,
-        an error is raised.
-
-        If `indices_or_sections` is a 1-D array of sorted integers, the entries
-        indicate where along `axis` the array is split.  For example,
-        ``[2, 3]`` would, for ``axis=0``, result in
-
-          - ary[:2]
-          - ary[2:3]
-          - ary[3:]
-
-        If an index exceeds the dimension of the array along `axis`,
-        an empty sub-array is returned correspondingly.
-    axis : int, optional
-        The axis along which to split, default is 0.
-
-    Returns
-    -------
-    sub-arrays : list of ndarrays
-        A list of sub-arrays as views into `ary`.
-
-    Raises
-    ------
-    ValueError
-        If `indices_or_sections` is given as an integer, but
-        a split does not result in equal division.
-
-    See Also
-    --------
-    array_split : Split an array into multiple sub-arrays of equal or
-                  near-equal size.  Does not raise an exception if
-                  an equal division cannot be made.
-    hsplit : Split array into multiple sub-arrays horizontally (column-wise).
-    vsplit : Split array into multiple sub-arrays vertically (row wise).
-    dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
-    concatenate : Join a sequence of arrays along an existing axis.
-    stack : Join a sequence of arrays along a new axis.
-    hstack : Stack arrays in sequence horizontally (column wise).
-    vstack : Stack arrays in sequence vertically (row wise).
-    dstack : Stack arrays in sequence depth wise (along third dimension).
-
-    Examples
-    --------
-    >>> x = np.arange(9.0)
-    >>> np.split(x, 3)
-    [array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.,  8.])]
-
-    >>> x = np.arange(8.0)
-    >>> np.split(x, [3, 5, 6, 10])
-    [array([0.,  1.,  2.]),
-     array([3.,  4.]),
-     array([5.]),
-     array([6.,  7.]),
-     array([], dtype=float64)]
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def asfarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asfarray"))))
-(alter-meta! #'asfarray assoc :doc "
-    Return an array converted to a float type.
-
-    Parameters
-    ----------
-    a : array_like
-        The input array.
-    dtype : str or dtype object, optional
-        Float type code to coerce input array `a`.  If `dtype` is one of the
-        'int' dtypes, it is replaced with float64.
-
-    Returns
-    -------
-    out : ndarray
-        The input `a` as a float ndarray.
-
-    Examples
-    --------
-    >>> np.asfarray([2, 3])
-    array([2.,  3.])
-    >>> np.asfarray([2, 3], dtype='float')
-    array([2.,  3.])
-    >>> np.asfarray([2, 3], dtype='int8')
-    array([2.,  3.])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def recfromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "recfromtxt"))))
-(alter-meta! #'recfromtxt assoc :doc "
-    Load ASCII data from a file and return it in a record array.
-
-    If ``usemask=False`` a standard `recarray` is returned,
-    if ``usemask=True`` a MaskedRecords array is returned.
-
-    Parameters
-    ----------
-    fname, kwargs : For a description of input parameters, see `genfromtxt`.
-
-    See Also
-    --------
-    numpy.genfromtxt : generic function
-
-    Notes
-    -----
-    By default, `dtype` is None, which means that the data-type of the output
-    array will be determined from the data.
-
-    " :arglists '[[fname & [{:as kwargs}]]])
-
-(def empty_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "empty_like"))))
-(alter-meta! #'empty_like assoc :doc "
-    empty_like(prototype, dtype=None, order='K', subok=True, shape=None)
-
-    Return a new array with the same shape and type as a given array.
-
-    Parameters
-    ----------
-    prototype : array_like
-        The shape and data-type of `prototype` define these same attributes
-        of the returned array.
-    dtype : data-type, optional
-        Overrides the data type of the result.
-
-        .. versionadded:: 1.6.0
-    order : {'C', 'F', 'A', or 'K'}, optional
-        Overrides the memory layout of the result. 'C' means C-order,
-        'F' means F-order, 'A' means 'F' if ``prototype`` is Fortran
-        contiguous, 'C' otherwise. 'K' means match the layout of ``prototype``
-        as closely as possible.
-
-        .. versionadded:: 1.6.0
-    subok : bool, optional.
-        If True, then the newly created array will use the sub-class
-        type of 'a', otherwise it will be a base-class array. Defaults
-        to True.
-    shape : int or sequence of ints, optional.
-        Overrides the shape of the result. If order='K' and the number of
-        dimensions is unchanged, will try to keep order, otherwise,
-        order='C' is implied.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    out : ndarray
-        Array of uninitialized (arbitrary) data with the same
-        shape and type as `prototype`.
-
-    See Also
-    --------
-    ones_like : Return an array of ones with shape and type of input.
-    zeros_like : Return an array of zeros with shape and type of input.
-    full_like : Return a new array with shape of input filled with value.
-    empty : Return a new uninitialized array.
-
-    Notes
-    -----
-    This function does *not* initialize the returned array; to do that use
-    `zeros_like` or `ones_like` instead.  It may be marginally faster than
-    the functions that do set the array values.
-
-    Examples
-    --------
-    >>> a = ([1,2,3], [4,5,6])                         # a is array-like
-    >>> np.empty_like(a)
-    array([[-1073741821, -1073741821,           3],    # uninitialized
-           [          0,           0, -1073741821]])
-    >>> a = np.array([[1., 2., 3.],[4.,5.,6.]])
-    >>> np.empty_like(a)
-    array([[ -2.00000715e+000,   1.48219694e-323,  -2.00000572e+000], # uninitialized
-           [  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def log10 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log10"))))
-(alter-meta! #'log10 assoc :doc "log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the base 10 logarithm of the input array, element-wise.
-
-Parameters
-----------
-x : array_like
-    Input values.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The logarithm to the base 10 of `x`, element-wise. NaNs are
-    returned where x is negative.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-emath.log10
-
-Notes
------
-Logarithm is a multivalued function: for each `x` there is an infinite
-number of `z` such that `10**z = x`. The convention is to return the
-`z` whose imaginary part lies in `[-pi, pi]`.
-
-For real-valued input data types, `log10` always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields ``nan`` and sets the `invalid` floating point error flag.
-
-For complex-valued input, `log10` is a complex analytical function that
-has a branch cut `[-inf, 0]` and is continuous from above on it.
-`log10` handles the floating-point negative zero as an infinitesimal
-negative number, conforming to the C99 standard.
-
-References
-----------
-.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
-       10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/
-.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm
-
-Examples
---------
->>> np.log10([1e-15, -3.])
-array([-15.,  nan])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def mask_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mask_indices"))))
-(alter-meta! #'mask_indices assoc :doc "
-    Return the indices to access (n, n) arrays, given a masking function.
-
-    Assume `mask_func` is a function that, for a square array a of size
-    ``(n, n)`` with a possible offset argument `k`, when called as
-    ``mask_func(a, k)`` returns a new array with zeros in certain locations
-    (functions like `triu` or `tril` do precisely this). Then this function
-    returns the indices where the non-zero values would be located.
-
-    Parameters
-    ----------
-    n : int
-        The returned indices will be valid to access arrays of shape (n, n).
-    mask_func : callable
-        A function whose call signature is similar to that of `triu`, `tril`.
-        That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`.
-        `k` is an optional argument to the function.
-    k : scalar
-        An optional argument which is passed through to `mask_func`. Functions
-        like `triu`, `tril` take a second argument that is interpreted as an
-        offset.
-
-    Returns
-    -------
-    indices : tuple of arrays.
-        The `n` arrays of indices corresponding to the locations where
-        ``mask_func(np.ones((n, n)), k)`` is True.
-
-    See Also
-    --------
-    triu, tril, triu_indices, tril_indices
-
-    Notes
-    -----
-    .. versionadded:: 1.4.0
-
-    Examples
-    --------
-    These are the indices that would allow you to access the upper triangular
-    part of any 3x3 array:
-
-    >>> iu = np.mask_indices(3, np.triu)
-
-    For example, if `a` is a 3x3 array:
-
-    >>> a = np.arange(9).reshape(3, 3)
-    >>> a
-    array([[0, 1, 2],
-           [3, 4, 5],
-           [6, 7, 8]])
-    >>> a[iu]
-    array([0, 1, 2, 4, 5, 8])
-
-    An offset can be passed also to the masking function.  This gets us the
-    indices starting on the first diagonal right of the main one:
-
-    >>> iu1 = np.mask_indices(3, np.triu, 1)
-
-    with which we now extract only three elements:
-
-    >>> a[iu1]
-    array([1, 2, 5])
-
-    " :arglists '[[n mask_func & [{k :k}]] [n mask_func]])
-
-(def str0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "str0"))))
-(alter-meta! #'str0 assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def number (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "number"))))
-(alter-meta! #'number assoc :doc "Abstract base class of all numeric scalar types." :arglists '[[self & [args {:as kwargs}]]])
-
-(def nanargmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanargmax"))))
-(alter-meta! #'nanargmax assoc :doc "
-    Return the indices of the maximum values in the specified axis ignoring
-    NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the
-    results cannot be trusted if a slice contains only NaNs and -Infs.
-
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-    axis : int, optional
-        Axis along which to operate.  By default flattened input is used.
-
-    Returns
-    -------
-    index_array : ndarray
-        An array of indices or a single index value.
-
-    See Also
-    --------
-    argmax, nanargmin
-
-    Examples
-    --------
-    >>> a = np.array([[np.nan, 4], [2, 3]])
-    >>> np.argmax(a)
-    0
-    >>> np.nanargmax(a)
-    1
-    >>> np.nanargmax(a, axis=0)
-    array([1, 0])
-    >>> np.nanargmax(a, axis=1)
-    array([1, 1])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def sinc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sinc"))))
-(alter-meta! #'sinc assoc :doc "
-    Return the sinc function.
-
-    The sinc function is :math:`\\sin(\\pi x)/(\\pi x)`.
-
-    Parameters
-    ----------
-    x : ndarray
-        Array (possibly multi-dimensional) of values for which to to
-        calculate ``sinc(x)``.
-
-    Returns
-    -------
-    out : ndarray
-        ``sinc(x)``, which has the same shape as the input.
-
-    Notes
-    -----
-    ``sinc(0)`` is the limit value 1.
-
-    The name sinc is short for \"sine cardinal\" or \"sinus cardinalis\".
-
-    The sinc function is used in various signal processing applications,
-    including in anti-aliasing, in the construction of a Lanczos resampling
-    filter, and in interpolation.
-
-    For bandlimited interpolation of discrete-time signals, the ideal
-    interpolation kernel is proportional to the sinc function.
-
-    References
-    ----------
-    .. [1] Weisstein, Eric W. \"Sinc Function.\" From MathWorld--A Wolfram Web
-           Resource. http://mathworld.wolfram.com/SincFunction.html
-    .. [2] Wikipedia, \"Sinc function\",
-           https://en.wikipedia.org/wiki/Sinc_function
-
-    Examples
-    --------
-    >>> import matplotlib.pyplot as plt
-    >>> x = np.linspace(-4, 4, 41)
-    >>> np.sinc(x)
-     array([-3.89804309e-17,  -4.92362781e-02,  -8.40918587e-02, # may vary
-            -8.90384387e-02,  -5.84680802e-02,   3.89804309e-17,
-            6.68206631e-02,   1.16434881e-01,   1.26137788e-01,
-            8.50444803e-02,  -3.89804309e-17,  -1.03943254e-01,
-            -1.89206682e-01,  -2.16236208e-01,  -1.55914881e-01,
-            3.89804309e-17,   2.33872321e-01,   5.04551152e-01,
-            7.56826729e-01,   9.35489284e-01,   1.00000000e+00,
-            9.35489284e-01,   7.56826729e-01,   5.04551152e-01,
-            2.33872321e-01,   3.89804309e-17,  -1.55914881e-01,
-           -2.16236208e-01,  -1.89206682e-01,  -1.03943254e-01,
-           -3.89804309e-17,   8.50444803e-02,   1.26137788e-01,
-            1.16434881e-01,   6.68206631e-02,   3.89804309e-17,
-            -5.84680802e-02,  -8.90384387e-02,  -8.40918587e-02,
-            -4.92362781e-02,  -3.89804309e-17])
-
-    >>> plt.plot(x, np.sinc(x))
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.title(\"Sinc Function\")
-    Text(0.5, 1.0, 'Sinc Function')
-    >>> plt.ylabel(\"Amplitude\")
-    Text(0, 0.5, 'Amplitude')
-    >>> plt.xlabel(\"X\")
-    Text(0.5, 0, 'X')
-    >>> plt.show()
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def fmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fmax"))))
-(alter-meta! #'fmax assoc :doc "fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Element-wise maximum of array elements.
-
-Compare two arrays and returns a new array containing the element-wise
-maxima. If one of the elements being compared is a NaN, then the
-non-nan element is returned. If both elements are NaNs then the first
-is returned.  The latter distinction is important for complex NaNs,
-which are defined as at least one of the real or imaginary parts being
-a NaN. The net effect is that NaNs are ignored when possible.
-
-Parameters
-----------
-x1, x2 : array_like
-    The arrays holding the elements to be compared. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or scalar
-    The maximum of `x1` and `x2`, element-wise.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-fmin :
-    Element-wise minimum of two arrays, ignores NaNs.
-maximum :
-    Element-wise maximum of two arrays, propagates NaNs.
-amax :
-    The maximum value of an array along a given axis, propagates NaNs.
-nanmax :
-    The maximum value of an array along a given axis, ignores NaNs.
-
-minimum, amin, nanmin
-
-Notes
------
-.. versionadded:: 1.3.0
-
-The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither
-x1 nor x2 are NaNs, but it is faster and does proper broadcasting.
-
-Examples
---------
->>> np.fmax([2, 3, 4], [1, 5, 2])
-array([ 2.,  5.,  4.])
-
->>> np.fmax(np.eye(2), [0.5, 2])
-array([[ 1. ,  2. ],
-       [ 0.5,  2. ]])
-
->>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan])
-array([ 0.,  0., nan])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ravel (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ravel"))))
-(alter-meta! #'ravel assoc :doc "Return a contiguous flattened array.
-
-    A 1-D array, containing the elements of the input, is returned.  A copy is
-    made only if needed.
-
-    As of NumPy 1.10, the returned array will have the same type as the input
-    array. (for example, a masked array will be returned for a masked array
-    input)
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.  The elements in `a` are read in the order specified by
-        `order`, and packed as a 1-D array.
-    order : {'C','F', 'A', 'K'}, optional
-
-        The elements of `a` are read using this index order. 'C' means
-        to index the elements in row-major, C-style order,
-        with the last axis index changing fastest, back to the first
-        axis index changing slowest.  'F' means to index the elements
-        in column-major, Fortran-style order, with the
-        first index changing fastest, and the last index changing
-        slowest. Note that the 'C' and 'F' options take no account of
-        the memory layout of the underlying array, and only refer to
-        the order of axis indexing.  'A' means to read the elements in
-        Fortran-like index order if `a` is Fortran *contiguous* in
-        memory, C-like order otherwise.  'K' means to read the
-        elements in the order they occur in memory, except for
-        reversing the data when strides are negative.  By default, 'C'
-        index order is used.
-
-    Returns
-    -------
-    y : array_like
-        y is an array of the same subtype as `a`, with shape ``(a.size,)``.
-        Note that matrices are special cased for backward compatibility, if `a`
-        is a matrix, then y is a 1-D ndarray.
-
-    See Also
-    --------
-    ndarray.flat : 1-D iterator over an array.
-    ndarray.flatten : 1-D array copy of the elements of an array
-                      in row-major order.
-    ndarray.reshape : Change the shape of an array without changing its data.
-
-    Notes
-    -----
-    In row-major, C-style order, in two dimensions, the row index
-    varies the slowest, and the column index the quickest.  This can
-    be generalized to multiple dimensions, where row-major order
-    implies that the index along the first axis varies slowest, and
-    the index along the last quickest.  The opposite holds for
-    column-major, Fortran-style index ordering.
-
-    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
-    may be preferable.
-
-    Examples
-    --------
-    It is equivalent to ``reshape(-1, order=order)``.
-
-    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
-    >>> np.ravel(x)
-    array([1, 2, 3, 4, 5, 6])
-
-    >>> x.reshape(-1)
-    array([1, 2, 3, 4, 5, 6])
-
-    >>> np.ravel(x, order='F')
-    array([1, 4, 2, 5, 3, 6])
-
-    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
-
-    >>> np.ravel(x.T)
-    array([1, 4, 2, 5, 3, 6])
-    >>> np.ravel(x.T, order='A')
-    array([1, 2, 3, 4, 5, 6])
-
-    When ``order`` is 'K', it will preserve orderings that are neither 'C'
-    nor 'F', but won't reverse axes:
-
-    >>> a = np.arange(3)[::-1]; a
-    array([2, 1, 0])
-    >>> a.ravel(order='C')
-    array([2, 1, 0])
-    >>> a.ravel(order='K')
-    array([2, 1, 0])
-
-    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
-    array([[[ 0,  2,  4],
-            [ 1,  3,  5]],
-           [[ 6,  8, 10],
-            [ 7,  9, 11]]])
-    >>> a.ravel(order='C')
-    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
-    >>> a.ravel(order='K')
-    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def correlate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "correlate"))))
-(alter-meta! #'correlate assoc :doc "
-    Cross-correlation of two 1-dimensional sequences.
-
-    This function computes the correlation as generally defined in signal
-    processing texts::
-
-        c_{av}[k] = sum_n a[n+k] * conj(v[n])
-
-    with a and v sequences being zero-padded where necessary and conj being
-    the conjugate.
-
-    Parameters
-    ----------
-    a, v : array_like
-        Input sequences.
-    mode : {'valid', 'same', 'full'}, optional
-        Refer to the `convolve` docstring.  Note that the default
-        is 'valid', unlike `convolve`, which uses 'full'.
-    old_behavior : bool
-        `old_behavior` was removed in NumPy 1.10. If you need the old
-        behavior, use `multiarray.correlate`.
-
-    Returns
-    -------
-    out : ndarray
-        Discrete cross-correlation of `a` and `v`.
-
-    See Also
-    --------
-    convolve : Discrete, linear convolution of two one-dimensional sequences.
-    multiarray.correlate : Old, no conjugate, version of correlate.
-
-    Notes
-    -----
-    The definition of correlation above is not unique and sometimes correlation
-    may be defined differently. Another common definition is::
-
-        c'_{av}[k] = sum_n a[n] conj(v[n+k])
-
-    which is related to ``c_{av}[k]`` by ``c'_{av}[k] = c_{av}[-k]``.
-
-    Examples
-    --------
-    >>> np.correlate([1, 2, 3], [0, 1, 0.5])
-    array([3.5])
-    >>> np.correlate([1, 2, 3], [0, 1, 0.5], \"same\")
-    array([2. ,  3.5,  3. ])
-    >>> np.correlate([1, 2, 3], [0, 1, 0.5], \"full\")
-    array([0.5,  2. ,  3.5,  3. ,  0. ])
-
-    Using complex sequences:
-
-    >>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full')
-    array([ 0.5-0.5j,  1.0+0.j ,  1.5-1.5j,  3.0-1.j ,  0.0+0.j ])
-
-    Note that you get the time reversed, complex conjugated result
-    when the two input sequences change places, i.e.,
-    ``c_{va}[k] = c^{*}_{av}[-k]``:
-
-    >>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')
-    array([ 0.0+0.j ,  3.0+1.j ,  1.5+1.5j,  1.0+0.j ,  0.5+0.5j])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def nanmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmin"))))
-(alter-meta! #'nanmin assoc :doc "
-    Return minimum of an array or minimum along an axis, ignoring any NaNs.
-    When all-NaN slices are encountered a ``RuntimeWarning`` is raised and
-    Nan is returned for that slice.
-
-    Parameters
-    ----------
-    a : array_like
-        Array containing numbers whose minimum is desired. If `a` is not an
-        array, a conversion is attempted.
-    axis : {int, tuple of int, None}, optional
-        Axis or axes along which the minimum is computed. The default is to compute
-        the minimum of the flattened array.
-    out : ndarray, optional
-        Alternate output array in which to place the result.  The default
-        is ``None``; if provided, it must have the same shape as the
-        expected output, but the type will be cast if necessary. See
-        `ufuncs-output-type` for more details.
-
-        .. versionadded:: 1.8.0
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the original `a`.
-
-        If the value is anything but the default, then
-        `keepdims` will be passed through to the `min` method
-        of sub-classes of `ndarray`.  If the sub-classes methods
-        does not implement `keepdims` any exceptions will be raised.
-
-        .. versionadded:: 1.8.0
-
-    Returns
-    -------
-    nanmin : ndarray
-        An array with the same shape as `a`, with the specified axis
-        removed.  If `a` is a 0-d array, or if axis is None, an ndarray
-        scalar is returned.  The same dtype as `a` is returned.
-
-    See Also
-    --------
-    nanmax :
-        The maximum value of an array along a given axis, ignoring any NaNs.
-    amin :
-        The minimum value of an array along a given axis, propagating any NaNs.
-    fmin :
-        Element-wise minimum of two arrays, ignoring any NaNs.
-    minimum :
-        Element-wise minimum of two arrays, propagating any NaNs.
-    isnan :
-        Shows which elements are Not a Number (NaN).
-    isfinite:
-        Shows which elements are neither NaN nor infinity.
-
-    amax, fmax, maximum
-
-    Notes
-    -----
-    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
-    (IEEE 754). This means that Not a Number is not equivalent to infinity.
-    Positive infinity is treated as a very large number and negative
-    infinity is treated as a very small (i.e. negative) number.
-
-    If the input has a integer type the function is equivalent to np.min.
-
-    Examples
-    --------
-    >>> a = np.array([[1, 2], [3, np.nan]])
-    >>> np.nanmin(a)
-    1.0
-    >>> np.nanmin(a, axis=0)
-    array([1.,  2.])
-    >>> np.nanmin(a, axis=1)
-    array([1.,  3.])
-
-    When positive infinity and negative infinity are present:
-
-    >>> np.nanmin([1, 2, np.nan, np.inf])
-    1.0
-    >>> np.nanmin([1, 2, np.nan, np.NINF])
-    -inf
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def polyadd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyadd"))))
-(alter-meta! #'polyadd assoc :doc "
-    Find the sum of two polynomials.
-
-    Returns the polynomial resulting from the sum of two input polynomials.
-    Each input must be either a poly1d object or a 1D sequence of polynomial
-    coefficients, from highest to lowest degree.
-
-    Parameters
-    ----------
-    a1, a2 : array_like or poly1d object
-        Input polynomials.
-
-    Returns
-    -------
-    out : ndarray or poly1d object
-        The sum of the inputs. If either input is a poly1d object, then the
-        output is also a poly1d object. Otherwise, it is a 1D array of
-        polynomial coefficients from highest to lowest degree.
-
-    See Also
-    --------
-    poly1d : A one-dimensional polynomial class.
-    poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
-
-    Examples
-    --------
-    >>> np.polyadd([1, 2], [9, 5, 4])
-    array([9, 6, 6])
-
-    Using poly1d objects:
-
-    >>> p1 = np.poly1d([1, 2])
-    >>> p2 = np.poly1d([9, 5, 4])
-    >>> print(p1)
-    1 x + 2
-    >>> print(p2)
-       2
-    9 x + 5 x + 4
-    >>> print(np.polyadd(p1, p2))
-       2
-    9 x + 6 x + 6
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "The specification for a module, used for loading.
-
-    A module's spec is the source for information about the module.  For
-    data associated with the module, including source, use the spec's
-    loader.
-
-    `name` is the absolute name of the module.  `loader` is the loader
-    to use when loading the module.  `parent` is the name of the
-    package the module is in.  The parent is derived from the name.
-
-    `is_package` determines if the module is considered a package or
-    not.  On modules this is reflected by the `__path__` attribute.
-
-    `origin` is the specific location used by the loader from which to
-    load the module, if that information is available.  When filename is
-    set, origin will match.
-
-    `has_location` indicates that a spec's \"origin\" reflects a location.
-    When this is True, `__file__` attribute of the module is set.
-
-    `cached` is the location of the cached bytecode file, if any.  It
-    corresponds to the `__cached__` attribute.
-
-    `submodule_search_locations` is the sequence of path entries to
-    search when importing submodules.  If set, is_package should be
-    True--and False otherwise.
-
-    Packages are simply modules that (may) have submodules.  If a spec
-    has a non-None value in `submodule_search_locations`, the import
-    system will consider modules loaded from the spec as packages.
-
-    Only finders (see importlib.abc.MetaPathFinder and
-    importlib.abc.PathEntryFinder) should modify ModuleSpec instances.
-
-    "} __spec__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__spec__"))))
-
-(def ^{:doc ""} print_function (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "print_function"))))
-
-(def arcsinh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arcsinh"))))
-(alter-meta! #'arcsinh assoc :doc "arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Inverse hyperbolic sine element-wise.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Array of the same shape as `x`.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-`arcsinh` is a multivalued function: for each `x` there are infinitely
-many numbers `z` such that `sinh(z) = x`. The convention is to return the
-`z` whose imaginary part lies in `[-pi/2, pi/2]`.
-
-For real-valued input data types, `arcsinh` always returns real output.
-For each value that cannot be expressed as a real number or infinity, it
-returns ``nan`` and sets the `invalid` floating point error flag.
-
-For complex-valued input, `arccos` is a complex analytical function that
-has branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from
-the right on the former and from the left on the latter.
-
-The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``.
-
-References
-----------
-.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
-       10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/
-.. [2] Wikipedia, \"Inverse hyperbolic function\",
-       https://en.wikipedia.org/wiki/Arcsinh
-
-Examples
---------
->>> np.arcsinh(np.array([np.e, 10.0]))
-array([ 1.72538256,  2.99822295])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc "
-    A nicer way to build up index tuples for arrays.
-
-    .. note::
-       Use one of the two predefined instances `index_exp` or `s_`
-       rather than directly using `IndexExpression`.
-
-    For any index combination, including slicing and axis insertion,
-    ``a[indices]`` is the same as ``a[np.index_exp[indices]]`` for any
-    array `a`. However, ``np.index_exp[indices]`` can be used anywhere
-    in Python code and returns a tuple of slice objects that can be
-    used in the construction of complex index expressions.
-
-    Parameters
-    ----------
-    maketuple : bool
-        If True, always returns a tuple.
-
-    See Also
-    --------
-    index_exp : Predefined instance that always returns a tuple:
-       `index_exp = IndexExpression(maketuple=True)`.
-    s_ : Predefined instance without tuple conversion:
-       `s_ = IndexExpression(maketuple=False)`.
-
-    Notes
-    -----
-    You can do all this with `slice()` plus a few special objects,
-    but there's a lot to remember and this version is simpler because
-    it uses the standard array indexing syntax.
-
-    Examples
-    --------
-    >>> np.s_[2::2]
-    slice(2, None, 2)
-    >>> np.index_exp[2::2]
-    (slice(2, None, 2),)
-
-    >>> np.array([0, 1, 2, 3, 4])[np.s_[2::2]]
-    array([2, 4])
-
-    "} index_exp (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "index_exp"))))
-
-(def ComplexWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ComplexWarning"))))
-(alter-meta! #'ComplexWarning assoc :doc "
-    The warning raised when casting a complex dtype to a real dtype.
-
-    As implemented, casting a complex number to a real discards its imaginary
-    part, but this behavior may not be what the user actually wants.
-
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def issctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issctype"))))
-(alter-meta! #'issctype assoc :doc "
-    Determines whether the given object represents a scalar data-type.
-
-    Parameters
-    ----------
-    rep : any
-        If `rep` is an instance of a scalar dtype, True is returned. If not,
-        False is returned.
-
-    Returns
-    -------
-    out : bool
-        Boolean result of check whether `rep` is a scalar dtype.
-
-    See Also
-    --------
-    issubsctype, issubdtype, obj2sctype, sctype2char
-
-    Examples
-    --------
-    >>> np.issctype(np.int32)
-    True
-    >>> np.issctype(list)
-    False
-    >>> np.issctype(1.1)
-    False
-
-    Strings are also a scalar type:
-
-    >>> np.issctype(np.dtype('str'))
-    True
-
-    " :arglists '[[rep]])
-
-(def sqrt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sqrt"))))
-(alter-meta! #'sqrt assoc :doc "sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the non-negative square-root of an array, element-wise.
-
-Parameters
-----------
-x : array_like
-    The values whose square-roots are required.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    An array of the same shape as `x`, containing the positive
-    square-root of each element in `x`.  If any element in `x` is
-    complex, a complex array is returned (and the square-roots of
-    negative reals are calculated).  If all of the elements in `x`
-    are real, so is `y`, with negative elements returning ``nan``.
-    If `out` was provided, `y` is a reference to it.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-lib.scimath.sqrt
-    A version which returns complex numbers when given negative reals.
-
-Notes
------
-*sqrt* has--consistent with common convention--as its branch cut the
-real \"interval\" [`-inf`, 0), and is continuous from above on it.
-A branch cut is a curve in the complex plane across which a given
-complex function fails to be continuous.
-
-Examples
---------
->>> np.sqrt([1,4,9])
-array([ 1.,  2.,  3.])
-
->>> np.sqrt([4, -1, -3+4J])
-array([ 2.+0.j,  0.+1.j,  1.+2.j])
-
->>> np.sqrt([4, -1, np.inf])
-array([ 2., nan, inf])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def polymul (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polymul"))))
-(alter-meta! #'polymul assoc :doc "
-    Find the product of two polynomials.
-
-    Finds the polynomial resulting from the multiplication of the two input
-    polynomials. Each input must be either a poly1d object or a 1D sequence
-    of polynomial coefficients, from highest to lowest degree.
-
-    Parameters
-    ----------
-    a1, a2 : array_like or poly1d object
-        Input polynomials.
-
-    Returns
-    -------
-    out : ndarray or poly1d object
-        The polynomial resulting from the multiplication of the inputs. If
-        either inputs is a poly1d object, then the output is also a poly1d
-        object. Otherwise, it is a 1D array of polynomial coefficients from
-        highest to lowest degree.
-
-    See Also
-    --------
-    poly1d : A one-dimensional polynomial class.
-    poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
-    convolve : Array convolution. Same output as polymul, but has parameter
-               for overlap mode.
-
-    Examples
-    --------
-    >>> np.polymul([1, 2, 3], [9, 5, 1])
-    array([ 9, 23, 38, 17,  3])
-
-    Using poly1d objects:
-
-    >>> p1 = np.poly1d([1, 2, 3])
-    >>> p2 = np.poly1d([9, 5, 1])
-    >>> print(p1)
-       2
-    1 x + 2 x + 3
-    >>> print(p2)
-       2
-    9 x + 5 x + 1
-    >>> print(np.polymul(p1, p2))
-       4      3      2
-    9 x + 23 x + 38 x + 17 x + 3
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def empty (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "empty"))))
-(alter-meta! #'empty assoc :doc "empty(shape, dtype=float, order='C')
-
-    Return a new array of given shape and type, without initializing entries.
-
-    Parameters
-    ----------
-    shape : int or tuple of int
-        Shape of the empty array, e.g., ``(2, 3)`` or ``2``.
-    dtype : data-type, optional
-        Desired output data-type for the array, e.g, `numpy.int8`. Default is
-        `numpy.float64`.
-    order : {'C', 'F'}, optional, default: 'C'
-        Whether to store multi-dimensional data in row-major
-        (C-style) or column-major (Fortran-style) order in
-        memory.
-
-    Returns
-    -------
-    out : ndarray
-        Array of uninitialized (arbitrary) data of the given shape, dtype, and
-        order.  Object arrays will be initialized to None.
-
-    See Also
-    --------
-    empty_like : Return an empty array with shape and type of input.
-    ones : Return a new array setting values to one.
-    zeros : Return a new array setting values to zero.
-    full : Return a new array of given shape filled with value.
-
-
-    Notes
-    -----
-    `empty`, unlike `zeros`, does not set the array values to zero,
-    and may therefore be marginally faster.  On the other hand, it requires
-    the user to manually set all the values in the array, and should be
-    used with caution.
-
-    Examples
-    --------
-    >>> np.empty([2, 2])
-    array([[ -9.74499359e+001,   6.69583040e-309],
-           [  2.13182611e-314,   3.06959433e-309]])         #uninitialized
-
-    >>> np.empty([2, 2], dtype=int)
-    array([[-1073741821, -1067949133],
-           [  496041986,    19249760]])                     #uninitialized" :arglists '[[self & [args {:as kwargs}]]])
-
-(def object0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "object0"))))
-(alter-meta! #'object0 assoc :doc "Any Python object.
-    Character code: ``'O'``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ndim (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndim"))))
-(alter-meta! #'ndim assoc :doc "
-    Return the number of dimensions of an array.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.  If it is not already an ndarray, a conversion is
-        attempted.
-
-    Returns
-    -------
-    number_of_dimensions : int
-        The number of dimensions in `a`.  Scalars are zero-dimensional.
-
-    See Also
-    --------
-    ndarray.ndim : equivalent method
-    shape : dimensions of array
-    ndarray.shape : dimensions of array
-
-    Examples
-    --------
-    >>> np.ndim([[1,2,3],[4,5,6]])
-    2
-    >>> np.ndim(np.array([[1,2,3],[4,5,6]]))
-    2
-    >>> np.ndim(1)
-    0
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def polyfit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyfit"))))
-(alter-meta! #'polyfit assoc :doc "
-    Least squares polynomial fit.
-
-    Fit a polynomial ``p(x) = p[0] * x**deg + ... + p[deg]`` of degree `deg`
-    to points `(x, y)`. Returns a vector of coefficients `p` that minimises
-    the squared error in the order `deg`, `deg-1`, ... `0`.
-
-    The `Polynomial.fit <numpy.polynomial.polynomial.Polynomial.fit>` class
-    method is recommended for new code as it is more stable numerically. See
-    the documentation of the method for more information.
-
-    Parameters
-    ----------
-    x : array_like, shape (M,)
-        x-coordinates of the M sample points ``(x[i], y[i])``.
-    y : array_like, shape (M,) or (M, K)
-        y-coordinates of the sample points. Several data sets of sample
-        points sharing the same x-coordinates can be fitted at once by
-        passing in a 2D-array that contains one dataset per column.
-    deg : int
-        Degree of the fitting polynomial
-    rcond : float, optional
-        Relative condition number of the fit. Singular values smaller than
-        this relative to the largest singular value will be ignored. The
-        default value is len(x)*eps, where eps is the relative precision of
-        the float type, about 2e-16 in most cases.
-    full : bool, optional
-        Switch determining nature of return value. When it is False (the
-        default) just the coefficients are returned, when True diagnostic
-        information from the singular value decomposition is also returned.
-    w : array_like, shape (M,), optional
-        Weights to apply to the y-coordinates of the sample points. For
-        gaussian uncertainties, use 1/sigma (not 1/sigma**2).
-    cov : bool or str, optional
-        If given and not `False`, return not just the estimate but also its
-        covariance matrix. By default, the covariance are scaled by
-        chi2/sqrt(N-dof), i.e., the weights are presumed to be unreliable
-        except in a relative sense and everything is scaled such that the
-        reduced chi2 is unity. This scaling is omitted if ``cov='unscaled'``,
-        as is relevant for the case that the weights are 1/sigma**2, with
-        sigma known to be a reliable estimate of the uncertainty.
-
-    Returns
-    -------
-    p : ndarray, shape (deg + 1,) or (deg + 1, K)
-        Polynomial coefficients, highest power first.  If `y` was 2-D, the
-        coefficients for `k`-th data set are in ``p[:,k]``.
-
-    residuals, rank, singular_values, rcond
-        Present only if `full` = True.  Residuals is sum of squared residuals
-        of the least-squares fit, the effective rank of the scaled Vandermonde
-        coefficient matrix, its singular values, and the specified value of
-        `rcond`. For more details, see `linalg.lstsq`.
-
-    V : ndarray, shape (M,M) or (M,M,K)
-        Present only if `full` = False and `cov`=True.  The covariance
-        matrix of the polynomial coefficient estimates.  The diagonal of
-        this matrix are the variance estimates for each coefficient.  If y
-        is a 2-D array, then the covariance matrix for the `k`-th data set
-        are in ``V[:,:,k]``
-
-
-    Warns
-    -----
-    RankWarning
-        The rank of the coefficient matrix in the least-squares fit is
-        deficient. The warning is only raised if `full` = False.
-
-        The warnings can be turned off by
-
-        >>> import warnings
-        >>> warnings.simplefilter('ignore', np.RankWarning)
-
-    See Also
-    --------
-    polyval : Compute polynomial values.
-    linalg.lstsq : Computes a least-squares fit.
-    scipy.interpolate.UnivariateSpline : Computes spline fits.
-
-    Notes
-    -----
-    The solution minimizes the squared error
-
-    .. math ::
-        E = \\sum_{j=0}^k |p(x_j) - y_j|^2
-
-    in the equations::
-
-        x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]
-        x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]
-        ...
-        x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]
-
-    The coefficient matrix of the coefficients `p` is a Vandermonde matrix.
-
-    `polyfit` issues a `RankWarning` when the least-squares fit is badly
-    conditioned. This implies that the best fit is not well-defined due
-    to numerical error. The results may be improved by lowering the polynomial
-    degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter
-    can also be set to a value smaller than its default, but the resulting
-    fit may be spurious: including contributions from the small singular
-    values can add numerical noise to the result.
-
-    Note that fitting polynomial coefficients is inherently badly conditioned
-    when the degree of the polynomial is large or the interval of sample points
-    is badly centered. The quality of the fit should always be checked in these
-    cases. When polynomial fits are not satisfactory, splines may be a good
-    alternative.
-
-    References
-    ----------
-    .. [1] Wikipedia, \"Curve fitting\",
-           https://en.wikipedia.org/wiki/Curve_fitting
-    .. [2] Wikipedia, \"Polynomial interpolation\",
-           https://en.wikipedia.org/wiki/Polynomial_interpolation
-
-    Examples
-    --------
-    >>> import warnings
-    >>> x = np.array([0.0, 1.0, 2.0, 3.0,  4.0,  5.0])
-    >>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])
-    >>> z = np.polyfit(x, y, 3)
-    >>> z
-    array([ 0.08703704, -0.81349206,  1.69312169, -0.03968254]) # may vary
-
-    It is convenient to use `poly1d` objects for dealing with polynomials:
-
-    >>> p = np.poly1d(z)
-    >>> p(0.5)
-    0.6143849206349179 # may vary
-    >>> p(3.5)
-    -0.34732142857143039 # may vary
-    >>> p(10)
-    22.579365079365115 # may vary
-
-    High-order polynomials may oscillate wildly:
-
-    >>> with warnings.catch_warnings():
-    ...     warnings.simplefilter('ignore', np.RankWarning)
-    ...     p30 = np.poly1d(np.polyfit(x, y, 30))
-    ...
-    >>> p30(4)
-    -0.80000000000000204 # may vary
-    >>> p30(5)
-    -0.99999999999999445 # may vary
-    >>> p30(4.5)
-    -0.10547061179440398 # may vary
-
-    Illustration:
-
-    >>> import matplotlib.pyplot as plt
-    >>> xp = np.linspace(-2, 6, 100)
-    >>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')
-    >>> plt.ylim(-2,2)
-    (-2, 2)
-    >>> plt.show()
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def string_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "string_"))))
-(alter-meta! #'string_ assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def choose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "choose"))))
-(alter-meta! #'choose assoc :doc "
-    Construct an array from an index array and a set of arrays to choose from.
-
-    First of all, if confused or uncertain, definitely look at the Examples -
-    in its full generality, this function is less simple than it might
-    seem from the following code description (below ndi =
-    `numpy.lib.index_tricks`):
-
-    ``np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])``.
-
-    But this omits some subtleties.  Here is a fully general summary:
-
-    Given an \"index\" array (`a`) of integers and a sequence of `n` arrays
-    (`choices`), `a` and each choice array are first broadcast, as necessary,
-    to arrays of a common shape; calling these *Ba* and *Bchoices[i], i =
-    0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape``
-    for each `i`.  Then, a new array with shape ``Ba.shape`` is created as
-    follows:
-
-    * if ``mode=raise`` (the default), then, first of all, each element of
-      `a` (and thus `Ba`) must be in the range `[0, n-1]`; now, suppose that
-      `i` (in that range) is the value at the `(j0, j1, ..., jm)` position
-      in `Ba` - then the value at the same position in the new array is the
-      value in `Bchoices[i]` at that same position;
-
-    * if ``mode=wrap``, values in `a` (and thus `Ba`) may be any (signed)
-      integer; modular arithmetic is used to map integers outside the range
-      `[0, n-1]` back into that range; and then the new array is constructed
-      as above;
-
-    * if ``mode=clip``, values in `a` (and thus `Ba`) may be any (signed)
-      integer; negative integers are mapped to 0; values greater than `n-1`
-      are mapped to `n-1`; and then the new array is constructed as above.
-
-    Parameters
-    ----------
-    a : int array
-        This array must contain integers in `[0, n-1]`, where `n` is the number
-        of choices, unless ``mode=wrap`` or ``mode=clip``, in which cases any
-        integers are permissible.
-    choices : sequence of arrays
-        Choice arrays. `a` and all of the choices must be broadcastable to the
-        same shape.  If `choices` is itself an array (not recommended), then
-        its outermost dimension (i.e., the one corresponding to
-        ``choices.shape[0]``) is taken as defining the \"sequence\".
-    out : array, optional
-        If provided, the result will be inserted into this array. It should
-        be of the appropriate shape and dtype. Note that `out` is always
-        buffered if `mode='raise'`; use other modes for better performance.
-    mode : {'raise' (default), 'wrap', 'clip'}, optional
-        Specifies how indices outside `[0, n-1]` will be treated:
-
-          * 'raise' : an exception is raised
-          * 'wrap' : value becomes value mod `n`
-          * 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1
-
-    Returns
-    -------
-    merged_array : array
-        The merged result.
-
-    Raises
-    ------
-    ValueError: shape mismatch
-        If `a` and each choice array are not all broadcastable to the same
-        shape.
-
-    See Also
-    --------
-    ndarray.choose : equivalent method
-    numpy.take_along_axis : Preferable if `choices` is an array
-
-    Notes
-    -----
-    To reduce the chance of misinterpretation, even though the following
-    \"abuse\" is nominally supported, `choices` should neither be, nor be
-    thought of as, a single array, i.e., the outermost sequence-like container
-    should be either a list or a tuple.
-
-    Examples
-    --------
-
-    >>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],
-    ...   [20, 21, 22, 23], [30, 31, 32, 33]]
-    >>> np.choose([2, 3, 1, 0], choices
-    ... # the first element of the result will be the first element of the
-    ... # third (2+1) \"array\" in choices, namely, 20; the second element
-    ... # will be the second element of the fourth (3+1) choice array, i.e.,
-    ... # 31, etc.
-    ... )
-    array([20, 31, 12,  3])
-    >>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)
-    array([20, 31, 12,  3])
-    >>> # because there are 4 choice arrays
-    >>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)
-    array([20,  1, 12,  3])
-    >>> # i.e., 0
-
-    A couple examples illustrating how choose broadcasts:
-
-    >>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
-    >>> choices = [-10, 10]
-    >>> np.choose(a, choices)
-    array([[ 10, -10,  10],
-           [-10,  10, -10],
-           [ 10, -10,  10]])
-
-    >>> # With thanks to Anne Archibald
-    >>> a = np.array([0, 1]).reshape((2,1,1))
-    >>> c1 = np.array([1, 2, 3]).reshape((1,3,1))
-    >>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5))
-    >>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2
-    array([[[ 1,  1,  1,  1,  1],
-            [ 2,  2,  2,  2,  2],
-            [ 3,  3,  3,  3,  3]],
-           [[-1, -2, -3, -4, -5],
-            [-1, -2, -3, -4, -5],
-            [-1, -2, -3, -4, -5]]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def irr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "irr"))))
-(alter-meta! #'irr assoc :doc "
-    Return the Internal Rate of Return (IRR).
-
-    .. deprecated:: 1.18
-
-       `irr` is deprecated; for details, see NEP 32 [1]_.
-       Use the corresponding function in the numpy-financial library,
-       https://pypi.org/project/numpy-financial.
-
-    This is the \"average\" periodically compounded rate of return
-    that gives a net present value of 0.0; for a more complete explanation,
-    see Notes below.
-
-    :class:`decimal.Decimal` type is not supported.
-
-    Parameters
-    ----------
-    values : array_like, shape(N,)
-        Input cash flows per time period.  By convention, net \"deposits\"
-        are negative and net \"withdrawals\" are positive.  Thus, for
-        example, at least the first element of `values`, which represents
-        the initial investment, will typically be negative.
-
-    Returns
-    -------
-    out : float
-        Internal Rate of Return for periodic input values.
-
-    Notes
-    -----
-    The IRR is perhaps best understood through an example (illustrated
-    using np.irr in the Examples section below).  Suppose one invests 100
-    units and then makes the following withdrawals at regular (fixed)
-    intervals: 39, 59, 55, 20.  Assuming the ending value is 0, one's 100
-    unit investment yields 173 units; however, due to the combination of
-    compounding and the periodic withdrawals, the \"average\" rate of return
-    is neither simply 0.73/4 nor (1.73)^0.25-1.  Rather, it is the solution
-    (for :math:`r`) of the equation:
-
-    .. math:: -100 + \\frac{39}{1+r} + \\frac{59}{(1+r)^2}
-     + \\frac{55}{(1+r)^3} + \\frac{20}{(1+r)^4} = 0
-
-    In general, for `values` :math:`= [v_0, v_1, ... v_M]`,
-    irr is the solution of the equation: [2]_
-
-    .. math:: \\sum_{t=0}^M{\\frac{v_t}{(1+irr)^{t}}} = 0
-
-    References
-    ----------
-    .. [1] NumPy Enhancement Proposal (NEP) 32,
-       https://numpy.org/neps/nep-0032-remove-financial-functions.html
-    .. [2] L. J. Gitman, \"Principles of Managerial Finance, Brief,\" 3rd ed.,
-       Addison-Wesley, 2003, pg. 348.
-
-    Examples
-    --------
-    >>> round(np.irr([-100, 39, 59, 55, 20]), 5)
-    0.28095
-    >>> round(np.irr([-100, 0, 0, 74]), 5)
-    -0.0955
-    >>> round(np.irr([-100, 100, 0, -7]), 5)
-    -0.0833
-    >>> round(np.irr([-100, 100, 0, 7]), 5)
-    0.06206
-    >>> round(np.irr([-5, 10.5, 1, -8, 1]), 5)
-    0.0886
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def logspace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logspace"))))
-(alter-meta! #'logspace assoc :doc "
-    Return numbers spaced evenly on a log scale.
-
-    In linear space, the sequence starts at ``base ** start``
-    (`base` to the power of `start`) and ends with ``base ** stop``
-    (see `endpoint` below).
-
-    .. versionchanged:: 1.16.0
-        Non-scalar `start` and `stop` are now supported.
-
-    Parameters
-    ----------
-    start : array_like
-        ``base ** start`` is the starting value of the sequence.
-    stop : array_like
-        ``base ** stop`` is the final value of the sequence, unless `endpoint`
-        is False.  In that case, ``num + 1`` values are spaced over the
-        interval in log-space, of which all but the last (a sequence of
-        length `num`) are returned.
-    num : integer, optional
-        Number of samples to generate.  Default is 50.
-    endpoint : boolean, optional
-        If true, `stop` is the last sample. Otherwise, it is not included.
-        Default is True.
-    base : float, optional
-        The base of the log space. The step size between the elements in
-        ``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform.
-        Default is 10.0.
-    dtype : dtype
-        The type of the output array.  If `dtype` is not given, infer the data
-        type from the other input arguments.
-    axis : int, optional
-        The axis in the result to store the samples.  Relevant only if start
-        or stop are array-like.  By default (0), the samples will be along a
-        new axis inserted at the beginning. Use -1 to get an axis at the end.
-
-        .. versionadded:: 1.16.0
-
-
-    Returns
-    -------
-    samples : ndarray
-        `num` samples, equally spaced on a log scale.
-
-    See Also
-    --------
-    arange : Similar to linspace, with the step size specified instead of the
-             number of samples. Note that, when used with a float endpoint, the
-             endpoint may or may not be included.
-    linspace : Similar to logspace, but with the samples uniformly distributed
-               in linear space, instead of log space.
-    geomspace : Similar to logspace, but with endpoints specified directly.
-
-    Notes
-    -----
-    Logspace is equivalent to the code
-
-    >>> y = np.linspace(start, stop, num=num, endpoint=endpoint)
-    ... # doctest: +SKIP
-    >>> power(base, y).astype(dtype)
-    ... # doctest: +SKIP
-
-    Examples
-    --------
-    >>> np.logspace(2.0, 3.0, num=4)
-    array([ 100.        ,  215.443469  ,  464.15888336, 1000.        ])
-    >>> np.logspace(2.0, 3.0, num=4, endpoint=False)
-    array([100.        ,  177.827941  ,  316.22776602,  562.34132519])
-    >>> np.logspace(2.0, 3.0, num=4, base=2.0)
-    array([4.        ,  5.0396842 ,  6.34960421,  8.        ])
-
-    Graphical illustration:
-
-    >>> import matplotlib.pyplot as plt
-    >>> N = 10
-    >>> x1 = np.logspace(0.1, 1, N, endpoint=True)
-    >>> x2 = np.logspace(0.1, 1, N, endpoint=False)
-    >>> y = np.zeros(N)
-    >>> plt.plot(x1, y, 'o')
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.plot(x2, y + 0.5, 'o')
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.ylim([-0.5, 1])
-    (-0.5, 1)
-    >>> plt.show()
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def logical_not (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_not"))))
-(alter-meta! #'logical_not assoc :doc "logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute the truth value of NOT x element-wise.
-
-Parameters
-----------
-x : array_like
-    Logical NOT is applied to the elements of `x`.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : bool or ndarray of bool
-    Boolean result with the same shape as `x` of the NOT operation
-    on elements of `x`.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-logical_and, logical_or, logical_xor
-
-Examples
---------
->>> np.logical_not(3)
-False
->>> np.logical_not([True, False, 0, 1])
-array([False,  True,  True, False])
-
->>> x = np.arange(5)
->>> np.logical_not(x<3)
-array([False, False, False,  True,  True])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def loads (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "loads"))))
-(alter-meta! #'loads assoc :doc "" :arglists '[[& [args {:as kwargs}]]])
-
-(def bincount (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bincount"))))
-(alter-meta! #'bincount assoc :doc "
-    bincount(x, weights=None, minlength=0)
-
-    Count number of occurrences of each value in array of non-negative ints.
-
-    The number of bins (of size 1) is one larger than the largest value in
-    `x`. If `minlength` is specified, there will be at least this number
-    of bins in the output array (though it will be longer if necessary,
-    depending on the contents of `x`).
-    Each bin gives the number of occurrences of its index value in `x`.
-    If `weights` is specified the input array is weighted by it, i.e. if a
-    value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead
-    of ``out[n] += 1``.
-
-    Parameters
-    ----------
-    x : array_like, 1 dimension, nonnegative ints
-        Input array.
-    weights : array_like, optional
-        Weights, array of the same shape as `x`.
-    minlength : int, optional
-        A minimum number of bins for the output array.
-
-        .. versionadded:: 1.6.0
-
-    Returns
-    -------
-    out : ndarray of ints
-        The result of binning the input array.
-        The length of `out` is equal to ``np.amax(x)+1``.
-
-    Raises
-    ------
-    ValueError
-        If the input is not 1-dimensional, or contains elements with negative
-        values, or if `minlength` is negative.
-    TypeError
-        If the type of the input is float or complex.
-
-    See Also
-    --------
-    histogram, digitize, unique
-
-    Examples
-    --------
-    >>> np.bincount(np.arange(5))
-    array([1, 1, 1, 1, 1])
-    >>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7]))
-    array([1, 3, 1, 1, 0, 0, 0, 1])
-
-    >>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23])
-    >>> np.bincount(x).size == np.amax(x)+1
-    True
-
-    The input array needs to be of integer dtype, otherwise a
-    TypeError is raised:
-
-    >>> np.bincount(np.arange(5, dtype=float))
-    Traceback (most recent call last):
-      File \"<stdin>\", line 1, in <module>
-    TypeError: array cannot be safely cast to required type
-
-    A possible use of ``bincount`` is to perform sums over
-    variable-size chunks of an array, using the ``weights`` keyword.
-
-    >>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights
-    >>> x = np.array([0, 1, 1, 2, 2, 2])
-    >>> np.bincount(x,  weights=w)
-    array([ 0.3,  0.7,  1.1])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def format_float_scientific (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "format_float_scientific"))))
-(alter-meta! #'format_float_scientific assoc :doc "
-    Format a floating-point scalar as a decimal string in scientific notation.
-
-    Provides control over rounding, trimming and padding. Uses and assumes
-    IEEE unbiased rounding. Uses the \"Dragon4\" algorithm.
-
-    Parameters
-    ----------
-    x : python float or numpy floating scalar
-        Value to format.
-    precision : non-negative integer or None, optional
-        Maximum number of digits to print. May be None if `unique` is
-        `True`, but must be an integer if unique is `False`.
-    unique : boolean, optional
-        If `True`, use a digit-generation strategy which gives the shortest
-        representation which uniquely identifies the floating-point number from
-        other values of the same type, by judicious rounding. If `precision`
-        was omitted, print all necessary digits, otherwise digit generation is
-        cut off after `precision` digits and the remaining value is rounded.
-        If `False`, digits are generated as if printing an infinite-precision
-        value and stopping after `precision` digits, rounding the remaining
-        value.
-    trim : one of 'k', '.', '0', '-', optional
-        Controls post-processing trimming of trailing digits, as follows:
-
-        * 'k' : keep trailing zeros, keep decimal point (no trimming)
-        * '.' : trim all trailing zeros, leave decimal point
-        * '0' : trim all but the zero before the decimal point. Insert the
-          zero if it is missing.
-        * '-' : trim trailing zeros and any trailing decimal point
-    sign : boolean, optional
-        Whether to show the sign for positive values.
-    pad_left : non-negative integer, optional
-        Pad the left side of the string with whitespace until at least that
-        many characters are to the left of the decimal point.
-    exp_digits : non-negative integer, optional
-        Pad the exponent with zeros until it contains at least this many digits.
-        If omitted, the exponent will be at least 2 digits.
-
-    Returns
-    -------
-    rep : string
-        The string representation of the floating point value
-
-    See Also
-    --------
-    format_float_positional
-
-    Examples
-    --------
-    >>> np.format_float_scientific(np.float32(np.pi))
-    '3.1415927e+00'
-    >>> s = np.float32(1.23e24)
-    >>> np.format_float_scientific(s, unique=False, precision=15)
-    '1.230000071797338e+24'
-    >>> np.format_float_scientific(s, exp_digits=4)
-    '1.23e+0024'
-    " :arglists '[[x & [{precision :precision, unique :unique, trim :trim, sign :sign, pad_left :pad_left, exp_digits :exp_digits}]] [x & [{precision :precision, unique :unique, trim :trim, sign :sign, pad_left :pad_left}]] [x & [{precision :precision, unique :unique, trim :trim, sign :sign}]] [x & [{precision :precision, unique :unique, trim :trim}]] [x & [{precision :precision, unique :unique}]] [x & [{precision :precision}]] [x]])
-
-(def tan (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tan"))))
-(alter-meta! #'tan assoc :doc "tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute tangent element-wise.
-
-Equivalent to ``np.sin(x)/np.cos(x)`` element-wise.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The corresponding tangent values.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-If `out` is provided, the function writes the result into it,
-and returns a reference to `out`.  (See Examples)
-
-References
-----------
-M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
-New York, NY: Dover, 1972.
-
-Examples
---------
->>> from math import pi
->>> np.tan(np.array([-pi,pi/2,pi]))
-array([  1.22460635e-16,   1.63317787e+16,  -1.22460635e-16])
->>>
->>> # Example of providing the optional output parameter illustrating
->>> # that what is returned is a reference to said parameter
->>> out1 = np.array([0], dtype='d')
->>> out2 = np.cos([0.1], out1)
->>> out2 is out1
-True
->>>
->>> # Example of ValueError due to provision of shape mis-matched `out`
->>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
-Traceback (most recent call last):
-  File \"<stdin>\", line 1, in <module>
-ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]])
-
-(def int_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int_"))))
-(alter-meta! #'int_ assoc :doc "Signed integer type, compatible with Python `int` anc C ``long``.
-    Character code: ``'l'``.
-    Canonical name: ``np.int_``.
-    Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807).
-    Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def recarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "recarray"))))
-(alter-meta! #'recarray assoc :doc "Construct an ndarray that allows field access using attributes.
-
-    Arrays may have a data-types containing fields, analogous
-    to columns in a spread sheet.  An example is ``[(x, int), (y, float)]``,
-    where each entry in the array is a pair of ``(int, float)``.  Normally,
-    these attributes are accessed using dictionary lookups such as ``arr['x']``
-    and ``arr['y']``.  Record arrays allow the fields to be accessed as members
-    of the array, using ``arr.x`` and ``arr.y``.
-
-    Parameters
-    ----------
-    shape : tuple
-        Shape of output array.
-    dtype : data-type, optional
-        The desired data-type.  By default, the data-type is determined
-        from `formats`, `names`, `titles`, `aligned` and `byteorder`.
-    formats : list of data-types, optional
-        A list containing the data-types for the different columns, e.g.
-        ``['i4', 'f8', 'i4']``.  `formats` does *not* support the new
-        convention of using types directly, i.e. ``(int, float, int)``.
-        Note that `formats` must be a list, not a tuple.
-        Given that `formats` is somewhat limited, we recommend specifying
-        `dtype` instead.
-    names : tuple of str, optional
-        The name of each column, e.g. ``('x', 'y', 'z')``.
-    buf : buffer, optional
-        By default, a new array is created of the given shape and data-type.
-        If `buf` is specified and is an object exposing the buffer interface,
-        the array will use the memory from the existing buffer.  In this case,
-        the `offset` and `strides` keywords are available.
-
-    Other Parameters
-    ----------------
-    titles : tuple of str, optional
-        Aliases for column names.  For example, if `names` were
-        ``('x', 'y', 'z')`` and `titles` is
-        ``('x_coordinate', 'y_coordinate', 'z_coordinate')``, then
-        ``arr['x']`` is equivalent to both ``arr.x`` and ``arr.x_coordinate``.
-    byteorder : {'<', '>', '='}, optional
-        Byte-order for all fields.
-    aligned : bool, optional
-        Align the fields in memory as the C-compiler would.
-    strides : tuple of ints, optional
-        Buffer (`buf`) is interpreted according to these strides (strides
-        define how many bytes each array element, row, column, etc.
-        occupy in memory).
-    offset : int, optional
-        Start reading buffer (`buf`) from this offset onwards.
-    order : {'C', 'F'}, optional
-        Row-major (C-style) or column-major (Fortran-style) order.
-
-    Returns
-    -------
-    rec : recarray
-        Empty array of the given shape and type.
-
-    See Also
-    --------
-    rec.fromrecords : Construct a record array from data.
-    record : fundamental data-type for `recarray`.
-    format_parser : determine a data-type from formats, names, titles.
-
-    Notes
-    -----
-    This constructor can be compared to ``empty``: it creates a new record
-    array but does not fill it with data.  To create a record array from data,
-    use one of the following methods:
-
-    1. Create a standard ndarray and convert it to a record array,
-       using ``arr.view(np.recarray)``
-    2. Use the `buf` keyword.
-    3. Use `np.rec.fromrecords`.
-
-    Examples
-    --------
-    Create an array with two fields, ``x`` and ``y``:
-
-    >>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', '<f8'), ('y', '<i8')])
-    >>> x
-    array([(1., 2), (3., 4)], dtype=[('x', '<f8'), ('y', '<i8')])
-
-    >>> x['x']
-    array([1., 3.])
-
-    View the array as a record array:
-
-    >>> x = x.view(np.recarray)
-
-    >>> x.x
-    array([1., 3.])
-
-    >>> x.y
-    array([2, 4])
-
-    Create a new, empty record array:
-
-    >>> np.recarray((2,),
-    ... dtype=[('x', int), ('y', float), ('z', int)]) #doctest: +SKIP
-    rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),
-           (3471280, 1.2134086255804012e-316, 0)],
-          dtype=[('x', '<i4'), ('y', '<f8'), ('z', '<i4')])
-
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def cos (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cos"))))
-(alter-meta! #'cos assoc :doc "cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Cosine element-wise.
-
-Parameters
-----------
-x : array_like
-    Input array in radians.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The corresponding cosine values.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-If `out` is provided, the function writes the result into it,
-and returns a reference to `out`.  (See Examples)
-
-References
-----------
-M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
-New York, NY: Dover, 1972.
-
-Examples
---------
->>> np.cos(np.array([0, np.pi/2, np.pi]))
-array([  1.00000000e+00,   6.12303177e-17,  -1.00000000e+00])
->>>
->>> # Example of providing the optional output parameter
->>> out1 = np.array([0], dtype='d')
->>> out2 = np.cos([0.1], out1)
->>> out2 is out1
-True
->>>
->>> # Example of ValueError due to provision of shape mis-matched `out`
->>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
-Traceback (most recent call last):
-  File \"<stdin>\", line 1, in <module>
-ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]])
-
-(def tensordot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tensordot"))))
-(alter-meta! #'tensordot assoc :doc "
-    Compute tensor dot product along specified axes.
-
-    Given two tensors, `a` and `b`, and an array_like object containing
-    two array_like objects, ``(a_axes, b_axes)``, sum the products of
-    `a`'s and `b`'s elements (components) over the axes specified by
-    ``a_axes`` and ``b_axes``. The third argument can be a single non-negative
-    integer_like scalar, ``N``; if it is such, then the last ``N`` dimensions
-    of `a` and the first ``N`` dimensions of `b` are summed over.
-
-    Parameters
-    ----------
-    a, b : array_like
-        Tensors to \"dot\".
-
-    axes : int or (2,) array_like
-        * integer_like
-          If an int N, sum over the last N axes of `a` and the first N axes
-          of `b` in order. The sizes of the corresponding axes must match.
-        * (2,) array_like
-          Or, a list of axes to be summed over, first sequence applying to `a`,
-          second to `b`. Both elements array_like must be of the same length.
-
-    Returns
-    -------
-    output : ndarray
-        The tensor dot product of the input.
-
-    See Also
-    --------
-    dot, einsum
-
-    Notes
-    -----
-    Three common use cases are:
-        * ``axes = 0`` : tensor product :math:`a\\otimes b`
-        * ``axes = 1`` : tensor dot product :math:`a\\cdot b`
-        * ``axes = 2`` : (default) tensor double contraction :math:`a:b`
-
-    When `axes` is integer_like, the sequence for evaluation will be: first
-    the -Nth axis in `a` and 0th axis in `b`, and the -1th axis in `a` and
-    Nth axis in `b` last.
-
-    When there is more than one axis to sum over - and they are not the last
-    (first) axes of `a` (`b`) - the argument `axes` should consist of
-    two sequences of the same length, with the first axis to sum over given
-    first in both sequences, the second axis second, and so forth.
-
-    The shape of the result consists of the non-contracted axes of the
-    first tensor, followed by the non-contracted axes of the second.
-
-    Examples
-    --------
-    A \"traditional\" example:
-
-    >>> a = np.arange(60.).reshape(3,4,5)
-    >>> b = np.arange(24.).reshape(4,3,2)
-    >>> c = np.tensordot(a,b, axes=([1,0],[0,1]))
-    >>> c.shape
-    (5, 2)
-    >>> c
-    array([[4400., 4730.],
-           [4532., 4874.],
-           [4664., 5018.],
-           [4796., 5162.],
-           [4928., 5306.]])
-    >>> # A slower but equivalent way of computing the same...
-    >>> d = np.zeros((5,2))
-    >>> for i in range(5):
-    ...   for j in range(2):
-    ...     for k in range(3):
-    ...       for n in range(4):
-    ...         d[i,j] += a[k,n,i] * b[n,k,j]
-    >>> c == d
-    array([[ True,  True],
-           [ True,  True],
-           [ True,  True],
-           [ True,  True],
-           [ True,  True]])
-
-    An extended example taking advantage of the overloading of + and \\*:
-
-    >>> a = np.array(range(1, 9))
-    >>> a.shape = (2, 2, 2)
-    >>> A = np.array(('a', 'b', 'c', 'd'), dtype=object)
-    >>> A.shape = (2, 2)
-    >>> a; A
-    array([[[1, 2],
-            [3, 4]],
-           [[5, 6],
-            [7, 8]]])
-    array([['a', 'b'],
-           ['c', 'd']], dtype=object)
-
-    >>> np.tensordot(a, A) # third argument default is 2 for double-contraction
-    array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object)
-
-    >>> np.tensordot(a, A, 1)
-    array([[['acc', 'bdd'],
-            ['aaacccc', 'bbbdddd']],
-           [['aaaaacccccc', 'bbbbbdddddd'],
-            ['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object)
-
-    >>> np.tensordot(a, A, 0) # tensor product (result too long to incl.)
-    array([[[[['a', 'b'],
-              ['c', 'd']],
-              ...
-
-    >>> np.tensordot(a, A, (0, 1))
-    array([[['abbbbb', 'cddddd'],
-            ['aabbbbbb', 'ccdddddd']],
-           [['aaabbbbbbb', 'cccddddddd'],
-            ['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object)
-
-    >>> np.tensordot(a, A, (2, 1))
-    array([[['abb', 'cdd'],
-            ['aaabbbb', 'cccdddd']],
-           [['aaaaabbbbbb', 'cccccdddddd'],
-            ['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object)
-
-    >>> np.tensordot(a, A, ((0, 1), (0, 1)))
-    array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object)
-
-    >>> np.tensordot(a, A, ((2, 1), (1, 0)))
-    array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def DataSource (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "DataSource"))))
-(alter-meta! #'DataSource assoc :doc "
-    DataSource(destpath='.')
-
-    A generic data source file (file, http, ftp, ...).
-
-    DataSources can be local files or remote files/URLs.  The files may
-    also be compressed or uncompressed. DataSource hides some of the
-    low-level details of downloading the file, allowing you to simply pass
-    in a valid file path (or URL) and obtain a file object.
-
-    Parameters
-    ----------
-    destpath : str or None, optional
-        Path to the directory where the source file gets downloaded to for
-        use.  If `destpath` is None, a temporary directory will be created.
-        The default path is the current directory.
-
-    Notes
-    -----
-    URLs require a scheme string (``http://``) to be used, without it they
-    will fail::
-
-        >>> repos = np.DataSource()
-        >>> repos.exists('www.google.com/index.html')
-        False
-        >>> repos.exists('http://www.google.com/index.html')
-        True
-
-    Temporary directories are deleted when the DataSource is deleted.
-
-    Examples
-    --------
-    ::
-
-        >>> ds = np.DataSource('/home/guido')
-        >>> urlname = 'http://www.google.com/'
-        >>> gfile = ds.open('http://www.google.com/')
-        >>> ds.abspath(urlname)
-        '/home/guido/www.google.com/index.html'
-
-        >>> ds = np.DataSource(None)  # use with temporary file
-        >>> ds.open('/home/guido/foobar.txt')
-        <open file '/home/guido.foobar.txt', mode 'r' at 0x91d4430>
-        >>> ds.abspath('/home/guido/foobar.txt')
-        '/tmp/.../home/guido/foobar.txt'
-
-    " :arglists '[[self & [{destpath :destpath}]] [self]])
-
-(def argsort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argsort"))))
-(alter-meta! #'argsort assoc :doc "
-    Returns the indices that would sort an array.
-
-    Perform an indirect sort along the given axis using the algorithm specified
-    by the `kind` keyword. It returns an array of indices of the same shape as
-    `a` that index data along the given axis in sorted order.
-
-    Parameters
-    ----------
-    a : array_like
-        Array to sort.
-    axis : int or None, optional
-        Axis along which to sort.  The default is -1 (the last axis). If None,
-        the flattened array is used.
-    kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
-        Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
-        and 'mergesort' use timsort under the covers and, in general, the
-        actual implementation will vary with data type. The 'mergesort' option
-        is retained for backwards compatibility.
-
-        .. versionchanged:: 1.15.0.
-           The 'stable' option was added.
-    order : str or list of str, optional
-        When `a` is an array with fields defined, this argument specifies
-        which fields to compare first, second, etc.  A single field can
-        be specified as a string, and not all fields need be specified,
-        but unspecified fields will still be used, in the order in which
-        they come up in the dtype, to break ties.
-
-    Returns
-    -------
-    index_array : ndarray, int
-        Array of indices that sort `a` along the specified `axis`.
-        If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.
-        More generally, ``np.take_along_axis(a, index_array, axis=axis)``
-        always yields the sorted `a`, irrespective of dimensionality.
-
-    See Also
-    --------
-    sort : Describes sorting algorithms used.
-    lexsort : Indirect stable sort with multiple keys.
-    ndarray.sort : Inplace sort.
-    argpartition : Indirect partial sort.
-    take_along_axis : Apply ``index_array`` from argsort 
-                      to an array as if by calling sort.
-
-    Notes
-    -----
-    See `sort` for notes on the different sorting algorithms.
-
-    As of NumPy 1.4.0 `argsort` works with real/complex arrays containing
-    nan values. The enhanced sort order is documented in `sort`.
-
-    Examples
-    --------
-    One dimensional array:
-
-    >>> x = np.array([3, 1, 2])
-    >>> np.argsort(x)
-    array([1, 2, 0])
-
-    Two-dimensional array:
-
-    >>> x = np.array([[0, 3], [2, 2]])
-    >>> x
-    array([[0, 3],
-           [2, 2]])
-
-    >>> ind = np.argsort(x, axis=0)  # sorts along first axis (down)
-    >>> ind
-    array([[0, 1],
-           [1, 0]])
-    >>> np.take_along_axis(x, ind, axis=0)  # same as np.sort(x, axis=0)
-    array([[0, 2],
-           [2, 3]])
-
-    >>> ind = np.argsort(x, axis=1)  # sorts along last axis (across)
-    >>> ind
-    array([[0, 1],
-           [0, 1]])
-    >>> np.take_along_axis(x, ind, axis=1)  # same as np.sort(x, axis=1)
-    array([[0, 3],
-           [2, 2]])
-
-    Indices of the sorted elements of a N-dimensional array:
-
-    >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape)
-    >>> ind
-    (array([0, 1, 1, 0]), array([0, 0, 1, 1]))
-    >>> x[ind]  # same as np.sort(x, axis=None)
-    array([0, 2, 2, 3])
-
-    Sorting with keys:
-
-    >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
-    >>> x
-    array([(1, 0), (0, 1)],
-          dtype=[('x', '<i4'), ('y', '<i4')])
-
-    >>> np.argsort(x, order=('x','y'))
-    array([1, 0])
-
-    >>> np.argsort(x, order=('y','x'))
-    array([0, 1])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def trunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trunc"))))
-(alter-meta! #'trunc assoc :doc "trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the truncated value of the input, element-wise.
-
-The truncated value of the scalar `x` is the nearest integer `i` which
-is closer to zero than `x` is. In short, the fractional part of the
-signed number `x` is discarded.
-
-Parameters
-----------
-x : array_like
-    Input data.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or scalar
-    The truncated value of each element in `x`.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-ceil, floor, rint
-
-Notes
------
-.. versionadded:: 1.3.0
-
-Examples
---------
->>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
->>> np.trunc(a)
-array([-1., -1., -0.,  0.,  1.,  1.,  2.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def intersect1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "intersect1d"))))
-(alter-meta! #'intersect1d assoc :doc "
-    Find the intersection of two arrays.
-
-    Return the sorted, unique values that are in both of the input arrays.
-
-    Parameters
-    ----------
-    ar1, ar2 : array_like
-        Input arrays. Will be flattened if not already 1D.
-    assume_unique : bool
-        If True, the input arrays are both assumed to be unique, which
-        can speed up the calculation.  Default is False.
-    return_indices : bool
-        If True, the indices which correspond to the intersection of the two
-        arrays are returned. The first instance of a value is used if there are
-        multiple. Default is False.
-
-        .. versionadded:: 1.15.0
-
-    Returns
-    -------
-    intersect1d : ndarray
-        Sorted 1D array of common and unique elements.
-    comm1 : ndarray
-        The indices of the first occurrences of the common values in `ar1`.
-        Only provided if `return_indices` is True.
-    comm2 : ndarray
-        The indices of the first occurrences of the common values in `ar2`.
-        Only provided if `return_indices` is True.
-
-
-    See Also
-    --------
-    numpy.lib.arraysetops : Module with a number of other functions for
-                            performing set operations on arrays.
-
-    Examples
-    --------
-    >>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
-    array([1, 3])
-
-    To intersect more than two arrays, use functools.reduce:
-
-    >>> from functools import reduce
-    >>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
-    array([3])
-
-    To return the indices of the values common to the input arrays
-    along with the intersected values:
-
-    >>> x = np.array([1, 1, 2, 3, 4])
-    >>> y = np.array([2, 1, 4, 6])
-    >>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)
-    >>> x_ind, y_ind
-    (array([0, 2, 4]), array([1, 0, 2]))
-    >>> xy, x[x_ind], y[y_ind]
-    (array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def fill_diagonal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fill_diagonal"))))
-(alter-meta! #'fill_diagonal assoc :doc "Fill the main diagonal of the given array of any dimensionality.
-
-    For an array `a` with ``a.ndim >= 2``, the diagonal is the list of
-    locations with indices ``a[i, ..., i]`` all identical. This function
-    modifies the input array in-place, it does not return a value.
-
-    Parameters
-    ----------
-    a : array, at least 2-D.
-      Array whose diagonal is to be filled, it gets modified in-place.
-
-    val : scalar
-      Value to be written on the diagonal, its type must be compatible with
-      that of the array a.
-
-    wrap : bool
-      For tall matrices in NumPy version up to 1.6.2, the
-      diagonal \"wrapped\" after N columns. You can have this behavior
-      with this option. This affects only tall matrices.
-
-    See also
-    --------
-    diag_indices, diag_indices_from
-
-    Notes
-    -----
-    .. versionadded:: 1.4.0
-
-    This functionality can be obtained via `diag_indices`, but internally
-    this version uses a much faster implementation that never constructs the
-    indices and uses simple slicing.
-
-    Examples
-    --------
-    >>> a = np.zeros((3, 3), int)
-    >>> np.fill_diagonal(a, 5)
-    >>> a
-    array([[5, 0, 0],
-           [0, 5, 0],
-           [0, 0, 5]])
-
-    The same function can operate on a 4-D array:
-
-    >>> a = np.zeros((3, 3, 3, 3), int)
-    >>> np.fill_diagonal(a, 4)
-
-    We only show a few blocks for clarity:
-
-    >>> a[0, 0]
-    array([[4, 0, 0],
-           [0, 0, 0],
-           [0, 0, 0]])
-    >>> a[1, 1]
-    array([[0, 0, 0],
-           [0, 4, 0],
-           [0, 0, 0]])
-    >>> a[2, 2]
-    array([[0, 0, 0],
-           [0, 0, 0],
-           [0, 0, 4]])
-
-    The wrap option affects only tall matrices:
-
-    >>> # tall matrices no wrap
-    >>> a = np.zeros((5, 3), int)
-    >>> np.fill_diagonal(a, 4)
-    >>> a
-    array([[4, 0, 0],
-           [0, 4, 0],
-           [0, 0, 4],
-           [0, 0, 0],
-           [0, 0, 0]])
-
-    >>> # tall matrices wrap
-    >>> a = np.zeros((5, 3), int)
-    >>> np.fill_diagonal(a, 4, wrap=True)
-    >>> a
-    array([[4, 0, 0],
-           [0, 4, 0],
-           [0, 0, 4],
-           [0, 0, 0],
-           [4, 0, 0]])
-
-    >>> # wide matrices
-    >>> a = np.zeros((3, 5), int)
-    >>> np.fill_diagonal(a, 4, wrap=True)
-    >>> a
-    array([[4, 0, 0, 0, 0],
-           [0, 4, 0, 0, 0],
-           [0, 0, 4, 0, 0]])
-
-    The anti-diagonal can be filled by reversing the order of elements
-    using either `numpy.flipud` or `numpy.fliplr`.
-
-    >>> a = np.zeros((3, 3), int);
-    >>> np.fill_diagonal(np.fliplr(a), [1,2,3])  # Horizontal flip
-    >>> a
-    array([[0, 0, 1],
-           [0, 2, 0],
-           [3, 0, 0]])
-    >>> np.fill_diagonal(np.flipud(a), [1,2,3])  # Vertical flip
-    >>> a
-    array([[0, 0, 3],
-           [0, 2, 0],
-           [1, 0, 0]])
-
-    Note that the order in which the diagonal is filled varies depending
-    on the flip function.
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "
-``numpy.linalg``
-================
-
-The NumPy linear algebra functions rely on BLAS and LAPACK to provide efficient
-low level implementations of standard linear algebra algorithms. Those
-libraries may be provided by NumPy itself using C versions of a subset of their
-reference implementations but, when possible, highly optimized libraries that
-take advantage of specialized processor functionality are preferred. Examples
-of such libraries are OpenBLAS, MKL (TM), and ATLAS. Because those libraries
-are multithreaded and processor dependent, environmental variables and external
-packages such as threadpoolctl may be needed to control the number of threads
-or specify the processor architecture.
-
-- OpenBLAS: https://www.openblas.net/
-- threadpoolctl: https://github.com/joblib/threadpoolctl
-
-Please note that the most-used linear algebra functions in NumPy are present in
-the main ``numpy`` namespace rather than in ``numpy.linalg``.  There are:
-``dot``, ``vdot``, ``inner``, ``outer``, ``matmul``, ``tensordot``, ``einsum``,
-``einsum_path`` and ``kron``.
-
-Functions present in numpy.linalg are listed below.
-
-
-Matrix and vector products
---------------------------
-
-   multi_dot
-   matrix_power
-
-Decompositions
---------------
-
-   cholesky
-   qr
-   svd
-
-Matrix eigenvalues
-------------------
-
-   eig
-   eigh
-   eigvals
-   eigvalsh
-
-Norms and other numbers
------------------------
-
-   norm
-   cond
-   det
-   matrix_rank
-   slogdet
-
-Solving equations and inverting matrices
-----------------------------------------
-
-   solve
-   tensorsolve
-   lstsq
-   inv
-   pinv
-   tensorinv
-
-Exceptions
-----------
-
-   LinAlgError
-
-"} linalg (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "linalg"))))
-
-(def triu_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "triu_indices"))))
-(alter-meta! #'triu_indices assoc :doc "
-    Return the indices for the upper-triangle of an (n, m) array.
-
-    Parameters
-    ----------
-    n : int
-        The size of the arrays for which the returned indices will
-        be valid.
-    k : int, optional
-        Diagonal offset (see `triu` for details).
-    m : int, optional
-        .. versionadded:: 1.9.0
-
-        The column dimension of the arrays for which the returned
-        arrays will be valid.
-        By default `m` is taken equal to `n`.
-
-
-    Returns
-    -------
-    inds : tuple, shape(2) of ndarrays, shape(`n`)
-        The indices for the triangle. The returned tuple contains two arrays,
-        each with the indices along one dimension of the array.  Can be used
-        to slice a ndarray of shape(`n`, `n`).
-
-    See also
-    --------
-    tril_indices : similar function, for lower-triangular.
-    mask_indices : generic function accepting an arbitrary mask function.
-    triu, tril
-
-    Notes
-    -----
-    .. versionadded:: 1.4.0
-
-    Examples
-    --------
-    Compute two different sets of indices to access 4x4 arrays, one for the
-    upper triangular part starting at the main diagonal, and one starting two
-    diagonals further right:
-
-    >>> iu1 = np.triu_indices(4)
-    >>> iu2 = np.triu_indices(4, 2)
-
-    Here is how they can be used with a sample array:
-
-    >>> a = np.arange(16).reshape(4, 4)
-    >>> a
-    array([[ 0,  1,  2,  3],
-           [ 4,  5,  6,  7],
-           [ 8,  9, 10, 11],
-           [12, 13, 14, 15]])
-
-    Both for indexing:
-
-    >>> a[iu1]
-    array([ 0,  1,  2, ..., 10, 11, 15])
-
-    And for assigning values:
-
-    >>> a[iu1] = -1
-    >>> a
-    array([[-1, -1, -1, -1],
-           [ 4, -1, -1, -1],
-           [ 8,  9, -1, -1],
-           [12, 13, 14, -1]])
-
-    These cover only a small part of the whole array (two diagonals right
-    of the main one):
-
-    >>> a[iu2] = -10
-    >>> a
-    array([[ -1,  -1, -10, -10],
-           [  4,  -1,  -1, -10],
-           [  8,   9,  -1,  -1],
-           [ 12,  13,  14,  -1]])
-
-    " :arglists '[[n & [{k :k, m :m}]] [n & [{k :k}]] [n]])
-
-(def mod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mod"))))
-(alter-meta! #'mod assoc :doc "remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return element-wise remainder of division.
-
-Computes the remainder complementary to the `floor_divide` function.  It is
-equivalent to the Python modulus operator``x1 % x2`` and has the same sign
-as the divisor `x2`. The MATLAB function equivalent to ``np.remainder``
-is ``mod``.
-
-.. warning::
-
-    This should not be confused with:
-
-    * Python 3.7's `math.remainder` and C's ``remainder``, which
-      computes the IEEE remainder, which are the complement to
-      ``round(x1 / x2)``.
-    * The MATLAB ``rem`` function and or the C ``%`` operator which is the
-      complement to ``int(x1 / x2)``.
-
-Parameters
-----------
-x1 : array_like
-    Dividend array.
-x2 : array_like
-    Divisor array. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-floor_divide : Equivalent of Python ``//`` operator.
-divmod : Simultaneous floor division and remainder.
-fmod : Equivalent of the MATLAB ``rem`` function.
-divide, floor
-
-Notes
------
-Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
-integers.
-``mod`` is an alias of ``remainder``.
-
-Examples
---------
->>> np.remainder([4, 7], [2, 3])
-array([0, 1])
->>> np.remainder(np.arange(7), 5)
-array([0, 1, 2, 3, 4, 0, 1])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def mirr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mirr"))))
-(alter-meta! #'mirr assoc :doc "
-    Modified internal rate of return.
-
-    .. deprecated:: 1.18
-
-       `mirr` is deprecated; for details, see NEP 32 [1]_.
-       Use the corresponding function in the numpy-financial library,
-       https://pypi.org/project/numpy-financial.
-
-    Parameters
-    ----------
-    values : array_like
-        Cash flows (must contain at least one positive and one negative
-        value) or nan is returned.  The first value is considered a sunk
-        cost at time zero.
-    finance_rate : scalar
-        Interest rate paid on the cash flows
-    reinvest_rate : scalar
-        Interest rate received on the cash flows upon reinvestment
-
-    Returns
-    -------
-    out : float
-        Modified internal rate of return
-
-    References
-    ----------
-    .. [1] NumPy Enhancement Proposal (NEP) 32,
-       https://numpy.org/neps/nep-0032-remove-financial-functions.html
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def broadcast_arrays (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "broadcast_arrays"))))
-(alter-meta! #'broadcast_arrays assoc :doc "
-    Broadcast any number of arrays against each other.
-
-    Parameters
-    ----------
-    `*args` : array_likes
-        The arrays to broadcast.
-
-    subok : bool, optional
-        If True, then sub-classes will be passed-through, otherwise
-        the returned arrays will be forced to be a base-class array (default).
-
-    Returns
-    -------
-    broadcasted : list of arrays
-        These arrays are views on the original arrays.  They are typically
-        not contiguous.  Furthermore, more than one element of a
-        broadcasted array may refer to a single memory location. If you need
-        to write to the arrays, make copies first. While you can set the
-        ``writable`` flag True, writing to a single output value may end up
-        changing more than one location in the output array.
-
-        .. deprecated:: 1.17
-            The output is currently marked so that if written to, a deprecation
-            warning will be emitted. A future version will set the
-            ``writable`` flag False so writing to it will raise an error.
-
-    Examples
-    --------
-    >>> x = np.array([[1,2,3]])
-    >>> y = np.array([[4],[5]])
-    >>> np.broadcast_arrays(x, y)
-    [array([[1, 2, 3],
-           [1, 2, 3]]), array([[4, 4, 4],
-           [5, 5, 5]])]
-
-    Here is a useful idiom for getting contiguous copies instead of
-    non-contiguous views.
-
-    >>> [np.array(a) for a in np.broadcast_arrays(x, y)]
-    [array([[1, 2, 3],
-           [1, 2, 3]]), array([[4, 4, 4],
-           [5, 5, 5]])]
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def integer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "integer"))))
-(alter-meta! #'integer assoc :doc "Abstract base class of all integer scalar types." :arglists '[[self & [args {:as kwargs}]]])
-
-(def geterrobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geterrobj"))))
-(alter-meta! #'geterrobj assoc :doc "geterrobj()
-
-    Return the current object that defines floating-point error handling.
-
-    The error object contains all information that defines the error handling
-    behavior in NumPy. `geterrobj` is used internally by the other
-    functions that get and set error handling behavior (`geterr`, `seterr`,
-    `geterrcall`, `seterrcall`).
-
-    Returns
-    -------
-    errobj : list
-        The error object, a list containing three elements:
-        [internal numpy buffer size, error mask, error callback function].
-
-        The error mask is a single integer that holds the treatment information
-        on all four floating point errors. The information for each error type
-        is contained in three bits of the integer. If we print it in base 8, we
-        can see what treatment is set for \"invalid\", \"under\", \"over\", and
-        \"divide\" (in that order). The printed string can be interpreted with
-
-        * 0 : 'ignore'
-        * 1 : 'warn'
-        * 2 : 'raise'
-        * 3 : 'call'
-        * 4 : 'print'
-        * 5 : 'log'
-
-    See Also
-    --------
-    seterrobj, seterr, geterr, seterrcall, geterrcall
-    getbufsize, setbufsize
-
-    Notes
-    -----
-    For complete documentation of the types of floating-point exceptions and
-    treatment options, see `seterr`.
-
-    Examples
-    --------
-    >>> np.geterrobj()  # first get the defaults
-    [8192, 521, None]
-
-    >>> def err_handler(type, flag):
-    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
-    ...
-    >>> old_bufsize = np.setbufsize(20000)
-    >>> old_err = np.seterr(divide='raise')
-    >>> old_handler = np.seterrcall(err_handler)
-    >>> np.geterrobj()
-    [8192, 521, <function err_handler at 0x91dcaac>]
-
-    >>> old_err = np.seterr(all='ignore')
-    >>> np.base_repr(np.geterrobj()[1], 8)
-    '0'
-    >>> old_err = np.seterr(divide='warn', over='log', under='call',
-    ...                     invalid='print')
-    >>> np.base_repr(np.geterrobj()[1], 8)
-    '4351'" :arglists '[[self & [args {:as kwargs}]]])
-
-(def printoptions (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "printoptions"))))
-(alter-meta! #'printoptions assoc :doc "Context manager for setting print options.
-
-    Set print options for the scope of the `with` block, and restore the old
-    options at the end. See `set_printoptions` for the full description of
-    available options.
-
-    Examples
-    --------
-
-    >>> from numpy.testing import assert_equal
-    >>> with np.printoptions(precision=2):
-    ...     np.array([2.0]) / 3
-    array([0.67])
-
-    The `as`-clause of the `with`-statement gives the current print options:
-
-    >>> with np.printoptions(precision=2) as opts:
-    ...      assert_equal(opts, np.get_printoptions())
-
-    See Also
-    --------
-    set_printoptions, get_printoptions
-
-    " :arglists '[[& [args {:as kwds}]]])
-
-(def int8 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int8"))))
-(alter-meta! #'int8 assoc :doc "Signed integer type, compatible with C ``char``.
-    Character code: ``'b'``.
-    Canonical name: ``np.byte``.
-    Alias *on this platform*: ``np.int8``: 8-bit signed integer (-128 to 127)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def safe_eval (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "safe_eval"))))
-(alter-meta! #'safe_eval assoc :doc "
-    Protected string evaluation.
-
-    Evaluate a string containing a Python literal expression without
-    allowing the execution of arbitrary non-literal code.
-
-    Parameters
-    ----------
-    source : str
-        The string to evaluate.
-
-    Returns
-    -------
-    obj : object
-       The result of evaluating `source`.
-
-    Raises
-    ------
-    SyntaxError
-        If the code has invalid Python syntax, or if it contains
-        non-literal code.
-
-    Examples
-    --------
-    >>> np.safe_eval('1')
-    1
-    >>> np.safe_eval('[1, 2, 3]')
-    [1, 2, 3]
-    >>> np.safe_eval('{\"foo\": (\"bar\", 10.0)}')
-    {'foo': ('bar', 10.0)}
-
-    >>> np.safe_eval('import os')
-    Traceback (most recent call last):
-      ...
-    SyntaxError: invalid syntax
-
-    >>> np.safe_eval('open(\"/home/user/.ssh/id_dsa\").read()')
-    Traceback (most recent call last):
-      ...
-    ValueError: malformed node or string: <_ast.Call object at 0x...>
-
-    " :arglists '[[source]])
-
-(def ^{:doc "
-**Note:** almost all functions in the ``numpy.lib`` namespace
-are also present in the main ``numpy`` namespace.  Please use the
-functions as ``np.<funcname>`` where possible.
-
-``numpy.lib`` is mostly a space for implementing functions that don't
-belong in core or in another NumPy submodule with a clear purpose
-(e.g. ``random``, ``fft``, ``linalg``, ``ma``).
-
-Most contains basic functions that are used by several submodules and are
-useful to have in the main name-space.
-
-"} lib (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "lib"))))
-
-(def promote_types (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "promote_types"))))
-(alter-meta! #'promote_types assoc :doc "promote_types(type1, type2)
-
-    Returns the data type with the smallest size and smallest scalar
-    kind to which both ``type1`` and ``type2`` may be safely cast.
-    The returned data type is always in native byte order.
-
-    This function is symmetric, but rarely associative.
-
-    Parameters
-    ----------
-    type1 : dtype or dtype specifier
-        First data type.
-    type2 : dtype or dtype specifier
-        Second data type.
-
-    Returns
-    -------
-    out : dtype
-        The promoted data type.
-
-    Notes
-    -----
-    .. versionadded:: 1.6.0
-
-    Starting in NumPy 1.9, promote_types function now returns a valid string
-    length when given an integer or float dtype as one argument and a string
-    dtype as another argument. Previously it always returned the input string
-    dtype, even if it wasn't long enough to store the max integer/float value
-    converted to a string.
-
-    See Also
-    --------
-    result_type, dtype, can_cast
-
-    Examples
-    --------
-    >>> np.promote_types('f4', 'f8')
-    dtype('float64')
-
-    >>> np.promote_types('i8', 'f4')
-    dtype('float64')
-
-    >>> np.promote_types('>i8', '<c8')
-    dtype('complex128')
-
-    >>> np.promote_types('i4', 'S8')
-    dtype('S11')
-
-    An example of a non-associative case:
-
-    >>> p = np.promote_types
-    >>> p('S', p('i1', 'u1'))
-    dtype('S6')
-    >>> p(p('S', 'i1'), 'u1')
-    dtype('S4')" :arglists '[[self & [args {:as kwargs}]]])
-
-(def square (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "square"))))
-(alter-meta! #'square assoc :doc "square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the element-wise square of the input.
-
-Parameters
-----------
-x : array_like
-    Input data.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Element-wise `x*x`, of the same shape and dtype as `x`.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-numpy.linalg.matrix_power
-sqrt
-power
-
-Examples
---------
->>> np.square([-1j, 1])
-array([-1.-0.j,  1.+0.j])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ModuleDeprecationWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ModuleDeprecationWarning"))))
-(alter-meta! #'ModuleDeprecationWarning assoc :doc "Module deprecation warning.
-
-    The nose tester turns ordinary Deprecation warnings into test failures.
-    That makes it hard to deprecate whole modules, because they get
-    imported by default. So this is a special Deprecation warning that the
-    nose tester will let pass without making tests fail.
-
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def may_share_memory (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "may_share_memory"))))
-(alter-meta! #'may_share_memory assoc :doc "
-    may_share_memory(a, b, max_work=None)
-
-    Determine if two arrays might share memory
-
-    A return of True does not necessarily mean that the two arrays
-    share any element.  It just means that they *might*.
-
-    Only the memory bounds of a and b are checked by default.
-
-    Parameters
-    ----------
-    a, b : ndarray
-        Input arrays
-    max_work : int, optional
-        Effort to spend on solving the overlap problem.  See
-        `shares_memory` for details.  Default for ``may_share_memory``
-        is to do a bounds check.
-
-    Returns
-    -------
-    out : bool
-
-    See Also
-    --------
-    shares_memory
-
-    Examples
-    --------
-    >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9]))
-    False
-    >>> x = np.zeros([3, 4])
-    >>> np.may_share_memory(x[:,0], x[:,1])
-    True
-
-    " :arglists '[[& [args {:as kwargs}]]])
-(def ^{:doc "dict() -> new empty dictionary
-dict(mapping) -> new dictionary initialized from a mapping object's
-    (key, value) pairs
-dict(iterable) -> new dictionary initialized as if via:
-    d = {}
-    for k, v in iterable:
-        d[k] = v
-dict(**kwargs) -> new dictionary initialized with the name=value pairs
-    in the keyword argument list.  For example:  dict(one=1, two=2)"} __builtins__ (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "__builtins__")))) 
-
-(def source (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "source"))))
-(alter-meta! #'source assoc :doc "
-    Print or write to a file the source code for a NumPy object.
-
-    The source code is only returned for objects written in Python. Many
-    functions and classes are defined in C and will therefore not return
-    useful information.
-
-    Parameters
-    ----------
-    object : numpy object
-        Input object. This can be any object (function, class, module,
-        ...).
-    output : file object, optional
-        If `output` not supplied then source code is printed to screen
-        (sys.stdout).  File object must be created with either write 'w' or
-        append 'a' modes.
-
-    See Also
-    --------
-    lookfor, info
-
-    Examples
-    --------
-    >>> np.source(np.interp)                        #doctest: +SKIP
-    In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py
-    def interp(x, xp, fp, left=None, right=None):
-        \"\"\".... (full docstring printed)\"\"\"
-        if isinstance(x, (float, int, number)):
-            return compiled_interp([x], xp, fp, left, right).item()
-        else:
-            return compiled_interp(x, xp, fp, left, right)
-
-    The source code is only returned for objects written in Python.
-
-    >>> np.source(np.array)                         #doctest: +SKIP
-    Not available for this object.
-
-    " :arglists '[[object & [{output :output}]] [object]])
-
-(def swapaxes (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "swapaxes"))))
-(alter-meta! #'swapaxes assoc :doc "
-    Interchange two axes of an array.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    axis1 : int
-        First axis.
-    axis2 : int
-        Second axis.
-
-    Returns
-    -------
-    a_swapped : ndarray
-        For NumPy >= 1.10.0, if `a` is an ndarray, then a view of `a` is
-        returned; otherwise a new array is created. For earlier NumPy
-        versions a view of `a` is returned only if the order of the
-        axes is changed, otherwise the input array is returned.
-
-    Examples
-    --------
-    >>> x = np.array([[1,2,3]])
-    >>> np.swapaxes(x,0,1)
-    array([[1],
-           [2],
-           [3]])
-
-    >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
-    >>> x
-    array([[[0, 1],
-            [2, 3]],
-           [[4, 5],
-            [6, 7]]])
-
-    >>> np.swapaxes(x,0,2)
-    array([[[0, 4],
-            [2, 6]],
-           [[1, 5],
-            [3, 7]]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} ERR_LOG (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_LOG"))))
-
-(def sort_complex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sort_complex"))))
-(alter-meta! #'sort_complex assoc :doc "
-    Sort a complex array using the real part first, then the imaginary part.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array
-
-    Returns
-    -------
-    out : complex ndarray
-        Always returns a sorted complex array.
-
-    Examples
-    --------
-    >>> np.sort_complex([5, 3, 6, 2, 1])
-    array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])
-
-    >>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])
-    array([1.+2.j,  2.-1.j,  3.-3.j,  3.-2.j,  3.+5.j])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def less (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "less"))))
-(alter-meta! #'less assoc :doc "less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the truth value of (x1 < x2) element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Output array, element-wise comparison of `x1` and `x2`.
-    Typically of type bool, unless ``dtype=object`` is passed.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-greater, less_equal, greater_equal, equal, not_equal
-
-Examples
---------
->>> np.less([1, 2], [2, 2])
-array([ True, False])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def complexfloating (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complexfloating"))))
-(alter-meta! #'complexfloating assoc :doc "Abstract base class of all complex number scalar types that are made up of
-    floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def unpackbits (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unpackbits"))))
-(alter-meta! #'unpackbits assoc :doc "
-    unpackbits(a, axis=None, count=None, bitorder='big')
-
-    Unpacks elements of a uint8 array into a binary-valued output array.
-
-    Each element of `a` represents a bit-field that should be unpacked
-    into a binary-valued output array. The shape of the output array is
-    either 1-D (if `axis` is ``None``) or the same shape as the input
-    array with unpacking done along the axis specified.
-
-    Parameters
-    ----------
-    a : ndarray, uint8 type
-       Input array.
-    axis : int, optional
-        The dimension over which bit-unpacking is done.
-        ``None`` implies unpacking the flattened array.
-    count : int or None, optional
-        The number of elements to unpack along `axis`, provided as a way
-        of undoing the effect of packing a size that is not a multiple
-        of eight. A non-negative number means to only unpack `count`
-        bits. A negative number means to trim off that many bits from
-        the end. ``None`` means to unpack the entire array (the
-        default). Counts larger than the available number of bits will
-        add zero padding to the output. Negative counts must not
-        exceed the available number of bits.
-
-        .. versionadded:: 1.17.0
-
-    bitorder : {'big', 'little'}, optional
-        The order of the returned bits. 'big' will mimic bin(val),
-        ``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse
-        the order to ``[1, 1, 0, 0, 0, 0, 0, 0]``.
-        Defaults to 'big'.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    unpacked : ndarray, uint8 type
-       The elements are binary-valued (0 or 1).
-
-    See Also
-    --------
-    packbits : Packs the elements of a binary-valued array into bits in
-               a uint8 array.
-
-    Examples
-    --------
-    >>> a = np.array([[2], [7], [23]], dtype=np.uint8)
-    >>> a
-    array([[ 2],
-           [ 7],
-           [23]], dtype=uint8)
-    >>> b = np.unpackbits(a, axis=1)
-    >>> b
-    array([[0, 0, 0, 0, 0, 0, 1, 0],
-           [0, 0, 0, 0, 0, 1, 1, 1],
-           [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)
-    >>> c = np.unpackbits(a, axis=1, count=-3)
-    >>> c
-    array([[0, 0, 0, 0, 0],
-           [0, 0, 0, 0, 0],
-           [0, 0, 0, 1, 0]], dtype=uint8)
-
-    >>> p = np.packbits(b, axis=0)
-    >>> np.unpackbits(p, axis=0)
-    array([[0, 0, 0, 0, 0, 0, 1, 0],
-           [0, 0, 0, 0, 0, 1, 1, 1],
-           [0, 0, 0, 1, 0, 1, 1, 1],
-           [0, 0, 0, 0, 0, 0, 0, 0],
-           [0, 0, 0, 0, 0, 0, 0, 0],
-           [0, 0, 0, 0, 0, 0, 0, 0],
-           [0, 0, 0, 0, 0, 0, 0, 0],
-           [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
-    >>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0]))
-    True
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def union1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "union1d"))))
-(alter-meta! #'union1d assoc :doc "
-    Find the union of two arrays.
-
-    Return the unique, sorted array of values that are in either of the two
-    input arrays.
-
-    Parameters
-    ----------
-    ar1, ar2 : array_like
-        Input arrays. They are flattened if they are not already 1D.
-
-    Returns
-    -------
-    union1d : ndarray
-        Unique, sorted union of the input arrays.
-
-    See Also
-    --------
-    numpy.lib.arraysetops : Module with a number of other functions for
-                            performing set operations on arrays.
-
-    Examples
-    --------
-    >>> np.union1d([-1, 0, 1], [-2, 0, 2])
-    array([-2, -1,  0,  1,  2])
-
-    To find the union of more than two arrays, use functools.reduce:
-
-    >>> from functools import reduce
-    >>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
-    array([1, 2, 3, 4, 6])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def piecewise (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "piecewise"))))
-(alter-meta! #'piecewise assoc :doc "
-    Evaluate a piecewise-defined function.
-
-    Given a set of conditions and corresponding functions, evaluate each
-    function on the input data wherever its condition is true.
-
-    Parameters
-    ----------
-    x : ndarray or scalar
-        The input domain.
-    condlist : list of bool arrays or bool scalars
-        Each boolean array corresponds to a function in `funclist`.  Wherever
-        `condlist[i]` is True, `funclist[i](x)` is used as the output value.
-
-        Each boolean array in `condlist` selects a piece of `x`,
-        and should therefore be of the same shape as `x`.
-
-        The length of `condlist` must correspond to that of `funclist`.
-        If one extra function is given, i.e. if
-        ``len(funclist) == len(condlist) + 1``, then that extra function
-        is the default value, used wherever all conditions are false.
-    funclist : list of callables, f(x,*args,**kw), or scalars
-        Each function is evaluated over `x` wherever its corresponding
-        condition is True.  It should take a 1d array as input and give an 1d
-        array or a scalar value as output.  If, instead of a callable,
-        a scalar is provided then a constant function (``lambda x: scalar``) is
-        assumed.
-    args : tuple, optional
-        Any further arguments given to `piecewise` are passed to the functions
-        upon execution, i.e., if called ``piecewise(..., ..., 1, 'a')``, then
-        each function is called as ``f(x, 1, 'a')``.
-    kw : dict, optional
-        Keyword arguments used in calling `piecewise` are passed to the
-        functions upon execution, i.e., if called
-        ``piecewise(..., ..., alpha=1)``, then each function is called as
-        ``f(x, alpha=1)``.
-
-    Returns
-    -------
-    out : ndarray
-        The output is the same shape and type as x and is found by
-        calling the functions in `funclist` on the appropriate portions of `x`,
-        as defined by the boolean arrays in `condlist`.  Portions not covered
-        by any condition have a default value of 0.
-
-
-    See Also
-    --------
-    choose, select, where
-
-    Notes
-    -----
-    This is similar to choose or select, except that functions are
-    evaluated on elements of `x` that satisfy the corresponding condition from
-    `condlist`.
-
-    The result is::
-
-            |--
-            |funclist[0](x[condlist[0]])
-      out = |funclist[1](x[condlist[1]])
-            |...
-            |funclist[n2](x[condlist[n2]])
-            |--
-
-    Examples
-    --------
-    Define the sigma function, which is -1 for ``x < 0`` and +1 for ``x >= 0``.
-
-    >>> x = np.linspace(-2.5, 2.5, 6)
-    >>> np.piecewise(x, [x < 0, x >= 0], [-1, 1])
-    array([-1., -1., -1.,  1.,  1.,  1.])
-
-    Define the absolute value, which is ``-x`` for ``x <0`` and ``x`` for
-    ``x >= 0``.
-
-    >>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x])
-    array([2.5,  1.5,  0.5,  0.5,  1.5,  2.5])
-
-    Apply the same function to a scalar value.
-
-    >>> y = -2
-    >>> np.piecewise(y, [y < 0, y >= 0], [lambda x: -x, lambda x: x])
-    array(2)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def abs (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "abs"))))
-(alter-meta! #'abs assoc :doc "absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Calculate the absolute value element-wise.
-
-``np.abs`` is a shorthand for this function.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-absolute : ndarray
-    An ndarray containing the absolute value of
-    each element in `x`.  For complex input, ``a + ib``, the
-    absolute value is :math:`\\sqrt{ a^2 + b^2 }`.
-    This is a scalar if `x` is a scalar.
-
-Examples
---------
->>> x = np.array([-1.2, 1.2])
->>> np.absolute(x)
-array([ 1.2,  1.2])
->>> np.absolute(1.2 + 1j)
-1.5620499351813308
-
-Plot the function over ``[-10, 10]``:
-
->>> import matplotlib.pyplot as plt
-
->>> x = np.linspace(start=-10, stop=10, num=101)
->>> plt.plot(x, np.absolute(x))
->>> plt.show()
-
-Plot the function over the complex plane:
-
->>> xx = x + 1j * x[:, np.newaxis]
->>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')
->>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
-
-(def getbufsize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "getbufsize"))))
-(alter-meta! #'getbufsize assoc :doc "
-    Return the size of the buffer used in ufuncs.
-
-    Returns
-    -------
-    getbufsize : int
-        Size of ufunc buffer in bytes.
-
-    " :arglists '[[]])
-
-(def tril_indices_from (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tril_indices_from"))))
-(alter-meta! #'tril_indices_from assoc :doc "
-    Return the indices for the lower-triangle of arr.
-
-    See `tril_indices` for full details.
-
-    Parameters
-    ----------
-    arr : array_like
-        The indices will be valid for square arrays whose dimensions are
-        the same as arr.
-    k : int, optional
-        Diagonal offset (see `tril` for details).
-
-    See Also
-    --------
-    tril_indices, tril
-
-    Notes
-    -----
-    .. versionadded:: 1.4.0
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "
-Module defining global singleton classes.
-
-This module raises a RuntimeError if an attempt to reload it is made. In that
-way the identities of the classes defined here are fixed and will remain so
-even if numpy itself is reloaded. In particular, a function like the following
-will still work correctly after numpy is reloaded::
-
-    def foo(arg=np._NoValue):
-        if arg is np._NoValue:
-            ...
-
-That was not the case when the singleton classes were defined in the numpy
-``__init__.py`` file. See gh-7844 for a discussion of the reload problem that
-motivated this module.
-
-"} _globals (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_globals"))))
-
-(def conj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "conj"))))
-(alter-meta! #'conj assoc :doc "conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the complex conjugate, element-wise.
-
-The complex conjugate of a complex number is obtained by changing the
-sign of its imaginary part.
-
-Parameters
-----------
-x : array_like
-    Input value.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The complex conjugate of `x`, with same dtype as `y`.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-`conj` is an alias for `conjugate`:
-
->>> np.conj is np.conjugate
-True
-
-Examples
---------
->>> np.conjugate(1+2j)
-(1-2j)
-
->>> x = np.eye(2) + 1j * np.eye(2)
->>> np.conjugate(x)
-array([[ 1.-1.j,  0.-0.j],
-       [ 0.-0.j,  1.-1.j]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def argpartition (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argpartition"))))
-(alter-meta! #'argpartition assoc :doc "
-    Perform an indirect partition along the given axis using the
-    algorithm specified by the `kind` keyword. It returns an array of
-    indices of the same shape as `a` that index data along the given
-    axis in partitioned order.
-
-    .. versionadded:: 1.8.0
-
-    Parameters
-    ----------
-    a : array_like
-        Array to sort.
-    kth : int or sequence of ints
-        Element index to partition by. The k-th element will be in its
-        final sorted position and all smaller elements will be moved
-        before it and all larger elements behind it. The order all
-        elements in the partitions is undefined. If provided with a
-        sequence of k-th it will partition all of them into their sorted
-        position at once.
-    axis : int or None, optional
-        Axis along which to sort. The default is -1 (the last axis). If
-        None, the flattened array is used.
-    kind : {'introselect'}, optional
-        Selection algorithm. Default is 'introselect'
-    order : str or list of str, optional
-        When `a` is an array with fields defined, this argument
-        specifies which fields to compare first, second, etc. A single
-        field can be specified as a string, and not all fields need be
-        specified, but unspecified fields will still be used, in the
-        order in which they come up in the dtype, to break ties.
-
-    Returns
-    -------
-    index_array : ndarray, int
-        Array of indices that partition `a` along the specified axis.
-        If `a` is one-dimensional, ``a[index_array]`` yields a partitioned `a`.
-        More generally, ``np.take_along_axis(a, index_array, axis=a)`` always
-        yields the partitioned `a`, irrespective of dimensionality.
-
-    See Also
-    --------
-    partition : Describes partition algorithms used.
-    ndarray.partition : Inplace partition.
-    argsort : Full indirect sort.
-    take_along_axis : Apply ``index_array`` from argpartition 
-                      to an array as if by calling partition.
-
-    Notes
-    -----
-    See `partition` for notes on the different selection algorithms.
-
-    Examples
-    --------
-    One dimensional array:
-
-    >>> x = np.array([3, 4, 2, 1])
-    >>> x[np.argpartition(x, 3)]
-    array([2, 1, 3, 4])
-    >>> x[np.argpartition(x, (1, 3))]
-    array([1, 2, 3, 4])
-
-    >>> x = [3, 4, 2, 1]
-    >>> np.array(x)[np.argpartition(x, 3)]
-    array([2, 1, 3, 4])
-
-    Multi-dimensional array:
-
-    >>> x = np.array([[3, 4, 2], [1, 3, 1]])
-    >>> index_array = np.argpartition(x, kth=1, axis=-1)
-    >>> np.take_along_axis(x, index_array, axis=-1)  # same as np.partition(x, kth=1)
-    array([[2, 3, 4],
-           [1, 1, 3]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def show_config (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "show_config"))))
-(alter-meta! #'show_config assoc :doc "" :arglists '[[]])
-
-(def arange (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arange"))))
-(alter-meta! #'arange assoc :doc "arange([start,] stop[, step,], dtype=None)
-
-    Return evenly spaced values within a given interval.
-
-    Values are generated within the half-open interval ``[start, stop)``
-    (in other words, the interval including `start` but excluding `stop`).
-    For integer arguments the function is equivalent to the Python built-in
-    `range` function, but returns an ndarray rather than a list.
-
-    When using a non-integer step, such as 0.1, the results will often not
-    be consistent.  It is better to use `numpy.linspace` for these cases.
-
-    Parameters
-    ----------
-    start : number, optional
-        Start of interval.  The interval includes this value.  The default
-        start value is 0.
-    stop : number
-        End of interval.  The interval does not include this value, except
-        in some cases where `step` is not an integer and floating point
-        round-off affects the length of `out`.
-    step : number, optional
-        Spacing between values.  For any output `out`, this is the distance
-        between two adjacent values, ``out[i+1] - out[i]``.  The default
-        step size is 1.  If `step` is specified as a position argument,
-        `start` must also be given.
-    dtype : dtype
-        The type of the output array.  If `dtype` is not given, infer the data
-        type from the other input arguments.
-
-    Returns
-    -------
-    arange : ndarray
-        Array of evenly spaced values.
-
-        For floating point arguments, the length of the result is
-        ``ceil((stop - start)/step)``.  Because of floating point overflow,
-        this rule may result in the last element of `out` being greater
-        than `stop`.
-
-    See Also
-    --------
-    numpy.linspace : Evenly spaced numbers with careful handling of endpoints.
-    numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.
-    numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
-
-    Examples
-    --------
-    >>> np.arange(3)
-    array([0, 1, 2])
-    >>> np.arange(3.0)
-    array([ 0.,  1.,  2.])
-    >>> np.arange(3,7)
-    array([3, 4, 5, 6])
-    >>> np.arange(3,7,2)
-    array([3, 5])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def vander (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vander"))))
-(alter-meta! #'vander assoc :doc "
-    Generate a Vandermonde matrix.
-
-    The columns of the output matrix are powers of the input vector. The
-    order of the powers is determined by the `increasing` boolean argument.
-    Specifically, when `increasing` is False, the `i`-th output column is
-    the input vector raised element-wise to the power of ``N - i - 1``. Such
-    a matrix with a geometric progression in each row is named for Alexandre-
-    Theophile Vandermonde.
-
-    Parameters
-    ----------
-    x : array_like
-        1-D input array.
-    N : int, optional
-        Number of columns in the output.  If `N` is not specified, a square
-        array is returned (``N = len(x)``).
-    increasing : bool, optional
-        Order of the powers of the columns.  If True, the powers increase
-        from left to right, if False (the default) they are reversed.
-
-        .. versionadded:: 1.9.0
-
-    Returns
-    -------
-    out : ndarray
-        Vandermonde matrix.  If `increasing` is False, the first column is
-        ``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is
-        True, the columns are ``x^0, x^1, ..., x^(N-1)``.
-
-    See Also
-    --------
-    polynomial.polynomial.polyvander
-
-    Examples
-    --------
-    >>> x = np.array([1, 2, 3, 5])
-    >>> N = 3
-    >>> np.vander(x, N)
-    array([[ 1,  1,  1],
-           [ 4,  2,  1],
-           [ 9,  3,  1],
-           [25,  5,  1]])
-
-    >>> np.column_stack([x**(N-1-i) for i in range(N)])
-    array([[ 1,  1,  1],
-           [ 4,  2,  1],
-           [ 9,  3,  1],
-           [25,  5,  1]])
-
-    >>> x = np.array([1, 2, 3, 5])
-    >>> np.vander(x)
-    array([[  1,   1,   1,   1],
-           [  8,   4,   2,   1],
-           [ 27,   9,   3,   1],
-           [125,  25,   5,   1]])
-    >>> np.vander(x, increasing=True)
-    array([[  1,   1,   1,   1],
-           [  1,   2,   4,   8],
-           [  1,   3,   9,  27],
-           [  1,   5,  25, 125]])
-
-    The determinant of a square Vandermonde matrix is the product
-    of the differences between the values of the input vector:
-
-    >>> np.linalg.det(np.vander(x))
-    48.000000000000043 # may vary
-    >>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)
-    48
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def expm1 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "expm1"))))
-(alter-meta! #'expm1 assoc :doc "expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Calculate ``exp(x) - 1`` for all elements in the array.
-
-Parameters
-----------
-x : array_like
-   Input values.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Element-wise exponential minus one: ``out = exp(x) - 1``.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-log1p : ``log(1 + x)``, the inverse of expm1.
-
-
-Notes
------
-This function provides greater precision than ``exp(x) - 1``
-for small values of ``x``.
-
-Examples
---------
-The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to
-about 32 significant digits. This example shows the superiority of
-expm1 in this case.
-
->>> np.expm1(1e-10)
-1.00000000005e-10
->>> np.exp(1e-10) - 1
-1.000000082740371e-10" :arglists '[[self & [args {:as kwargs}]]])
-
-(def binary_repr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "binary_repr"))))
-(alter-meta! #'binary_repr assoc :doc "
-    Return the binary representation of the input number as a string.
-
-    For negative numbers, if width is not given, a minus sign is added to the
-    front. If width is given, the two's complement of the number is
-    returned, with respect to that width.
-
-    In a two's-complement system negative numbers are represented by the two's
-    complement of the absolute value. This is the most common method of
-    representing signed integers on computers [1]_. A N-bit two's-complement
-    system can represent every integer in the range
-    :math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
-
-    Parameters
-    ----------
-    num : int
-        Only an integer decimal number can be used.
-    width : int, optional
-        The length of the returned string if `num` is positive, or the length
-        of the two's complement if `num` is negative, provided that `width` is
-        at least a sufficient number of bits for `num` to be represented in the
-        designated form.
-
-        If the `width` value is insufficient, it will be ignored, and `num` will
-        be returned in binary (`num` > 0) or two's complement (`num` < 0) form
-        with its width equal to the minimum number of bits needed to represent
-        the number in the designated form. This behavior is deprecated and will
-        later raise an error.
-
-        .. deprecated:: 1.12.0
-
-    Returns
-    -------
-    bin : str
-        Binary representation of `num` or two's complement of `num`.
-
-    See Also
-    --------
-    base_repr: Return a string representation of a number in the given base
-               system.
-    bin: Python's built-in binary representation generator of an integer.
-
-    Notes
-    -----
-    `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x
-    faster.
-
-    References
-    ----------
-    .. [1] Wikipedia, \"Two's complement\",
-        https://en.wikipedia.org/wiki/Two's_complement
-
-    Examples
-    --------
-    >>> np.binary_repr(3)
-    '11'
-    >>> np.binary_repr(-3)
-    '-11'
-    >>> np.binary_repr(3, width=4)
-    '0011'
-
-    The two's complement is returned when the input number is negative and
-    width is specified:
-
-    >>> np.binary_repr(-3, width=3)
-    '101'
-    >>> np.binary_repr(-3, width=5)
-    '11101'
-
-    " :arglists '[[num & [{width :width}]] [num]])
-
-(def double (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "double"))))
-(alter-meta! #'double assoc :doc "Double-precision floating-point number type, compatible with Python `float`
-    and C ``double``.
-    Character code: ``'d'``.
-    Canonical name: ``np.double``.
-    Alias: ``np.float_``.
-    Alias *on this platform*: ``np.float64``: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
-
-(def vstack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vstack"))))
-(alter-meta! #'vstack assoc :doc "
-    Stack arrays in sequence vertically (row wise).
-
-    This is equivalent to concatenation along the first axis after 1-D arrays
-    of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
-    `vsplit`.
-
-    This function makes most sense for arrays with up to 3 dimensions. For
-    instance, for pixel-data with a height (first axis), width (second axis),
-    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
-    `block` provide more general stacking and concatenation operations.
-
-    Parameters
-    ----------
-    tup : sequence of ndarrays
-        The arrays must have the same shape along all but the first axis.
-        1-D arrays must have the same length.
-
-    Returns
-    -------
-    stacked : ndarray
-        The array formed by stacking the given arrays, will be at least 2-D.
-
-    See Also
-    --------
-    stack : Join a sequence of arrays along a new axis.
-    hstack : Stack arrays in sequence horizontally (column wise).
-    dstack : Stack arrays in sequence depth wise (along third dimension).
-    concatenate : Join a sequence of arrays along an existing axis.
-    vsplit : Split array into a list of multiple sub-arrays vertically.
-    block : Assemble arrays from blocks.
-
-    Examples
-    --------
-    >>> a = np.array([1, 2, 3])
-    >>> b = np.array([2, 3, 4])
-    >>> np.vstack((a,b))
-    array([[1, 2, 3],
-           [2, 3, 4]])
-
-    >>> a = np.array([[1], [2], [3]])
-    >>> b = np.array([[2], [3], [4]])
-    >>> np.vstack((a,b))
-    array([[1],
-           [2],
-           [3],
-           [2],
-           [3],
-           [4]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} version (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "version"))))
-
-(def argwhere (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argwhere"))))
-(alter-meta! #'argwhere assoc :doc "
-    Find the indices of array elements that are non-zero, grouped by element.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-
-    Returns
-    -------
-    index_array : (N, a.ndim) ndarray
-        Indices of elements that are non-zero. Indices are grouped by element.
-        This array will have shape ``(N, a.ndim)`` where ``N`` is the number of
-        non-zero items.
-
-    See Also
-    --------
-    where, nonzero
-
-    Notes
-    -----
-    ``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``,
-    but produces a result of the correct shape for a 0D array.
-
-    The output of ``argwhere`` is not suitable for indexing arrays.
-    For this purpose use ``nonzero(a)`` instead.
-
-    Examples
-    --------
-    >>> x = np.arange(6).reshape(2,3)
-    >>> x
-    array([[0, 1, 2],
-           [3, 4, 5]])
-    >>> np.argwhere(x>1)
-    array([[0, 2],
-           [1, 0],
-           [1, 1],
-           [1, 2]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def iterable (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iterable"))))
-(alter-meta! #'iterable assoc :doc "
-    Check whether or not an object can be iterated over.
-
-    Parameters
-    ----------
-    y : object
-      Input object.
-
-    Returns
-    -------
-    b : bool
-      Return ``True`` if the object has an iterator method or is a
-      sequence and ``False`` otherwise.
-
-
-    Examples
-    --------
-    >>> np.iterable([1, 2, 3])
-    True
-    >>> np.iterable(2)
-    False
-
-    " :arglists '[[y]])
-
-(def _add_newdoc_ufunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "_add_newdoc_ufunc"))))
-(alter-meta! #'_add_newdoc_ufunc assoc :doc "add_ufunc_docstring(ufunc, new_docstring)
-
-    Replace the docstring for a ufunc with new_docstring.
-    This method will only work if the current docstring for
-    the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)
-
-    Parameters
-    ----------
-    ufunc : numpy.ufunc
-        A ufunc whose current doc is NULL.
-    new_docstring : string
-        The new docstring for the ufunc.
-
-    Notes
-    -----
-    This method allocates memory for new_docstring on
-    the heap. Technically this creates a mempory leak, since this
-    memory will not be reclaimed until the end of the program
-    even if the ufunc itself is removed. However this will only
-    be a problem if the user is repeatedly creating ufuncs with
-    no documentation, adding documentation via add_newdoc_ufunc,
-    and then throwing away the ufunc." :arglists '[[self & [args {:as kwargs}]]])
-
-(def append (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "append"))))
-(alter-meta! #'append assoc :doc "
-    Append values to the end of an array.
-
-    Parameters
-    ----------
-    arr : array_like
-        Values are appended to a copy of this array.
-    values : array_like
-        These values are appended to a copy of `arr`.  It must be of the
-        correct shape (the same shape as `arr`, excluding `axis`).  If
-        `axis` is not specified, `values` can be any shape and will be
-        flattened before use.
-    axis : int, optional
-        The axis along which `values` are appended.  If `axis` is not
-        given, both `arr` and `values` are flattened before use.
-
-    Returns
-    -------
-    append : ndarray
-        A copy of `arr` with `values` appended to `axis`.  Note that
-        `append` does not occur in-place: a new array is allocated and
-        filled.  If `axis` is None, `out` is a flattened array.
-
-    See Also
-    --------
-    insert : Insert elements into an array.
-    delete : Delete elements from an array.
-
-    Examples
-    --------
-    >>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]])
-    array([1, 2, 3, ..., 7, 8, 9])
-
-    When `axis` is specified, `values` must have the correct shape.
-
-    >>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)
-    array([[1, 2, 3],
-           [4, 5, 6],
-           [7, 8, 9]])
-    >>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)
-    Traceback (most recent call last):
-        ...
-    ValueError: all the input arrays must have same number of dimensions
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def iinfo (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iinfo"))))
-(alter-meta! #'iinfo assoc :doc "
-    iinfo(type)
-
-    Machine limits for integer types.
-
-    Attributes
-    ----------
-    bits : int
-        The number of bits occupied by the type.
-    min : int
-        The smallest integer expressible by the type.
-    max : int
-        The largest integer expressible by the type.
-
-    Parameters
-    ----------
-    int_type : integer type, dtype, or instance
-        The kind of integer data type to get information about.
-
-    See Also
-    --------
-    finfo : The equivalent for floating point data types.
-
-    Examples
-    --------
-    With types:
-
-    >>> ii16 = np.iinfo(np.int16)
-    >>> ii16.min
-    -32768
-    >>> ii16.max
-    32767
-    >>> ii32 = np.iinfo(np.int32)
-    >>> ii32.min
-    -2147483648
-    >>> ii32.max
-    2147483647
-
-    With instances:
-
-    >>> ii32 = np.iinfo(np.int32(10))
-    >>> ii32.min
-    -2147483648
-    >>> ii32.max
-    2147483647
-
-    " :arglists '[[self int_type]])
-
-(def ones_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ones_like"))))
-(alter-meta! #'ones_like assoc :doc "
-    Return an array of ones with the same shape and type as a given array.
-
-    Parameters
-    ----------
-    a : array_like
-        The shape and data-type of `a` define these same attributes of
-        the returned array.
-    dtype : data-type, optional
-        Overrides the data type of the result.
-
-        .. versionadded:: 1.6.0
-    order : {'C', 'F', 'A', or 'K'}, optional
-        Overrides the memory layout of the result. 'C' means C-order,
-        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
-        'C' otherwise. 'K' means match the layout of `a` as closely
-        as possible.
-
-        .. versionadded:: 1.6.0
-    subok : bool, optional.
-        If True, then the newly created array will use the sub-class
-        type of 'a', otherwise it will be a base-class array. Defaults
-        to True.
-    shape : int or sequence of ints, optional.
-        Overrides the shape of the result. If order='K' and the number of
-        dimensions is unchanged, will try to keep order, otherwise,
-        order='C' is implied.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    out : ndarray
-        Array of ones with the same shape and type as `a`.
-
-    See Also
-    --------
-    empty_like : Return an empty array with shape and type of input.
-    zeros_like : Return an array of zeros with shape and type of input.
-    full_like : Return a new array with shape of input filled with value.
-    ones : Return a new array setting values to one.
-
-    Examples
-    --------
-    >>> x = np.arange(6)
-    >>> x = x.reshape((2, 3))
-    >>> x
-    array([[0, 1, 2],
-           [3, 4, 5]])
-    >>> np.ones_like(x)
-    array([[1, 1, 1],
-           [1, 1, 1]])
-
-    >>> y = np.arange(3, dtype=float)
-    >>> y
-    array([0., 1., 2.])
-    >>> np.ones_like(y)
-    array([1.,  1.,  1.])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def full_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "full_like"))))
-(alter-meta! #'full_like assoc :doc "
-    Return a full array with the same shape and type as a given array.
-
-    Parameters
-    ----------
-    a : array_like
-        The shape and data-type of `a` define these same attributes of
-        the returned array.
-    fill_value : scalar
-        Fill value.
-    dtype : data-type, optional
-        Overrides the data type of the result.
-    order : {'C', 'F', 'A', or 'K'}, optional
-        Overrides the memory layout of the result. 'C' means C-order,
-        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
-        'C' otherwise. 'K' means match the layout of `a` as closely
-        as possible.
-    subok : bool, optional.
-        If True, then the newly created array will use the sub-class
-        type of 'a', otherwise it will be a base-class array. Defaults
-        to True.
-    shape : int or sequence of ints, optional.
-        Overrides the shape of the result. If order='K' and the number of
-        dimensions is unchanged, will try to keep order, otherwise,
-        order='C' is implied.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    out : ndarray
-        Array of `fill_value` with the same shape and type as `a`.
-
-    See Also
-    --------
-    empty_like : Return an empty array with shape and type of input.
-    ones_like : Return an array of ones with shape and type of input.
-    zeros_like : Return an array of zeros with shape and type of input.
-    full : Return a new array of given shape filled with value.
-
-    Examples
-    --------
-    >>> x = np.arange(6, dtype=int)
-    >>> np.full_like(x, 1)
-    array([1, 1, 1, 1, 1, 1])
-    >>> np.full_like(x, 0.1)
-    array([0, 0, 0, 0, 0, 0])
-    >>> np.full_like(x, 0.1, dtype=np.double)
-    array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
-    >>> np.full_like(x, np.nan, dtype=np.double)
-    array([nan, nan, nan, nan, nan, nan])
-
-    >>> y = np.arange(6, dtype=np.double)
-    >>> np.full_like(y, 0.1)
-    array([0.1,  0.1,  0.1,  0.1,  0.1,  0.1])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def atleast_1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "atleast_1d"))))
-(alter-meta! #'atleast_1d assoc :doc "
-    Convert inputs to arrays with at least one dimension.
-
-    Scalar inputs are converted to 1-dimensional arrays, whilst
-    higher-dimensional inputs are preserved.
-
-    Parameters
-    ----------
-    arys1, arys2, ... : array_like
-        One or more input arrays.
-
-    Returns
-    -------
-    ret : ndarray
-        An array, or list of arrays, each with ``a.ndim >= 1``.
-        Copies are made only if necessary.
-
-    See Also
-    --------
-    atleast_2d, atleast_3d
-
-    Examples
-    --------
-    >>> np.atleast_1d(1.0)
-    array([1.])
-
-    >>> x = np.arange(9.0).reshape(3,3)
-    >>> np.atleast_1d(x)
-    array([[0., 1., 2.],
-           [3., 4., 5.],
-           [6., 7., 8.]])
-    >>> np.atleast_1d(x) is x
-    True
-
-    >>> np.atleast_1d(1, [3, 4])
-    [array([1]), array([3, 4])]
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} SHIFT_UNDERFLOW (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "SHIFT_UNDERFLOW"))))
-
-(def asanyarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asanyarray"))))
-(alter-meta! #'asanyarray assoc :doc "Convert the input to an ndarray, but pass ndarray subclasses through.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data, in any form that can be converted to an array.  This
-        includes scalars, lists, lists of tuples, tuples, tuples of tuples,
-        tuples of lists, and ndarrays.
-    dtype : data-type, optional
-        By default, the data-type is inferred from the input data.
-    order : {'C', 'F'}, optional
-        Whether to use row-major (C-style) or column-major
-        (Fortran-style) memory representation.  Defaults to 'C'.
-
-    Returns
-    -------
-    out : ndarray or an ndarray subclass
-        Array interpretation of `a`.  If `a` is an ndarray or a subclass
-        of ndarray, it is returned as-is and no copy is performed.
-
-    See Also
-    --------
-    asarray : Similar function which always returns ndarrays.
-    ascontiguousarray : Convert input to a contiguous array.
-    asfarray : Convert input to a floating point ndarray.
-    asfortranarray : Convert input to an ndarray with column-major
-                     memory order.
-    asarray_chkfinite : Similar function which checks input for NaNs and
-                        Infs.
-    fromiter : Create an array from an iterator.
-    fromfunction : Construct an array by executing a function on grid
-                   positions.
-
-    Examples
-    --------
-    Convert a list into an array:
-
-    >>> a = [1, 2]
-    >>> np.asanyarray(a)
-    array([1, 2])
-
-    Instances of `ndarray` subclasses are passed through as-is:
-
-    >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
-    >>> np.asanyarray(a) is a
-    True
-
-    " :arglists '[[a & [{dtype :dtype, order :order}]] [a & [{dtype :dtype}]] [a]])
-
-(def lookfor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "lookfor"))))
-(alter-meta! #'lookfor assoc :doc "
-    Do a keyword search on docstrings.
-
-    A list of objects that matched the search is displayed,
-    sorted by relevance. All given keywords need to be found in the
-    docstring for it to be returned as a result, but the order does
-    not matter.
-
-    Parameters
-    ----------
-    what : str
-        String containing words to look for.
-    module : str or list, optional
-        Name of module(s) whose docstrings to go through.
-    import_modules : bool, optional
-        Whether to import sub-modules in packages. Default is True.
-    regenerate : bool, optional
-        Whether to re-generate the docstring cache. Default is False.
-    output : file-like, optional
-        File-like object to write the output to. If omitted, use a pager.
-
-    See Also
-    --------
-    source, info
-
-    Notes
-    -----
-    Relevance is determined only roughly, by checking if the keywords occur
-    in the function name, at the start of a docstring, etc.
-
-    Examples
-    --------
-    >>> np.lookfor('binary representation') # doctest: +SKIP
-    Search results for 'binary representation'
-    ------------------------------------------
-    numpy.binary_repr
-        Return the binary representation of the input number as a string.
-    numpy.core.setup_common.long_double_representation
-        Given a binary dump as given by GNU od -b, look for long double
-    numpy.base_repr
-        Return a string representation of a number in the given base system.
-    ...
-
-    " :arglists '[[what & [{module :module, import_modules :import_modules, regenerate :regenerate, output :output}]] [what & [{module :module, import_modules :import_modules, regenerate :regenerate}]] [what & [{module :module, import_modules :import_modules}]] [what & [{module :module}]] [what]])
-
-(def divide (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "divide"))))
-(alter-meta! #'divide assoc :doc "true_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Returns a true division of the inputs, element-wise.
-
-Instead of the Python traditional 'floor division', this returns a true
-division.  True division adjusts the output type to present the best
-answer, regardless of input types.
-
-Parameters
-----------
-x1 : array_like
-    Dividend array.
-x2 : array_like
-    Divisor array. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    This is a scalar if both `x1` and `x2` are scalars.
-
-Notes
------
-The floor division operator ``//`` was added in Python 2.2 making
-``//`` and ``/`` equivalent operators.  The default floor division
-operation of ``/`` can be replaced by true division with ``from
-__future__ import division``.
-
-In Python 3.0, ``//`` is the floor division operator and ``/`` the
-true division operator.  The ``true_divide(x1, x2)`` function is
-equivalent to true division in Python.
-
-Examples
---------
->>> x = np.arange(5)
->>> np.true_divide(x, 4)
-array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
-
->>> x//4
-array([0, 0, 0, 0, 1])
-
->>> from __future__ import division
->>> x/4
-array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
->>> x//4
-array([0, 0, 0, 0, 1])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def trim_zeros (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trim_zeros"))))
-(alter-meta! #'trim_zeros assoc :doc "
-    Trim the leading and/or trailing zeros from a 1-D array or sequence.
-
-    Parameters
-    ----------
-    filt : 1-D array or sequence
-        Input array.
-    trim : str, optional
-        A string with 'f' representing trim from front and 'b' to trim from
-        back. Default is 'fb', trim zeros from both front and back of the
-        array.
-
-    Returns
-    -------
-    trimmed : 1-D array or sequence
-        The result of trimming the input. The input data type is preserved.
-
-    Examples
-    --------
-    >>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0))
-    >>> np.trim_zeros(a)
-    array([1, 2, 3, 0, 2, 1])
-
-    >>> np.trim_zeros(a, 'b')
-    array([0, 0, 0, ..., 0, 2, 1])
-
-    The input data type is preserved, list/tuple in means list/tuple out.
-
-    >>> np.trim_zeros([0, 1, 2, 0])
-    [1, 2]
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def insert (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "insert"))))
-(alter-meta! #'insert assoc :doc "
-    Insert values along the given axis before the given indices.
-
-    Parameters
-    ----------
-    arr : array_like
-        Input array.
-    obj : int, slice or sequence of ints
-        Object that defines the index or indices before which `values` is
-        inserted.
-
-        .. versionadded:: 1.8.0
-
-        Support for multiple insertions when `obj` is a single scalar or a
-        sequence with one element (similar to calling insert multiple
-        times).
-    values : array_like
-        Values to insert into `arr`. If the type of `values` is different
-        from that of `arr`, `values` is converted to the type of `arr`.
-        `values` should be shaped so that ``arr[...,obj,...] = values``
-        is legal.
-    axis : int, optional
-        Axis along which to insert `values`.  If `axis` is None then `arr`
-        is flattened first.
-
-    Returns
-    -------
-    out : ndarray
-        A copy of `arr` with `values` inserted.  Note that `insert`
-        does not occur in-place: a new array is returned. If
-        `axis` is None, `out` is a flattened array.
-
-    See Also
-    --------
-    append : Append elements at the end of an array.
-    concatenate : Join a sequence of arrays along an existing axis.
-    delete : Delete elements from an array.
-
-    Notes
-    -----
-    Note that for higher dimensional inserts `obj=0` behaves very different
-    from `obj=[0]` just like `arr[:,0,:] = values` is different from
-    `arr[:,[0],:] = values`.
-
-    Examples
-    --------
-    >>> a = np.array([[1, 1], [2, 2], [3, 3]])
-    >>> a
-    array([[1, 1],
-           [2, 2],
-           [3, 3]])
-    >>> np.insert(a, 1, 5)
-    array([1, 5, 1, ..., 2, 3, 3])
-    >>> np.insert(a, 1, 5, axis=1)
-    array([[1, 5, 1],
-           [2, 5, 2],
-           [3, 5, 3]])
-
-    Difference between sequence and scalars:
-
-    >>> np.insert(a, [1], [[1],[2],[3]], axis=1)
-    array([[1, 1, 1],
-           [2, 2, 2],
-           [3, 3, 3]])
-    >>> np.array_equal(np.insert(a, 1, [1, 2, 3], axis=1),
-    ...                np.insert(a, [1], [[1],[2],[3]], axis=1))
-    True
-
-    >>> b = a.flatten()
-    >>> b
-    array([1, 1, 2, 2, 3, 3])
-    >>> np.insert(b, [2, 2], [5, 6])
-    array([1, 1, 5, ..., 2, 3, 3])
-
-    >>> np.insert(b, slice(2, 4), [5, 6])
-    array([1, 1, 5, ..., 2, 3, 3])
-
-    >>> np.insert(b, [2, 2], [7.13, False]) # type casting
-    array([1, 1, 7, ..., 2, 3, 3])
-
-    >>> x = np.arange(8).reshape(2, 4)
-    >>> idx = (1, 3)
-    >>> np.insert(x, idx, 999, axis=1)
-    array([[  0, 999,   1,   2, 999,   3],
-           [  4, 999,   5,   6, 999,   7]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} __version__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__version__"))))
-
-(def compare_chararrays (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "compare_chararrays"))))
-(alter-meta! #'compare_chararrays assoc :doc "compare_chararrays(a, b, cmp_op, rstrip)
-
-    Performs element-wise comparison of two string arrays using the
-    comparison operator specified by `cmp_op`.
-
-    Parameters
-    ----------
-    a, b : array_like
-        Arrays to be compared.
-    cmp_op : {\"<\", \"<=\", \"==\", \">=\", \">\", \"!=\"}
-        Type of comparison.
-    rstrip : Boolean
-        If True, the spaces at the end of Strings are removed before the comparison.
-
-    Returns
-    -------
-    out : ndarray
-        The output array of type Boolean with the same shape as a and b.
-
-    Raises
-    ------
-    ValueError
-        If `cmp_op` is not valid.
-    TypeError
-        If at least one of `a` or `b` is a non-string array
-
-    Examples
-    --------
-    >>> a = np.array([\"a\", \"b\", \"cde\"])
-    >>> b = np.array([\"a\", \"a\", \"dec\"])
-    >>> np.compare_chararrays(a, b, \">\", True)
-    array([False,  True, False])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} __git_revision__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__git_revision__"))))
-
-(def array_repr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_repr"))))
-(alter-meta! #'array_repr assoc :doc "
-    Return the string representation of an array.
-
-    Parameters
-    ----------
-    arr : ndarray
-        Input array.
-    max_line_width : int, optional
-        Inserts newlines if text is longer than `max_line_width`.
-        Defaults to ``numpy.get_printoptions()['linewidth']``.
-    precision : int, optional
-        Floating point precision.
-        Defaults to ``numpy.get_printoptions()['precision']``.
-    suppress_small : bool, optional
-        Represent numbers \"very close\" to zero as zero; default is False.
-        Very close is defined by precision: if the precision is 8, e.g.,
-        numbers smaller (in absolute value) than 5e-9 are represented as
-        zero.
-        Defaults to ``numpy.get_printoptions()['suppress']``.
-
-    Returns
-    -------
-    string : str
-      The string representation of an array.
-
-    See Also
-    --------
-    array_str, array2string, set_printoptions
-
-    Examples
-    --------
-    >>> np.array_repr(np.array([1,2]))
-    'array([1, 2])'
-    >>> np.array_repr(np.ma.array([0.]))
-    'MaskedArray([0.])'
-    >>> np.array_repr(np.array([], np.int32))
-    'array([], dtype=int32)'
-
-    >>> x = np.array([1e-6, 4e-7, 2, 3])
-    >>> np.array_repr(x, precision=6, suppress_small=True)
-    'array([0.000001,  0.      ,  2.      ,  3.      ])'
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def issubsctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issubsctype"))))
-(alter-meta! #'issubsctype assoc :doc "
-    Determine if the first argument is a subclass of the second argument.
-
-    Parameters
-    ----------
-    arg1, arg2 : dtype or dtype specifier
-        Data-types.
-
-    Returns
-    -------
-    out : bool
-        The result.
-
-    See Also
-    --------
-    issctype, issubdtype, obj2sctype
-
-    Examples
-    --------
-    >>> np.issubsctype('S8', str)
-    False
-    >>> np.issubsctype(np.array([1]), int)
-    True
-    >>> np.issubsctype(np.array([1]), float)
-    False
-
-    " :arglists '[[arg1 arg2]])
-
-(def ^{:doc ""} PINF (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "PINF"))))
-(def ^{:doc "Built-in immutable sequence.
-
-If no argument is given, the constructor returns an empty tuple.
-If iterable is specified the tuple is initialized from iterable's items.
-
-If the argument is a tuple, the return value is the same object."} ScalarType (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* "ScalarType")))) 
-
-(def dstack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dstack"))))
-(alter-meta! #'dstack assoc :doc "
-    Stack arrays in sequence depth wise (along third axis).
-
-    This is equivalent to concatenation along the third axis after 2-D arrays
-    of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape
-    `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by
-    `dsplit`.
-
-    This function makes most sense for arrays with up to 3 dimensions. For
-    instance, for pixel-data with a height (first axis), width (second axis),
-    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
-    `block` provide more general stacking and concatenation operations.
-
-    Parameters
-    ----------
-    tup : sequence of arrays
-        The arrays must have the same shape along all but the third axis.
-        1-D or 2-D arrays must have the same shape.
-
-    Returns
-    -------
-    stacked : ndarray
-        The array formed by stacking the given arrays, will be at least 3-D.
-
-    See Also
-    --------
-    stack : Join a sequence of arrays along a new axis.
-    vstack : Stack along first axis.
-    hstack : Stack along second axis.
-    concatenate : Join a sequence of arrays along an existing axis.
-    dsplit : Split array along third axis.
-
-    Examples
-    --------
-    >>> a = np.array((1,2,3))
-    >>> b = np.array((2,3,4))
-    >>> np.dstack((a,b))
-    array([[[1, 2],
-            [2, 3],
-            [3, 4]]])
-
-    >>> a = np.array([[1],[2],[3]])
-    >>> b = np.array([[2],[3],[4]])
-    >>> np.dstack((a,b))
-    array([[[1, 2]],
-           [[2, 3]],
-           [[3, 4]]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "
-    `nd_grid` instance which returns an open multi-dimensional \"meshgrid\".
-
-    An instance of `numpy.lib.index_tricks.nd_grid` which returns an open
-    (i.e. not fleshed out) mesh-grid when indexed, so that only one dimension
-    of each returned array is greater than 1.  The dimension and number of the
-    output arrays are equal to the number of indexing dimensions.  If the step
-    length is not a complex number, then the stop is not inclusive.
-
-    However, if the step length is a **complex number** (e.g. 5j), then
-    the integer part of its magnitude is interpreted as specifying the
-    number of points to create between the start and stop values, where
-    the stop value **is inclusive**.
-
-    Returns
-    -------
-    mesh-grid
-        `ndarrays` with only one dimension not equal to 1
-
-    See Also
-    --------
-    np.lib.index_tricks.nd_grid : class of `ogrid` and `mgrid` objects
-    mgrid : like `ogrid` but returns dense (or fleshed out) mesh grids
-    r_ : array concatenator
-
-    Examples
-    --------
-    >>> from numpy import ogrid
-    >>> ogrid[-1:1:5j]
-    array([-1. , -0.5,  0. ,  0.5,  1. ])
-    >>> ogrid[0:5,0:5]
-    [array([[0],
-            [1],
-            [2],
-            [3],
-            [4]]), array([[0, 1, 2, 3, 4]])]
-
-    "} ogrid (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ogrid"))))
-
-(def isposinf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isposinf"))))
-(alter-meta! #'isposinf assoc :doc "
-    Test element-wise for positive infinity, return result as bool array.
-
-    Parameters
-    ----------
-    x : array_like
-        The input array.
-    y : array_like, optional
-        A boolean array with the same shape as `x` to store the result.
-
-    Returns
-    -------
-    out : ndarray
-        A boolean array with the same dimensions as the input.
-        If second argument is not supplied then a boolean array is returned
-        with values True where the corresponding element of the input is
-        positive infinity and values False where the element of the input is
-        not positive infinity.
-
-        If a second argument is supplied the result is stored there. If the
-        type of that array is a numeric type the result is represented as zeros
-        and ones, if the type is boolean then as False and True.
-        The return value `out` is then a reference to that array.
-
-    See Also
-    --------
-    isinf, isneginf, isfinite, isnan
-
-    Notes
-    -----
-    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
-    (IEEE 754).
-
-    Errors result if the second argument is also supplied when x is a scalar
-    input, if first and second arguments have different shapes, or if the
-    first argument has complex values
-
-    Examples
-    --------
-    >>> np.isposinf(np.PINF)
-    True
-    >>> np.isposinf(np.inf)
-    True
-    >>> np.isposinf(np.NINF)
-    False
-    >>> np.isposinf([-np.inf, 0., np.inf])
-    array([False, False,  True])
-
-    >>> x = np.array([-np.inf, 0., np.inf])
-    >>> y = np.array([2, 2, 2])
-    >>> np.isposinf(x, y)
-    array([0, 0, 1])
-    >>> y
-    array([0, 0, 1])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def exp2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "exp2"))))
-(alter-meta! #'exp2 assoc :doc "exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Calculate `2**p` for all `p` in the input array.
-
-Parameters
-----------
-x : array_like
-    Input values.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Element-wise 2 to the power `x`.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-power
-
-Notes
------
-.. versionadded:: 1.3.0
-
-
-
-Examples
---------
->>> np.exp2([2, 3])
-array([ 4.,  8.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def roll (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "roll"))))
-(alter-meta! #'roll assoc :doc "
-    Roll array elements along a given axis.
-
-    Elements that roll beyond the last position are re-introduced at
-    the first.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    shift : int or tuple of ints
-        The number of places by which elements are shifted.  If a tuple,
-        then `axis` must be a tuple of the same size, and each of the
-        given axes is shifted by the corresponding number.  If an int
-        while `axis` is a tuple of ints, then the same value is used for
-        all given axes.
-    axis : int or tuple of ints, optional
-        Axis or axes along which elements are shifted.  By default, the
-        array is flattened before shifting, after which the original
-        shape is restored.
-
-    Returns
-    -------
-    res : ndarray
-        Output array, with the same shape as `a`.
-
-    See Also
-    --------
-    rollaxis : Roll the specified axis backwards, until it lies in a
-               given position.
-
-    Notes
-    -----
-    .. versionadded:: 1.12.0
-
-    Supports rolling over multiple dimensions simultaneously.
-
-    Examples
-    --------
-    >>> x = np.arange(10)
-    >>> np.roll(x, 2)
-    array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
-    >>> np.roll(x, -2)
-    array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])
-
-    >>> x2 = np.reshape(x, (2,5))
-    >>> x2
-    array([[0, 1, 2, 3, 4],
-           [5, 6, 7, 8, 9]])
-    >>> np.roll(x2, 1)
-    array([[9, 0, 1, 2, 3],
-           [4, 5, 6, 7, 8]])
-    >>> np.roll(x2, -1)
-    array([[1, 2, 3, 4, 5],
-           [6, 7, 8, 9, 0]])
-    >>> np.roll(x2, 1, axis=0)
-    array([[5, 6, 7, 8, 9],
-           [0, 1, 2, 3, 4]])
-    >>> np.roll(x2, -1, axis=0)
-    array([[5, 6, 7, 8, 9],
-           [0, 1, 2, 3, 4]])
-    >>> np.roll(x2, 1, axis=1)
-    array([[4, 0, 1, 2, 3],
-           [9, 5, 6, 7, 8]])
-    >>> np.roll(x2, -1, axis=1)
-    array([[1, 2, 3, 4, 0],
-           [6, 7, 8, 9, 5]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} WRAP (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "WRAP"))))
-
-(def asarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asarray"))))
-(alter-meta! #'asarray assoc :doc "Convert the input to an array.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data, in any form that can be converted to an array.  This
-        includes lists, lists of tuples, tuples, tuples of tuples, tuples
-        of lists and ndarrays.
-    dtype : data-type, optional
-        By default, the data-type is inferred from the input data.
-    order : {'C', 'F'}, optional
-        Whether to use row-major (C-style) or
-        column-major (Fortran-style) memory representation.
-        Defaults to 'C'.
-
-    Returns
-    -------
-    out : ndarray
-        Array interpretation of `a`.  No copy is performed if the input
-        is already an ndarray with matching dtype and order.  If `a` is a
-        subclass of ndarray, a base class ndarray is returned.
-
-    See Also
-    --------
-    asanyarray : Similar function which passes through subclasses.
-    ascontiguousarray : Convert input to a contiguous array.
-    asfarray : Convert input to a floating point ndarray.
-    asfortranarray : Convert input to an ndarray with column-major
-                     memory order.
-    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
-    fromiter : Create an array from an iterator.
-    fromfunction : Construct an array by executing a function on grid
-                   positions.
-
-    Examples
-    --------
-    Convert a list into an array:
-
-    >>> a = [1, 2]
-    >>> np.asarray(a)
-    array([1, 2])
-
-    Existing arrays are not copied:
-
-    >>> a = np.array([1, 2])
-    >>> np.asarray(a) is a
-    True
-
-    If `dtype` is set, array is copied only if dtype does not match:
-
-    >>> a = np.array([1, 2], dtype=np.float32)
-    >>> np.asarray(a, dtype=np.float32) is a
-    True
-    >>> np.asarray(a, dtype=np.float64) is a
-    False
-
-    Contrary to `asanyarray`, ndarray subclasses are not passed through:
-
-    >>> issubclass(np.recarray, np.ndarray)
-    True
-    >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
-    >>> np.asarray(a) is a
-    False
-    >>> np.asanyarray(a) is a
-    True
-
-    " :arglists '[[a & [{dtype :dtype, order :order}]] [a & [{dtype :dtype}]] [a]])
-
-(def fastCopyAndTranspose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fastCopyAndTranspose"))))
-(alter-meta! #'fastCopyAndTranspose assoc :doc "_fastCopyAndTranspose(a)" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} oldnumeric (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "oldnumeric"))))
-
-(def isclose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isclose"))))
-(alter-meta! #'isclose assoc :doc "
-    Returns a boolean array where two arrays are element-wise equal within a
-    tolerance.
-
-    The tolerance values are positive, typically very small numbers.  The
-    relative difference (`rtol` * abs(`b`)) and the absolute difference
-    `atol` are added together to compare against the absolute difference
-    between `a` and `b`.
-
-    .. warning:: The default `atol` is not appropriate for comparing numbers
-                 that are much smaller than one (see Notes).
-
-    Parameters
-    ----------
-    a, b : array_like
-        Input arrays to compare.
-    rtol : float
-        The relative tolerance parameter (see Notes).
-    atol : float
-        The absolute tolerance parameter (see Notes).
-    equal_nan : bool
-        Whether to compare NaN's as equal.  If True, NaN's in `a` will be
-        considered equal to NaN's in `b` in the output array.
-
-    Returns
-    -------
-    y : array_like
-        Returns a boolean array of where `a` and `b` are equal within the
-        given tolerance. If both `a` and `b` are scalars, returns a single
-        boolean value.
-
-    See Also
-    --------
-    allclose
-
-    Notes
-    -----
-    .. versionadded:: 1.7.0
-
-    For finite values, isclose uses the following equation to test whether
-    two floating point values are equivalent.
-
-     absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
-
-    Unlike the built-in `math.isclose`, the above equation is not symmetric
-    in `a` and `b` -- it assumes `b` is the reference value -- so that
-    `isclose(a, b)` might be different from `isclose(b, a)`. Furthermore,
-    the default value of atol is not zero, and is used to determine what
-    small values should be considered close to zero. The default value is
-    appropriate for expected values of order unity: if the expected values
-    are significantly smaller than one, it can result in false positives.
-    `atol` should be carefully selected for the use case at hand. A zero value
-    for `atol` will result in `False` if either `a` or `b` is zero.
-
-    Examples
-    --------
-    >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
-    array([ True, False])
-    >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
-    array([ True, True])
-    >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
-    array([False,  True])
-    >>> np.isclose([1.0, np.nan], [1.0, np.nan])
-    array([ True, False])
-    >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
-    array([ True, True])
-    >>> np.isclose([1e-8, 1e-7], [0.0, 0.0])
-    array([ True, False])
-    >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)
-    array([False, False])
-    >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0])
-    array([ True,  True])
-    >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0)
-    array([False,  True])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def bitwise_not (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_not"))))
-(alter-meta! #'bitwise_not assoc :doc "invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute bit-wise inversion, or bit-wise NOT, element-wise.
-
-Computes the bit-wise NOT of the underlying binary representation of
-the integers in the input arrays. This ufunc implements the C/Python
-operator ``~``.
-
-For signed integer inputs, the two's complement is returned.  In a
-two's-complement system negative numbers are represented by the two's
-complement of the absolute value. This is the most common method of
-representing signed integers on computers [1]_. A N-bit
-two's-complement system can represent every integer in the range
-:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
-
-Parameters
-----------
-x : array_like
-    Only integer and boolean types are handled.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Result.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-bitwise_and, bitwise_or, bitwise_xor
-logical_not
-binary_repr :
-    Return the binary representation of the input number as a string.
-
-Notes
------
-`bitwise_not` is an alias for `invert`:
-
->>> np.bitwise_not is np.invert
-True
-
-References
-----------
-.. [1] Wikipedia, \"Two's complement\",
-    https://en.wikipedia.org/wiki/Two's_complement
-
-Examples
---------
-We've seen that 13 is represented by ``00001101``.
-The invert or bit-wise NOT of 13 is then:
-
->>> x = np.invert(np.array(13, dtype=np.uint8))
->>> x
-242
->>> np.binary_repr(x, width=8)
-'11110010'
-
-The result depends on the bit-width:
-
->>> x = np.invert(np.array(13, dtype=np.uint16))
->>> x
-65522
->>> np.binary_repr(x, width=16)
-'1111111111110010'
-
-When using signed integer types the result is the two's complement of
-the result for the unsigned type:
-
->>> np.invert(np.array([13], dtype=np.int8))
-array([-14], dtype=int8)
->>> np.binary_repr(-14, width=8)
-'11110010'
-
-Booleans are accepted as well:
-
->>> np.invert(np.array([True, False]))
-array([False,  True])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def int0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int0"))))
-(alter-meta! #'int0 assoc :doc "Signed integer type, compatible with Python `int` anc C ``long``.
-    Character code: ``'l'``.
-    Canonical name: ``np.int_``.
-    Alias *on this platform*: ``np.int64``: 64-bit signed integer (-9223372036854775808 to 9223372036854775807).
-    Alias *on this platform*: ``np.intp``: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ldexp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ldexp"))))
-(alter-meta! #'ldexp assoc :doc "ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Returns x1 * 2**x2, element-wise.
-
-The mantissas `x1` and twos exponents `x2` are used to construct
-floating point numbers ``x1 * 2**x2``.
-
-Parameters
-----------
-x1 : array_like
-    Array of multipliers.
-x2 : array_like, int
-    Array of twos exponents. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray or scalar
-    The result of ``x1 * 2**x2``.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`.
-
-Notes
------
-Complex dtypes are not supported, they will raise a TypeError.
-
-`ldexp` is useful as the inverse of `frexp`, if used by itself it is
-more clear to simply use the expression ``x1 * 2**x2``.
-
-Examples
---------
->>> np.ldexp(5, np.arange(4))
-array([ 5., 10., 20., 40.], dtype=float16)
-
->>> x = np.arange(6)
->>> np.ldexp(*np.frexp(x))
-array([ 0.,  1.,  2.,  3.,  4.,  5.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def around (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "around"))))
-(alter-meta! #'around assoc :doc "
-    Evenly round to the given number of decimals.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-    decimals : int, optional
-        Number of decimal places to round to (default: 0).  If
-        decimals is negative, it specifies the number of positions to
-        the left of the decimal point.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must have
-        the same shape as the expected output, but the type of the output
-        values will be cast if necessary. See `ufuncs-output-type` for more
-        details.
-
-    Returns
-    -------
-    rounded_array : ndarray
-        An array of the same type as `a`, containing the rounded values.
-        Unless `out` was specified, a new array is created.  A reference to
-        the result is returned.
-
-        The real and imaginary parts of complex numbers are rounded
-        separately.  The result of rounding a float is a float.
-
-    See Also
-    --------
-    ndarray.round : equivalent method
-
-    ceil, fix, floor, rint, trunc
-
-
-    Notes
-    -----
-    For values exactly halfway between rounded decimal values, NumPy
-    rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,
-    -0.5 and 0.5 round to 0.0, etc.
-
-    ``np.around`` uses a fast but sometimes inexact algorithm to round
-    floating-point datatypes. For positive `decimals` it is equivalent to
-    ``np.true_divide(np.rint(a * 10**decimals), 10**decimals)``, which has
-    error due to the inexact representation of decimal fractions in the IEEE
-    floating point standard [1]_ and errors introduced when scaling by powers
-    of ten. For instance, note the extra \"1\" in the following:
-
-        >>> np.round(56294995342131.5, 3)
-        56294995342131.51
-
-    If your goal is to print such values with a fixed number of decimals, it is
-    preferable to use numpy's float printing routines to limit the number of
-    printed decimals:
-
-        >>> np.format_float_positional(56294995342131.5, precision=3)
-        '56294995342131.5'
-
-    The float printing routines use an accurate but much more computationally
-    demanding algorithm to compute the number of digits after the decimal
-    point.
-
-    Alternatively, Python's builtin `round` function uses a more accurate
-    but slower algorithm for 64-bit floating point values:
-
-        >>> round(56294995342131.5, 3)
-        56294995342131.5
-        >>> np.round(16.055, 2), round(16.055, 2)  # equals 16.0549999999999997
-        (16.06, 16.05)
-
-
-    References
-    ----------
-    .. [1] \"Lecture Notes on the Status of IEEE 754\", William Kahan,
-           https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF
-    .. [2] \"How Futile are Mindless Assessments of
-           Roundoff in Floating-Point Computation?\", William Kahan,
-           https://people.eecs.berkeley.edu/~wkahan/Mindless.pdf
-
-    Examples
-    --------
-    >>> np.around([0.37, 1.64])
-    array([0.,  2.])
-    >>> np.around([0.37, 1.64], decimals=1)
-    array([0.4,  1.6])
-    >>> np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value
-    array([0.,  2.,  2.,  4.,  4.])
-    >>> np.around([1,2,3,11], decimals=1) # ndarray of ints is returned
-    array([ 1,  2,  3, 11])
-    >>> np.around([1,2,3,11], decimals=-1)
-    array([ 0,  0,  0, 10])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def convolve (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "convolve"))))
-(alter-meta! #'convolve assoc :doc "
-    Returns the discrete, linear convolution of two one-dimensional sequences.
-
-    The convolution operator is often seen in signal processing, where it
-    models the effect of a linear time-invariant system on a signal [1]_.  In
-    probability theory, the sum of two independent random variables is
-    distributed according to the convolution of their individual
-    distributions.
-
-    If `v` is longer than `a`, the arrays are swapped before computation.
-
-    Parameters
-    ----------
-    a : (N,) array_like
-        First one-dimensional input array.
-    v : (M,) array_like
-        Second one-dimensional input array.
-    mode : {'full', 'valid', 'same'}, optional
-        'full':
-          By default, mode is 'full'.  This returns the convolution
-          at each point of overlap, with an output shape of (N+M-1,). At
-          the end-points of the convolution, the signals do not overlap
-          completely, and boundary effects may be seen.
-
-        'same':
-          Mode 'same' returns output of length ``max(M, N)``.  Boundary
-          effects are still visible.
-
-        'valid':
-          Mode 'valid' returns output of length
-          ``max(M, N) - min(M, N) + 1``.  The convolution product is only given
-          for points where the signals overlap completely.  Values outside
-          the signal boundary have no effect.
-
-    Returns
-    -------
-    out : ndarray
-        Discrete, linear convolution of `a` and `v`.
-
-    See Also
-    --------
-    scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier
-                               Transform.
-    scipy.linalg.toeplitz : Used to construct the convolution operator.
-    polymul : Polynomial multiplication. Same output as convolve, but also
-              accepts poly1d objects as input.
-
-    Notes
-    -----
-    The discrete convolution operation is defined as
-
-    .. math:: (a * v)[n] = \\sum_{m = -\\infty}^{\\infty} a[m] v[n - m]
-
-    It can be shown that a convolution :math:`x(t) * y(t)` in time/space
-    is equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier
-    domain, after appropriate padding (padding is necessary to prevent
-    circular convolution).  Since multiplication is more efficient (faster)
-    than convolution, the function `scipy.signal.fftconvolve` exploits the
-    FFT to calculate the convolution of large data-sets.
-
-    References
-    ----------
-    .. [1] Wikipedia, \"Convolution\",
-        https://en.wikipedia.org/wiki/Convolution
-
-    Examples
-    --------
-    Note how the convolution operator flips the second array
-    before \"sliding\" the two across one another:
-
-    >>> np.convolve([1, 2, 3], [0, 1, 0.5])
-    array([0. , 1. , 2.5, 4. , 1.5])
-
-    Only return the middle values of the convolution.
-    Contains boundary effects, where zeros are taken
-    into account:
-
-    >>> np.convolve([1,2,3],[0,1,0.5], 'same')
-    array([1. ,  2.5,  4. ])
-
-    The two arrays are of the same length, so there
-    is only one position where they completely overlap:
-
-    >>> np.convolve([1,2,3],[0,1,0.5], 'valid')
-    array([2.5])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def round_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "round_"))))
-(alter-meta! #'round_ assoc :doc "
-    Round an array to the given number of decimals.
-
-    See Also
-    --------
-    around : equivalent function; see for details.
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def add (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add"))))
-(alter-meta! #'add assoc :doc "add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Add arguments element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    The arrays to be added. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-add : ndarray or scalar
-    The sum of `x1` and `x2`, element-wise.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-Notes
------
-Equivalent to `x1` + `x2` in terms of array broadcasting.
-
-Examples
---------
->>> np.add(1.0, 4.0)
-5.0
->>> x1 = np.arange(9.0).reshape((3, 3))
->>> x2 = np.arange(3.0)
->>> np.add(x1, x2)
-array([[  0.,   2.,   4.],
-       [  3.,   5.,   7.],
-       [  6.,   8.,  10.]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def base_repr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "base_repr"))))
-(alter-meta! #'base_repr assoc :doc "
-    Return a string representation of a number in the given base system.
-
-    Parameters
-    ----------
-    number : int
-        The value to convert. Positive and negative values are handled.
-    base : int, optional
-        Convert `number` to the `base` number system. The valid range is 2-36,
-        the default value is 2.
-    padding : int, optional
-        Number of zeros padded on the left. Default is 0 (no padding).
-
-    Returns
-    -------
-    out : str
-        String representation of `number` in `base` system.
-
-    See Also
-    --------
-    binary_repr : Faster version of `base_repr` for base 2.
-
-    Examples
-    --------
-    >>> np.base_repr(5)
-    '101'
-    >>> np.base_repr(6, 5)
-    '11'
-    >>> np.base_repr(7, base=5, padding=3)
-    '00012'
-
-    >>> np.base_repr(10, base=16)
-    'A'
-    >>> np.base_repr(32, base=16)
-    '20'
-
-    " :arglists '[[number & [{base :base, padding :padding}]] [number & [{base :base}]] [number]])
-
-(def mafromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mafromtxt"))))
-(alter-meta! #'mafromtxt assoc :doc "
-    Load ASCII data stored in a text file and return a masked array.
-
-    .. deprecated:: 1.17
-        np.mafromtxt is a deprecated alias of `genfromtxt` which
-        overwrites the ``usemask`` argument with `True` even when
-        explicitly called as ``mafromtxt(..., usemask=False)``.
-        Use `genfromtxt` instead.
-
-    Parameters
-    ----------
-    fname, kwargs : For a description of input parameters, see `genfromtxt`.
-
-    See Also
-    --------
-    numpy.genfromtxt : generic function to load ASCII data.
-
-    " :arglists '[[fname & [{:as kwargs}]]])
-
-(def nanstd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanstd"))))
-(alter-meta! #'nanstd assoc :doc "
-    Compute the standard deviation along the specified axis, while
-    ignoring NaNs.
-
-    Returns the standard deviation, a measure of the spread of a
-    distribution, of the non-NaN array elements. The standard deviation is
-    computed for the flattened array by default, otherwise over the
-    specified axis.
-
-    For all-NaN slices or slices with zero degrees of freedom, NaN is
-    returned and a `RuntimeWarning` is raised.
-
-    .. versionadded:: 1.8.0
-
-    Parameters
-    ----------
-    a : array_like
-        Calculate the standard deviation of the non-NaN values.
-    axis : {int, tuple of int, None}, optional
-        Axis or axes along which the standard deviation is computed. The default is
-        to compute the standard deviation of the flattened array.
-    dtype : dtype, optional
-        Type to use in computing the standard deviation. For arrays of
-        integer type the default is float64, for arrays of float types it
-        is the same as the array type.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must have
-        the same shape as the expected output but the type (of the
-        calculated values) will be cast if necessary.
-    ddof : int, optional
-        Means Delta Degrees of Freedom.  The divisor used in calculations
-        is ``N - ddof``, where ``N`` represents the number of non-NaN
-        elements.  By default `ddof` is zero.
-
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the original `a`.
-
-        If this value is anything but the default it is passed through
-        as-is to the relevant functions of the sub-classes.  If these
-        functions do not have a `keepdims` kwarg, a RuntimeError will
-        be raised.
-
-    Returns
-    -------
-    standard_deviation : ndarray, see dtype parameter above.
-        If `out` is None, return a new array containing the standard
-        deviation, otherwise return a reference to the output array. If
-        ddof is >= the number of non-NaN elements in a slice or the slice
-        contains only NaNs, then the result for that slice is NaN.
-
-    See Also
-    --------
-    var, mean, std
-    nanvar, nanmean
-    ufuncs-output-type
-
-    Notes
-    -----
-    The standard deviation is the square root of the average of the squared
-    deviations from the mean: ``std = sqrt(mean(abs(x - x.mean())**2))``.
-
-    The average squared deviation is normally calculated as
-    ``x.sum() / N``, where ``N = len(x)``.  If, however, `ddof` is
-    specified, the divisor ``N - ddof`` is used instead. In standard
-    statistical practice, ``ddof=1`` provides an unbiased estimator of the
-    variance of the infinite population. ``ddof=0`` provides a maximum
-    likelihood estimate of the variance for normally distributed variables.
-    The standard deviation computed in this function is the square root of
-    the estimated variance, so even with ``ddof=1``, it will not be an
-    unbiased estimate of the standard deviation per se.
-
-    Note that, for complex numbers, `std` takes the absolute value before
-    squaring, so that the result is always real and nonnegative.
-
-    For floating-point input, the *std* is computed using the same
-    precision the input has. Depending on the input data, this can cause
-    the results to be inaccurate, especially for float32 (see example
-    below).  Specifying a higher-accuracy accumulator using the `dtype`
-    keyword can alleviate this issue.
-
-    Examples
-    --------
-    >>> a = np.array([[1, np.nan], [3, 4]])
-    >>> np.nanstd(a)
-    1.247219128924647
-    >>> np.nanstd(a, axis=0)
-    array([1., 0.])
-    >>> np.nanstd(a, axis=1)
-    array([0.,  0.5]) # may vary
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def single (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "single"))))
-(alter-meta! #'single assoc :doc "Single-precision floating-point number type, compatible with C ``float``.
-    Character code: ``'f'``.
-    Canonical name: ``np.single``.
-    Alias *on this platform*: ``np.float32``: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa." :arglists '[[self & [args {:as kwargs}]]])
-
-(def inner (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "inner"))))
-(alter-meta! #'inner assoc :doc "
-    inner(a, b)
-
-    Inner product of two arrays.
-
-    Ordinary inner product of vectors for 1-D arrays (without complex
-    conjugation), in higher dimensions a sum product over the last axes.
-
-    Parameters
-    ----------
-    a, b : array_like
-        If `a` and `b` are nonscalar, their last dimensions must match.
-
-    Returns
-    -------
-    out : ndarray
-        `out.shape = a.shape[:-1] + b.shape[:-1]`
-
-    Raises
-    ------
-    ValueError
-        If the last dimension of `a` and `b` has different size.
-
-    See Also
-    --------
-    tensordot : Sum products over arbitrary axes.
-    dot : Generalised matrix product, using second last dimension of `b`.
-    einsum : Einstein summation convention.
-
-    Notes
-    -----
-    For vectors (1-D arrays) it computes the ordinary inner-product::
-
-        np.inner(a, b) = sum(a[:]*b[:])
-
-    More generally, if `ndim(a) = r > 0` and `ndim(b) = s > 0`::
-
-        np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))
-
-    or explicitly::
-
-        np.inner(a, b)[i0,...,ir-1,j0,...,js-1]
-             = sum(a[i0,...,ir-1,:]*b[j0,...,js-1,:])
-
-    In addition `a` or `b` may be scalars, in which case::
-
-       np.inner(a,b) = a*b
-
-    Examples
-    --------
-    Ordinary inner product for vectors:
-
-    >>> a = np.array([1,2,3])
-    >>> b = np.array([0,1,0])
-    >>> np.inner(a, b)
-    2
-
-    A multidimensional example:
-
-    >>> a = np.arange(24).reshape((2,3,4))
-    >>> b = np.arange(4)
-    >>> np.inner(a, b)
-    array([[ 14,  38,  62],
-           [ 86, 110, 134]])
-
-    An example where `b` is a scalar:
-
-    >>> np.inner(np.eye(2), 7)
-    array([[7., 0.],
-           [0., 7.]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def column_stack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "column_stack"))))
-(alter-meta! #'column_stack assoc :doc "
-    Stack 1-D arrays as columns into a 2-D array.
-
-    Take a sequence of 1-D arrays and stack them as columns
-    to make a single 2-D array. 2-D arrays are stacked as-is,
-    just like with `hstack`.  1-D arrays are turned into 2-D columns
-    first.
-
-    Parameters
-    ----------
-    tup : sequence of 1-D or 2-D arrays.
-        Arrays to stack. All of them must have the same first dimension.
-
-    Returns
-    -------
-    stacked : 2-D array
-        The array formed by stacking the given arrays.
-
-    See Also
-    --------
-    stack, hstack, vstack, concatenate
-
-    Examples
-    --------
-    >>> a = np.array((1,2,3))
-    >>> b = np.array((2,3,4))
-    >>> np.column_stack((a,b))
-    array([[1, 2],
-           [2, 3],
-           [3, 4]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def cov (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cov"))))
-(alter-meta! #'cov assoc :doc "
-    Estimate a covariance matrix, given data and weights.
-
-    Covariance indicates the level to which two variables vary together.
-    If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`,
-    then the covariance matrix element :math:`C_{ij}` is the covariance of
-    :math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance
-    of :math:`x_i`.
-
-    See the notes for an outline of the algorithm.
-
-    Parameters
-    ----------
-    m : array_like
-        A 1-D or 2-D array containing multiple variables and observations.
-        Each row of `m` represents a variable, and each column a single
-        observation of all those variables. Also see `rowvar` below.
-    y : array_like, optional
-        An additional set of variables and observations. `y` has the same form
-        as that of `m`.
-    rowvar : bool, optional
-        If `rowvar` is True (default), then each row represents a
-        variable, with observations in the columns. Otherwise, the relationship
-        is transposed: each column represents a variable, while the rows
-        contain observations.
-    bias : bool, optional
-        Default normalization (False) is by ``(N - 1)``, where ``N`` is the
-        number of observations given (unbiased estimate). If `bias` is True,
-        then normalization is by ``N``. These values can be overridden by using
-        the keyword ``ddof`` in numpy versions >= 1.5.
-    ddof : int, optional
-        If not ``None`` the default value implied by `bias` is overridden.
-        Note that ``ddof=1`` will return the unbiased estimate, even if both
-        `fweights` and `aweights` are specified, and ``ddof=0`` will return
-        the simple average. See the notes for the details. The default value
-        is ``None``.
-
-        .. versionadded:: 1.5
-    fweights : array_like, int, optional
-        1-D array of integer frequency weights; the number of times each
-        observation vector should be repeated.
-
-        .. versionadded:: 1.10
-    aweights : array_like, optional
-        1-D array of observation vector weights. These relative weights are
-        typically large for observations considered \"important\" and smaller for
-        observations considered less \"important\". If ``ddof=0`` the array of
-        weights can be used to assign probabilities to observation vectors.
-
-        .. versionadded:: 1.10
-
-    Returns
-    -------
-    out : ndarray
-        The covariance matrix of the variables.
-
-    See Also
-    --------
-    corrcoef : Normalized covariance matrix
-
-    Notes
-    -----
-    Assume that the observations are in the columns of the observation
-    array `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The
-    steps to compute the weighted covariance are as follows::
-
-        >>> m = np.arange(10, dtype=np.float64)
-        >>> f = np.arange(10) * 2
-        >>> a = np.arange(10) ** 2.
-        >>> ddof = 1
-        >>> w = f * a
-        >>> v1 = np.sum(w)
-        >>> v2 = np.sum(w * a)
-        >>> m -= np.sum(m * w, axis=None, keepdims=True) / v1
-        >>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)
-
-    Note that when ``a == 1``, the normalization factor
-    ``v1 / (v1**2 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)``
-    as it should.
-
-    Examples
-    --------
-    Consider two variables, :math:`x_0` and :math:`x_1`, which
-    correlate perfectly, but in opposite directions:
-
-    >>> x = np.array([[0, 2], [1, 1], [2, 0]]).T
-    >>> x
-    array([[0, 1, 2],
-           [2, 1, 0]])
-
-    Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance
-    matrix shows this clearly:
-
-    >>> np.cov(x)
-    array([[ 1., -1.],
-           [-1.,  1.]])
-
-    Note that element :math:`C_{0,1}`, which shows the correlation between
-    :math:`x_0` and :math:`x_1`, is negative.
-
-    Further, note how `x` and `y` are combined:
-
-    >>> x = [-2.1, -1,  4.3]
-    >>> y = [3,  1.1,  0.12]
-    >>> X = np.stack((x, y), axis=0)
-    >>> np.cov(X)
-    array([[11.71      , -4.286     ], # may vary
-           [-4.286     ,  2.144133]])
-    >>> np.cov(x, y)
-    array([[11.71      , -4.286     ], # may vary
-           [-4.286     ,  2.144133]])
-    >>> np.cov(x)
-    array(11.71)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def geterrcall (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geterrcall"))))
-(alter-meta! #'geterrcall assoc :doc "
-    Return the current callback function used on floating-point errors.
-
-    When the error handling for a floating-point error (one of \"divide\",
-    \"over\", \"under\", or \"invalid\") is set to 'call' or 'log', the function
-    that is called or the log instance that is written to is returned by
-    `geterrcall`. This function or log instance has been set with
-    `seterrcall`.
-
-    Returns
-    -------
-    errobj : callable, log instance or None
-        The current error handler. If no handler was set through `seterrcall`,
-        ``None`` is returned.
-
-    See Also
-    --------
-    seterrcall, seterr, geterr
-
-    Notes
-    -----
-    For complete documentation of the types of floating-point exceptions and
-    treatment options, see `seterr`.
-
-    Examples
-    --------
-    >>> np.geterrcall()  # we did not yet set a handler, returns None
-
-    >>> oldsettings = np.seterr(all='call')
-    >>> def err_handler(type, flag):
-    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
-    >>> oldhandler = np.seterrcall(err_handler)
-    >>> np.array([1, 2, 3]) / 0.0
-    Floating point error (divide by zero), with flag 1
-    array([inf, inf, inf])
-
-    >>> cur_handler = np.geterrcall()
-    >>> cur_handler is err_handler
-    True
-
-    " :arglists '[[]])
-
-(def signbit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "signbit"))))
-(alter-meta! #'signbit assoc :doc "signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Returns element-wise True where signbit is set (less than zero).
-
-Parameters
-----------
-x : array_like
-    The input value(s).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-result : ndarray of bool
-    Output array, or reference to `out` if that was supplied.
-    This is a scalar if `x` is a scalar.
-
-Examples
---------
->>> np.signbit(-1.2)
-True
->>> np.signbit(np.array([1, -2.3, 2.1]))
-array([False,  True, False])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def amax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "amax"))))
-(alter-meta! #'amax assoc :doc "
-    Return the maximum of an array or maximum along an axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which to operate.  By default, flattened input is
-        used.
-
-        .. versionadded:: 1.7.0
-
-        If this is a tuple of ints, the maximum is selected over multiple axes,
-        instead of a single axis or all the axes as before.
-    out : ndarray, optional
-        Alternative output array in which to place the result.  Must
-        be of the same shape and buffer length as the expected output.
-        See `ufuncs-output-type` for more details.
-
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `amax` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-
-    initial : scalar, optional
-        The minimum value of an output element. Must be present to allow
-        computation on empty slice. See `~numpy.ufunc.reduce` for details.
-
-        .. versionadded:: 1.15.0
-
-    where : array_like of bool, optional
-        Elements to compare for the maximum. See `~numpy.ufunc.reduce`
-        for details.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    amax : ndarray or scalar
-        Maximum of `a`. If `axis` is None, the result is a scalar value.
-        If `axis` is given, the result is an array of dimension
-        ``a.ndim - 1``.
-
-    See Also
-    --------
-    amin :
-        The minimum value of an array along a given axis, propagating any NaNs.
-    nanmax :
-        The maximum value of an array along a given axis, ignoring any NaNs.
-    maximum :
-        Element-wise maximum of two arrays, propagating any NaNs.
-    fmax :
-        Element-wise maximum of two arrays, ignoring any NaNs.
-    argmax :
-        Return the indices of the maximum values.
-
-    nanmin, minimum, fmin
-
-    Notes
-    -----
-    NaN values are propagated, that is if at least one item is NaN, the
-    corresponding max value will be NaN as well. To ignore NaN values
-    (MATLAB behavior), please use nanmax.
-
-    Don't use `amax` for element-wise comparison of 2 arrays; when
-    ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
-    ``amax(a, axis=0)``.
-
-    Examples
-    --------
-    >>> a = np.arange(4).reshape((2,2))
-    >>> a
-    array([[0, 1],
-           [2, 3]])
-    >>> np.amax(a)           # Maximum of the flattened array
-    3
-    >>> np.amax(a, axis=0)   # Maxima along the first axis
-    array([2, 3])
-    >>> np.amax(a, axis=1)   # Maxima along the second axis
-    array([1, 3])
-    >>> np.amax(a, where=[False, True], initial=-1, axis=0)
-    array([-1,  3])
-    >>> b = np.arange(5, dtype=float)
-    >>> b[2] = np.NaN
-    >>> np.amax(b)
-    nan
-    >>> np.amax(b, where=~np.isnan(b), initial=-1)
-    4.0
-    >>> np.nanmax(b)
-    4.0
-
-    You can use an initial value to compute the maximum of an empty slice, or
-    to initialize it to a different value:
-
-    >>> np.max([[-50], [10]], axis=-1, initial=0)
-    array([ 0, 10])
-
-    Notice that the initial value is used as one of the elements for which the
-    maximum is determined, unlike for the default argument Python's max
-    function, which is only used for empty iterables.
-
-    >>> np.max([5], initial=6)
-    6
-    >>> max([5], default=6)
-    5
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def all (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "all"))))
-(alter-meta! #'all assoc :doc "
-    Test whether all array elements along a given axis evaluate to True.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array or object that can be converted to an array.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which a logical AND reduction is performed.
-        The default (``axis=None``) is to perform a logical AND over all
-        the dimensions of the input array. `axis` may be negative, in
-        which case it counts from the last to the first axis.
-
-        .. versionadded:: 1.7.0
-
-        If this is a tuple of ints, a reduction is performed on multiple
-        axes, instead of a single axis or all the axes as before.
-    out : ndarray, optional
-        Alternate output array in which to place the result.
-        It must have the same shape as the expected output and its
-        type is preserved (e.g., if ``dtype(out)`` is float, the result
-        will consist of 0.0's and 1.0's). See `ufuncs-output-type` for more
-        details.
-
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `all` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-
-    Returns
-    -------
-    all : ndarray, bool
-        A new boolean or array is returned unless `out` is specified,
-        in which case a reference to `out` is returned.
-
-    See Also
-    --------
-    ndarray.all : equivalent method
-
-    any : Test whether any element along a given axis evaluates to True.
-
-    Notes
-    -----
-    Not a Number (NaN), positive infinity and negative infinity
-    evaluate to `True` because these are not equal to zero.
-
-    Examples
-    --------
-    >>> np.all([[True,False],[True,True]])
-    False
-
-    >>> np.all([[True,False],[True,True]], axis=0)
-    array([ True, False])
-
-    >>> np.all([-1, 4, 5])
-    True
-
-    >>> np.all([1.0, np.nan])
-    True
-
-    >>> o=np.array(False)
-    >>> z=np.all([-1, 4, 5], out=o)
-    >>> id(z), id(o), z
-    (28293632, 28293632, array(True)) # may vary
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "This module provides access to some objects used or maintained by the
-interpreter and to functions that interact strongly with the interpreter.
-
-Dynamic objects:
-
-argv -- command line arguments; argv[0] is the script pathname if known
-path -- module search path; path[0] is the script directory, else ''
-modules -- dictionary of loaded modules
-
-displayhook -- called to show results in an interactive session
-excepthook -- called to handle any uncaught exception other than SystemExit
-  To customize printing in an interactive session or to install a custom
-  top-level exception handler, assign other functions to replace these.
-
-stdin -- standard input file object; used by input()
-stdout -- standard output file object; used by print()
-stderr -- standard error object; used for error messages
-  By assigning other file objects (or objects that behave like files)
-  to these, it is possible to redirect all of the interpreter's I/O.
-
-last_type -- type of last uncaught exception
-last_value -- value of last uncaught exception
-last_traceback -- traceback of last uncaught exception
-  These three are only available in an interactive session after a
-  traceback has been printed.
-
-Static objects:
-
-builtin_module_names -- tuple of module names built into this interpreter
-copyright -- copyright notice pertaining to this interpreter
-exec_prefix -- prefix used to find the machine-specific Python library
-executable -- absolute path of the executable binary of the Python interpreter
-float_info -- a named tuple with information about the float implementation.
-float_repr_style -- string indicating the style of repr() output for floats
-hash_info -- a named tuple with information about the hash algorithm.
-hexversion -- version information encoded as a single integer
-implementation -- Python implementation information.
-int_info -- a named tuple with information about the int implementation.
-maxsize -- the largest supported length of containers.
-maxunicode -- the value of the largest Unicode code point
-platform -- platform identifier
-prefix -- prefix used to find the Python library
-thread_info -- a named tuple with information about the thread implementation.
-version -- the version of this interpreter as a string
-version_info -- version information as a named tuple
-__stdin__ -- the original stdin; don't touch!
-__stdout__ -- the original stdout; don't touch!
-__stderr__ -- the original stderr; don't touch!
-__displayhook__ -- the original displayhook; don't touch!
-__excepthook__ -- the original excepthook; don't touch!
-
-Functions:
-
-displayhook() -- print an object to the screen, and save it in builtins._
-excepthook() -- print an exception and its traceback to sys.stderr
-exc_info() -- return thread-safe information about the current exception
-exit() -- exit the interpreter by raising SystemExit
-getdlopenflags() -- returns flags to be used for dlopen() calls
-getprofile() -- get the global profiling function
-getrefcount() -- return the reference count for an object (plus one :-)
-getrecursionlimit() -- return the max recursion depth for the interpreter
-getsizeof() -- return the size of an object in bytes
-gettrace() -- get the global debug tracing function
-setcheckinterval() -- control how often the interpreter checks for events
-setdlopenflags() -- set the flags to be used for dlopen() calls
-setprofile() -- set the global profiling function
-setrecursionlimit() -- set the max recursion depth for the interpreter
-settrace() -- set the global debug tracing function
-"} sys (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "sys"))))
-
-(def true_divide (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "true_divide"))))
-(alter-meta! #'true_divide assoc :doc "true_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Returns a true division of the inputs, element-wise.
-
-Instead of the Python traditional 'floor division', this returns a true
-division.  True division adjusts the output type to present the best
-answer, regardless of input types.
-
-Parameters
-----------
-x1 : array_like
-    Dividend array.
-x2 : array_like
-    Divisor array. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    This is a scalar if both `x1` and `x2` are scalars.
-
-Notes
------
-The floor division operator ``//`` was added in Python 2.2 making
-``//`` and ``/`` equivalent operators.  The default floor division
-operation of ``/`` can be replaced by true division with ``from
-__future__ import division``.
-
-In Python 3.0, ``//`` is the floor division operator and ``/`` the
-true division operator.  The ``true_divide(x1, x2)`` function is
-equivalent to true division in Python.
-
-Examples
---------
->>> x = np.arange(5)
->>> np.true_divide(x, 4)
-array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
-
->>> x//4
-array([0, 0, 0, 0, 1])
-
->>> from __future__ import division
->>> x/4
-array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
->>> x//4
-array([0, 0, 0, 0, 1])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} NZERO (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "NZERO"))))
-
-(def ^{:doc ""} FPE_INVALID (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "FPE_INVALID"))))
-
-(def hanning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hanning"))))
-(alter-meta! #'hanning assoc :doc "
-    Return the Hanning window.
-
-    The Hanning window is a taper formed by using a weighted cosine.
-
-    Parameters
-    ----------
-    M : int
-        Number of points in the output window. If zero or less, an
-        empty array is returned.
-
-    Returns
-    -------
-    out : ndarray, shape(M,)
-        The window, with the maximum value normalized to one (the value
-        one appears only if `M` is odd).
-
-    See Also
-    --------
-    bartlett, blackman, hamming, kaiser
-
-    Notes
-    -----
-    The Hanning window is defined as
-
-    .. math::  w(n) = 0.5 - 0.5cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
-               \\qquad 0 \\leq n \\leq M-1
-
-    The Hanning was named for Julius von Hann, an Austrian meteorologist.
-    It is also known as the Cosine Bell. Some authors prefer that it be
-    called a Hann window, to help avoid confusion with the very similar
-    Hamming window.
-
-    Most references to the Hanning window come from the signal processing
-    literature, where it is used as one of many windowing functions for
-    smoothing values.  It is also known as an apodization (which means
-    \"removing the foot\", i.e. smoothing discontinuities at the beginning
-    and end of the sampled signal) or tapering function.
-
-    References
-    ----------
-    .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
-           spectra, Dover Publications, New York.
-    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\",
-           The University of Alberta Press, 1975, pp. 106-108.
-    .. [3] Wikipedia, \"Window function\",
-           https://en.wikipedia.org/wiki/Window_function
-    .. [4] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
-           \"Numerical Recipes\", Cambridge University Press, 1986, page 425.
-
-    Examples
-    --------
-    >>> np.hanning(12)
-    array([0.        , 0.07937323, 0.29229249, 0.57115742, 0.82743037,
-           0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249,
-           0.07937323, 0.        ])
-
-    Plot the window and its frequency response:
-
-    >>> import matplotlib.pyplot as plt
-    >>> from numpy.fft import fft, fftshift
-    >>> window = np.hanning(51)
-    >>> plt.plot(window)
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.title(\"Hann window\")
-    Text(0.5, 1.0, 'Hann window')
-    >>> plt.ylabel(\"Amplitude\")
-    Text(0, 0.5, 'Amplitude')
-    >>> plt.xlabel(\"Sample\")
-    Text(0.5, 0, 'Sample')
-    >>> plt.show()
-
-    >>> plt.figure()
-    <Figure size 640x480 with 0 Axes>
-    >>> A = fft(window, 2048) / 25.5
-    >>> mag = np.abs(fftshift(A))
-    >>> freq = np.linspace(-0.5, 0.5, len(A))
-    >>> with np.errstate(divide='ignore', invalid='ignore'):
-    ...     response = 20 * np.log10(mag)
-    ...
-    >>> response = np.clip(response, -100, 100)
-    >>> plt.plot(freq, response)
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.title(\"Frequency response of the Hann window\")
-    Text(0.5, 1.0, 'Frequency response of the Hann window')
-    >>> plt.ylabel(\"Magnitude [dB]\")
-    Text(0, 0.5, 'Magnitude [dB]')
-    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
-    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
-    >>> plt.axis('tight')
-    ...
-    >>> plt.show()
-
-    " :arglists '[[M]])
-
-(def ^{:doc "Python part of the warnings subsystem."} warnings (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "warnings"))))
-
-(def uintc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uintc"))))
-(alter-meta! #'uintc assoc :doc "Unsigned integer type, compatible with C ``unsigned int``.
-    Character code: ``'I'``.
-    Canonical name: ``np.uintc``.
-    Alias *on this platform*: ``np.uint32``: 32-bit unsigned integer (0 to 4294967295)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def resize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "resize"))))
-(alter-meta! #'resize assoc :doc "
-    Return a new array with the specified shape.
-
-    If the new array is larger than the original array, then the new
-    array is filled with repeated copies of `a`.  Note that this behavior
-    is different from a.resize(new_shape) which fills with zeros instead
-    of repeated copies of `a`.
-
-    Parameters
-    ----------
-    a : array_like
-        Array to be resized.
-
-    new_shape : int or tuple of int
-        Shape of resized array.
-
-    Returns
-    -------
-    reshaped_array : ndarray
-        The new array is formed from the data in the old array, repeated
-        if necessary to fill out the required number of elements.  The
-        data are repeated in the order that they are stored in memory.
-
-    See Also
-    --------
-    ndarray.resize : resize an array in-place.
-
-    Notes
-    -----
-    Warning: This functionality does **not** consider axes separately,
-    i.e. it does not apply interpolation/extrapolation.
-    It fills the return array with the required number of elements, taken
-    from `a` as they are laid out in memory, disregarding strides and axes.
-    (This is in case the new shape is smaller. For larger, see above.)
-    This functionality is therefore not suitable to resize images,
-    or data where each axis represents a separate and distinct entity.
-
-    Examples
-    --------
-    >>> a=np.array([[0,1],[2,3]])
-    >>> np.resize(a,(2,3))
-    array([[0, 1, 2],
-           [3, 0, 1]])
-    >>> np.resize(a,(1,4))
-    array([[0, 1, 2, 3]])
-    >>> np.resize(a,(2,4))
-    array([[0, 1, 2, 3],
-           [0, 1, 2, 3]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def size (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "size"))))
-(alter-meta! #'size assoc :doc "
-    Return the number of elements along a given axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-    axis : int, optional
-        Axis along which the elements are counted.  By default, give
-        the total number of elements.
-
-    Returns
-    -------
-    element_count : int
-        Number of elements along the specified axis.
-
-    See Also
-    --------
-    shape : dimensions of array
-    ndarray.shape : dimensions of array
-    ndarray.size : number of elements in array
-
-    Examples
-    --------
-    >>> a = np.array([[1,2,3],[4,5,6]])
-    >>> np.size(a)
-    6
-    >>> np.size(a,1)
-    3
-    >>> np.size(a,0)
-    2
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def unsignedinteger (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unsignedinteger"))))
-(alter-meta! #'unsignedinteger assoc :doc "Abstract base class of all unsigned integer scalar types." :arglists '[[self & [args {:as kwargs}]]])
-
-(def float_power (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float_power"))))
-(alter-meta! #'float_power assoc :doc "float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-First array elements raised to powers from second array, element-wise.
-
-Raise each base in `x1` to the positionally-corresponding power in `x2`.
-`x1` and `x2` must be broadcastable to the same shape. This differs from
-the power function in that integers, float16, and float32  are promoted to
-floats with a minimum precision of float64 so that the result is always
-inexact.  The intent is that the function will return a usable result for
-negative powers and seldom overflow for positive powers.
-
-.. versionadded:: 1.12.0
-
-Parameters
-----------
-x1 : array_like
-    The bases.
-x2 : array_like
-    The exponents. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The bases in `x1` raised to the exponents in `x2`.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-power : power function that preserves type
-
-Examples
---------
-Cube each element in a list.
-
->>> x1 = range(6)
->>> x1
-[0, 1, 2, 3, 4, 5]
->>> np.float_power(x1, 3)
-array([   0.,    1.,    8.,   27.,   64.,  125.])
-
-Raise the bases to different exponents.
-
->>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
->>> np.float_power(x1, x2)
-array([  0.,   1.,   8.,  27.,  16.,   5.])
-
-The effect of broadcasting.
-
->>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
->>> x2
-array([[1, 2, 3, 3, 2, 1],
-       [1, 2, 3, 3, 2, 1]])
->>> np.float_power(x1, x2)
-array([[  0.,   1.,   8.,  27.,  16.,   5.],
-       [  0.,   1.,   8.,  27.,  16.,   5.]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def logical_xor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_xor"))))
-(alter-meta! #'logical_xor assoc :doc "logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute the truth value of x1 XOR x2, element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    Logical XOR is applied to the elements of `x1` and `x2`. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : bool or ndarray of bool
-    Boolean result of the logical XOR operation applied to the elements
-    of `x1` and `x2`; the shape is determined by broadcasting.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-logical_and, logical_or, logical_not, bitwise_xor
-
-Examples
---------
->>> np.logical_xor(True, False)
-True
->>> np.logical_xor([True, True, False, False], [True, False, True, False])
-array([False,  True,  True, False])
-
->>> x = np.arange(5)
->>> np.logical_xor(x < 1, x > 3)
-array([ True, False, False, False,  True])
-
-Simple example showing support of broadcasting
-
->>> np.logical_xor(0, np.eye(2))
-array([[ True, False],
-       [False,  True]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def set_string_function (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "set_string_function"))))
-(alter-meta! #'set_string_function assoc :doc "
-    Set a Python function to be used when pretty printing arrays.
-
-    Parameters
-    ----------
-    f : function or None
-        Function to be used to pretty print arrays. The function should expect
-        a single array argument and return a string of the representation of
-        the array. If None, the function is reset to the default NumPy function
-        to print arrays.
-    repr : bool, optional
-        If True (default), the function for pretty printing (``__repr__``)
-        is set, if False the function that returns the default string
-        representation (``__str__``) is set.
-
-    See Also
-    --------
-    set_printoptions, get_printoptions
-
-    Examples
-    --------
-    >>> def pprint(arr):
-    ...     return 'HA! - What are you going to do now?'
-    ...
-    >>> np.set_string_function(pprint)
-    >>> a = np.arange(10)
-    >>> a
-    HA! - What are you going to do now?
-    >>> _ = a
-    >>> # [0 1 2 3 4 5 6 7 8 9]
-
-    We can reset the function to the default:
-
-    >>> np.set_string_function(None)
-    >>> a
-    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-
-    `repr` affects either pretty printing or normal string representation.
-    Note that ``__repr__`` is still affected by setting ``__str__``
-    because the width of each array element in the returned string becomes
-    equal to the length of the result of ``__str__()``.
-
-    >>> x = np.arange(4)
-    >>> np.set_string_function(lambda x:'random', repr=False)
-    >>> x.__str__()
-    'random'
-    >>> x.__repr__()
-    'array([0, 1, 2, 3])'
-
-    " :arglists '[[f & [{repr :repr}]] [f]])
-
-(def allclose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "allclose"))))
-(alter-meta! #'allclose assoc :doc "
-    Returns True if two arrays are element-wise equal within a tolerance.
-
-    The tolerance values are positive, typically very small numbers.  The
-    relative difference (`rtol` * abs(`b`)) and the absolute difference
-    `atol` are added together to compare against the absolute difference
-    between `a` and `b`.
-
-    NaNs are treated as equal if they are in the same place and if
-    ``equal_nan=True``.  Infs are treated as equal if they are in the same
-    place and of the same sign in both arrays.
-
-    Parameters
-    ----------
-    a, b : array_like
-        Input arrays to compare.
-    rtol : float
-        The relative tolerance parameter (see Notes).
-    atol : float
-        The absolute tolerance parameter (see Notes).
-    equal_nan : bool
-        Whether to compare NaN's as equal.  If True, NaN's in `a` will be
-        considered equal to NaN's in `b` in the output array.
-
-        .. versionadded:: 1.10.0
-
-    Returns
-    -------
-    allclose : bool
-        Returns True if the two arrays are equal within the given
-        tolerance; False otherwise.
-
-    See Also
-    --------
-    isclose, all, any, equal
-
-    Notes
-    -----
-    If the following equation is element-wise True, then allclose returns
-    True.
-
-     absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
-
-    The above equation is not symmetric in `a` and `b`, so that
-    ``allclose(a, b)`` might be different from ``allclose(b, a)`` in
-    some rare cases.
-
-    The comparison of `a` and `b` uses standard broadcasting, which
-    means that `a` and `b` need not have the same shape in order for
-    ``allclose(a, b)`` to evaluate to True.  The same is true for
-    `equal` but not `array_equal`.
-
-    Examples
-    --------
-    >>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])
-    False
-    >>> np.allclose([1e10,1e-8], [1.00001e10,1e-9])
-    True
-    >>> np.allclose([1e10,1e-8], [1.0001e10,1e-9])
-    False
-    >>> np.allclose([1.0, np.nan], [1.0, np.nan])
-    False
-    >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
-    True
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} Inf (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "Inf"))))
-
-(def cumproduct (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cumproduct"))))
-(alter-meta! #'cumproduct assoc :doc "
-    Return the cumulative product over the given axis.
-
-    See Also
-    --------
-    cumprod : equivalent function; see for details.
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def amin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "amin"))))
-(alter-meta! #'amin assoc :doc "
-    Return the minimum of an array or minimum along an axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data.
-    axis : None or int or tuple of ints, optional
-        Axis or axes along which to operate.  By default, flattened input is
-        used.
-
-        .. versionadded:: 1.7.0
-
-        If this is a tuple of ints, the minimum is selected over multiple axes,
-        instead of a single axis or all the axes as before.
-    out : ndarray, optional
-        Alternative output array in which to place the result.  Must
-        be of the same shape and buffer length as the expected output.
-        See `ufuncs-output-type` for more details.
-
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the input array.
-
-        If the default value is passed, then `keepdims` will not be
-        passed through to the `amin` method of sub-classes of
-        `ndarray`, however any non-default value will be.  If the
-        sub-class' method does not implement `keepdims` any
-        exceptions will be raised.
-
-    initial : scalar, optional
-        The maximum value of an output element. Must be present to allow
-        computation on empty slice. See `~numpy.ufunc.reduce` for details.
-
-        .. versionadded:: 1.15.0
-
-    where : array_like of bool, optional
-        Elements to compare for the minimum. See `~numpy.ufunc.reduce`
-        for details.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    amin : ndarray or scalar
-        Minimum of `a`. If `axis` is None, the result is a scalar value.
-        If `axis` is given, the result is an array of dimension
-        ``a.ndim - 1``.
-
-    See Also
-    --------
-    amax :
-        The maximum value of an array along a given axis, propagating any NaNs.
-    nanmin :
-        The minimum value of an array along a given axis, ignoring any NaNs.
-    minimum :
-        Element-wise minimum of two arrays, propagating any NaNs.
-    fmin :
-        Element-wise minimum of two arrays, ignoring any NaNs.
-    argmin :
-        Return the indices of the minimum values.
-
-    nanmax, maximum, fmax
-
-    Notes
-    -----
-    NaN values are propagated, that is if at least one item is NaN, the
-    corresponding min value will be NaN as well. To ignore NaN values
-    (MATLAB behavior), please use nanmin.
-
-    Don't use `amin` for element-wise comparison of 2 arrays; when
-    ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than
-    ``amin(a, axis=0)``.
-
-    Examples
-    --------
-    >>> a = np.arange(4).reshape((2,2))
-    >>> a
-    array([[0, 1],
-           [2, 3]])
-    >>> np.amin(a)           # Minimum of the flattened array
-    0
-    >>> np.amin(a, axis=0)   # Minima along the first axis
-    array([0, 1])
-    >>> np.amin(a, axis=1)   # Minima along the second axis
-    array([0, 2])
-    >>> np.amin(a, where=[False, True], initial=10, axis=0)
-    array([10,  1])
-
-    >>> b = np.arange(5, dtype=float)
-    >>> b[2] = np.NaN
-    >>> np.amin(b)
-    nan
-    >>> np.amin(b, where=~np.isnan(b), initial=10)
-    0.0
-    >>> np.nanmin(b)
-    0.0
-
-    >>> np.min([[-50], [10]], axis=-1, initial=0)
-    array([-50,   0])
-
-    Notice that the initial value is used as one of the elements for which the
-    minimum is determined, unlike for the default argument Python's max
-    function, which is only used for empty iterables.
-
-    Notice that this isn't the same as Python's ``default`` argument.
-
-    >>> np.min([6], initial=5)
-    5
-    >>> min([6], default=5)
-    6
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def nan_to_num (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nan_to_num"))))
-(alter-meta! #'nan_to_num assoc :doc "
-    Replace NaN with zero and infinity with large finite numbers (default
-    behaviour) or with the numbers defined by the user using the `nan`, 
-    `posinf` and/or `neginf` keywords.
-
-    If `x` is inexact, NaN is replaced by zero or by the user defined value in
-    `nan` keyword, infinity is replaced by the largest finite floating point 
-    values representable by ``x.dtype`` or by the user defined value in 
-    `posinf` keyword and -infinity is replaced by the most negative finite 
-    floating point values representable by ``x.dtype`` or by the user defined 
-    value in `neginf` keyword.
-
-    For complex dtypes, the above is applied to each of the real and
-    imaginary components of `x` separately.
-
-    If `x` is not inexact, then no replacements are made.
-
-    Parameters
-    ----------
-    x : scalar or array_like
-        Input data.
-    copy : bool, optional
-        Whether to create a copy of `x` (True) or to replace values
-        in-place (False). The in-place operation only occurs if
-        casting to an array does not require a copy.
-        Default is True.
-        
-        .. versionadded:: 1.13
-    nan : int, float, optional
-        Value to be used to fill NaN values. If no value is passed 
-        then NaN values will be replaced with 0.0.
-        
-        .. versionadded:: 1.17
-    posinf : int, float, optional
-        Value to be used to fill positive infinity values. If no value is 
-        passed then positive infinity values will be replaced with a very
-        large number.
-        
-        .. versionadded:: 1.17
-    neginf : int, float, optional
-        Value to be used to fill negative infinity values. If no value is 
-        passed then negative infinity values will be replaced with a very
-        small (or negative) number.
-        
-        .. versionadded:: 1.17
-
-        
-
-    Returns
-    -------
-    out : ndarray
-        `x`, with the non-finite values replaced. If `copy` is False, this may
-        be `x` itself.
-
-    See Also
-    --------
-    isinf : Shows which elements are positive or negative infinity.
-    isneginf : Shows which elements are negative infinity.
-    isposinf : Shows which elements are positive infinity.
-    isnan : Shows which elements are Not a Number (NaN).
-    isfinite : Shows which elements are finite (not NaN, not infinity)
-
-    Notes
-    -----
-    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
-    (IEEE 754). This means that Not a Number is not equivalent to infinity.
-
-    Examples
-    --------
-    >>> np.nan_to_num(np.inf)
-    1.7976931348623157e+308
-    >>> np.nan_to_num(-np.inf)
-    -1.7976931348623157e+308
-    >>> np.nan_to_num(np.nan)
-    0.0
-    >>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])
-    >>> np.nan_to_num(x)
-    array([ 1.79769313e+308, -1.79769313e+308,  0.00000000e+000, # may vary
-           -1.28000000e+002,  1.28000000e+002])
-    >>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)
-    array([ 3.3333333e+07,  3.3333333e+07, -9.9990000e+03, 
-           -1.2800000e+02,  1.2800000e+02])
-    >>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])
-    array([  1.79769313e+308,  -1.79769313e+308,   0.00000000e+000, # may vary
-         -1.28000000e+002,   1.28000000e+002])
-    >>> np.nan_to_num(y)
-    array([  1.79769313e+308 +0.00000000e+000j, # may vary
-             0.00000000e+000 +0.00000000e+000j,
-             0.00000000e+000 +1.79769313e+308j])
-    >>> np.nan_to_num(y, nan=111111, posinf=222222)
-    array([222222.+111111.j, 111111.     +0.j, 111111.+222222.j])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def diag_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diag_indices"))))
-(alter-meta! #'diag_indices assoc :doc "
-    Return the indices to access the main diagonal of an array.
-
-    This returns a tuple of indices that can be used to access the main
-    diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape
-    (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for
-    ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]``
-    for ``i = [0..n-1]``.
-
-    Parameters
-    ----------
-    n : int
-      The size, along each dimension, of the arrays for which the returned
-      indices can be used.
-
-    ndim : int, optional
-      The number of dimensions.
-
-    See also
-    --------
-    diag_indices_from
-
-    Notes
-    -----
-    .. versionadded:: 1.4.0
-
-    Examples
-    --------
-    Create a set of indices to access the diagonal of a (4, 4) array:
-
-    >>> di = np.diag_indices(4)
-    >>> di
-    (array([0, 1, 2, 3]), array([0, 1, 2, 3]))
-    >>> a = np.arange(16).reshape(4, 4)
-    >>> a
-    array([[ 0,  1,  2,  3],
-           [ 4,  5,  6,  7],
-           [ 8,  9, 10, 11],
-           [12, 13, 14, 15]])
-    >>> a[di] = 100
-    >>> a
-    array([[100,   1,   2,   3],
-           [  4, 100,   6,   7],
-           [  8,   9, 100,  11],
-           [ 12,  13,  14, 100]])
-
-    Now, we create indices to manipulate a 3-D array:
-
-    >>> d3 = np.diag_indices(2, 3)
-    >>> d3
-    (array([0, 1]), array([0, 1]), array([0, 1]))
-
-    And use it to set the diagonal of an array of zeros to 1:
-
-    >>> a = np.zeros((2, 2, 2), dtype=int)
-    >>> a[d3] = 1
-    >>> a
-    array([[[1, 0],
-            [0, 0]],
-           [[0, 0],
-            [0, 1]]])
-
-    " :arglists '[[n & [{ndim :ndim}]] [n]])
-
-(def sometrue (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sometrue"))))
-(alter-meta! #'sometrue assoc :doc "
-    Check whether some values are true.
-
-    Refer to `any` for full documentation.
-
-    See Also
-    --------
-    any : equivalent function; see for details.
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def str_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "str_"))))
-(alter-meta! #'str_ assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def singlecomplex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "singlecomplex"))))
-(alter-meta! #'singlecomplex assoc :doc "Complex number type composed of two single-precision floating-point
-    numbers.
-    Character code: ``'F'``.
-    Canonical name: ``np.csingle``.
-    Alias: ``np.singlecomplex``.
-    Alias *on this platform*: ``np.complex64``: Complex number type composed of 2 32-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def get_printoptions (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "get_printoptions"))))
-(alter-meta! #'get_printoptions assoc :doc "
-    Return the current print options.
-
-    Returns
-    -------
-    print_opts : dict
-        Dictionary of current print options with keys
-
-          - precision : int
-          - threshold : int
-          - edgeitems : int
-          - linewidth : int
-          - suppress : bool
-          - nanstr : str
-          - infstr : str
-          - formatter : dict of callables
-          - sign : str
-
-        For a full description of these options, see `set_printoptions`.
-
-    See Also
-    --------
-    set_printoptions, printoptions, set_string_function
-
-    " :arglists '[[]])
-
-(def sinh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sinh"))))
-(alter-meta! #'sinh assoc :doc "sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Hyperbolic sine, element-wise.
-
-Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or
-``-1j * np.sin(1j*x)``.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The corresponding hyperbolic sine values.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-If `out` is provided, the function writes the result into it,
-and returns a reference to `out`.  (See Examples)
-
-References
-----------
-M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
-New York, NY: Dover, 1972, pg. 83.
-
-Examples
---------
->>> np.sinh(0)
-0.0
->>> np.sinh(np.pi*1j/2)
-1j
->>> np.sinh(np.pi*1j) # (exact value is 0)
-1.2246063538223773e-016j
->>> # Discrepancy due to vagaries of floating point arithmetic.
-
->>> # Example of providing the optional output parameter
->>> out1 = np.array([0], dtype='d')
->>> out2 = np.sinh([0.1], out1)
->>> out2 is out1
-True
-
->>> # Example of ValueError due to provision of shape mis-matched `out`
->>> np.sinh(np.zeros((3,3)),np.zeros((2,2)))
-Traceback (most recent call last):
-  File \"<stdin>\", line 1, in <module>
-ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]])
-
-(def triu_indices_from (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "triu_indices_from"))))
-(alter-meta! #'triu_indices_from assoc :doc "
-    Return the indices for the upper-triangle of arr.
-
-    See `triu_indices` for full details.
-
-    Parameters
-    ----------
-    arr : ndarray, shape(N, N)
-        The indices will be valid for square arrays.
-    k : int, optional
-        Diagonal offset (see `triu` for details).
-
-    Returns
-    -------
-    triu_indices_from : tuple, shape(2) of ndarray, shape(N)
-        Indices for the upper-triangle of `arr`.
-
-    See Also
-    --------
-    triu_indices, triu
-
-    Notes
-    -----
-    .. versionadded:: 1.4.0
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} __doc__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__doc__"))))
-
-(def rot90 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rot90"))))
-(alter-meta! #'rot90 assoc :doc "
-    Rotate an array by 90 degrees in the plane specified by axes.
-
-    Rotation direction is from the first towards the second axis.
-
-    Parameters
-    ----------
-    m : array_like
-        Array of two or more dimensions.
-    k : integer
-        Number of times the array is rotated by 90 degrees.
-    axes: (2,) array_like
-        The array is rotated in the plane defined by the axes.
-        Axes must be different.
-
-        .. versionadded:: 1.12.0
-
-    Returns
-    -------
-    y : ndarray
-        A rotated view of `m`.
-
-    See Also
-    --------
-    flip : Reverse the order of elements in an array along the given axis.
-    fliplr : Flip an array horizontally.
-    flipud : Flip an array vertically.
-
-    Notes
-    -----
-    rot90(m, k=1, axes=(1,0)) is the reverse of rot90(m, k=1, axes=(0,1))
-    rot90(m, k=1, axes=(1,0)) is equivalent to rot90(m, k=-1, axes=(0,1))
-
-    Examples
-    --------
-    >>> m = np.array([[1,2],[3,4]], int)
-    >>> m
-    array([[1, 2],
-           [3, 4]])
-    >>> np.rot90(m)
-    array([[2, 4],
-           [1, 3]])
-    >>> np.rot90(m, 2)
-    array([[4, 3],
-           [2, 1]])
-    >>> m = np.arange(8).reshape((2,2,2))
-    >>> np.rot90(m, 1, (1,2))
-    array([[[1, 3],
-            [0, 2]],
-           [[5, 7],
-            [4, 6]]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def dsplit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dsplit"))))
-(alter-meta! #'dsplit assoc :doc "
-    Split array into multiple sub-arrays along the 3rd axis (depth).
-
-    Please refer to the `split` documentation.  `dsplit` is equivalent
-    to `split` with ``axis=2``, the array is always split along the third
-    axis provided the array dimension is greater than or equal to 3.
-
-    See Also
-    --------
-    split : Split an array into multiple sub-arrays of equal size.
-
-    Examples
-    --------
-    >>> x = np.arange(16.0).reshape(2, 2, 4)
-    >>> x
-    array([[[ 0.,   1.,   2.,   3.],
-            [ 4.,   5.,   6.,   7.]],
-           [[ 8.,   9.,  10.,  11.],
-            [12.,  13.,  14.,  15.]]])
-    >>> np.dsplit(x, 2)
-    [array([[[ 0.,  1.],
-            [ 4.,  5.]],
-           [[ 8.,  9.],
-            [12., 13.]]]), array([[[ 2.,  3.],
-            [ 6.,  7.]],
-           [[10., 11.],
-            [14., 15.]]])]
-    >>> np.dsplit(x, np.array([3, 6]))
-    [array([[[ 0.,   1.,   2.],
-            [ 4.,   5.,   6.]],
-           [[ 8.,   9.,  10.],
-            [12.,  13.,  14.]]]),
-     array([[[ 3.],
-            [ 7.]],
-           [[11.],
-            [15.]]]),
-    array([], shape=(2, 2, 0), dtype=float64)]
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "equal"))))
-(alter-meta! #'equal assoc :doc "equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return (x1 == x2) element-wise.
-
-Parameters
-----------
-x1, x2 : array_like
-    Input arrays. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Output array, element-wise comparison of `x1` and `x2`.
-    Typically of type bool, unless ``dtype=object`` is passed.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-not_equal, greater_equal, less_equal, greater, less
-
-Examples
---------
->>> np.equal([0, 1, 3], np.arange(3))
-array([ True,  True, False])
-
-What is compared are values, not types. So an int (1) and an array of
-length one can evaluate as True:
-
->>> np.equal(1, np.ones(1))
-array([ True])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} CLIP (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "CLIP"))))
-
-(def broadcast_to (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "broadcast_to"))))
-(alter-meta! #'broadcast_to assoc :doc "Broadcast an array to a new shape.
-
-    Parameters
-    ----------
-    array : array_like
-        The array to broadcast.
-    shape : tuple
-        The shape of the desired array.
-    subok : bool, optional
-        If True, then sub-classes will be passed-through, otherwise
-        the returned array will be forced to be a base-class array (default).
-
-    Returns
-    -------
-    broadcast : array
-        A readonly view on the original array with the given shape. It is
-        typically not contiguous. Furthermore, more than one element of a
-        broadcasted array may refer to a single memory location.
-
-    Raises
-    ------
-    ValueError
-        If the array is not compatible with the new shape according to NumPy's
-        broadcasting rules.
-
-    Notes
-    -----
-    .. versionadded:: 1.10.0
-
-    Examples
-    --------
-    >>> x = np.array([1, 2, 3])
-    >>> np.broadcast_to(x, (3, 3))
-    array([[1, 2, 3],
-           [1, 2, 3],
-           [1, 2, 3]])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def einsum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "einsum"))))
-(alter-meta! #'einsum assoc :doc "
-    einsum(subscripts, *operands, out=None, dtype=None, order='K',
-           casting='safe', optimize=False)
-
-    Evaluates the Einstein summation convention on the operands.
-
-    Using the Einstein summation convention, many common multi-dimensional,
-    linear algebraic array operations can be represented in a simple fashion.
-    In *implicit* mode `einsum` computes these values.
-
-    In *explicit* mode, `einsum` provides further flexibility to compute
-    other array operations that might not be considered classical Einstein
-    summation operations, by disabling, or forcing summation over specified
-    subscript labels.
-
-    See the notes and examples for clarification.
-
-    Parameters
-    ----------
-    subscripts : str
-        Specifies the subscripts for summation as comma separated list of
-        subscript labels. An implicit (classical Einstein summation)
-        calculation is performed unless the explicit indicator '->' is
-        included as well as subscript labels of the precise output form.
-    operands : list of array_like
-        These are the arrays for the operation.
-    out : ndarray, optional
-        If provided, the calculation is done into this array.
-    dtype : {data-type, None}, optional
-        If provided, forces the calculation to use the data type specified.
-        Note that you may have to also give a more liberal `casting`
-        parameter to allow the conversions. Default is None.
-    order : {'C', 'F', 'A', 'K'}, optional
-        Controls the memory layout of the output. 'C' means it should
-        be C contiguous. 'F' means it should be Fortran contiguous,
-        'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise.
-        'K' means it should be as close to the layout as the inputs as
-        is possible, including arbitrarily permuted axes.
-        Default is 'K'.
-    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
-        Controls what kind of data casting may occur.  Setting this to
-        'unsafe' is not recommended, as it can adversely affect accumulations.
-
-          * 'no' means the data types should not be cast at all.
-          * 'equiv' means only byte-order changes are allowed.
-          * 'safe' means only casts which can preserve values are allowed.
-          * 'same_kind' means only safe casts or casts within a kind,
-            like float64 to float32, are allowed.
-          * 'unsafe' means any data conversions may be done.
-
-        Default is 'safe'.
-    optimize : {False, True, 'greedy', 'optimal'}, optional
-        Controls if intermediate optimization should occur. No optimization
-        will occur if False and True will default to the 'greedy' algorithm.
-        Also accepts an explicit contraction list from the ``np.einsum_path``
-        function. See ``np.einsum_path`` for more details. Defaults to False.
-
-    Returns
-    -------
-    output : ndarray
-        The calculation based on the Einstein summation convention.
-
-    See Also
-    --------
-    einsum_path, dot, inner, outer, tensordot, linalg.multi_dot
-
-    Notes
-    -----
-    .. versionadded:: 1.6.0
-
-    The Einstein summation convention can be used to compute
-    many multi-dimensional, linear algebraic array operations. `einsum`
-    provides a succinct way of representing these.
-
-    A non-exhaustive list of these operations,
-    which can be computed by `einsum`, is shown below along with examples:
-
-    * Trace of an array, :py:func:`numpy.trace`.
-    * Return a diagonal, :py:func:`numpy.diag`.
-    * Array axis summations, :py:func:`numpy.sum`.
-    * Transpositions and permutations, :py:func:`numpy.transpose`.
-    * Matrix multiplication and dot product, :py:func:`numpy.matmul` :py:func:`numpy.dot`.
-    * Vector inner and outer products, :py:func:`numpy.inner` :py:func:`numpy.outer`.
-    * Broadcasting, element-wise and scalar multiplication, :py:func:`numpy.multiply`.
-    * Tensor contractions, :py:func:`numpy.tensordot`.
-    * Chained array operations, in efficient calculation order, :py:func:`numpy.einsum_path`.
-
-    The subscripts string is a comma-separated list of subscript labels,
-    where each label refers to a dimension of the corresponding operand.
-    Whenever a label is repeated it is summed, so ``np.einsum('i,i', a, b)``
-    is equivalent to :py:func:`np.inner(a,b) <numpy.inner>`. If a label
-    appears only once, it is not summed, so ``np.einsum('i', a)`` produces a
-    view of ``a`` with no changes. A further example ``np.einsum('ij,jk', a, b)``
-    describes traditional matrix multiplication and is equivalent to
-    :py:func:`np.matmul(a,b) <numpy.matmul>`. Repeated subscript labels in one
-    operand take the diagonal. For example, ``np.einsum('ii', a)`` is equivalent
-    to :py:func:`np.trace(a) <numpy.trace>`.
-
-    In *implicit mode*, the chosen subscripts are important
-    since the axes of the output are reordered alphabetically.  This
-    means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while
-    ``np.einsum('ji', a)`` takes its transpose. Additionally,
-    ``np.einsum('ij,jk', a, b)`` returns a matrix multiplication, while,
-    ``np.einsum('ij,jh', a, b)`` returns the transpose of the
-    multiplication since subscript 'h' precedes subscript 'i'.
-
-    In *explicit mode* the output can be directly controlled by
-    specifying output subscript labels.  This requires the
-    identifier '->' as well as the list of output subscript labels.
-    This feature increases the flexibility of the function since
-    summing can be disabled or forced when required. The call
-    ``np.einsum('i->', a)`` is like :py:func:`np.sum(a, axis=-1) <numpy.sum>`,
-    and ``np.einsum('ii->i', a)`` is like :py:func:`np.diag(a) <numpy.diag>`.
-    The difference is that `einsum` does not allow broadcasting by default.
-    Additionally ``np.einsum('ij,jh->ih', a, b)`` directly specifies the
-    order of the output subscript labels and therefore returns matrix
-    multiplication, unlike the example above in implicit mode.
-
-    To enable and control broadcasting, use an ellipsis.  Default
-    NumPy-style broadcasting is done by adding an ellipsis
-    to the left of each term, like ``np.einsum('...ii->...i', a)``.
-    To take the trace along the first and last axes,
-    you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix
-    product with the left-most indices instead of rightmost, one can do
-    ``np.einsum('ij...,jk...->ik...', a, b)``.
-
-    When there is only one operand, no axes are summed, and no output
-    parameter is provided, a view into the operand is returned instead
-    of a new array.  Thus, taking the diagonal as ``np.einsum('ii->i', a)``
-    produces a view (changed in version 1.10.0).
-
-    `einsum` also provides an alternative way to provide the subscripts
-    and operands as ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``.
-    If the output shape is not provided in this format `einsum` will be
-    calculated in implicit mode, otherwise it will be performed explicitly.
-    The examples below have corresponding `einsum` calls with the two
-    parameter methods.
-
-    .. versionadded:: 1.10.0
-
-    Views returned from einsum are now writeable whenever the input array
-    is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now
-    have the same effect as :py:func:`np.swapaxes(a, 0, 2) <numpy.swapaxes>`
-    and ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal
-    of a 2D array.
-
-    .. versionadded:: 1.12.0
-
-    Added the ``optimize`` argument which will optimize the contraction order
-    of an einsum expression. For a contraction with three or more operands this
-    can greatly increase the computational efficiency at the cost of a larger
-    memory footprint during computation.
-
-    Typically a 'greedy' algorithm is applied which empirical tests have shown
-    returns the optimal path in the majority of cases. In some cases 'optimal'
-    will return the superlative path through a more expensive, exhaustive search.
-    For iterative calculations it may be advisable to calculate the optimal path
-    once and reuse that path by supplying it as an argument. An example is given
-    below.
-
-    See :py:func:`numpy.einsum_path` for more details.
-
-    Examples
-    --------
-    >>> a = np.arange(25).reshape(5,5)
-    >>> b = np.arange(5)
-    >>> c = np.arange(6).reshape(2,3)
-
-    Trace of a matrix:
-
-    >>> np.einsum('ii', a)
-    60
-    >>> np.einsum(a, [0,0])
-    60
-    >>> np.trace(a)
-    60
-
-    Extract the diagonal (requires explicit form):
-
-    >>> np.einsum('ii->i', a)
-    array([ 0,  6, 12, 18, 24])
-    >>> np.einsum(a, [0,0], [0])
-    array([ 0,  6, 12, 18, 24])
-    >>> np.diag(a)
-    array([ 0,  6, 12, 18, 24])
-
-    Sum over an axis (requires explicit form):
-
-    >>> np.einsum('ij->i', a)
-    array([ 10,  35,  60,  85, 110])
-    >>> np.einsum(a, [0,1], [0])
-    array([ 10,  35,  60,  85, 110])
-    >>> np.sum(a, axis=1)
-    array([ 10,  35,  60,  85, 110])
-
-    For higher dimensional arrays summing a single axis can be done with ellipsis:
-
-    >>> np.einsum('...j->...', a)
-    array([ 10,  35,  60,  85, 110])
-    >>> np.einsum(a, [Ellipsis,1], [Ellipsis])
-    array([ 10,  35,  60,  85, 110])
-
-    Compute a matrix transpose, or reorder any number of axes:
-
-    >>> np.einsum('ji', c)
-    array([[0, 3],
-           [1, 4],
-           [2, 5]])
-    >>> np.einsum('ij->ji', c)
-    array([[0, 3],
-           [1, 4],
-           [2, 5]])
-    >>> np.einsum(c, [1,0])
-    array([[0, 3],
-           [1, 4],
-           [2, 5]])
-    >>> np.transpose(c)
-    array([[0, 3],
-           [1, 4],
-           [2, 5]])
-
-    Vector inner products:
-
-    >>> np.einsum('i,i', b, b)
-    30
-    >>> np.einsum(b, [0], b, [0])
-    30
-    >>> np.inner(b,b)
-    30
-
-    Matrix vector multiplication:
-
-    >>> np.einsum('ij,j', a, b)
-    array([ 30,  80, 130, 180, 230])
-    >>> np.einsum(a, [0,1], b, [1])
-    array([ 30,  80, 130, 180, 230])
-    >>> np.dot(a, b)
-    array([ 30,  80, 130, 180, 230])
-    >>> np.einsum('...j,j', a, b)
-    array([ 30,  80, 130, 180, 230])
-
-    Broadcasting and scalar multiplication:
-
-    >>> np.einsum('..., ...', 3, c)
-    array([[ 0,  3,  6],
-           [ 9, 12, 15]])
-    >>> np.einsum(',ij', 3, c)
-    array([[ 0,  3,  6],
-           [ 9, 12, 15]])
-    >>> np.einsum(3, [Ellipsis], c, [Ellipsis])
-    array([[ 0,  3,  6],
-           [ 9, 12, 15]])
-    >>> np.multiply(3, c)
-    array([[ 0,  3,  6],
-           [ 9, 12, 15]])
-
-    Vector outer product:
-
-    >>> np.einsum('i,j', np.arange(2)+1, b)
-    array([[0, 1, 2, 3, 4],
-           [0, 2, 4, 6, 8]])
-    >>> np.einsum(np.arange(2)+1, [0], b, [1])
-    array([[0, 1, 2, 3, 4],
-           [0, 2, 4, 6, 8]])
-    >>> np.outer(np.arange(2)+1, b)
-    array([[0, 1, 2, 3, 4],
-           [0, 2, 4, 6, 8]])
-
-    Tensor contraction:
-
-    >>> a = np.arange(60.).reshape(3,4,5)
-    >>> b = np.arange(24.).reshape(4,3,2)
-    >>> np.einsum('ijk,jil->kl', a, b)
-    array([[4400., 4730.],
-           [4532., 4874.],
-           [4664., 5018.],
-           [4796., 5162.],
-           [4928., 5306.]])
-    >>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3])
-    array([[4400., 4730.],
-           [4532., 4874.],
-           [4664., 5018.],
-           [4796., 5162.],
-           [4928., 5306.]])
-    >>> np.tensordot(a,b, axes=([1,0],[0,1]))
-    array([[4400., 4730.],
-           [4532., 4874.],
-           [4664., 5018.],
-           [4796., 5162.],
-           [4928., 5306.]])
-
-    Writeable returned arrays (since version 1.10.0):
-
-    >>> a = np.zeros((3, 3))
-    >>> np.einsum('ii->i', a)[:] = 1
-    >>> a
-    array([[1., 0., 0.],
-           [0., 1., 0.],
-           [0., 0., 1.]])
-
-    Example of ellipsis use:
-
-    >>> a = np.arange(6).reshape((3,2))
-    >>> b = np.arange(12).reshape((4,3))
-    >>> np.einsum('ki,jk->ij', a, b)
-    array([[10, 28, 46, 64],
-           [13, 40, 67, 94]])
-    >>> np.einsum('ki,...k->i...', a, b)
-    array([[10, 28, 46, 64],
-           [13, 40, 67, 94]])
-    >>> np.einsum('k...,jk', a, b)
-    array([[10, 28, 46, 64],
-           [13, 40, 67, 94]])
-
-    Chained array operations. For more complicated contractions, speed ups
-    might be achieved by repeatedly computing a 'greedy' path or pre-computing the
-    'optimal' path and repeatedly applying it, using an
-    `einsum_path` insertion (since version 1.12.0). Performance improvements can be
-    particularly significant with larger arrays:
-
-    >>> a = np.ones(64).reshape(2,4,8)
-
-    Basic `einsum`: ~1520ms  (benchmarked on 3.1GHz Intel i5.)
-
-    >>> for iteration in range(500):
-    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a)
-
-    Sub-optimal `einsum` (due to repeated path calculation time): ~330ms
-
-    >>> for iteration in range(500):
-    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')
-
-    Greedy `einsum` (faster optimal path approximation): ~160ms
-
-    >>> for iteration in range(500):
-    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy')
-
-    Optimal `einsum` (best usage pattern in some use cases): ~110ms
-
-    >>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')[0]
-    >>> for iteration in range(500):
-    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} numarray (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "numarray"))))
-
-(def bytes0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bytes0"))))
-(alter-meta! #'bytes0 assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} little_endian (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "little_endian"))))
-
-(def VisibleDeprecationWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "VisibleDeprecationWarning"))))
-(alter-meta! #'VisibleDeprecationWarning assoc :doc "Visible deprecation warning.
-
-    By default, python will not show deprecation warnings, so this class
-    can be used when a very visible warning is helpful, for example because
-    the usage is most likely a user bug.
-
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def AxisError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "AxisError"))))
-(alter-meta! #'AxisError assoc :doc " Axis supplied was invalid. " :arglists '[[self axis & [{ndim :ndim, msg_prefix :msg_prefix}]] [self axis & [{ndim :ndim}]] [self axis]])
-
-(def apply_along_axis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "apply_along_axis"))))
-(alter-meta! #'apply_along_axis assoc :doc "
-    Apply a function to 1-D slices along the given axis.
-
-    Execute `func1d(a, *args)` where `func1d` operates on 1-D arrays and `a`
-    is a 1-D slice of `arr` along `axis`.
-
-    This is equivalent to (but faster than) the following use of `ndindex` and
-    `s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices::
-
-        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
-        for ii in ndindex(Ni):
-            for kk in ndindex(Nk):
-                f = func1d(arr[ii + s_[:,] + kk])
-                Nj = f.shape
-                for jj in ndindex(Nj):
-                    out[ii + jj + kk] = f[jj]
-
-    Equivalently, eliminating the inner loop, this can be expressed as::
-
-        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
-        for ii in ndindex(Ni):
-            for kk in ndindex(Nk):
-                out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])
-
-    Parameters
-    ----------
-    func1d : function (M,) -> (Nj...)
-        This function should accept 1-D arrays. It is applied to 1-D
-        slices of `arr` along the specified axis.
-    axis : integer
-        Axis along which `arr` is sliced.
-    arr : ndarray (Ni..., M, Nk...)
-        Input array.
-    args : any
-        Additional arguments to `func1d`.
-    kwargs : any
-        Additional named arguments to `func1d`.
-
-        .. versionadded:: 1.9.0
-
-
-    Returns
-    -------
-    out : ndarray  (Ni..., Nj..., Nk...)
-        The output array. The shape of `out` is identical to the shape of
-        `arr`, except along the `axis` dimension. This axis is removed, and
-        replaced with new dimensions equal to the shape of the return value
-        of `func1d`. So if `func1d` returns a scalar `out` will have one
-        fewer dimensions than `arr`.
-
-    See Also
-    --------
-    apply_over_axes : Apply a function repeatedly over multiple axes.
-
-    Examples
-    --------
-    >>> def my_func(a):
-    ...     \"\"\"Average first and last element of a 1-D array\"\"\"
-    ...     return (a[0] + a[-1]) * 0.5
-    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
-    >>> np.apply_along_axis(my_func, 0, b)
-    array([4., 5., 6.])
-    >>> np.apply_along_axis(my_func, 1, b)
-    array([2.,  5.,  8.])
-
-    For a function that returns a 1D array, the number of dimensions in
-    `outarr` is the same as `arr`.
-
-    >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])
-    >>> np.apply_along_axis(sorted, 1, b)
-    array([[1, 7, 8],
-           [3, 4, 9],
-           [2, 5, 6]])
-
-    For a function that returns a higher dimensional array, those dimensions
-    are inserted in place of the `axis` dimension.
-
-    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
-    >>> np.apply_along_axis(np.diag, -1, b)
-    array([[[1, 0, 0],
-            [0, 2, 0],
-            [0, 0, 3]],
-           [[4, 0, 0],
-            [0, 5, 0],
-            [0, 0, 6]],
-           [[7, 0, 0],
-            [0, 8, 0],
-            [0, 0, 9]]])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def nextafter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nextafter"))))
-(alter-meta! #'nextafter assoc :doc "nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the next floating-point value after x1 towards x2, element-wise.
-
-Parameters
-----------
-x1 : array_like
-    Values to find the next representable value of.
-x2 : array_like
-    The direction where to look for the next representable value of `x1`.
-    If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    The next representable values of `x1` in the direction of `x2`.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-Examples
---------
->>> eps = np.finfo(np.float64).eps
->>> np.nextafter(1, 2) == eps + 1
-True
->>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps]
-array([ True,  True])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def cumsum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cumsum"))))
-(alter-meta! #'cumsum assoc :doc "
-    Return the cumulative sum of the elements along a given axis.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    axis : int, optional
-        Axis along which the cumulative sum is computed. The default
-        (None) is to compute the cumsum over the flattened array.
-    dtype : dtype, optional
-        Type of the returned array and of the accumulator in which the
-        elements are summed.  If `dtype` is not specified, it defaults
-        to the dtype of `a`, unless `a` has an integer dtype with a
-        precision less than that of the default platform integer.  In
-        that case, the default platform integer is used.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must
-        have the same shape and buffer length as the expected output
-        but the type will be cast if necessary. See `ufuncs-output-type` for
-        more details.
-
-    Returns
-    -------
-    cumsum_along_axis : ndarray.
-        A new array holding the result is returned unless `out` is
-        specified, in which case a reference to `out` is returned. The
-        result has the same size as `a`, and the same shape as `a` if
-        `axis` is not None or `a` is a 1-d array.
-
-
-    See Also
-    --------
-    sum : Sum array elements.
-
-    trapz : Integration of array values using the composite trapezoidal rule.
-
-    diff :  Calculate the n-th discrete difference along given axis.
-
-    Notes
-    -----
-    Arithmetic is modular when using integer types, and no error is
-    raised on overflow.
-
-    Examples
-    --------
-    >>> a = np.array([[1,2,3], [4,5,6]])
-    >>> a
-    array([[1, 2, 3],
-           [4, 5, 6]])
-    >>> np.cumsum(a)
-    array([ 1,  3,  6, 10, 15, 21])
-    >>> np.cumsum(a, dtype=float)     # specifies type of output value(s)
-    array([  1.,   3.,   6.,  10.,  15.,  21.])
-
-    >>> np.cumsum(a,axis=0)      # sum over rows for each of the 3 columns
-    array([[1, 2, 3],
-           [5, 7, 9]])
-    >>> np.cumsum(a,axis=1)      # sum over columns for each of the 2 rows
-    array([[ 1,  3,  6],
-           [ 4,  9, 15]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def bartlett (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bartlett"))))
-(alter-meta! #'bartlett assoc :doc "
-    Return the Bartlett window.
-
-    The Bartlett window is very similar to a triangular window, except
-    that the end points are at zero.  It is often used in signal
-    processing for tapering a signal, without generating too much
-    ripple in the frequency domain.
-
-    Parameters
-    ----------
-    M : int
-        Number of points in the output window. If zero or less, an
-        empty array is returned.
-
-    Returns
-    -------
-    out : array
-        The triangular window, with the maximum value normalized to one
-        (the value one appears only if the number of samples is odd), with
-        the first and last samples equal to zero.
-
-    See Also
-    --------
-    blackman, hamming, hanning, kaiser
-
-    Notes
-    -----
-    The Bartlett window is defined as
-
-    .. math:: w(n) = \\frac{2}{M-1} \\left(
-              \\frac{M-1}{2} - \\left|n - \\frac{M-1}{2}\\right|
-              \\right)
-
-    Most references to the Bartlett window come from the signal
-    processing literature, where it is used as one of many windowing
-    functions for smoothing values.  Note that convolution with this
-    window produces linear interpolation.  It is also known as an
-    apodization (which means\"removing the foot\", i.e. smoothing
-    discontinuities at the beginning and end of the sampled signal) or
-    tapering function. The fourier transform of the Bartlett is the product
-    of two sinc functions.
-    Note the excellent discussion in Kanasewich.
-
-    References
-    ----------
-    .. [1] M.S. Bartlett, \"Periodogram Analysis and Continuous Spectra\",
-           Biometrika 37, 1-16, 1950.
-    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\",
-           The University of Alberta Press, 1975, pp. 109-110.
-    .. [3] A.V. Oppenheim and R.W. Schafer, \"Discrete-Time Signal
-           Processing\", Prentice-Hall, 1999, pp. 468-471.
-    .. [4] Wikipedia, \"Window function\",
-           https://en.wikipedia.org/wiki/Window_function
-    .. [5] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
-           \"Numerical Recipes\", Cambridge University Press, 1986, page 429.
-
-    Examples
-    --------
-    >>> import matplotlib.pyplot as plt
-    >>> np.bartlett(12)
-    array([ 0.        ,  0.18181818,  0.36363636,  0.54545455,  0.72727273, # may vary
-            0.90909091,  0.90909091,  0.72727273,  0.54545455,  0.36363636,
-            0.18181818,  0.        ])
-
-    Plot the window and its frequency response (requires SciPy and matplotlib):
-
-    >>> from numpy.fft import fft, fftshift
-    >>> window = np.bartlett(51)
-    >>> plt.plot(window)
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.title(\"Bartlett window\")
-    Text(0.5, 1.0, 'Bartlett window')
-    >>> plt.ylabel(\"Amplitude\")
-    Text(0, 0.5, 'Amplitude')
-    >>> plt.xlabel(\"Sample\")
-    Text(0.5, 0, 'Sample')
-    >>> plt.show()
-
-    >>> plt.figure()
-    <Figure size 640x480 with 0 Axes>
-    >>> A = fft(window, 2048) / 25.5
-    >>> mag = np.abs(fftshift(A))
-    >>> freq = np.linspace(-0.5, 0.5, len(A))
-    >>> with np.errstate(divide='ignore', invalid='ignore'):
-    ...     response = 20 * np.log10(mag)
-    ...
-    >>> response = np.clip(response, -100, 100)
-    >>> plt.plot(freq, response)
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.title(\"Frequency response of Bartlett window\")
-    Text(0.5, 1.0, 'Frequency response of Bartlett window')
-    >>> plt.ylabel(\"Magnitude [dB]\")
-    Text(0, 0.5, 'Magnitude [dB]')
-    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
-    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
-    >>> _ = plt.axis('tight')
-    >>> plt.show()
-
-    " :arglists '[[M]])
-
-(def bool8 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bool8"))))
-(alter-meta! #'bool8 assoc :doc "Boolean type (True or False), stored as a byte.
-    Character code: ``'?'``.
-    Alias: ``np.bool8``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def nanmean (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmean"))))
-(alter-meta! #'nanmean assoc :doc "
-    Compute the arithmetic mean along the specified axis, ignoring NaNs.
-
-    Returns the average of the array elements.  The average is taken over
-    the flattened array by default, otherwise over the specified axis.
-    `float64` intermediate and return values are used for integer inputs.
-
-    For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised.
-
-    .. versionadded:: 1.8.0
-
-    Parameters
-    ----------
-    a : array_like
-        Array containing numbers whose mean is desired. If `a` is not an
-        array, a conversion is attempted.
-    axis : {int, tuple of int, None}, optional
-        Axis or axes along which the means are computed. The default is to compute
-        the mean of the flattened array.
-    dtype : data-type, optional
-        Type to use in computing the mean.  For integer inputs, the default
-        is `float64`; for inexact inputs, it is the same as the input
-        dtype.
-    out : ndarray, optional
-        Alternate output array in which to place the result.  The default
-        is ``None``; if provided, it must have the same shape as the
-        expected output, but the type will be cast if necessary. See
-        `ufuncs-output-type` for more details.
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the original `a`.
-
-        If the value is anything but the default, then
-        `keepdims` will be passed through to the `mean` or `sum` methods
-        of sub-classes of `ndarray`.  If the sub-classes methods
-        does not implement `keepdims` any exceptions will be raised.
-
-    Returns
-    -------
-    m : ndarray, see dtype parameter above
-        If `out=None`, returns a new array containing the mean values,
-        otherwise a reference to the output array is returned. Nan is
-        returned for slices that contain only NaNs.
-
-    See Also
-    --------
-    average : Weighted average
-    mean : Arithmetic mean taken while not ignoring NaNs
-    var, nanvar
-
-    Notes
-    -----
-    The arithmetic mean is the sum of the non-NaN elements along the axis
-    divided by the number of non-NaN elements.
-
-    Note that for floating-point input, the mean is computed using the same
-    precision the input has.  Depending on the input data, this can cause
-    the results to be inaccurate, especially for `float32`.  Specifying a
-    higher-precision accumulator using the `dtype` keyword can alleviate
-    this issue.
-
-    Examples
-    --------
-    >>> a = np.array([[1, np.nan], [3, 4]])
-    >>> np.nanmean(a)
-    2.6666666666666665
-    >>> np.nanmean(a, axis=0)
-    array([2.,  4.])
-    >>> np.nanmean(a, axis=1)
-    array([1.,  3.5]) # may vary
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def dtype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dtype"))))
-(alter-meta! #'dtype assoc :doc "dtype(obj, align=False, copy=False)
-
-    Create a data type object.
-
-    A numpy array is homogeneous, and contains elements described by a
-    dtype object. A dtype object can be constructed from different
-    combinations of fundamental numeric types.
-
-    Parameters
-    ----------
-    obj
-        Object to be converted to a data type object.
-    align : bool, optional
-        Add padding to the fields to match what a C compiler would output
-        for a similar C-struct. Can be ``True`` only if `obj` is a dictionary
-        or a comma-separated string. If a struct dtype is being created,
-        this also sets a sticky alignment flag ``isalignedstruct``.
-    copy : bool, optional
-        Make a new copy of the data-type object. If ``False``, the result
-        may just be a reference to a built-in data-type object.
-
-    See also
-    --------
-    result_type
-
-    Examples
-    --------
-    Using array-scalar type:
-
-    >>> np.dtype(np.int16)
-    dtype('int16')
-
-    Structured type, one field name 'f1', containing int16:
-
-    >>> np.dtype([('f1', np.int16)])
-    dtype([('f1', '<i2')])
-
-    Structured type, one field named 'f1', in itself containing a structured
-    type with one field:
-
-    >>> np.dtype([('f1', [('f1', np.int16)])])
-    dtype([('f1', [('f1', '<i2')])])
-
-    Structured type, two fields: the first field contains an unsigned int, the
-    second an int32:
-
-    >>> np.dtype([('f1', np.uint64), ('f2', np.int32)])
-    dtype([('f1', '<u8'), ('f2', '<i4')])
-
-    Using array-protocol type strings:
-
-    >>> np.dtype([('a','f8'),('b','S10')])
-    dtype([('a', '<f8'), ('b', 'S10')])
-
-    Using comma-separated field formats.  The shape is (2,3):
-
-    >>> np.dtype(\"i4, (2,3)f8\")
-    dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])
-
-    Using tuples.  ``int`` is a fixed type, 3 the field's shape.  ``void``
-    is a flexible type, here of size 10:
-
-    >>> np.dtype([('hello',(np.int64,3)),('world',np.void,10)])
-    dtype([('hello', '<i8', (3,)), ('world', 'V10')])
-
-    Subdivide ``int16`` into 2 ``int8``'s, called x and y.  0 and 1 are
-    the offsets in bytes:
-
-    >>> np.dtype((np.int16, {'x':(np.int8,0), 'y':(np.int8,1)}))
-    dtype((numpy.int16, [('x', 'i1'), ('y', 'i1')]))
-
-    Using dictionaries.  Two fields named 'gender' and 'age':
-
-    >>> np.dtype({'names':['gender','age'], 'formats':['S1',np.uint8]})
-    dtype([('gender', 'S1'), ('age', 'u1')])
-
-    Offsets in bytes, here 0 and 25:
-
-    >>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
-    dtype([('surname', 'S25'), ('age', 'u1')])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def geomspace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geomspace"))))
-(alter-meta! #'geomspace assoc :doc "
-    Return numbers spaced evenly on a log scale (a geometric progression).
-
-    This is similar to `logspace`, but with endpoints specified directly.
-    Each output sample is a constant multiple of the previous.
-
-    .. versionchanged:: 1.16.0
-        Non-scalar `start` and `stop` are now supported.
-
-    Parameters
-    ----------
-    start : array_like
-        The starting value of the sequence.
-    stop : array_like
-        The final value of the sequence, unless `endpoint` is False.
-        In that case, ``num + 1`` values are spaced over the
-        interval in log-space, of which all but the last (a sequence of
-        length `num`) are returned.
-    num : integer, optional
-        Number of samples to generate.  Default is 50.
-    endpoint : boolean, optional
-        If true, `stop` is the last sample. Otherwise, it is not included.
-        Default is True.
-    dtype : dtype
-        The type of the output array.  If `dtype` is not given, infer the data
-        type from the other input arguments.
-    axis : int, optional
-        The axis in the result to store the samples.  Relevant only if start
-        or stop are array-like.  By default (0), the samples will be along a
-        new axis inserted at the beginning. Use -1 to get an axis at the end.
-
-        .. versionadded:: 1.16.0
-
-    Returns
-    -------
-    samples : ndarray
-        `num` samples, equally spaced on a log scale.
-
-    See Also
-    --------
-    logspace : Similar to geomspace, but with endpoints specified using log
-               and base.
-    linspace : Similar to geomspace, but with arithmetic instead of geometric
-               progression.
-    arange : Similar to linspace, with the step size specified instead of the
-             number of samples.
-
-    Notes
-    -----
-    If the inputs or dtype are complex, the output will follow a logarithmic
-    spiral in the complex plane.  (There are an infinite number of spirals
-    passing through two points; the output will follow the shortest such path.)
-
-    Examples
-    --------
-    >>> np.geomspace(1, 1000, num=4)
-    array([    1.,    10.,   100.,  1000.])
-    >>> np.geomspace(1, 1000, num=3, endpoint=False)
-    array([   1.,   10.,  100.])
-    >>> np.geomspace(1, 1000, num=4, endpoint=False)
-    array([   1.        ,    5.62341325,   31.6227766 ,  177.827941  ])
-    >>> np.geomspace(1, 256, num=9)
-    array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.])
-
-    Note that the above may not produce exact integers:
-
-    >>> np.geomspace(1, 256, num=9, dtype=int)
-    array([  1,   2,   4,   7,  16,  32,  63, 127, 256])
-    >>> np.around(np.geomspace(1, 256, num=9)).astype(int)
-    array([  1,   2,   4,   8,  16,  32,  64, 128, 256])
-
-    Negative, decreasing, and complex inputs are allowed:
-
-    >>> np.geomspace(1000, 1, num=4)
-    array([1000.,  100.,   10.,    1.])
-    >>> np.geomspace(-1000, -1, num=4)
-    array([-1000.,  -100.,   -10.,    -1.])
-    >>> np.geomspace(1j, 1000j, num=4)  # Straight line
-    array([0.   +1.j, 0.  +10.j, 0. +100.j, 0.+1000.j])
-    >>> np.geomspace(-1+0j, 1+0j, num=5)  # Circle
-    array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,
-            6.12323400e-17+1.00000000e+00j,  7.07106781e-01+7.07106781e-01j,
-            1.00000000e+00+0.00000000e+00j])
-
-    Graphical illustration of ``endpoint`` parameter:
-
-    >>> import matplotlib.pyplot as plt
-    >>> N = 10
-    >>> y = np.zeros(N)
-    >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o')
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o')
-    [<matplotlib.lines.Line2D object at 0x...>]
-    >>> plt.axis([0.5, 2000, 0, 3])
-    [0.5, 2000, 0, 3]
-    >>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both')
-    >>> plt.show()
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def round (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "round"))))
-(alter-meta! #'round assoc :doc "
-    Round an array to the given number of decimals.
-
-    See Also
-    --------
-    around : equivalent function; see for details.
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def uintp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uintp"))))
-(alter-meta! #'uintp assoc :doc "Unsigned integer type, compatible with C ``unsigned long``.
-    Character code: ``'L'``.
-    Canonical name: ``np.uint``.
-    Alias *on this platform*: ``np.uint64``: 64-bit unsigned integer (0 to 18446744073709551615).
-    Alias *on this platform*: ``np.uintp``: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ubyte (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ubyte"))))
-(alter-meta! #'ubyte assoc :doc "Unsigned integer type, compatible with C ``unsigned char``.
-    Character code: ``'B'``.
-    Canonical name: ``np.ubyte``.
-    Alias *on this platform*: ``np.uint8``: 8-bit unsigned integer (0 to 255)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def triu (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "triu"))))
-(alter-meta! #'triu assoc :doc "
-    Upper triangle of an array.
-
-    Return a copy of a matrix with the elements below the `k`-th diagonal
-    zeroed.
-
-    Please refer to the documentation for `tril` for further details.
-
-    See Also
-    --------
-    tril : lower triangle of an array
-
-    Examples
-    --------
-    >>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
-    array([[ 1,  2,  3],
-           [ 4,  5,  6],
-           [ 0,  8,  9],
-           [ 0,  0, 12]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def diagflat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diagflat"))))
-(alter-meta! #'diagflat assoc :doc "
-    Create a two-dimensional array with the flattened input as a diagonal.
-
-    Parameters
-    ----------
-    v : array_like
-        Input data, which is flattened and set as the `k`-th
-        diagonal of the output.
-    k : int, optional
-        Diagonal to set; 0, the default, corresponds to the \"main\" diagonal,
-        a positive (negative) `k` giving the number of the diagonal above
-        (below) the main.
-
-    Returns
-    -------
-    out : ndarray
-        The 2-D output array.
-
-    See Also
-    --------
-    diag : MATLAB work-alike for 1-D and 2-D arrays.
-    diagonal : Return specified diagonals.
-    trace : Sum along diagonals.
-
-    Examples
-    --------
-    >>> np.diagflat([[1,2], [3,4]])
-    array([[1, 0, 0, 0],
-           [0, 2, 0, 0],
-           [0, 0, 3, 0],
-           [0, 0, 0, 4]])
-
-    >>> np.diagflat([1,2], 1)
-    array([[0, 1, 0],
-           [0, 0, 2],
-           [0, 0, 0]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def complex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex"))))
-(alter-meta! #'complex assoc :doc "Create a complex number from a real part and an optional imaginary part.
-
-This is equivalent to (real + imag*1j) where imag defaults to 0." :arglists '[[self & [args {:as kwargs}]]])
-
-(def object_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "object_"))))
-(alter-meta! #'object_ assoc :doc "Any Python object.
-    Character code: ``'O'``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def isrealobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isrealobj"))))
-(alter-meta! #'isrealobj assoc :doc "
-    Return True if x is a not complex type or an array of complex numbers.
-
-    The type of the input is checked, not the value. So even if the input
-    has an imaginary part equal to zero, `isrealobj` evaluates to False
-    if the data type is complex.
-
-    Parameters
-    ----------
-    x : any
-        The input can be of any type and shape.
-
-    Returns
-    -------
-    y : bool
-        The return value, False if `x` is of a complex type.
-
-    See Also
-    --------
-    iscomplexobj, isreal
-
-    Examples
-    --------
-    >>> np.isrealobj(1)
-    True
-    >>> np.isrealobj(1+0j)
-    False
-    >>> np.isrealobj([3, 1+0j, True])
-    False
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} __name__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__name__"))))
-
-(def ^{:doc "
-Record Arrays
-=============
-Record arrays expose the fields of structured arrays as properties.
-
-Most commonly, ndarrays contain elements of a single type, e.g. floats,
-integers, bools etc.  However, it is possible for elements to be combinations
-of these using structured types, such as::
-
-  >>> a = np.array([(1, 2.0), (1, 2.0)], dtype=[('x', np.int64), ('y', np.float64)])
-  >>> a
-  array([(1, 2.), (1, 2.)], dtype=[('x', '<i8'), ('y', '<f8')])
-
-Here, each element consists of two fields: x (and int), and y (a float).
-This is known as a structured array.  The different fields are analogous
-to columns in a spread-sheet.  The different fields can be accessed as
-one would a dictionary::
-
-  >>> a['x']
-  array([1, 1])
-
-  >>> a['y']
-  array([2., 2.])
-
-Record arrays allow us to access fields as properties::
-
-  >>> ar = np.rec.array(a)
-
-  >>> ar.x
-  array([1, 1])
-
-  >>> ar.y
-  array([2., 2.])
-
-"} rec (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "rec"))))
-
-(def ^{:doc ""} euler_gamma (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "euler_gamma"))))
-
-(def cfloat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cfloat"))))
-(alter-meta! #'cfloat assoc :doc "Complex number type composed of two double-precision floating-point
-    numbers, compatible with Python `complex`.
-    Character code: ``'D'``.
-    Canonical name: ``np.cdouble``.
-    Alias: ``np.cfloat``.
-    Alias: ``np.complex_``.
-    Alias *on this platform*: ``np.complex128``: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def hstack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hstack"))))
-(alter-meta! #'hstack assoc :doc "
-    Stack arrays in sequence horizontally (column wise).
-
-    This is equivalent to concatenation along the second axis, except for 1-D
-    arrays where it concatenates along the first axis. Rebuilds arrays divided
-    by `hsplit`.
-
-    This function makes most sense for arrays with up to 3 dimensions. For
-    instance, for pixel-data with a height (first axis), width (second axis),
-    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
-    `block` provide more general stacking and concatenation operations.
-
-    Parameters
-    ----------
-    tup : sequence of ndarrays
-        The arrays must have the same shape along all but the second axis,
-        except 1-D arrays which can be any length.
-
-    Returns
-    -------
-    stacked : ndarray
-        The array formed by stacking the given arrays.
-
-    See Also
-    --------
-    stack : Join a sequence of arrays along a new axis.
-    vstack : Stack arrays in sequence vertically (row wise).
-    dstack : Stack arrays in sequence depth wise (along third axis).
-    concatenate : Join a sequence of arrays along an existing axis.
-    hsplit : Split array along second axis.
-    block : Assemble arrays from blocks.
-
-    Examples
-    --------
-    >>> a = np.array((1,2,3))
-    >>> b = np.array((2,3,4))
-    >>> np.hstack((a,b))
-    array([1, 2, 3, 2, 3, 4])
-    >>> a = np.array([[1],[2],[3]])
-    >>> b = np.array([[2],[3],[4]])
-    >>> np.hstack((a,b))
-    array([[1, 2],
-           [2, 3],
-           [3, 4]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "
-    Base object for a dictionary for look-up with any alias for an array dtype.
-
-    Instances of `_typedict` can not be used as dictionaries directly,
-    first they have to be populated.
-
-    "} nbytes (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "nbytes"))))
-
-(def nanmedian (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmedian"))))
-(alter-meta! #'nanmedian assoc :doc "
-    Compute the median along the specified axis, while ignoring NaNs.
-
-    Returns the median of the array elements.
-
-    .. versionadded:: 1.9.0
-
-    Parameters
-    ----------
-    a : array_like
-        Input array or object that can be converted to an array.
-    axis : {int, sequence of int, None}, optional
-        Axis or axes along which the medians are computed. The default
-        is to compute the median along a flattened version of the array.
-        A sequence of axes is supported since version 1.9.0.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must
-        have the same shape and buffer length as the expected output,
-        but the type (of the output) will be cast if necessary.
-    overwrite_input : bool, optional
-       If True, then allow use of memory of input array `a` for
-       calculations. The input array will be modified by the call to
-       `median`. This will save memory when you do not need to preserve
-       the contents of the input array. Treat the input as undefined,
-       but it will probably be fully or partially sorted. Default is
-       False. If `overwrite_input` is ``True`` and `a` is not already an
-       `ndarray`, an error will be raised.
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the original `a`.
-
-        If this is anything but the default value it will be passed
-        through (in the special case of an empty array) to the
-        `mean` function of the underlying array.  If the array is
-        a sub-class and `mean` does not have the kwarg `keepdims` this
-        will raise a RuntimeError.
-
-    Returns
-    -------
-    median : ndarray
-        A new array holding the result. If the input contains integers
-        or floats smaller than ``float64``, then the output data-type is
-        ``np.float64``.  Otherwise, the data-type of the output is the
-        same as that of the input. If `out` is specified, that array is
-        returned instead.
-
-    See Also
-    --------
-    mean, median, percentile
-
-    Notes
-    -----
-    Given a vector ``V`` of length ``N``, the median of ``V`` is the
-    middle value of a sorted copy of ``V``, ``V_sorted`` - i.e.,
-    ``V_sorted[(N-1)/2]``, when ``N`` is odd and the average of the two
-    middle values of ``V_sorted`` when ``N`` is even.
-
-    Examples
-    --------
-    >>> a = np.array([[10.0, 7, 4], [3, 2, 1]])
-    >>> a[0, 1] = np.nan
-    >>> a
-    array([[10., nan,  4.],
-           [ 3.,  2.,  1.]])
-    >>> np.median(a)
-    nan
-    >>> np.nanmedian(a)
-    3.0
-    >>> np.nanmedian(a, axis=0)
-    array([6.5, 2. , 2.5])
-    >>> np.median(a, axis=1)
-    array([nan,  2.])
-    >>> b = a.copy()
-    >>> np.nanmedian(b, axis=1, overwrite_input=True)
-    array([7.,  2.])
-    >>> assert not np.all(a==b)
-    >>> b = a.copy()
-    >>> np.nanmedian(b, axis=None, overwrite_input=True)
-    3.0
-    >>> assert not np.all(a==b)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def sign (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sign"))))
-(alter-meta! #'sign assoc :doc "sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Returns an element-wise indication of the sign of a number.
-
-The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``.  nan
-is returned for nan inputs.
-
-For complex inputs, the `sign` function returns
-``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``.
-
-complex(nan, 0) is returned for complex nan inputs.
-
-Parameters
-----------
-x : array_like
-    Input values.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The sign of `x`.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-There is more than one definition of sign in common use for complex
-numbers.  The definition used here is equivalent to :math:`x/\\sqrt{x*x}`
-which is different from a common alternative, :math:`x/|x|`.
-
-Examples
---------
->>> np.sign([-5., 4.5])
-array([-1.,  1.])
->>> np.sign(0)
-0
->>> np.sign(5-2j)
-(1+0j)" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc "
-Discrete Fourier Transform (:mod:`numpy.fft`)
-=============================================
-
-.. currentmodule:: numpy.fft
-
-Standard FFTs
--------------
-
-.. autosummary::
-   :toctree: generated/
-
-   fft       Discrete Fourier transform.
-   ifft      Inverse discrete Fourier transform.
-   fft2      Discrete Fourier transform in two dimensions.
-   ifft2     Inverse discrete Fourier transform in two dimensions.
-   fftn      Discrete Fourier transform in N-dimensions.
-   ifftn     Inverse discrete Fourier transform in N dimensions.
-
-Real FFTs
----------
-
-.. autosummary::
-   :toctree: generated/
-
-   rfft      Real discrete Fourier transform.
-   irfft     Inverse real discrete Fourier transform.
-   rfft2     Real discrete Fourier transform in two dimensions.
-   irfft2    Inverse real discrete Fourier transform in two dimensions.
-   rfftn     Real discrete Fourier transform in N dimensions.
-   irfftn    Inverse real discrete Fourier transform in N dimensions.
-
-Hermitian FFTs
---------------
-
-.. autosummary::
-   :toctree: generated/
-
-   hfft      Hermitian discrete Fourier transform.
-   ihfft     Inverse Hermitian discrete Fourier transform.
-
-Helper routines
----------------
-
-.. autosummary::
-   :toctree: generated/
-
-   fftfreq   Discrete Fourier Transform sample frequencies.
-   rfftfreq  DFT sample frequencies (for usage with rfft, irfft).
-   fftshift  Shift zero-frequency component to center of spectrum.
-   ifftshift Inverse of fftshift.
-
-
-Background information
-----------------------
-
-Fourier analysis is fundamentally a method for expressing a function as a
-sum of periodic components, and for recovering the function from those
-components.  When both the function and its Fourier transform are
-replaced with discretized counterparts, it is called the discrete Fourier
-transform (DFT).  The DFT has become a mainstay of numerical computing in
-part because of a very fast algorithm for computing it, called the Fast
-Fourier Transform (FFT), which was known to Gauss (1805) and was brought
-to light in its current form by Cooley and Tukey [CT]_.  Press et al. [NR]_
-provide an accessible introduction to Fourier analysis and its
-applications.
-
-Because the discrete Fourier transform separates its input into
-components that contribute at discrete frequencies, it has a great number
-of applications in digital signal processing, e.g., for filtering, and in
-this context the discretized input to the transform is customarily
-referred to as a *signal*, which exists in the *time domain*.  The output
-is called a *spectrum* or *transform* and exists in the *frequency
-domain*.
-
-Implementation details
-----------------------
-
-There are many ways to define the DFT, varying in the sign of the
-exponent, normalization, etc.  In this implementation, the DFT is defined
-as
-
-.. math::
-   A_k =  \\sum_{m=0}^{n-1} a_m \\exp\\left\\{-2\\pi i{mk \\over n}\\right\\}
-   \\qquad k = 0,\\ldots,n-1.
-
-The DFT is in general defined for complex inputs and outputs, and a
-single-frequency component at linear frequency :math:`f` is
-represented by a complex exponential
-:math:`a_m = \\exp\\{2\\pi i\\,f m\\Delta t\\}`, where :math:`\\Delta t`
-is the sampling interval.
-
-The values in the result follow so-called \"standard\" order: If ``A =
-fft(a, n)``, then ``A[0]`` contains the zero-frequency term (the sum of
-the signal), which is always purely real for real inputs. Then ``A[1:n/2]``
-contains the positive-frequency terms, and ``A[n/2+1:]`` contains the
-negative-frequency terms, in order of decreasingly negative frequency.
-For an even number of input points, ``A[n/2]`` represents both positive and
-negative Nyquist frequency, and is also purely real for real input.  For
-an odd number of input points, ``A[(n-1)/2]`` contains the largest positive
-frequency, while ``A[(n+1)/2]`` contains the largest negative frequency.
-The routine ``np.fft.fftfreq(n)`` returns an array giving the frequencies
-of corresponding elements in the output.  The routine
-``np.fft.fftshift(A)`` shifts transforms and their frequencies to put the
-zero-frequency components in the middle, and ``np.fft.ifftshift(A)`` undoes
-that shift.
-
-When the input `a` is a time-domain signal and ``A = fft(a)``, ``np.abs(A)``
-is its amplitude spectrum and ``np.abs(A)**2`` is its power spectrum.
-The phase spectrum is obtained by ``np.angle(A)``.
-
-The inverse DFT is defined as
-
-.. math::
-   a_m = \\frac{1}{n}\\sum_{k=0}^{n-1}A_k\\exp\\left\\{2\\pi i{mk\\over n}\\right\\}
-   \\qquad m = 0,\\ldots,n-1.
-
-It differs from the forward transform by the sign of the exponential
-argument and the default normalization by :math:`1/n`.
-
-Type Promotion
---------------
-
-`numpy.fft` promotes ``float32`` and ``complex64`` arrays to ``float64`` and
-``complex128`` arrays respectively. For an FFT implementation that does not
-promote input arrays, see `scipy.fftpack`.
-
-Normalization
--------------
-
-The default normalization has the direct transforms unscaled and the inverse
-transforms are scaled by :math:`1/n`. It is possible to obtain unitary
-transforms by setting the keyword argument ``norm`` to ``\"ortho\"`` (default is
-`None`) so that both direct and inverse transforms will be scaled by
-:math:`1/\\sqrt{n}`.
-
-Real and Hermitian transforms
------------------------------
-
-When the input is purely real, its transform is Hermitian, i.e., the
-component at frequency :math:`f_k` is the complex conjugate of the
-component at frequency :math:`-f_k`, which means that for real
-inputs there is no information in the negative frequency components that
-is not already available from the positive frequency components.
-The family of `rfft` functions is
-designed to operate on real inputs, and exploits this symmetry by
-computing only the positive frequency components, up to and including the
-Nyquist frequency.  Thus, ``n`` input points produce ``n/2+1`` complex
-output points.  The inverses of this family assumes the same symmetry of
-its input, and for an output of ``n`` points uses ``n/2+1`` input points.
-
-Correspondingly, when the spectrum is purely real, the signal is
-Hermitian.  The `hfft` family of functions exploits this symmetry by
-using ``n/2+1`` complex points in the input (time) domain for ``n`` real
-points in the frequency domain.
-
-In higher dimensions, FFTs are used, e.g., for image analysis and
-filtering.  The computational efficiency of the FFT means that it can
-also be a faster way to compute large convolutions, using the property
-that a convolution in the time domain is equivalent to a point-by-point
-multiplication in the frequency domain.
-
-Higher dimensions
------------------
-
-In two dimensions, the DFT is defined as
-
-.. math::
-   A_{kl} =  \\sum_{m=0}^{M-1} \\sum_{n=0}^{N-1}
-   a_{mn}\\exp\\left\\{-2\\pi i \\left({mk\\over M}+{nl\\over N}\\right)\\right\\}
-   \\qquad k = 0, \\ldots, M-1;\\quad l = 0, \\ldots, N-1,
-
-which extends in the obvious way to higher dimensions, and the inverses
-in higher dimensions also extend in the same way.
-
-References
-----------
-
-.. [CT] Cooley, James W., and John W. Tukey, 1965, \"An algorithm for the
-        machine calculation of complex Fourier series,\" *Math. Comput.*
-        19: 297-301.
-
-.. [NR] Press, W., Teukolsky, S., Vetterline, W.T., and Flannery, B.P.,
-        2007, *Numerical Recipes: The Art of Scientific Computing*, ch.
-        12-13.  Cambridge Univ. Press, Cambridge, UK.
-
-Examples
---------
-
-For examples, see the various functions.
-
-"} fft (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "fft"))))
-
-(def finfo (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "finfo"))))
-(alter-meta! #'finfo assoc :doc "
-    finfo(dtype)
-
-    Machine limits for floating point types.
-
-    Attributes
-    ----------
-    bits : int
-        The number of bits occupied by the type.
-    eps : float
-        The smallest representable positive number such that
-        ``1.0 + eps != 1.0``.  Type of `eps` is an appropriate floating
-        point type.
-    epsneg : floating point number of the appropriate type
-        The smallest representable positive number such that
-        ``1.0 - epsneg != 1.0``.
-    iexp : int
-        The number of bits in the exponent portion of the floating point
-        representation.
-    machar : MachAr
-        The object which calculated these parameters and holds more
-        detailed information.
-    machep : int
-        The exponent that yields `eps`.
-    max : floating point number of the appropriate type
-        The largest representable number.
-    maxexp : int
-        The smallest positive power of the base (2) that causes overflow.
-    min : floating point number of the appropriate type
-        The smallest representable number, typically ``-max``.
-    minexp : int
-        The most negative power of the base (2) consistent with there
-        being no leading 0's in the mantissa.
-    negep : int
-        The exponent that yields `epsneg`.
-    nexp : int
-        The number of bits in the exponent including its sign and bias.
-    nmant : int
-        The number of bits in the mantissa.
-    precision : int
-        The approximate number of decimal digits to which this kind of
-        float is precise.
-    resolution : floating point number of the appropriate type
-        The approximate decimal resolution of this type, i.e.,
-        ``10**-precision``.
-    tiny : float
-        The smallest positive usable number.  Type of `tiny` is an
-        appropriate floating point type.
-
-    Parameters
-    ----------
-    dtype : float, dtype, or instance
-        Kind of floating point data-type about which to get information.
-
-    See Also
-    --------
-    MachAr : The implementation of the tests that produce this information.
-    iinfo : The equivalent for integer data types.
-
-    Notes
-    -----
-    For developers of NumPy: do not instantiate this at the module level.
-    The initial calculation of these parameters is expensive and negatively
-    impacts import times.  These objects are cached, so calling ``finfo()``
-    repeatedly inside your functions is not a problem.
-
-    " :arglists '[[self & [args {:as kwargs}]]])
-
-(def issubdtype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issubdtype"))))
-(alter-meta! #'issubdtype assoc :doc "
-    Returns True if first argument is a typecode lower/equal in type hierarchy.
-
-    Parameters
-    ----------
-    arg1, arg2 : dtype_like
-        dtype or string representing a typecode.
-
-    Returns
-    -------
-    out : bool
-
-    See Also
-    --------
-    issubsctype, issubclass_
-    numpy.core.numerictypes : Overview of numpy type hierarchy.
-
-    Examples
-    --------
-    >>> np.issubdtype('S1', np.string_)
-    True
-    >>> np.issubdtype(np.float64, np.float32)
-    False
-
-    " :arglists '[[arg1 arg2]])
-
-(def array (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array"))))
-(alter-meta! #'array assoc :doc "array(object, dtype=None, copy=True, order='K', subok=False, ndmin=0)
-
-    Create an array.
-
-    Parameters
-    ----------
-    object : array_like
-        An array, any object exposing the array interface, an object whose
-        __array__ method returns an array, or any (nested) sequence.
-    dtype : data-type, optional
-        The desired data-type for the array.  If not given, then the type will
-        be determined as the minimum type required to hold the objects in the
-        sequence.
-    copy : bool, optional
-        If true (default), then the object is copied.  Otherwise, a copy will
-        only be made if __array__ returns a copy, if obj is a nested sequence,
-        or if a copy is needed to satisfy any of the other requirements
-        (`dtype`, `order`, etc.).
-    order : {'K', 'A', 'C', 'F'}, optional
-        Specify the memory layout of the array. If object is not an array, the
-        newly created array will be in C order (row major) unless 'F' is
-        specified, in which case it will be in Fortran order (column major).
-        If object is an array the following holds.
-
-        ===== ========= ===================================================
-        order  no copy                     copy=True
-        ===== ========= ===================================================
-        'K'   unchanged F & C order preserved, otherwise most similar order
-        'A'   unchanged F order if input is F and not C, otherwise C order
-        'C'   C order   C order
-        'F'   F order   F order
-        ===== ========= ===================================================
-
-        When ``copy=False`` and a copy is made for other reasons, the result is
-        the same as if ``copy=True``, with some exceptions for `A`, see the
-        Notes section. The default order is 'K'.
-    subok : bool, optional
-        If True, then sub-classes will be passed-through, otherwise
-        the returned array will be forced to be a base-class array (default).
-    ndmin : int, optional
-        Specifies the minimum number of dimensions that the resulting
-        array should have.  Ones will be pre-pended to the shape as
-        needed to meet this requirement.
-
-    Returns
-    -------
-    out : ndarray
-        An array object satisfying the specified requirements.
-
-    See Also
-    --------
-    empty_like : Return an empty array with shape and type of input.
-    ones_like : Return an array of ones with shape and type of input.
-    zeros_like : Return an array of zeros with shape and type of input.
-    full_like : Return a new array with shape of input filled with value.
-    empty : Return a new uninitialized array.
-    ones : Return a new array setting values to one.
-    zeros : Return a new array setting values to zero.
-    full : Return a new array of given shape filled with value.
-
-
-    Notes
-    -----
-    When order is 'A' and `object` is an array in neither 'C' nor 'F' order,
-    and a copy is forced by a change in dtype, then the order of the result is
-    not necessarily 'C' as expected. This is likely a bug.
-
-    Examples
-    --------
-    >>> np.array([1, 2, 3])
-    array([1, 2, 3])
-
-    Upcasting:
-
-    >>> np.array([1, 2, 3.0])
-    array([ 1.,  2.,  3.])
-
-    More than one dimension:
-
-    >>> np.array([[1, 2], [3, 4]])
-    array([[1, 2],
-           [3, 4]])
-
-    Minimum dimensions 2:
-
-    >>> np.array([1, 2, 3], ndmin=2)
-    array([[1, 2, 3]])
-
-    Type provided:
-
-    >>> np.array([1, 2, 3], dtype=complex)
-    array([ 1.+0.j,  2.+0.j,  3.+0.j])
-
-    Data-type consisting of more than one element:
-
-    >>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
-    >>> x['a']
-    array([1, 3])
-
-    Creating an array from sub-classes:
-
-    >>> np.array(np.mat('1 2; 3 4'))
-    array([[1, 2],
-           [3, 4]])
-
-    >>> np.array(np.mat('1 2; 3 4'), subok=True)
-    matrix([[1, 2],
-            [3, 4]])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def logaddexp2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logaddexp2"))))
-(alter-meta! #'logaddexp2 assoc :doc "logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Logarithm of the sum of exponentiations of the inputs in base-2.
-
-Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine
-learning when the calculated probabilities of events may be so small as
-to exceed the range of normal floating point numbers.  In such cases
-the base-2 logarithm of the calculated probability can be used instead.
-This function allows adding probabilities stored in such a fashion.
-
-Parameters
-----------
-x1, x2 : array_like
-    Input values. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-result : ndarray
-    Base-2 logarithm of ``2**x1 + 2**x2``.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-logaddexp: Logarithm of the sum of exponentiations of the inputs.
-
-Notes
------
-.. versionadded:: 1.3.0
-
-Examples
---------
->>> prob1 = np.log2(1e-50)
->>> prob2 = np.log2(2.5e-50)
->>> prob12 = np.logaddexp2(prob1, prob2)
->>> prob1, prob2, prob12
-(-166.09640474436813, -164.77447664948076, -164.28904982231052)
->>> 2**prob12
-3.4999999999999914e-50" :arglists '[[self & [args {:as kwargs}]]])
-
-(def transpose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "transpose"))))
-(alter-meta! #'transpose assoc :doc "
-    Permute the dimensions of an array.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    axes : list of ints, optional
-        By default, reverse the dimensions, otherwise permute the axes
-        according to the values given.
-
-    Returns
-    -------
-    p : ndarray
-        `a` with its axes permuted.  A view is returned whenever
-        possible.
-
-    See Also
-    --------
-    moveaxis
-    argsort
-
-    Notes
-    -----
-    Use `transpose(a, argsort(axes))` to invert the transposition of tensors
-    when using the `axes` keyword argument.
-
-    Transposing a 1-D array returns an unchanged view of the original array.
-
-    Examples
-    --------
-    >>> x = np.arange(4).reshape((2,2))
-    >>> x
-    array([[0, 1],
-           [2, 3]])
-
-    >>> np.transpose(x)
-    array([[0, 2],
-           [1, 3]])
-
-    >>> x = np.ones((1, 2, 3))
-    >>> np.transpose(x, (1, 0, 2)).shape
-    (2, 1, 3)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def tril_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tril_indices"))))
-(alter-meta! #'tril_indices assoc :doc "
-    Return the indices for the lower-triangle of an (n, m) array.
-
-    Parameters
-    ----------
-    n : int
-        The row dimension of the arrays for which the returned
-        indices will be valid.
-    k : int, optional
-        Diagonal offset (see `tril` for details).
-    m : int, optional
-        .. versionadded:: 1.9.0
-
-        The column dimension of the arrays for which the returned
-        arrays will be valid.
-        By default `m` is taken equal to `n`.
-
-
-    Returns
-    -------
-    inds : tuple of arrays
-        The indices for the triangle. The returned tuple contains two arrays,
-        each with the indices along one dimension of the array.
-
-    See also
-    --------
-    triu_indices : similar function, for upper-triangular.
-    mask_indices : generic function accepting an arbitrary mask function.
-    tril, triu
-
-    Notes
-    -----
-    .. versionadded:: 1.4.0
-
-    Examples
-    --------
-    Compute two different sets of indices to access 4x4 arrays, one for the
-    lower triangular part starting at the main diagonal, and one starting two
-    diagonals further right:
-
-    >>> il1 = np.tril_indices(4)
-    >>> il2 = np.tril_indices(4, 2)
-
-    Here is how they can be used with a sample array:
-
-    >>> a = np.arange(16).reshape(4, 4)
-    >>> a
-    array([[ 0,  1,  2,  3],
-           [ 4,  5,  6,  7],
-           [ 8,  9, 10, 11],
-           [12, 13, 14, 15]])
-
-    Both for indexing:
-
-    >>> a[il1]
-    array([ 0,  4,  5, ..., 13, 14, 15])
-
-    And for assigning values:
-
-    >>> a[il1] = -1
-    >>> a
-    array([[-1,  1,  2,  3],
-           [-1, -1,  6,  7],
-           [-1, -1, -1, 11],
-           [-1, -1, -1, -1]])
-
-    These cover almost the whole array (two diagonals right of the main one):
-
-    >>> a[il2] = -10
-    >>> a
-    array([[-10, -10, -10,   3],
-           [-10, -10, -10, -10],
-           [-10, -10, -10, -10],
-           [-10, -10, -10, -10]])
-
-    " :arglists '[[n & [{k :k, m :m}]] [n & [{k :k}]] [n]])
-
-(def asarray_chkfinite (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asarray_chkfinite"))))
-(alter-meta! #'asarray_chkfinite assoc :doc "Convert the input to an array, checking for NaNs or Infs.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data, in any form that can be converted to an array.  This
-        includes lists, lists of tuples, tuples, tuples of tuples, tuples
-        of lists and ndarrays.  Success requires no NaNs or Infs.
-    dtype : data-type, optional
-        By default, the data-type is inferred from the input data.
-    order : {'C', 'F'}, optional
-         Whether to use row-major (C-style) or
-         column-major (Fortran-style) memory representation.
-         Defaults to 'C'.
-
-    Returns
-    -------
-    out : ndarray
-        Array interpretation of `a`.  No copy is performed if the input
-        is already an ndarray.  If `a` is a subclass of ndarray, a base
-        class ndarray is returned.
-
-    Raises
-    ------
-    ValueError
-        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
-
-    See Also
-    --------
-    asarray : Create and array.
-    asanyarray : Similar function which passes through subclasses.
-    ascontiguousarray : Convert input to a contiguous array.
-    asfarray : Convert input to a floating point ndarray.
-    asfortranarray : Convert input to an ndarray with column-major
-                     memory order.
-    fromiter : Create an array from an iterator.
-    fromfunction : Construct an array by executing a function on grid
-                   positions.
-
-    Examples
-    --------
-    Convert a list into an array.  If all elements are finite
-    ``asarray_chkfinite`` is identical to ``asarray``.
-
-    >>> a = [1, 2]
-    >>> np.asarray_chkfinite(a, dtype=float)
-    array([1., 2.])
-
-    Raises ValueError if array_like contains Nans or Infs.
-
-    >>> a = [1, 2, np.inf]
-    >>> try:
-    ...     np.asarray_chkfinite(a)
-    ... except ValueError:
-    ...     print('ValueError')
-    ...
-    ValueError
-
-    " :arglists '[[a & [{dtype :dtype, order :order}]] [a & [{dtype :dtype}]] [a]])
-
-(def arccos (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arccos"))))
-(alter-meta! #'arccos assoc :doc "arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Trigonometric inverse cosine, element-wise.
-
-The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``.
-
-Parameters
-----------
-x : array_like
-    `x`-coordinate on the unit circle.
-    For real arguments, the domain is [-1, 1].
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-angle : ndarray
-    The angle of the ray intersecting the unit circle at the given
-    `x`-coordinate in radians [0, pi].
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-cos, arctan, arcsin, emath.arccos
-
-Notes
------
-`arccos` is a multivalued function: for each `x` there are infinitely
-many numbers `z` such that `cos(z) = x`. The convention is to return
-the angle `z` whose real part lies in `[0, pi]`.
-
-For real-valued input data types, `arccos` always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields ``nan`` and sets the `invalid` floating point error flag.
-
-For complex-valued input, `arccos` is a complex analytic function that
-has branch cuts `[-inf, -1]` and `[1, inf]` and is continuous from
-above on the former and from below on the latter.
-
-The inverse `cos` is also known as `acos` or cos^-1.
-
-References
-----------
-M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
-10th printing, 1964, pp. 79. http://www.math.sfu.ca/~cbm/aands/
-
-Examples
---------
-We expect the arccos of 1 to be 0, and of -1 to be pi:
-
->>> np.arccos([1, -1])
-array([ 0.        ,  3.14159265])
-
-Plot arccos:
-
->>> import matplotlib.pyplot as plt
->>> x = np.linspace(-1, 1, num=100)
->>> plt.plot(x, np.arccos(x))
->>> plt.axis('tight')
->>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc "
-    A nicer way to build up index tuples for arrays.
-
-    .. note::
-       Use one of the two predefined instances `index_exp` or `s_`
-       rather than directly using `IndexExpression`.
-
-    For any index combination, including slicing and axis insertion,
-    ``a[indices]`` is the same as ``a[np.index_exp[indices]]`` for any
-    array `a`. However, ``np.index_exp[indices]`` can be used anywhere
-    in Python code and returns a tuple of slice objects that can be
-    used in the construction of complex index expressions.
-
-    Parameters
-    ----------
-    maketuple : bool
-        If True, always returns a tuple.
-
-    See Also
-    --------
-    index_exp : Predefined instance that always returns a tuple:
-       `index_exp = IndexExpression(maketuple=True)`.
-    s_ : Predefined instance without tuple conversion:
-       `s_ = IndexExpression(maketuple=False)`.
-
-    Notes
-    -----
-    You can do all this with `slice()` plus a few special objects,
-    but there's a lot to remember and this version is simpler because
-    it uses the standard array indexing syntax.
-
-    Examples
-    --------
-    >>> np.s_[2::2]
-    slice(2, None, 2)
-    >>> np.index_exp[2::2]
-    (slice(2, None, 2),)
-
-    >>> np.array([0, 1, 2, 3, 4])[np.s_[2::2]]
-    array([2, 4])
-
-    "} s_ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "s_"))))
-
-(def ^{:doc "
-Contains the core of NumPy: ndarray, ufuncs, dtypes, etc.
-
-Please note that this module is private.  All functions and objects
-are available in the main ``numpy`` namespace - use that instead.
-
-"} core (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "core"))))
-
-(def complex64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex64"))))
-(alter-meta! #'complex64 assoc :doc "Complex number type composed of two single-precision floating-point
-    numbers.
-    Character code: ``'F'``.
-    Canonical name: ``np.csingle``.
-    Alias: ``np.singlecomplex``.
-    Alias *on this platform*: ``np.complex64``: Complex number type composed of 2 32-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def arccosh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arccosh"))))
-(alter-meta! #'arccosh assoc :doc "arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Inverse hyperbolic cosine, element-wise.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-arccosh : ndarray
-    Array of the same shape as `x`.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-
-cosh, arcsinh, sinh, arctanh, tanh
-
-Notes
------
-`arccosh` is a multivalued function: for each `x` there are infinitely
-many numbers `z` such that `cosh(z) = x`. The convention is to return the
-`z` whose imaginary part lies in `[-pi, pi]` and the real part in
-``[0, inf]``.
-
-For real-valued input data types, `arccosh` always returns real output.
-For each value that cannot be expressed as a real number or infinity, it
-yields ``nan`` and sets the `invalid` floating point error flag.
-
-For complex-valued input, `arccosh` is a complex analytical function that
-has a branch cut `[-inf, 1]` and is continuous from above on it.
-
-References
-----------
-.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
-       10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/
-.. [2] Wikipedia, \"Inverse hyperbolic function\",
-       https://en.wikipedia.org/wiki/Arccosh
-
-Examples
---------
->>> np.arccosh([np.e, 10.0])
-array([ 1.65745445,  2.99322285])
->>> np.arccosh(1)
-0.0" :arglists '[[self & [args {:as kwargs}]]])
-
-(def apply_over_axes (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "apply_over_axes"))))
-(alter-meta! #'apply_over_axes assoc :doc "
-    Apply a function repeatedly over multiple axes.
-
-    `func` is called as `res = func(a, axis)`, where `axis` is the first
-    element of `axes`.  The result `res` of the function call must have
-    either the same dimensions as `a` or one less dimension.  If `res`
-    has one less dimension than `a`, a dimension is inserted before
-    `axis`.  The call to `func` is then repeated for each axis in `axes`,
-    with `res` as the first argument.
-
-    Parameters
-    ----------
-    func : function
-        This function must take two arguments, `func(a, axis)`.
-    a : array_like
-        Input array.
-    axes : array_like
-        Axes over which `func` is applied; the elements must be integers.
-
-    Returns
-    -------
-    apply_over_axis : ndarray
-        The output array.  The number of dimensions is the same as `a`,
-        but the shape can be different.  This depends on whether `func`
-        changes the shape of its output with respect to its input.
-
-    See Also
-    --------
-    apply_along_axis :
-        Apply a function to 1-D slices of an array along the given axis.
-
-    Notes
-    ------
-    This function is equivalent to tuple axis arguments to reorderable ufuncs
-    with keepdims=True. Tuple axis arguments to ufuncs have been available since
-    version 1.7.0.
-
-    Examples
-    --------
-    >>> a = np.arange(24).reshape(2,3,4)
-    >>> a
-    array([[[ 0,  1,  2,  3],
-            [ 4,  5,  6,  7],
-            [ 8,  9, 10, 11]],
-           [[12, 13, 14, 15],
-            [16, 17, 18, 19],
-            [20, 21, 22, 23]]])
-
-    Sum over axes 0 and 2. The result has same number of dimensions
-    as the original array:
-
-    >>> np.apply_over_axes(np.sum, a, [0,2])
-    array([[[ 60],
-            [ 92],
-            [124]]])
-
-    Tuple axis arguments to ufuncs are equivalent:
-
-    >>> np.sum(a, axis=(0,2), keepdims=True)
-    array([[[ 60],
-            [ 92],
-            [124]]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def tanh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tanh"))))
-(alter-meta! #'tanh assoc :doc "tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute hyperbolic tangent element-wise.
-
-Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The corresponding hyperbolic tangent values.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-If `out` is provided, the function writes the result into it,
-and returns a reference to `out`.  (See Examples)
-
-References
-----------
-.. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
-       New York, NY: Dover, 1972, pg. 83.
-       http://www.math.sfu.ca/~cbm/aands/
-
-.. [2] Wikipedia, \"Hyperbolic function\",
-       https://en.wikipedia.org/wiki/Hyperbolic_function
-
-Examples
---------
->>> np.tanh((0, np.pi*1j, np.pi*1j/2))
-array([ 0. +0.00000000e+00j,  0. -1.22460635e-16j,  0. +1.63317787e+16j])
-
->>> # Example of providing the optional output parameter illustrating
->>> # that what is returned is a reference to said parameter
->>> out1 = np.array([0], dtype='d')
->>> out2 = np.tanh([0.1], out1)
->>> out2 is out1
-True
-
->>> # Example of ValueError due to provision of shape mis-matched `out`
->>> np.tanh(np.zeros((3,3)),np.zeros((2,2)))
-Traceback (most recent call last):
-  File \"<stdin>\", line 1, in <module>
-ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]])
-
-(def frompyfunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "frompyfunc"))))
-(alter-meta! #'frompyfunc assoc :doc "frompyfunc(func, nin, nout)
-
-    Takes an arbitrary Python function and returns a NumPy ufunc.
-
-    Can be used, for example, to add broadcasting to a built-in Python
-    function (see Examples section).
-
-    Parameters
-    ----------
-    func : Python function object
-        An arbitrary Python function.
-    nin : int
-        The number of input arguments.
-    nout : int
-        The number of objects returned by `func`.
-
-    Returns
-    -------
-    out : ufunc
-        Returns a NumPy universal function (``ufunc``) object.
-
-    See Also
-    --------
-    vectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy.
-
-    Notes
-    -----
-    The returned ufunc always returns PyObject arrays.
-
-    Examples
-    --------
-    Use frompyfunc to add broadcasting to the Python function ``oct``:
-
-    >>> oct_array = np.frompyfunc(oct, 1, 1)
-    >>> oct_array(np.array((10, 30, 100)))
-    array(['0o12', '0o36', '0o144'], dtype=object)
-    >>> np.array((oct(10), oct(30), oct(100))) # for comparison
-    array(['0o12', '0o36', '0o144'], dtype='<U5')" :arglists '[[self & [args {:as kwargs}]]])
-
-(def complex256 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex256"))))
-(alter-meta! #'complex256 assoc :doc "Complex number type composed of two extended-precision floating-point
-    numbers.
-    Character code: ``'G'``.
-    Canonical name: ``np.clongdouble``.
-    Alias: ``np.clongfloat``.
-    Alias: ``np.longcomplex``.
-    Alias *on this platform*: ``np.complex256``: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} MAXDIMS (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "MAXDIMS"))))
-
-(def expand_dims (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "expand_dims"))))
-(alter-meta! #'expand_dims assoc :doc "
-    Expand the shape of an array.
-
-    Insert a new axis that will appear at the `axis` position in the expanded
-    array shape.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    axis : int or tuple of ints
-        Position in the expanded axes where the new axis (or axes) is placed.
-
-        .. deprecated:: 1.13.0
-            Passing an axis where ``axis > a.ndim`` will be treated as
-            ``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will
-            be treated as ``axis == 0``. This behavior is deprecated.
-
-        .. versionchanged:: 1.18.0
-            A tuple of axes is now supported.  Out of range axes as
-            described above are now forbidden and raise an `AxisError`.
-
-    Returns
-    -------
-    result : ndarray
-        View of `a` with the number of dimensions increased.
-
-    See Also
-    --------
-    squeeze : The inverse operation, removing singleton dimensions
-    reshape : Insert, remove, and combine dimensions, and resize existing ones
-    doc.indexing, atleast_1d, atleast_2d, atleast_3d
-
-    Examples
-    --------
-    >>> x = np.array([1, 2])
-    >>> x.shape
-    (2,)
-
-    The following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``:
-
-    >>> y = np.expand_dims(x, axis=0)
-    >>> y
-    array([[1, 2]])
-    >>> y.shape
-    (1, 2)
-
-    The following is equivalent to ``x[:, np.newaxis]``:
-
-    >>> y = np.expand_dims(x, axis=1)
-    >>> y
-    array([[1],
-           [2]])
-    >>> y.shape
-    (2, 1)
-
-    ``axis`` may also be a tuple:
-
-    >>> y = np.expand_dims(x, axis=(0, 1))
-    >>> y
-    array([[[1, 2]]])
-
-    >>> y = np.expand_dims(x, axis=(2, 0))
-    >>> y
-    array([[[1],
-            [2]]])
-
-    Note that some examples may use ``None`` instead of ``np.newaxis``.  These
-    are the same objects:
-
-    >>> np.newaxis is None
-    True
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def fliplr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fliplr"))))
-(alter-meta! #'fliplr assoc :doc "
-    Flip array in the left/right direction.
-
-    Flip the entries in each row in the left/right direction.
-    Columns are preserved, but appear in a different order than before.
-
-    Parameters
-    ----------
-    m : array_like
-        Input array, must be at least 2-D.
-
-    Returns
-    -------
-    f : ndarray
-        A view of `m` with the columns reversed.  Since a view
-        is returned, this operation is :math:`\\mathcal O(1)`.
-
-    See Also
-    --------
-    flipud : Flip array in the up/down direction.
-    rot90 : Rotate array counterclockwise.
-
-    Notes
-    -----
-    Equivalent to m[:,::-1]. Requires the array to be at least 2-D.
-
-    Examples
-    --------
-    >>> A = np.diag([1.,2.,3.])
-    >>> A
-    array([[1.,  0.,  0.],
-           [0.,  2.,  0.],
-           [0.,  0.,  3.]])
-    >>> np.fliplr(A)
-    array([[0.,  0.,  1.],
-           [0.,  2.,  0.],
-           [3.,  0.,  0.]])
-
-    >>> A = np.random.randn(2,3,5)
-    >>> np.all(np.fliplr(A) == A[:,::-1,...])
-    True
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def tri (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tri"))))
-(alter-meta! #'tri assoc :doc "
-    An array with ones at and below the given diagonal and zeros elsewhere.
-
-    Parameters
-    ----------
-    N : int
-        Number of rows in the array.
-    M : int, optional
-        Number of columns in the array.
-        By default, `M` is taken equal to `N`.
-    k : int, optional
-        The sub-diagonal at and below which the array is filled.
-        `k` = 0 is the main diagonal, while `k` < 0 is below it,
-        and `k` > 0 is above.  The default is 0.
-    dtype : dtype, optional
-        Data type of the returned array.  The default is float.
-
-    Returns
-    -------
-    tri : ndarray of shape (N, M)
-        Array with its lower triangle filled with ones and zero elsewhere;
-        in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise.
-
-    Examples
-    --------
-    >>> np.tri(3, 5, 2, dtype=int)
-    array([[1, 1, 1, 0, 0],
-           [1, 1, 1, 1, 0],
-           [1, 1, 1, 1, 1]])
-
-    >>> np.tri(3, 5, -1)
-    array([[0.,  0.,  0.,  0.,  0.],
-           [1.,  0.,  0.,  0.,  0.],
-           [1.,  1.,  0.,  0.,  0.]])
-
-    " :arglists '[[N & [{M :M, k :k, dtype :dtype}]] [N & [{M :M, k :k}]] [N & [{M :M}]] [N]])
-
-(def absolute (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "absolute"))))
-(alter-meta! #'absolute assoc :doc "absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Calculate the absolute value element-wise.
-
-``np.abs`` is a shorthand for this function.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-absolute : ndarray
-    An ndarray containing the absolute value of
-    each element in `x`.  For complex input, ``a + ib``, the
-    absolute value is :math:`\\sqrt{ a^2 + b^2 }`.
-    This is a scalar if `x` is a scalar.
-
-Examples
---------
->>> x = np.array([-1.2, 1.2])
->>> np.absolute(x)
-array([ 1.2,  1.2])
->>> np.absolute(1.2 + 1j)
-1.5620499351813308
-
-Plot the function over ``[-10, 10]``:
-
->>> import matplotlib.pyplot as plt
-
->>> x = np.linspace(start=-10, stop=10, num=101)
->>> plt.plot(x, np.absolute(x))
->>> plt.show()
-
-Plot the function over the complex plane:
-
->>> xx = x + 1j * x[:, np.newaxis]
->>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')
->>> plt.show()" :arglists '[[self & [args {:as kwargs}]]])
-
-(def pv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "pv"))))
-(alter-meta! #'pv assoc :doc "
-    Compute the present value.
-
-    .. deprecated:: 1.18
-
-       `pv` is deprecated; for details, see NEP 32 [1]_.
-       Use the corresponding function in the numpy-financial library,
-       https://pypi.org/project/numpy-financial.
-
-    Given:
-     * a future value, `fv`
-     * an interest `rate` compounded once per period, of which
-       there are
-     * `nper` total
-     * a (fixed) payment, `pmt`, paid either
-     * at the beginning (`when` = {'begin', 1}) or the end
-       (`when` = {'end', 0}) of each period
-
-    Return:
-       the value now
-
-    Parameters
-    ----------
-    rate : array_like
-        Rate of interest (per period)
-    nper : array_like
-        Number of compounding periods
-    pmt : array_like
-        Payment
-    fv : array_like, optional
-        Future value
-    when : {{'begin', 1}, {'end', 0}}, {string, int}, optional
-        When payments are due ('begin' (1) or 'end' (0))
-
-    Returns
-    -------
-    out : ndarray, float
-        Present value of a series of payments or investments.
-
-    Notes
-    -----
-    The present value is computed by solving the equation::
-
-     fv +
-     pv*(1 + rate)**nper +
-     pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) = 0
-
-    or, when ``rate = 0``::
-
-     fv + pv + pmt * nper = 0
-
-    for `pv`, which is then returned.
-
-    References
-    ----------
-    .. [1] NumPy Enhancement Proposal (NEP) 32,
-       https://numpy.org/neps/nep-0032-remove-financial-functions.html
-    .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).
-       Open Document Format for Office Applications (OpenDocument)v1.2,
-       Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,
-       Pre-Draft 12. Organization for the Advancement of Structured Information
-       Standards (OASIS). Billerica, MA, USA. [ODT Document].
-       Available:
-       http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula
-       OpenDocument-formula-20090508.odt
-
-    Examples
-    --------
-    What is the present value (e.g., the initial investment)
-    of an investment that needs to total $15692.93
-    after 10 years of saving $100 every month?  Assume the
-    interest rate is 5% (annually) compounded monthly.
-
-    >>> np.pv(0.05/12, 10*12, -100, 15692.93)
-    -100.00067131625819
-
-    By convention, the negative sign represents cash flow out
-    (i.e., money not available today).  Thus, to end up with
-    $15,692.93 in 10 years saving $100 a month at 5% annual
-    interest, one's initial deposit should also be $100.
-
-    If any input is array_like, ``pv`` returns an array of equal shape.
-    Let's compare different interest rates in the example above:
-
-    >>> a = np.array((0.05, 0.04, 0.03))/12
-    >>> np.pv(a, 10*12, -100, 15692.93)
-    array([ -100.00067132,  -649.26771385, -1273.78633713]) # may vary
-
-    So, to end up with the same $15692.93 under the same $100 per month
-    \"savings plan,\" for annual interest rates of 4% and 3%, one would
-    need initial investments of $649.27 and $1273.79, respectively.
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def hsplit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hsplit"))))
-(alter-meta! #'hsplit assoc :doc "
-    Split an array into multiple sub-arrays horizontally (column-wise).
-
-    Please refer to the `split` documentation.  `hsplit` is equivalent
-    to `split` with ``axis=1``, the array is always split along the second
-    axis regardless of the array dimension.
-
-    See Also
-    --------
-    split : Split an array into multiple sub-arrays of equal size.
-
-    Examples
-    --------
-    >>> x = np.arange(16.0).reshape(4, 4)
-    >>> x
-    array([[ 0.,   1.,   2.,   3.],
-           [ 4.,   5.,   6.,   7.],
-           [ 8.,   9.,  10.,  11.],
-           [12.,  13.,  14.,  15.]])
-    >>> np.hsplit(x, 2)
-    [array([[  0.,   1.],
-           [  4.,   5.],
-           [  8.,   9.],
-           [12.,  13.]]),
-     array([[  2.,   3.],
-           [  6.,   7.],
-           [10.,  11.],
-           [14.,  15.]])]
-    >>> np.hsplit(x, np.array([3, 6]))
-    [array([[ 0.,   1.,   2.],
-           [ 4.,   5.,   6.],
-           [ 8.,   9.,  10.],
-           [12.,  13.,  14.]]),
-     array([[ 3.],
-           [ 7.],
-           [11.],
-           [15.]]),
-     array([], shape=(4, 0), dtype=float64)]
-
-    With a higher dimensional array the split is still along the second axis.
-
-    >>> x = np.arange(8.0).reshape(2, 2, 2)
-    >>> x
-    array([[[0.,  1.],
-            [2.,  3.]],
-           [[4.,  5.],
-            [6.,  7.]]])
-    >>> np.hsplit(x, 2)
-    [array([[[0.,  1.]],
-           [[4.,  5.]]]),
-     array([[[2.,  3.]],
-           [[6.,  7.]]])]
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def pmt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "pmt"))))
-(alter-meta! #'pmt assoc :doc "
-    Compute the payment against loan principal plus interest.
-
-    .. deprecated:: 1.18
-
-       `pmt` is deprecated; for details, see NEP 32 [1]_.
-       Use the corresponding function in the numpy-financial library,
-       https://pypi.org/project/numpy-financial.
-
-    Given:
-     * a present value, `pv` (e.g., an amount borrowed)
-     * a future value, `fv` (e.g., 0)
-     * an interest `rate` compounded once per period, of which
-       there are
-     * `nper` total
-     * and (optional) specification of whether payment is made
-       at the beginning (`when` = {'begin', 1}) or the end
-       (`when` = {'end', 0}) of each period
-
-    Return:
-       the (fixed) periodic payment.
-
-    Parameters
-    ----------
-    rate : array_like
-        Rate of interest (per period)
-    nper : array_like
-        Number of compounding periods
-    pv : array_like
-        Present value
-    fv : array_like,  optional
-        Future value (default = 0)
-    when : {{'begin', 1}, {'end', 0}}, {string, int}
-        When payments are due ('begin' (1) or 'end' (0))
-
-    Returns
-    -------
-    out : ndarray
-        Payment against loan plus interest.  If all input is scalar, returns a
-        scalar float.  If any input is array_like, returns payment for each
-        input element. If multiple inputs are array_like, they all must have
-        the same shape.
-
-    Notes
-    -----
-    The payment is computed by solving the equation::
-
-     fv +
-     pv*(1 + rate)**nper +
-     pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) == 0
-
-    or, when ``rate == 0``::
-
-      fv + pv + pmt * nper == 0
-
-    for ``pmt``.
-
-    Note that computing a monthly mortgage payment is only
-    one use for this function.  For example, pmt returns the
-    periodic deposit one must make to achieve a specified
-    future balance given an initial deposit, a fixed,
-    periodically compounded interest rate, and the total
-    number of periods.
-
-    References
-    ----------
-    .. [1] NumPy Enhancement Proposal (NEP) 32,
-       https://numpy.org/neps/nep-0032-remove-financial-functions.html
-    .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).
-       Open Document Format for Office Applications (OpenDocument)v1.2,
-       Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,
-       Pre-Draft 12. Organization for the Advancement of Structured Information
-       Standards (OASIS). Billerica, MA, USA. [ODT Document].
-       Available:
-       http://www.oasis-open.org/committees/documents.php
-       ?wg_abbrev=office-formulaOpenDocument-formula-20090508.odt
-
-    Examples
-    --------
-    What is the monthly payment needed to pay off a $200,000 loan in 15
-    years at an annual interest rate of 7.5%?
-
-    >>> np.pmt(0.075/12, 12*15, 200000)
-    -1854.0247200054619
-
-    In order to pay-off (i.e., have a future-value of 0) the $200,000 obtained
-    today, a monthly payment of $1,854.02 would be required.  Note that this
-    example illustrates usage of `fv` having a default value of 0.
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def byte (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "byte"))))
-(alter-meta! #'byte assoc :doc "Signed integer type, compatible with C ``char``.
-    Character code: ``'b'``.
-    Canonical name: ``np.byte``.
-    Alias *on this platform*: ``np.int8``: 8-bit signed integer (-128 to 127)." :arglists '[[self & [args {:as kwargs}]]])
-
-(def seterrobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "seterrobj"))))
-(alter-meta! #'seterrobj assoc :doc "seterrobj(errobj)
-
-    Set the object that defines floating-point error handling.
-
-    The error object contains all information that defines the error handling
-    behavior in NumPy. `seterrobj` is used internally by the other
-    functions that set error handling behavior (`seterr`, `seterrcall`).
-
-    Parameters
-    ----------
-    errobj : list
-        The error object, a list containing three elements:
-        [internal numpy buffer size, error mask, error callback function].
-
-        The error mask is a single integer that holds the treatment information
-        on all four floating point errors. The information for each error type
-        is contained in three bits of the integer. If we print it in base 8, we
-        can see what treatment is set for \"invalid\", \"under\", \"over\", and
-        \"divide\" (in that order). The printed string can be interpreted with
-
-        * 0 : 'ignore'
-        * 1 : 'warn'
-        * 2 : 'raise'
-        * 3 : 'call'
-        * 4 : 'print'
-        * 5 : 'log'
-
-    See Also
-    --------
-    geterrobj, seterr, geterr, seterrcall, geterrcall
-    getbufsize, setbufsize
-
-    Notes
-    -----
-    For complete documentation of the types of floating-point exceptions and
-    treatment options, see `seterr`.
-
-    Examples
-    --------
-    >>> old_errobj = np.geterrobj()  # first get the defaults
-    >>> old_errobj
-    [8192, 521, None]
-
-    >>> def err_handler(type, flag):
-    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
-    ...
-    >>> new_errobj = [20000, 12, err_handler]
-    >>> np.seterrobj(new_errobj)
-    >>> np.base_repr(12, 8)  # int for divide=4 ('print') and over=1 ('warn')
-    '14'
-    >>> np.geterr()
-    {'over': 'warn', 'divide': 'print', 'invalid': 'ignore', 'under': 'ignore'}
-    >>> np.geterrcall() is err_handler
-    True" :arglists '[[self & [args {:as kwargs}]]])
-
-(def log2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log2"))))
-(alter-meta! #'log2 assoc :doc "log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Base-2 logarithm of `x`.
-
-Parameters
-----------
-x : array_like
-    Input values.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    Base-2 logarithm of `x`.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-log, log10, log1p, emath.log2
-
-Notes
------
-.. versionadded:: 1.3.0
-
-Logarithm is a multivalued function: for each `x` there is an infinite
-number of `z` such that `2**z = x`. The convention is to return the `z`
-whose imaginary part lies in `[-pi, pi]`.
-
-For real-valued input data types, `log2` always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields ``nan`` and sets the `invalid` floating point error flag.
-
-For complex-valued input, `log2` is a complex analytical function that
-has a branch cut `[-inf, 0]` and is continuous from above on it. `log2`
-handles the floating-point negative zero as an infinitesimal negative
-number, conforming to the C99 standard.
-
-Examples
---------
->>> x = np.array([0, 1, 2, 2**4])
->>> np.log2(x)
-array([-Inf,   0.,   1.,   4.])
-
->>> xi = np.array([0+1.j, 1, 2+0.j, 4.j])
->>> np.log2(xi)
-array([ 0.+2.26618007j,  0.+0.j        ,  1.+0.j        ,  2.+2.26618007j])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def left_shift (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "left_shift"))))
-(alter-meta! #'left_shift assoc :doc "left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Shift the bits of an integer to the left.
-
-Bits are shifted to the left by appending `x2` 0s at the right of `x1`.
-Since the internal representation of numbers is in binary format, this
-operation is equivalent to multiplying `x1` by ``2**x2``.
-
-Parameters
-----------
-x1 : array_like of integer type
-    Input values.
-x2 : array_like of integer type
-    Number of zeros to append to `x1`. Has to be non-negative.
-    If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : array of integer type
-    Return `x1` with bits shifted `x2` times to the left.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-right_shift : Shift the bits of an integer to the right.
-binary_repr : Return the binary representation of the input number
-    as a string.
-
-Examples
---------
->>> np.binary_repr(5)
-'101'
->>> np.left_shift(5, 2)
-20
->>> np.binary_repr(20)
-'10100'
-
->>> np.left_shift(5, [1,2,3])
-array([10, 20, 40])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ascontiguousarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ascontiguousarray"))))
-(alter-meta! #'ascontiguousarray assoc :doc "
-    Return a contiguous array (ndim >= 1) in memory (C order).
-
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    dtype : str or dtype object, optional
-        Data-type of returned array.
-
-    Returns
-    -------
-    out : ndarray
-        Contiguous array of same shape and content as `a`, with type `dtype`
-        if specified.
-
-    See Also
-    --------
-    asfortranarray : Convert input to an ndarray with column-major
-                     memory order.
-    require : Return an ndarray that satisfies requirements.
-    ndarray.flags : Information about the memory layout of the array.
-
-    Examples
-    --------
-    >>> x = np.arange(6).reshape(2,3)
-    >>> np.ascontiguousarray(x, dtype=np.float32)
-    array([[0., 1., 2.],
-           [3., 4., 5.]], dtype=float32)
-    >>> x.flags['C_CONTIGUOUS']
-    True
-
-    Note: This function returns an array with at least one-dimension (1-d) 
-    so it will not preserve 0-d arrays.  
-
-    " :arglists '[[a & [{dtype :dtype}]] [a]])
-
-(def row_stack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "row_stack"))))
-(alter-meta! #'row_stack assoc :doc "
-    Stack arrays in sequence vertically (row wise).
-
-    This is equivalent to concatenation along the first axis after 1-D arrays
-    of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
-    `vsplit`.
-
-    This function makes most sense for arrays with up to 3 dimensions. For
-    instance, for pixel-data with a height (first axis), width (second axis),
-    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
-    `block` provide more general stacking and concatenation operations.
-
-    Parameters
-    ----------
-    tup : sequence of ndarrays
-        The arrays must have the same shape along all but the first axis.
-        1-D arrays must have the same length.
-
-    Returns
-    -------
-    stacked : ndarray
-        The array formed by stacking the given arrays, will be at least 2-D.
-
-    See Also
-    --------
-    stack : Join a sequence of arrays along a new axis.
-    hstack : Stack arrays in sequence horizontally (column wise).
-    dstack : Stack arrays in sequence depth wise (along third dimension).
-    concatenate : Join a sequence of arrays along an existing axis.
-    vsplit : Split array into a list of multiple sub-arrays vertically.
-    block : Assemble arrays from blocks.
-
-    Examples
-    --------
-    >>> a = np.array([1, 2, 3])
-    >>> b = np.array([2, 3, 4])
-    >>> np.vstack((a,b))
-    array([[1, 2, 3],
-           [2, 3, 4]])
-
-    >>> a = np.array([[1], [2], [3]])
-    >>> b = np.array([[2], [3], [4]])
-    >>> np.vstack((a,b))
-    array([[1],
-           [2],
-           [3],
-           [2],
-           [3],
-           [4]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def savez (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "savez"))))
-(alter-meta! #'savez assoc :doc "Save several arrays into a single file in uncompressed ``.npz`` format.
-
-    If arguments are passed in with no keywords, the corresponding variable
-    names, in the ``.npz`` file, are 'arr_0', 'arr_1', etc. If keyword
-    arguments are given, the corresponding variable names, in the ``.npz``
-    file will match the keyword names.
-
-    Parameters
-    ----------
-    file : str or file
-        Either the filename (string) or an open file (file-like object)
-        where the data will be saved. If file is a string or a Path, the
-        ``.npz`` extension will be appended to the filename if it is not
-        already there.
-    args : Arguments, optional
-        Arrays to save to the file. Since it is not possible for Python to
-        know the names of the arrays outside `savez`, the arrays will be saved
-        with names \"arr_0\", \"arr_1\", and so on. These arguments can be any
-        expression.
-    kwds : Keyword arguments, optional
-        Arrays to save to the file. Arrays will be saved in the file with the
-        keyword names.
-
-    Returns
-    -------
-    None
-
-    See Also
-    --------
-    save : Save a single array to a binary file in NumPy format.
-    savetxt : Save an array to a file as plain text.
-    savez_compressed : Save several arrays into a compressed ``.npz`` archive
-
-    Notes
-    -----
-    The ``.npz`` file format is a zipped archive of files named after the
-    variables they contain.  The archive is not compressed and each file
-    in the archive contains one variable in ``.npy`` format. For a
-    description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.
-
-    When opening the saved ``.npz`` file with `load` a `NpzFile` object is
-    returned. This is a dictionary-like object which can be queried for
-    its list of arrays (with the ``.files`` attribute), and for the arrays
-    themselves.
-
-    When saving dictionaries, the dictionary keys become filenames
-    inside the ZIP archive. Therefore, keys should be valid filenames.
-    E.g., avoid keys that begin with ``/`` or contain ``.``.
-
-    Examples
-    --------
-    >>> from tempfile import TemporaryFile
-    >>> outfile = TemporaryFile()
-    >>> x = np.arange(10)
-    >>> y = np.sin(x)
-
-    Using `savez` with \\*args, the arrays are saved with default names.
-
-    >>> np.savez(outfile, x, y)
-    >>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file
-    >>> npzfile = np.load(outfile)
-    >>> npzfile.files
-    ['arr_0', 'arr_1']
-    >>> npzfile['arr_0']
-    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-
-    Using `savez` with \\**kwds, the arrays are saved with the keyword names.
-
-    >>> outfile = TemporaryFile()
-    >>> np.savez(outfile, x=x, y=y)
-    >>> _ = outfile.seek(0)
-    >>> npzfile = np.load(outfile)
-    >>> sorted(npzfile.files)
-    ['x', 'y']
-    >>> npzfile['x']
-    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def typename (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "typename"))))
-(alter-meta! #'typename assoc :doc "
-    Return a description for the given data type code.
-
-    Parameters
-    ----------
-    char : str
-        Data type code.
-
-    Returns
-    -------
-    out : str
-        Description of the input data type code.
-
-    See Also
-    --------
-    dtype, typecodes
-
-    Examples
-    --------
-    >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',
-    ...              'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']
-    >>> for typechar in typechars:
-    ...     print(typechar, ' : ', np.typename(typechar))
-    ...
-    S1  :  character
-    ?  :  bool
-    B  :  unsigned char
-    D  :  complex double precision
-    G  :  complex long double precision
-    F  :  complex single precision
-    I  :  unsigned integer
-    H  :  unsigned short
-    L  :  unsigned long integer
-    O  :  object
-    Q  :  unsigned long long integer
-    S  :  string
-    U  :  unicode
-    V  :  void
-    b  :  signed char
-    d  :  double precision
-    g  :  long precision
-    f  :  single precision
-    i  :  integer
-    h  :  short
-    l  :  long integer
-    q  :  long long integer
-
-    " :arglists '[[char]])
-
-(def test (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "test"))))
-(alter-meta! #'test assoc :doc "
-    Pytest test runner.
-
-    A test function is typically added to a package's __init__.py like so::
-
-      from numpy._pytesttester import PytestTester
-      test = PytestTester(__name__).test
-      del PytestTester
-
-    Calling this test function finds and runs all tests associated with the
-    module and all its sub-modules.
-
-    Attributes
-    ----------
-    module_name : str
-        Full path to the package to test.
-
-    Parameters
-    ----------
-    module_name : module name
-        The name of the module to test.
-
-    Notes
-    -----
-    Unlike the previous ``nose``-based implementation, this class is not
-    publicly exposed as it performs some ``numpy``-specific warning
-    suppression.
-
-    " :arglists '[[self module_name]])
-
-(def ^{:doc ""} __package__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__package__"))))
-
-(def array_equiv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_equiv"))))
-(alter-meta! #'array_equiv assoc :doc "
-    Returns True if input arrays are shape consistent and all elements equal.
-
-    Shape consistent means they are either the same shape, or one input array
-    can be broadcasted to create the same shape as the other one.
-
-    Parameters
-    ----------
-    a1, a2 : array_like
-        Input arrays.
-
-    Returns
-    -------
-    out : bool
-        True if equivalent, False otherwise.
-
-    Examples
-    --------
-    >>> np.array_equiv([1, 2], [1, 2])
-    True
-    >>> np.array_equiv([1, 2], [1, 3])
-    False
-
-    Showing the shape equivalence:
-
-    >>> np.array_equiv([1, 2], [[1, 2], [1, 2]])
-    True
-    >>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])
-    False
-
-    >>> np.array_equiv([1, 2], [[1, 2], [1, 3]])
-    False
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def stack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "stack"))))
-(alter-meta! #'stack assoc :doc "
-    Join a sequence of arrays along a new axis.
-
-    The ``axis`` parameter specifies the index of the new axis in the
-    dimensions of the result. For example, if ``axis=0`` it will be the first
-    dimension and if ``axis=-1`` it will be the last dimension.
-
-    .. versionadded:: 1.10.0
-
-    Parameters
-    ----------
-    arrays : sequence of array_like
-        Each array must have the same shape.
-
-    axis : int, optional
-        The axis in the result array along which the input arrays are stacked.
-
-    out : ndarray, optional
-        If provided, the destination to place the result. The shape must be
-        correct, matching that of what stack would have returned if no
-        out argument were specified.
-
-    Returns
-    -------
-    stacked : ndarray
-        The stacked array has one more dimension than the input arrays.
-
-    See Also
-    --------
-    concatenate : Join a sequence of arrays along an existing axis.
-    split : Split array into a list of multiple sub-arrays of equal size.
-    block : Assemble arrays from blocks.
-
-    Examples
-    --------
-    >>> arrays = [np.random.randn(3, 4) for _ in range(10)]
-    >>> np.stack(arrays, axis=0).shape
-    (10, 3, 4)
-
-    >>> np.stack(arrays, axis=1).shape
-    (3, 10, 4)
-
-    >>> np.stack(arrays, axis=2).shape
-    (3, 4, 10)
-
-    >>> a = np.array([1, 2, 3])
-    >>> b = np.array([2, 3, 4])
-    >>> np.stack((a, b))
-    array([[1, 2, 3],
-           [2, 3, 4]])
-
-    >>> np.stack((a, b), axis=-1)
-    array([[1, 2],
-           [2, 3],
-           [3, 4]])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def right_shift (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "right_shift"))))
-(alter-meta! #'right_shift assoc :doc "right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Shift the bits of an integer to the right.
-
-Bits are shifted to the right `x2`.  Because the internal
-representation of numbers is in binary format, this operation is
-equivalent to dividing `x1` by ``2**x2``.
-
-Parameters
-----------
-x1 : array_like, int
-    Input values.
-x2 : array_like, int
-    Number of bits to remove at the right of `x1`. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray, int
-    Return `x1` with bits shifted `x2` times to the right.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-left_shift : Shift the bits of an integer to the left.
-binary_repr : Return the binary representation of the input number
-    as a string.
-
-Examples
---------
->>> np.binary_repr(10)
-'1010'
->>> np.right_shift(10, 1)
-5
->>> np.binary_repr(5)
-'101'
-
->>> np.right_shift(10, [1,2,3])
-array([5, 2, 1])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def nanvar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanvar"))))
-(alter-meta! #'nanvar assoc :doc "
-    Compute the variance along the specified axis, while ignoring NaNs.
-
-    Returns the variance of the array elements, a measure of the spread of
-    a distribution.  The variance is computed for the flattened array by
-    default, otherwise over the specified axis.
-
-    For all-NaN slices or slices with zero degrees of freedom, NaN is
-    returned and a `RuntimeWarning` is raised.
-
-    .. versionadded:: 1.8.0
-
-    Parameters
-    ----------
-    a : array_like
-        Array containing numbers whose variance is desired.  If `a` is not an
-        array, a conversion is attempted.
-    axis : {int, tuple of int, None}, optional
-        Axis or axes along which the variance is computed.  The default is to compute
-        the variance of the flattened array.
-    dtype : data-type, optional
-        Type to use in computing the variance.  For arrays of integer type
-        the default is `float64`; for arrays of float types it is the same as
-        the array type.
-    out : ndarray, optional
-        Alternate output array in which to place the result.  It must have
-        the same shape as the expected output, but the type is cast if
-        necessary.
-    ddof : int, optional
-        \"Delta Degrees of Freedom\": the divisor used in the calculation is
-        ``N - ddof``, where ``N`` represents the number of non-NaN
-        elements. By default `ddof` is zero.
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the original `a`.
-
-
-    Returns
-    -------
-    variance : ndarray, see dtype parameter above
-        If `out` is None, return a new array containing the variance,
-        otherwise return a reference to the output array. If ddof is >= the
-        number of non-NaN elements in a slice or the slice contains only
-        NaNs, then the result for that slice is NaN.
-
-    See Also
-    --------
-    std : Standard deviation
-    mean : Average
-    var : Variance while not ignoring NaNs
-    nanstd, nanmean
-    ufuncs-output-type
-
-    Notes
-    -----
-    The variance is the average of the squared deviations from the mean,
-    i.e.,  ``var = mean(abs(x - x.mean())**2)``.
-
-    The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``.
-    If, however, `ddof` is specified, the divisor ``N - ddof`` is used
-    instead.  In standard statistical practice, ``ddof=1`` provides an
-    unbiased estimator of the variance of a hypothetical infinite
-    population.  ``ddof=0`` provides a maximum likelihood estimate of the
-    variance for normally distributed variables.
-
-    Note that for complex numbers, the absolute value is taken before
-    squaring, so that the result is always real and nonnegative.
-
-    For floating-point input, the variance is computed using the same
-    precision the input has.  Depending on the input data, this can cause
-    the results to be inaccurate, especially for `float32` (see example
-    below).  Specifying a higher-accuracy accumulator using the ``dtype``
-    keyword can alleviate this issue.
-
-    For this function to work on sub-classes of ndarray, they must define
-    `sum` with the kwarg `keepdims`
-
-    Examples
-    --------
-    >>> a = np.array([[1, np.nan], [3, 4]])
-    >>> np.nanvar(a)
-    1.5555555555555554
-    >>> np.nanvar(a, axis=0)
-    array([1.,  0.])
-    >>> np.nanvar(a, axis=1)
-    array([0.,  0.25])  # may vary
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc "
-A sub-package for efficiently dealing with polynomials.
-
-Within the documentation for this sub-package, a \"finite power series,\"
-i.e., a polynomial (also referred to simply as a \"series\") is represented
-by a 1-D numpy array of the polynomial's coefficients, ordered from lowest
-order term to highest.  For example, array([1,2,3]) represents
-``P_0 + 2*P_1 + 3*P_2``, where P_n is the n-th order basis polynomial
-applicable to the specific module in question, e.g., `polynomial` (which
-\"wraps\" the \"standard\" basis) or `chebyshev`.  For optimal performance,
-all operations on polynomials, including evaluation at an argument, are
-implemented as operations on the coefficients.  Additional (module-specific)
-information can be found in the docstring for the module of interest.
-
-"} polynomial (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "polynomial"))))
-
-(def polyder (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyder"))))
-(alter-meta! #'polyder assoc :doc "
-    Return the derivative of the specified order of a polynomial.
-
-    Parameters
-    ----------
-    p : poly1d or sequence
-        Polynomial to differentiate.
-        A sequence is interpreted as polynomial coefficients, see `poly1d`.
-    m : int, optional
-        Order of differentiation (default: 1)
-
-    Returns
-    -------
-    der : poly1d
-        A new polynomial representing the derivative.
-
-    See Also
-    --------
-    polyint : Anti-derivative of a polynomial.
-    poly1d : Class for one-dimensional polynomials.
-
-    Examples
-    --------
-    The derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is:
-
-    >>> p = np.poly1d([1,1,1,1])
-    >>> p2 = np.polyder(p)
-    >>> p2
-    poly1d([3, 2, 1])
-
-    which evaluates to:
-
-    >>> p2(2.)
-    17.0
-
-    We can verify this, approximating the derivative with
-    ``(f(x + h) - f(x))/h``:
-
-    >>> (p(2. + 0.001) - p(2.)) / 0.001
-    17.007000999997857
-
-    The fourth-order derivative of a 3rd-order polynomial is zero:
-
-    >>> np.polyder(p, 2)
-    poly1d([6, 2])
-    >>> np.polyder(p, 3)
-    poly1d([6])
-    >>> np.polyder(p, 4)
-    poly1d([0.])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def moveaxis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "moveaxis"))))
-(alter-meta! #'moveaxis assoc :doc "
-    Move axes of an array to new positions.
-
-    Other axes remain in their original order.
-
-    .. versionadded:: 1.11.0
-
-    Parameters
-    ----------
-    a : np.ndarray
-        The array whose axes should be reordered.
-    source : int or sequence of int
-        Original positions of the axes to move. These must be unique.
-    destination : int or sequence of int
-        Destination positions for each of the original axes. These must also be
-        unique.
-
-    Returns
-    -------
-    result : np.ndarray
-        Array with moved axes. This array is a view of the input array.
-
-    See Also
-    --------
-    transpose: Permute the dimensions of an array.
-    swapaxes: Interchange two axes of an array.
-
-    Examples
-    --------
-
-    >>> x = np.zeros((3, 4, 5))
-    >>> np.moveaxis(x, 0, -1).shape
-    (4, 5, 3)
-    >>> np.moveaxis(x, -1, 0).shape
-    (5, 3, 4)
-
-    These all achieve the same result:
-
-    >>> np.transpose(x).shape
-    (5, 4, 3)
-    >>> np.swapaxes(x, 0, -1).shape
-    (5, 4, 3)
-    >>> np.moveaxis(x, [0, 1], [-1, -2]).shape
-    (5, 4, 3)
-    >>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape
-    (5, 4, 3)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def concatenate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "concatenate"))))
-(alter-meta! #'concatenate assoc :doc "
-    concatenate((a1, a2, ...), axis=0, out=None)
-
-    Join a sequence of arrays along an existing axis.
-
-    Parameters
-    ----------
-    a1, a2, ... : sequence of array_like
-        The arrays must have the same shape, except in the dimension
-        corresponding to `axis` (the first, by default).
-    axis : int, optional
-        The axis along which the arrays will be joined.  If axis is None,
-        arrays are flattened before use.  Default is 0.
-    out : ndarray, optional
-        If provided, the destination to place the result. The shape must be
-        correct, matching that of what concatenate would have returned if no
-        out argument were specified.
-
-    Returns
-    -------
-    res : ndarray
-        The concatenated array.
-
-    See Also
-    --------
-    ma.concatenate : Concatenate function that preserves input masks.
-    array_split : Split an array into multiple sub-arrays of equal or
-                  near-equal size.
-    split : Split array into a list of multiple sub-arrays of equal size.
-    hsplit : Split array into multiple sub-arrays horizontally (column wise)
-    vsplit : Split array into multiple sub-arrays vertically (row wise)
-    dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
-    stack : Stack a sequence of arrays along a new axis.
-    hstack : Stack arrays in sequence horizontally (column wise)
-    vstack : Stack arrays in sequence vertically (row wise)
-    dstack : Stack arrays in sequence depth wise (along third dimension)
-    block : Assemble arrays from blocks.
-
-    Notes
-    -----
-    When one or more of the arrays to be concatenated is a MaskedArray,
-    this function will return a MaskedArray object instead of an ndarray,
-    but the input masks are *not* preserved. In cases where a MaskedArray
-    is expected as input, use the ma.concatenate function from the masked
-    array module instead.
-
-    Examples
-    --------
-    >>> a = np.array([[1, 2], [3, 4]])
-    >>> b = np.array([[5, 6]])
-    >>> np.concatenate((a, b), axis=0)
-    array([[1, 2],
-           [3, 4],
-           [5, 6]])
-    >>> np.concatenate((a, b.T), axis=1)
-    array([[1, 2, 5],
-           [3, 4, 6]])
-    >>> np.concatenate((a, b), axis=None)
-    array([1, 2, 3, 4, 5, 6])
-
-    This function will not preserve masking of MaskedArray inputs.
-
-    >>> a = np.ma.arange(3)
-    >>> a[1] = np.ma.masked
-    >>> b = np.arange(2, 5)
-    >>> a
-    masked_array(data=[0, --, 2],
-                 mask=[False,  True, False],
-           fill_value=999999)
-    >>> b
-    array([2, 3, 4])
-    >>> np.concatenate([a, b])
-    masked_array(data=[0, 1, 2, 2, 3, 4],
-                 mask=False,
-           fill_value=999999)
-    >>> np.ma.concatenate([a, b])
-    masked_array(data=[0, --, 2, 2, 3, 4],
-                 mask=[False,  True, False, False, False, False],
-           fill_value=999999)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def zeros_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "zeros_like"))))
-(alter-meta! #'zeros_like assoc :doc "
-    Return an array of zeros with the same shape and type as a given array.
-
-    Parameters
-    ----------
-    a : array_like
-        The shape and data-type of `a` define these same attributes of
-        the returned array.
-    dtype : data-type, optional
-        Overrides the data type of the result.
-
-        .. versionadded:: 1.6.0
-    order : {'C', 'F', 'A', or 'K'}, optional
-        Overrides the memory layout of the result. 'C' means C-order,
-        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
-        'C' otherwise. 'K' means match the layout of `a` as closely
-        as possible.
-
-        .. versionadded:: 1.6.0
-    subok : bool, optional.
-        If True, then the newly created array will use the sub-class
-        type of 'a', otherwise it will be a base-class array. Defaults
-        to True.
-    shape : int or sequence of ints, optional.
-        Overrides the shape of the result. If order='K' and the number of
-        dimensions is unchanged, will try to keep order, otherwise,
-        order='C' is implied.
-
-        .. versionadded:: 1.17.0
-
-    Returns
-    -------
-    out : ndarray
-        Array of zeros with the same shape and type as `a`.
-
-    See Also
-    --------
-    empty_like : Return an empty array with shape and type of input.
-    ones_like : Return an array of ones with shape and type of input.
-    full_like : Return a new array with shape of input filled with value.
-    zeros : Return a new array setting values to zero.
-
-    Examples
-    --------
-    >>> x = np.arange(6)
-    >>> x = x.reshape((2, 3))
-    >>> x
-    array([[0, 1, 2],
-           [3, 4, 5]])
-    >>> np.zeros_like(x)
-    array([[0, 0, 0],
-           [0, 0, 0]])
-
-    >>> y = np.arange(3, dtype=float)
-    >>> y
-    array([0., 1., 2.])
-    >>> np.zeros_like(y)
-    array([0.,  0.,  0.])
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def rint (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rint"))))
-(alter-meta! #'rint assoc :doc "rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Round elements of the array to the nearest integer.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Output array is same shape and type as `x`.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-ceil, floor, trunc
-
-Examples
---------
->>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
->>> np.rint(a)
-array([-2., -2., -0.,  0.,  2.,  2.,  2.])" :arglists '[[self & [args {:as kwargs}]]])
-
-(def arcsin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arcsin"))))
-(alter-meta! #'arcsin assoc :doc "arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Inverse sine, element-wise.
-
-Parameters
-----------
-x : array_like
-    `y`-coordinate on the unit circle.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-angle : ndarray
-    The inverse sine of each element in `x`, in radians and in the
-    closed interval ``[-pi/2, pi/2]``.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-sin, cos, arccos, tan, arctan, arctan2, emath.arcsin
-
-Notes
------
-`arcsin` is a multivalued function: for each `x` there are infinitely
-many numbers `z` such that :math:`sin(z) = x`.  The convention is to
-return the angle `z` whose real part lies in [-pi/2, pi/2].
-
-For real-valued input data types, *arcsin* always returns real output.
-For each value that cannot be expressed as a real number or infinity,
-it yields ``nan`` and sets the `invalid` floating point error flag.
-
-For complex-valued input, `arcsin` is a complex analytic function that
-has, by convention, the branch cuts [-inf, -1] and [1, inf]  and is
-continuous from above on the former and from below on the latter.
-
-The inverse sine is also known as `asin` or sin^{-1}.
-
-References
-----------
-Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
-10th printing, New York: Dover, 1964, pp. 79ff.
-http://www.math.sfu.ca/~cbm/aands/
-
-Examples
---------
->>> np.arcsin(1)     # pi/2
-1.5707963267948966
->>> np.arcsin(-1)    # -pi/2
--1.5707963267948966
->>> np.arcsin(0)
-0.0" :arglists '[[self & [args {:as kwargs}]]])
-
-(def byte_bounds (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "byte_bounds"))))
-(alter-meta! #'byte_bounds assoc :doc "
-    Returns pointers to the end-points of an array.
-
-    Parameters
-    ----------
-    a : ndarray
-        Input array. It must conform to the Python-side of the array
-        interface.
-
-    Returns
-    -------
-    (low, high) : tuple of 2 integers
-        The first integer is the first byte of the array, the second
-        integer is just past the last byte of the array.  If `a` is not
-        contiguous it will not use every byte between the (`low`, `high`)
-        values.
-
-    Examples
-    --------
-    >>> I = np.eye(2, dtype='f'); I.dtype
-    dtype('float32')
-    >>> low, high = np.byte_bounds(I)
-    >>> high - low == I.size*I.itemsize
-    True
-    >>> I = np.eye(2); I.dtype
-    dtype('float64')
-    >>> low, high = np.byte_bounds(I)
-    >>> high - low == I.size*I.itemsize
-    True
-
-    " :arglists '[[a]])
-
-(def indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "indices"))))
-(alter-meta! #'indices assoc :doc "
-    Return an array representing the indices of a grid.
-
-    Compute an array where the subarrays contain index values 0, 1, ...
-    varying only along the corresponding axis.
-
-    Parameters
-    ----------
-    dimensions : sequence of ints
-        The shape of the grid.
-    dtype : dtype, optional
-        Data type of the result.
-    sparse : boolean, optional
-        Return a sparse representation of the grid instead of a dense
-        representation. Default is False.
-
-        .. versionadded:: 1.17
-
-    Returns
-    -------
-    grid : one ndarray or tuple of ndarrays
-        If sparse is False:
-            Returns one array of grid indices,
-            ``grid.shape = (len(dimensions),) + tuple(dimensions)``.
-        If sparse is True:
-            Returns a tuple of arrays, with
-            ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with
-            dimensions[i] in the ith place
-
-    See Also
-    --------
-    mgrid, ogrid, meshgrid
-
-    Notes
-    -----
-    The output shape in the dense case is obtained by prepending the number
-    of dimensions in front of the tuple of dimensions, i.e. if `dimensions`
-    is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is
-    ``(N, r0, ..., rN-1)``.
-
-    The subarrays ``grid[k]`` contains the N-D array of indices along the
-    ``k-th`` axis. Explicitly::
-
-        grid[k, i0, i1, ..., iN-1] = ik
-
-    Examples
-    --------
-    >>> grid = np.indices((2, 3))
-    >>> grid.shape
-    (2, 2, 3)
-    >>> grid[0]        # row indices
-    array([[0, 0, 0],
-           [1, 1, 1]])
-    >>> grid[1]        # column indices
-    array([[0, 1, 2],
-           [0, 1, 2]])
-
-    The indices can be used as an index into an array.
-
-    >>> x = np.arange(20).reshape(5, 4)
-    >>> row, col = np.indices((2, 3))
-    >>> x[row, col]
-    array([[0, 1, 2],
-           [4, 5, 6]])
-
-    Note that it would be more straightforward in the above example to
-    extract the required elements directly with ``x[:2, :3]``.
-
-    If sparse is set to true, the grid will be returned in a sparse
-    representation.
-
-    >>> i, j = np.indices((2, 3), sparse=True)
-    >>> i.shape
-    (2, 1)
-    >>> j.shape
-    (1, 3)
-    >>> i        # row indices
-    array([[0],
-           [1]])
-    >>> j        # column indices
-    array([[0, 1, 2]])
-
-    " :arglists '[[dimensions & [{dtype :dtype, sparse :sparse}]] [dimensions & [{dtype :dtype}]] [dimensions]])
-
-(def meshgrid (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "meshgrid"))))
-(alter-meta! #'meshgrid assoc :doc "
-    Return coordinate matrices from coordinate vectors.
-
-    Make N-D coordinate arrays for vectorized evaluations of
-    N-D scalar/vector fields over N-D grids, given
-    one-dimensional coordinate arrays x1, x2,..., xn.
-
-    .. versionchanged:: 1.9
-       1-D and 0-D cases are allowed.
-
-    Parameters
-    ----------
-    x1, x2,..., xn : array_like
-        1-D arrays representing the coordinates of a grid.
-    indexing : {'xy', 'ij'}, optional
-        Cartesian ('xy', default) or matrix ('ij') indexing of output.
-        See Notes for more details.
-
-        .. versionadded:: 1.7.0
-    sparse : bool, optional
-        If True a sparse grid is returned in order to conserve memory.
-        Default is False.
-
-        .. versionadded:: 1.7.0
-    copy : bool, optional
-        If False, a view into the original arrays are returned in order to
-        conserve memory.  Default is True.  Please note that
-        ``sparse=False, copy=False`` will likely return non-contiguous
-        arrays.  Furthermore, more than one element of a broadcast array
-        may refer to a single memory location.  If you need to write to the
-        arrays, make copies first.
-
-        .. versionadded:: 1.7.0
-
-    Returns
-    -------
-    X1, X2,..., XN : ndarray
-        For vectors `x1`, `x2`,..., 'xn' with lengths ``Ni=len(xi)`` ,
-        return ``(N1, N2, N3,...Nn)`` shaped arrays if indexing='ij'
-        or ``(N2, N1, N3,...Nn)`` shaped arrays if indexing='xy'
-        with the elements of `xi` repeated to fill the matrix along
-        the first dimension for `x1`, the second for `x2` and so on.
-
-    Notes
-    -----
-    This function supports both indexing conventions through the indexing
-    keyword argument.  Giving the string 'ij' returns a meshgrid with
-    matrix indexing, while 'xy' returns a meshgrid with Cartesian indexing.
-    In the 2-D case with inputs of length M and N, the outputs are of shape
-    (N, M) for 'xy' indexing and (M, N) for 'ij' indexing.  In the 3-D case
-    with inputs of length M, N and P, outputs are of shape (N, M, P) for
-    'xy' indexing and (M, N, P) for 'ij' indexing.  The difference is
-    illustrated by the following code snippet::
-
-        xv, yv = np.meshgrid(x, y, sparse=False, indexing='ij')
-        for i in range(nx):
-            for j in range(ny):
-                # treat xv[i,j], yv[i,j]
-
-        xv, yv = np.meshgrid(x, y, sparse=False, indexing='xy')
-        for i in range(nx):
-            for j in range(ny):
-                # treat xv[j,i], yv[j,i]
-
-    In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
-
-    See Also
-    --------
-    index_tricks.mgrid : Construct a multi-dimensional \"meshgrid\"
-                     using indexing notation.
-    index_tricks.ogrid : Construct an open multi-dimensional \"meshgrid\"
-                     using indexing notation.
-
-    Examples
-    --------
-    >>> nx, ny = (3, 2)
-    >>> x = np.linspace(0, 1, nx)
-    >>> y = np.linspace(0, 1, ny)
-    >>> xv, yv = np.meshgrid(x, y)
-    >>> xv
-    array([[0. , 0.5, 1. ],
-           [0. , 0.5, 1. ]])
-    >>> yv
-    array([[0.,  0.,  0.],
-           [1.,  1.,  1.]])
-    >>> xv, yv = np.meshgrid(x, y, sparse=True)  # make sparse output arrays
-    >>> xv
-    array([[0. ,  0.5,  1. ]])
-    >>> yv
-    array([[0.],
-           [1.]])
-
-    `meshgrid` is very useful to evaluate functions on a grid.
-
-    >>> import matplotlib.pyplot as plt
-    >>> x = np.arange(-5, 5, 0.1)
-    >>> y = np.arange(-5, 5, 0.1)
-    >>> xx, yy = np.meshgrid(x, y, sparse=True)
-    >>> z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2)
-    >>> h = plt.contourf(x,y,z)
-    >>> plt.show()
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def datetime64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "datetime64"))))
-(alter-meta! #'datetime64 assoc :doc "" :arglists '[[self & [args {:as kwargs}]]])
-
-(def copyto (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "copyto"))))
-(alter-meta! #'copyto assoc :doc "
-    copyto(dst, src, casting='same_kind', where=True)
-
-    Copies values from one array to another, broadcasting as necessary.
-
-    Raises a TypeError if the `casting` rule is violated, and if
-    `where` is provided, it selects which elements to copy.
-
-    .. versionadded:: 1.7.0
-
-    Parameters
-    ----------
-    dst : ndarray
-        The array into which values are copied.
-    src : array_like
-        The array from which values are copied.
-    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
-        Controls what kind of data casting may occur when copying.
-
-          * 'no' means the data types should not be cast at all.
-          * 'equiv' means only byte-order changes are allowed.
-          * 'safe' means only casts which can preserve values are allowed.
-          * 'same_kind' means only safe casts or casts within a kind,
-            like float64 to float32, are allowed.
-          * 'unsafe' means any data conversions may be done.
-    where : array_like of bool, optional
-        A boolean array which is broadcasted to match the dimensions
-        of `dst`, and selects elements to copy from `src` to `dst`
-        wherever it contains the value True.
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def polydiv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polydiv"))))
-(alter-meta! #'polydiv assoc :doc "
-    Returns the quotient and remainder of polynomial division.
-
-    The input arrays are the coefficients (including any coefficients
-    equal to zero) of the \"numerator\" (dividend) and \"denominator\"
-    (divisor) polynomials, respectively.
-
-    Parameters
-    ----------
-    u : array_like or poly1d
-        Dividend polynomial's coefficients.
-
-    v : array_like or poly1d
-        Divisor polynomial's coefficients.
-
-    Returns
-    -------
-    q : ndarray
-        Coefficients, including those equal to zero, of the quotient.
-    r : ndarray
-        Coefficients, including those equal to zero, of the remainder.
-
-    See Also
-    --------
-    poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub
-    polyval
-
-    Notes
-    -----
-    Both `u` and `v` must be 0-d or 1-d (ndim = 0 or 1), but `u.ndim` need
-    not equal `v.ndim`. In other words, all four possible combinations -
-    ``u.ndim = v.ndim = 0``, ``u.ndim = v.ndim = 1``,
-    ``u.ndim = 1, v.ndim = 0``, and ``u.ndim = 0, v.ndim = 1`` - work.
-
-    Examples
-    --------
-    .. math:: \\frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25
-
-    >>> x = np.array([3.0, 5.0, 2.0])
-    >>> y = np.array([2.0, 1.0])
-    >>> np.polydiv(x, y)
-    (array([1.5 , 1.75]), array([0.25]))
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def ^{:doc ""} ERR_PRINT (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ERR_PRINT"))))
-
-(def modf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "modf"))))
-(alter-meta! #'modf assoc :doc "modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Return the fractional and integral parts of an array, element-wise.
-
-The fractional and integral parts are negative if the given number is
-negative.
-
-Parameters
-----------
-x : array_like
-    Input array.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y1 : ndarray
-    Fractional part of `x`.
-    This is a scalar if `x` is a scalar.
-y2 : ndarray
-    Integral part of `x`.
-    This is a scalar if `x` is a scalar.
-
-Notes
------
-For integer input the return values are floats.
-
-See Also
---------
-divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values
-         switched, except it always has a positive remainder.
-
-Examples
---------
->>> np.modf([0, 3.5])
-(array([ 0. ,  0.5]), array([ 0.,  3.]))
->>> np.modf(-0.5)
-(-0.5, -0)" :arglists '[[self & [args {:as kwargs}]]])
-
-(def busdaycalendar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "busdaycalendar"))))
-(alter-meta! #'busdaycalendar assoc :doc "busdaycalendar(weekmask='1111100', holidays=None)
-
-    A business day calendar object that efficiently stores information
-    defining valid days for the busday family of functions.
-
-    The default valid days are Monday through Friday (\"business days\").
-    A busdaycalendar object can be specified with any set of weekly
-    valid days, plus an optional \"holiday\" dates that always will be invalid.
-
-    Once a busdaycalendar object is created, the weekmask and holidays
-    cannot be modified.
-
-    .. versionadded:: 1.7.0
-
-    Parameters
-    ----------
-    weekmask : str or array_like of bool, optional
-        A seven-element array indicating which of Monday through Sunday are
-        valid days. May be specified as a length-seven list or array, like
-        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
-        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
-        weekdays, optionally separated by white space. Valid abbreviations
-        are: Mon Tue Wed Thu Fri Sat Sun
-    holidays : array_like of datetime64[D], optional
-        An array of dates to consider as invalid dates, no matter which
-        weekday they fall upon.  Holiday dates may be specified in any
-        order, and NaT (not-a-time) dates are ignored.  This list is
-        saved in a normalized form that is suited for fast calculations
-        of valid days.
-
-    Returns
-    -------
-    out : busdaycalendar
-        A business day calendar object containing the specified
-        weekmask and holidays values.
-
-    See Also
-    --------
-    is_busday : Returns a boolean array indicating valid days.
-    busday_offset : Applies an offset counted in valid days.
-    busday_count : Counts how many valid days are in a half-open date range.
-
-    Attributes
-    ----------
-    Note: once a busdaycalendar object is created, you cannot modify the
-    weekmask or holidays.  The attributes return copies of internal data.
-    weekmask : (copy) seven-element array of bool
-    holidays : (copy) sorted array of datetime64[D]
-
-    Examples
-    --------
-    >>> # Some important days in July
-    ... bdd = np.busdaycalendar(
-    ...             holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
-    >>> # Default is Monday to Friday weekdays
-    ... bdd.weekmask
-    array([ True,  True,  True,  True,  True, False, False])
-    >>> # Any holidays already on the weekend are removed
-    ... bdd.holidays
-    array(['2011-07-01', '2011-07-04'], dtype='datetime64[D]')" :arglists '[[self & [args {:as kwargs}]]])
-
-(def deg2rad (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "deg2rad"))))
-(alter-meta! #'deg2rad assoc :doc "deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Convert angles from degrees to radians.
-
-Parameters
-----------
-x : array_like
-    Angles in degrees.
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-y : ndarray
-    The corresponding angle in radians.
-    This is a scalar if `x` is a scalar.
-
-See Also
---------
-rad2deg : Convert angles from radians to degrees.
-unwrap : Remove large jumps in angle by wrapping.
-
-Notes
------
-.. versionadded:: 1.3.0
-
-``deg2rad(x)`` is ``x * pi / 180``.
-
-Examples
---------
->>> np.deg2rad(180)
-3.1415926535897931" :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc ""} FPE_UNDERFLOW (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "FPE_UNDERFLOW"))))
-
-(def longlong (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longlong"))))
-(alter-meta! #'longlong assoc :doc "Signed integer type, compatible with C ``long long``.
-    Character code: ``'q'``." :arglists '[[self & [args {:as kwargs}]]])
-
-(def ^{:doc " Distributor init file
-
-Distributors: you can add custom code here to support particular distributions
-of numpy.
-
-For example, this is a good place to put any checks for hardware requirements.
-
-The numpy standard source distribution will not put code in this file, so you
-can safely replace this file with your own version.
-"} _distributor_init (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_distributor_init"))))
-
-(def add_docstring (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add_docstring"))))
-(alter-meta! #'add_docstring assoc :doc "add_docstring(obj, docstring)
-
-    Add a docstring to a built-in obj if possible.
-    If the obj already has a docstring raise a RuntimeError
-    If this routine does not know how to add a docstring to the object
-    raise a TypeError" :arglists '[[self & [args {:as kwargs}]]])
-
-(def median (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "median"))))
-(alter-meta! #'median assoc :doc "
-    Compute the median along the specified axis.
-
-    Returns the median of the array elements.
-
-    Parameters
-    ----------
-    a : array_like
-        Input array or object that can be converted to an array.
-    axis : {int, sequence of int, None}, optional
-        Axis or axes along which the medians are computed. The default
-        is to compute the median along a flattened version of the array.
-        A sequence of axes is supported since version 1.9.0.
-    out : ndarray, optional
-        Alternative output array in which to place the result. It must
-        have the same shape and buffer length as the expected output,
-        but the type (of the output) will be cast if necessary.
-    overwrite_input : bool, optional
-       If True, then allow use of memory of input array `a` for
-       calculations. The input array will be modified by the call to
-       `median`. This will save memory when you do not need to preserve
-       the contents of the input array. Treat the input as undefined,
-       but it will probably be fully or partially sorted. Default is
-       False. If `overwrite_input` is ``True`` and `a` is not already an
-       `ndarray`, an error will be raised.
-    keepdims : bool, optional
-        If this is set to True, the axes which are reduced are left
-        in the result as dimensions with size one. With this option,
-        the result will broadcast correctly against the original `arr`.
-
-        .. versionadded:: 1.9.0
-
-    Returns
-    -------
-    median : ndarray
-        A new array holding the result. If the input contains integers
-        or floats smaller than ``float64``, then the output data-type is
-        ``np.float64``.  Otherwise, the data-type of the output is the
-        same as that of the input. If `out` is specified, that array is
-        returned instead.
-
-    See Also
-    --------
-    mean, percentile
-
-    Notes
-    -----
-    Given a vector ``V`` of length ``N``, the median of ``V`` is the
-    middle value of a sorted copy of ``V``, ``V_sorted`` - i
-    e., ``V_sorted[(N-1)/2]``, when ``N`` is odd, and the average of the
-    two middle values of ``V_sorted`` when ``N`` is even.
-
-    Examples
-    --------
-    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
-    >>> a
-    array([[10,  7,  4],
-           [ 3,  2,  1]])
-    >>> np.median(a)
-    3.5
-    >>> np.median(a, axis=0)
-    array([6.5, 4.5, 2.5])
-    >>> np.median(a, axis=1)
-    array([7.,  2.])
-    >>> m = np.median(a, axis=0)
-    >>> out = np.zeros_like(m)
-    >>> np.median(a, axis=0, out=m)
-    array([6.5,  4.5,  2.5])
-    >>> m
-    array([6.5,  4.5,  2.5])
-    >>> b = a.copy()
-    >>> np.median(b, axis=1, overwrite_input=True)
-    array([7.,  2.])
-    >>> assert not np.all(a==b)
-    >>> b = a.copy()
-    >>> np.median(b, axis=None, overwrite_input=True)
-    3.5
-    >>> assert not np.all(a==b)
-
-    " :arglists '[[& [args {:as kwargs}]]])
-
-(def bitwise_xor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_xor"))))
-(alter-meta! #'bitwise_xor assoc :doc "bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
-
-Compute the bit-wise XOR of two arrays element-wise.
-
-Computes the bit-wise XOR of the underlying binary representation of
-the integers in the input arrays. This ufunc implements the C/Python
-operator ``^``.
-
-Parameters
-----------
-x1, x2 : array_like
-    Only integer and boolean types are handled. If ``x1.shape != x2.shape``, they must be broadcastable to a common shape (which becomes the shape of the output).
-out : ndarray, None, or tuple of ndarray and None, optional
-    A location into which the result is stored. If provided, it must have
-    a shape that the inputs broadcast to. If not provided or None,
-    a freshly-allocated array is returned. A tuple (possible only as a
-    keyword argument) must have length equal to the number of outputs.
-where : array_like, optional
-    This condition is broadcast over the input. At locations where the
-    condition is True, the `out` array will be set to the ufunc result.
-    Elsewhere, the `out` array will retain its original value.
-    Note that if an uninitialized `out` array is created via the default
-    ``out=None``, locations within it where the condition is False will
-    remain uninitialized.
-**kwargs
-    For other keyword-only arguments, see the
-    :ref:`ufunc docs <ufuncs.kwargs>`.
-
-Returns
--------
-out : ndarray or scalar
-    Result.
-    This is a scalar if both `x1` and `x2` are scalars.
-
-See Also
---------
-logical_xor
-bitwise_and
-bitwise_or
-binary_repr :
-    Return the binary representation of the input number as a string.
-
-Examples
---------
-The number 13 is represented by ``00001101``. Likewise, 17 is
-represented by ``00010001``.  The bit-wise XOR of 13 and 17 is
-therefore ``00011100``, or 28:
-
->>> np.bitwise_xor(13, 17)
-28
->>> np.binary_repr(28)
-'11100'
-
->>> np.bitwise_xor(31, 5)
-26
->>> np.bitwise_xor([31,3], 5)
-array([26,  6])
-
->>> np.bitwise_xor([31,3], [5,6])
-array([26,  5])
->>> np.bitwise_xor([True, True], [False, True])
-array([ True, False])" :arglists '[[self & [args {:as kwargs}]]])
\ No newline at end of file

From 9939ccfacdf35c4bed7658a89d6794040f3b5b36 Mon Sep 17 00:00:00 2001
From: Stephen Hopper <stephenmhopper@gmail.com>
Date: Thu, 20 May 2021 09:43:47 -0500
Subject: [PATCH 341/456] Add codegen handling for infinity and NaN values.
 Make generic codegen method a bit cleaner. (#166)

---
 src/libpython_clj2/codegen.clj | 39 +++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/src/libpython_clj2/codegen.clj b/src/libpython_clj2/codegen.clj
index 4aa0e4b..7f0ea7b 100644
--- a/src/libpython_clj2/codegen.clj
+++ b/src/libpython_clj2/codegen.clj
@@ -64,29 +64,28 @@
                   (get-docs v)
                   (:arglists v))))
 
-
 (defn- output-module-generic
   [^Writer writer clj-name k v vv]
-  (if (or (number? vv)
-          (string? vv)
-          (boolean? vv)
-          (nil? vv))
-        (.write writer
-            (format "
-
-(def ^{:doc \"%s\"} %s %s)"
-                    (get-docs v)
-                    clj-name
-                    (if (string? vv)
-                      (format "\"%s\"" vv)
-                      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\"" 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 "
-
-(def ^{:doc \"%s\"} %s (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* \"%s\"))))"
-                    (get-docs v)
-                    clj-name
-                    k))))
+      (format "\n\n(def ^{:doc \"%s\"} %s %s)"
+        (get-docs v)
+        clj-name
+        output-value))))
 
 
 (def ^:no-doc default-exclude

From f940515d6fda4e464d66c58521a4c471f1ed4fdc Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Fri, 21 May 2021 09:05:03 -0400
Subject: [PATCH 342/456] fix py. macro for go and go-loop (#168)

---
 src/libpython_clj2/python.clj | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index bb2c4f0..f0a35a1 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -490,8 +490,10 @@ user> (py/call-attr inst \"addarg\" 10)
 (defmacro py.
   "Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
   is equivalent to Python's obj.method(arg1, arg2, ..., argN) syntax."
-  [x & args]
-  (list* (into (vector #'$a x) args)))
+  [x method-name & args]
+  ;; method-name cast to a string specifically for go and go-loop
+  ;; compatability
+  `(~#'$a ~x ~(str method-name) ~@args))
 
 
 (defmacro py*

From 2ad435bac20fbe488c5defcf97313887403dda5a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 21 May 2021 07:08:37 -0600
Subject: [PATCH 343/456] 2.00-beta-20

---
 deps.edn                                 |     2 +-
 docs/Usage.html                          |     2 +-
 docs/design.html                         |     2 +-
 docs/embedded.html                       |     2 +-
 docs/environments.html                   |     2 +-
 docs/index.html                          |     2 +-
 docs/libpython-clj2.codegen.html         |     4 +-
 docs/libpython-clj2.embedded.html        |     2 +-
 docs/libpython-clj2.python.html          |    10 +-
 docs/libpython-clj2.python.np-array.html |     2 +-
 docs/libpython-clj2.require.html         |     2 +-
 docs/new-to-clojure.html                 |     2 +-
 docs/python.builtins.html                |   151 -
 docs/python.numpy.html                   | 12587 ---------------------
 docs/scopes-and-gc.html                  |     2 +-
 docs/slicing.html                        |     2 +-
 16 files changed, 19 insertions(+), 12757 deletions(-)
 delete mode 100644 docs/python.builtins.html
 delete mode 100644 docs/python.numpy.html

diff --git a/deps.edn b/deps.edn
index d2be636..0b48830 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-20-SNAPSHOT"
+                        :version "2.00-beta-20"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 13c3f2c..3fd76a0 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 59c436a..bf1fd69 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index b8c830b..2a6b4dd 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index c2a6608..16d9c5c 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index f9197ed..b55524c 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-19</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div><div class="namespace"><h3><a href="python.builtins.html">python.builtins</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.builtins.html#var-__build_class__">__build_class__</a> </li><li> <a href="python.builtins.html#var-__debug__">__debug__</a> </li><li> <a href="python.builtins.html#var-__doc__">__doc__</a> </li><li> <a href="python.builtins.html#var-__import__">__import__</a> </li><li> <a href="python.builtins.html#var-__loader__">__loader__</a> </li><li> <a href="python.builtins.html#var-__name__">__name__</a> </li><li> <a href="python.builtins.html#var-__package__">__package__</a> </li><li> <a href="python.builtins.html#var-__spec__">__spec__</a> </li><li> <a href="python.builtins.html#var-abs">abs</a> </li><li> <a href="python.builtins.html#var-all">all</a> </li><li> <a href="python.builtins.html#var-any">any</a> </li><li> <a href="python.builtins.html#var-ArithmeticError">ArithmeticError</a> </li><li> <a href="python.builtins.html#var-ascii">ascii</a> </li><li> <a href="python.builtins.html#var-AttributeError">AttributeError</a> </li><li> <a href="python.builtins.html#var-BaseException">BaseException</a> </li><li> <a href="python.builtins.html#var-bin">bin</a> </li><li> <a href="python.builtins.html#var-BlockingIOError">BlockingIOError</a> </li><li> <a href="python.builtins.html#var-bool">bool</a> </li><li> <a href="python.builtins.html#var-breakpoint">breakpoint</a> </li><li> <a href="python.builtins.html#var-BrokenPipeError">BrokenPipeError</a> </li><li> <a href="python.builtins.html#var-BufferError">BufferError</a> </li><li> <a href="python.builtins.html#var-bytearray">bytearray</a> </li><li> <a href="python.builtins.html#var-bytes">bytes</a> </li><li> <a href="python.builtins.html#var-BytesWarning">BytesWarning</a> </li><li> <a href="python.builtins.html#var-callable">callable</a> </li><li> <a href="python.builtins.html#var-ChildProcessError">ChildProcessError</a> </li><li> <a href="python.builtins.html#var-chr">chr</a> </li><li> <a href="python.builtins.html#var-classmethod">classmethod</a> </li><li> <a href="python.builtins.html#var-compile">compile</a> </li><li> <a href="python.builtins.html#var-complex">complex</a> </li><li> <a href="python.builtins.html#var-ConnectionAbortedError">ConnectionAbortedError</a> </li><li> <a href="python.builtins.html#var-ConnectionError">ConnectionError</a> </li><li> <a href="python.builtins.html#var-ConnectionRefusedError">ConnectionRefusedError</a> </li><li> <a href="python.builtins.html#var-ConnectionResetError">ConnectionResetError</a> </li><li> <a href="python.builtins.html#var-copyright">copyright</a> </li><li> <a href="python.builtins.html#var-credits">credits</a> </li><li> <a href="python.builtins.html#var-delattr">delattr</a> </li><li> <a href="python.builtins.html#var-DeprecationWarning">DeprecationWarning</a> </li><li> <a href="python.builtins.html#var-dict">dict</a> </li><li> <a href="python.builtins.html#var-dir">dir</a> </li><li> <a href="python.builtins.html#var-divmod">divmod</a> </li><li> <a href="python.builtins.html#var-Ellipsis">Ellipsis</a> </li><li> <a href="python.builtins.html#var-enumerate">enumerate</a> </li><li> <a href="python.builtins.html#var-EnvironmentError">EnvironmentError</a> </li><li> <a href="python.builtins.html#var-EOFError">EOFError</a> </li><li> <a href="python.builtins.html#var-eval">eval</a> </li><li> <a href="python.builtins.html#var-exec">exec</a> </li><li> <a href="python.builtins.html#var-exit">exit</a> </li><li> <a href="python.builtins.html#var-FileExistsError">FileExistsError</a> </li><li> <a href="python.builtins.html#var-FileNotFoundError">FileNotFoundError</a> </li><li> <a href="python.builtins.html#var-filter">filter</a> </li><li> <a href="python.builtins.html#var-float">float</a> </li><li> <a href="python.builtins.html#var-FloatingPointError">FloatingPointError</a> </li><li> <a href="python.builtins.html#var-format">format</a> </li><li> <a href="python.builtins.html#var-frozenset">frozenset</a> </li><li> <a href="python.builtins.html#var-FutureWarning">FutureWarning</a> </li><li> <a href="python.builtins.html#var-GeneratorExit">GeneratorExit</a> </li><li> <a href="python.builtins.html#var-getattr">getattr</a> </li><li> <a href="python.builtins.html#var-globals">globals</a> </li><li> <a href="python.builtins.html#var-hasattr">hasattr</a> </li><li> <a href="python.builtins.html#var-hash">hash</a> </li><li> <a href="python.builtins.html#var-help">help</a> </li><li> <a href="python.builtins.html#var-hex">hex</a> </li><li> <a href="python.builtins.html#var-id">id</a> </li><li> <a href="python.builtins.html#var-ImportError">ImportError</a> </li><li> <a href="python.builtins.html#var-ImportWarning">ImportWarning</a> </li><li> <a href="python.builtins.html#var-IndentationError">IndentationError</a> </li><li> <a href="python.builtins.html#var-IndexError">IndexError</a> </li><li> <a href="python.builtins.html#var-input">input</a> </li><li> <a href="python.builtins.html#var-int">int</a> </li><li> <a href="python.builtins.html#var-InterruptedError">InterruptedError</a> </li><li> <a href="python.builtins.html#var-IOError">IOError</a> </li><li> <a href="python.builtins.html#var-IsADirectoryError">IsADirectoryError</a> </li><li> <a href="python.builtins.html#var-isinstance">isinstance</a> </li><li> <a href="python.builtins.html#var-issubclass">issubclass</a> </li><li> <a href="python.builtins.html#var-iter">iter</a> </li><li> <a href="python.builtins.html#var-KeyboardInterrupt">KeyboardInterrupt</a> </li><li> <a href="python.builtins.html#var-KeyError">KeyError</a> </li><li> <a href="python.builtins.html#var-len">len</a> </li><li> <a href="python.builtins.html#var-license">license</a> </li><li> <a href="python.builtins.html#var-list">list</a> </li><li> <a href="python.builtins.html#var-locals">locals</a> </li><li> <a href="python.builtins.html#var-LookupError">LookupError</a> </li><li> <a href="python.builtins.html#var-map">map</a> </li><li> <a href="python.builtins.html#var-max">max</a> </li><li> <a href="python.builtins.html#var-MemoryError">MemoryError</a> </li><li> <a href="python.builtins.html#var-memoryview">memoryview</a> </li><li> <a href="python.builtins.html#var-min">min</a> </li><li> <a href="python.builtins.html#var-ModuleNotFoundError">ModuleNotFoundError</a> </li><li> <a href="python.builtins.html#var-NameError">NameError</a> </li><li> <a href="python.builtins.html#var-next">next</a> </li><li> <a href="python.builtins.html#var-NotADirectoryError">NotADirectoryError</a> </li><li> <a href="python.builtins.html#var-NotImplemented">NotImplemented</a> </li><li> <a href="python.builtins.html#var-NotImplementedError">NotImplementedError</a> </li><li> <a href="python.builtins.html#var-object">object</a> </li><li> <a href="python.builtins.html#var-oct">oct</a> </li><li> <a href="python.builtins.html#var-open">open</a> </li><li> <a href="python.builtins.html#var-ord">ord</a> </li><li> <a href="python.builtins.html#var-OSError">OSError</a> </li><li> <a href="python.builtins.html#var-OverflowError">OverflowError</a> </li><li> <a href="python.builtins.html#var-PendingDeprecationWarning">PendingDeprecationWarning</a> </li><li> <a href="python.builtins.html#var-PermissionError">PermissionError</a> </li><li> <a href="python.builtins.html#var-pow">pow</a> </li><li> <a href="python.builtins.html#var-print">print</a> </li><li> <a href="python.builtins.html#var-ProcessLookupError">ProcessLookupError</a> </li><li> <a href="python.builtins.html#var-property">property</a> </li><li> <a href="python.builtins.html#var-PyAssertionError">PyAssertionError</a> </li><li> <a href="python.builtins.html#var-PyException">PyException</a> </li><li> <a href="python.builtins.html#var-quit">quit</a> </li><li> <a href="python.builtins.html#var-range">range</a> </li><li> <a href="python.builtins.html#var-RecursionError">RecursionError</a> </li><li> <a href="python.builtins.html#var-ReferenceError">ReferenceError</a> </li><li> <a href="python.builtins.html#var-repr">repr</a> </li><li> <a href="python.builtins.html#var-ResourceWarning">ResourceWarning</a> </li><li> <a href="python.builtins.html#var-reversed">reversed</a> </li><li> <a href="python.builtins.html#var-round">round</a> </li><li> <a href="python.builtins.html#var-RuntimeError">RuntimeError</a> </li><li> <a href="python.builtins.html#var-RuntimeWarning">RuntimeWarning</a> </li><li> <a href="python.builtins.html#var-set">set</a> </li><li> <a href="python.builtins.html#var-setattr">setattr</a> </li><li> <a href="python.builtins.html#var-slice">slice</a> </li><li> <a href="python.builtins.html#var-sorted">sorted</a> </li><li> <a href="python.builtins.html#var-staticmethod">staticmethod</a> </li><li> <a href="python.builtins.html#var-StopAsyncIteration">StopAsyncIteration</a> </li><li> <a href="python.builtins.html#var-StopIteration">StopIteration</a> </li><li> <a href="python.builtins.html#var-str">str</a> </li><li> <a href="python.builtins.html#var-sum">sum</a> </li><li> <a href="python.builtins.html#var-super">super</a> </li><li> <a href="python.builtins.html#var-SyntaxError">SyntaxError</a> </li><li> <a href="python.builtins.html#var-SyntaxWarning">SyntaxWarning</a> </li><li> <a href="python.builtins.html#var-SystemError">SystemError</a> </li><li> <a href="python.builtins.html#var-SystemExit">SystemExit</a> </li><li> <a href="python.builtins.html#var-TabError">TabError</a> </li><li> <a href="python.builtins.html#var-TimeoutError">TimeoutError</a> </li><li> <a href="python.builtins.html#var-True">True</a> </li><li> <a href="python.builtins.html#var-tuple">tuple</a> </li><li> <a href="python.builtins.html#var-type">type</a> </li><li> <a href="python.builtins.html#var-TypeError">TypeError</a> </li><li> <a href="python.builtins.html#var-UnboundLocalError">UnboundLocalError</a> </li><li> <a href="python.builtins.html#var-UnicodeDecodeError">UnicodeDecodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeEncodeError">UnicodeEncodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeError">UnicodeError</a> </li><li> <a href="python.builtins.html#var-UnicodeTranslateError">UnicodeTranslateError</a> </li><li> <a href="python.builtins.html#var-UnicodeWarning">UnicodeWarning</a> </li><li> <a href="python.builtins.html#var-UserWarning">UserWarning</a> </li><li> <a href="python.builtins.html#var-ValueError">ValueError</a> </li><li> <a href="python.builtins.html#var-vars">vars</a> </li><li> <a href="python.builtins.html#var-Warning">Warning</a> </li><li> <a href="python.builtins.html#var-ZeroDivisionError">ZeroDivisionError</a> </li><li> <a href="python.builtins.html#var-zip">zip</a> </li></ul></div></div><div class="namespace"><h3><a href="python.numpy.html">python.numpy</a></h3><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="python.numpy.html#var-__all__">__all__</a> </li><li> <a href="python.numpy.html#var-__builtins__">__builtins__</a> </li><li> <a href="python.numpy.html#var-__cached__">__cached__</a> </li><li> <a href="python.numpy.html#var-__config__">__config__</a> </li><li> <a href="python.numpy.html#var-__dir__">__dir__</a> </li><li> <a href="python.numpy.html#var-__doc__">__doc__</a> </li><li> <a href="python.numpy.html#var-__file__">__file__</a> </li><li> <a href="python.numpy.html#var-__getattr__">__getattr__</a> </li><li> <a href="python.numpy.html#var-__git_revision__">__git_revision__</a> </li><li> <a href="python.numpy.html#var-__loader__">__loader__</a> </li><li> <a href="python.numpy.html#var-__name__">__name__</a> </li><li> <a href="python.numpy.html#var-__package__">__package__</a> </li><li> <a href="python.numpy.html#var-__path__">__path__</a> </li><li> <a href="python.numpy.html#var-__spec__">__spec__</a> </li><li> <a href="python.numpy.html#var-__version__">__version__</a> </li><li> <a href="python.numpy.html#var-_add_newdoc_ufunc">_add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-_distributor_init">_distributor_init</a> </li><li> <a href="python.numpy.html#var-_globals">_globals</a> </li><li> <a href="python.numpy.html#var-_mat">_mat</a> </li><li> <a href="python.numpy.html#var-_NoValue">_NoValue</a> </li><li> <a href="python.numpy.html#var-_pytesttester">_pytesttester</a> </li><li> <a href="python.numpy.html#var-_UFUNC_API">_UFUNC_API</a> </li><li> <a href="python.numpy.html#var-abs">abs</a> </li><li> <a href="python.numpy.html#var-absolute">absolute</a> </li><li> <a href="python.numpy.html#var-absolute_import">absolute_import</a> </li><li> <a href="python.numpy.html#var-add">add</a> </li><li> <a href="python.numpy.html#var-add_docstring">add_docstring</a> </li><li> <a href="python.numpy.html#var-add_newdoc">add_newdoc</a> </li><li> <a href="python.numpy.html#var-add_newdoc_ufunc">add_newdoc_ufunc</a> </li><li> <a href="python.numpy.html#var-alen">alen</a> </li><li> <a href="python.numpy.html#var-all">all</a> </li><li> <a href="python.numpy.html#var-allclose">allclose</a> </li><li> <a href="python.numpy.html#var-ALLOW_THREADS">ALLOW_THREADS</a> </li><li> <a href="python.numpy.html#var-alltrue">alltrue</a> </li><li> <a href="python.numpy.html#var-amax">amax</a> </li><li> <a href="python.numpy.html#var-amin">amin</a> </li><li> <a href="python.numpy.html#var-angle">angle</a> </li><li> <a href="python.numpy.html#var-any">any</a> </li><li> <a href="python.numpy.html#var-append">append</a> </li><li> <a href="python.numpy.html#var-apply_along_axis">apply_along_axis</a> </li><li> <a href="python.numpy.html#var-apply_over_axes">apply_over_axes</a> </li><li> <a href="python.numpy.html#var-arange">arange</a> </li><li> <a href="python.numpy.html#var-arccos">arccos</a> </li><li> <a href="python.numpy.html#var-arccosh">arccosh</a> </li><li> <a href="python.numpy.html#var-arcsin">arcsin</a> </li><li> <a href="python.numpy.html#var-arcsinh">arcsinh</a> </li><li> <a href="python.numpy.html#var-arctan">arctan</a> </li><li> <a href="python.numpy.html#var-arctan2">arctan2</a> </li><li> <a href="python.numpy.html#var-arctanh">arctanh</a> </li><li> <a href="python.numpy.html#var-argmax">argmax</a> </li><li> <a href="python.numpy.html#var-argmin">argmin</a> </li><li> <a href="python.numpy.html#var-argpartition">argpartition</a> </li><li> <a href="python.numpy.html#var-argsort">argsort</a> </li><li> <a href="python.numpy.html#var-argwhere">argwhere</a> </li><li> <a href="python.numpy.html#var-around">around</a> </li><li> <a href="python.numpy.html#var-array">array</a> </li><li> <a href="python.numpy.html#var-array2string">array2string</a> </li><li> <a href="python.numpy.html#var-array_equal">array_equal</a> </li><li> <a href="python.numpy.html#var-array_equiv">array_equiv</a> </li><li> <a href="python.numpy.html#var-array_repr">array_repr</a> </li><li> <a href="python.numpy.html#var-array_split">array_split</a> </li><li> <a href="python.numpy.html#var-array_str">array_str</a> </li><li> <a href="python.numpy.html#var-asanyarray">asanyarray</a> </li><li> <a href="python.numpy.html#var-asarray">asarray</a> </li><li> <a href="python.numpy.html#var-asarray_chkfinite">asarray_chkfinite</a> </li><li> <a href="python.numpy.html#var-ascontiguousarray">ascontiguousarray</a> </li><li> <a href="python.numpy.html#var-asfarray">asfarray</a> </li><li> <a href="python.numpy.html#var-asfortranarray">asfortranarray</a> </li><li> <a href="python.numpy.html#var-asmatrix">asmatrix</a> </li><li> <a href="python.numpy.html#var-asscalar">asscalar</a> </li><li> <a href="python.numpy.html#var-atleast_1d">atleast_1d</a> </li><li> <a href="python.numpy.html#var-atleast_2d">atleast_2d</a> </li><li> <a href="python.numpy.html#var-atleast_3d">atleast_3d</a> </li><li> <a href="python.numpy.html#var-average">average</a> </li><li> <a href="python.numpy.html#var-AxisError">AxisError</a> </li><li> <a href="python.numpy.html#var-bartlett">bartlett</a> </li><li> <a href="python.numpy.html#var-base_repr">base_repr</a> </li><li> <a href="python.numpy.html#var-binary_repr">binary_repr</a> </li><li> <a href="python.numpy.html#var-bincount">bincount</a> </li><li> <a href="python.numpy.html#var-bitwise_and">bitwise_and</a> </li><li> <a href="python.numpy.html#var-bitwise_not">bitwise_not</a> </li><li> <a href="python.numpy.html#var-bitwise_or">bitwise_or</a> </li><li> <a href="python.numpy.html#var-bitwise_xor">bitwise_xor</a> </li><li> <a href="python.numpy.html#var-blackman">blackman</a> </li><li> <a href="python.numpy.html#var-block">block</a> </li><li> <a href="python.numpy.html#var-bmat">bmat</a> </li><li> <a href="python.numpy.html#var-bool">bool</a> </li><li> <a href="python.numpy.html#var-bool8">bool8</a> </li><li> <a href="python.numpy.html#var-bool_">bool_</a> </li><li> <a href="python.numpy.html#var-broadcast">broadcast</a> </li><li> <a href="python.numpy.html#var-broadcast_arrays">broadcast_arrays</a> </li><li> <a href="python.numpy.html#var-broadcast_to">broadcast_to</a> </li><li> <a href="python.numpy.html#var-BUFSIZE">BUFSIZE</a> </li><li> <a href="python.numpy.html#var-busday_count">busday_count</a> </li><li> <a href="python.numpy.html#var-busday_offset">busday_offset</a> </li><li> <a href="python.numpy.html#var-busdaycalendar">busdaycalendar</a> </li><li> <a href="python.numpy.html#var-byte">byte</a> </li><li> <a href="python.numpy.html#var-byte_bounds">byte_bounds</a> </li><li> <a href="python.numpy.html#var-bytes0">bytes0</a> </li><li> <a href="python.numpy.html#var-bytes_">bytes_</a> </li><li> <a href="python.numpy.html#var-c_">c_</a> </li><li> <a href="python.numpy.html#var-can_cast">can_cast</a> </li><li> <a href="python.numpy.html#var-cast">cast</a> </li><li> <a href="python.numpy.html#var-cbrt">cbrt</a> </li><li> <a href="python.numpy.html#var-cdouble">cdouble</a> </li><li> <a href="python.numpy.html#var-ceil">ceil</a> </li><li> <a href="python.numpy.html#var-cfloat">cfloat</a> </li><li> <a href="python.numpy.html#var-char">char</a> </li><li> <a href="python.numpy.html#var-character">character</a> </li><li> <a href="python.numpy.html#var-chararray">chararray</a> </li><li> <a href="python.numpy.html#var-choose">choose</a> </li><li> <a href="python.numpy.html#var-CLIP">CLIP</a> </li><li> <a href="python.numpy.html#var-clip">clip</a> </li><li> <a href="python.numpy.html#var-clongdouble">clongdouble</a> </li><li> <a href="python.numpy.html#var-clongfloat">clongfloat</a> </li><li> <a href="python.numpy.html#var-column_stack">column_stack</a> </li><li> <a href="python.numpy.html#var-common_type">common_type</a> </li><li> <a href="python.numpy.html#var-compare_chararrays">compare_chararrays</a> </li><li> <a href="python.numpy.html#var-compat">compat</a> </li><li> <a href="python.numpy.html#var-complex">complex</a> </li><li> <a href="python.numpy.html#var-complex128">complex128</a> </li><li> <a href="python.numpy.html#var-complex256">complex256</a> </li><li> <a href="python.numpy.html#var-complex64">complex64</a> </li><li> <a href="python.numpy.html#var-complex_">complex_</a> </li><li> <a href="python.numpy.html#var-complexfloating">complexfloating</a> </li><li> <a href="python.numpy.html#var-ComplexWarning">ComplexWarning</a> </li><li> <a href="python.numpy.html#var-compress">compress</a> </li><li> <a href="python.numpy.html#var-concatenate">concatenate</a> </li><li> <a href="python.numpy.html#var-conj">conj</a> </li><li> <a href="python.numpy.html#var-conjugate">conjugate</a> </li><li> <a href="python.numpy.html#var-convolve">convolve</a> </li><li> <a href="python.numpy.html#var-copy">copy</a> </li><li> <a href="python.numpy.html#var-copysign">copysign</a> </li><li> <a href="python.numpy.html#var-copyto">copyto</a> </li><li> <a href="python.numpy.html#var-core">core</a> </li><li> <a href="python.numpy.html#var-corrcoef">corrcoef</a> </li><li> <a href="python.numpy.html#var-correlate">correlate</a> </li><li> <a href="python.numpy.html#var-cos">cos</a> </li><li> <a href="python.numpy.html#var-cosh">cosh</a> </li><li> <a href="python.numpy.html#var-count_nonzero">count_nonzero</a> </li><li> <a href="python.numpy.html#var-cov">cov</a> </li><li> <a href="python.numpy.html#var-cross">cross</a> </li><li> <a href="python.numpy.html#var-csingle">csingle</a> </li><li> <a href="python.numpy.html#var-ctypeslib">ctypeslib</a> </li><li> <a href="python.numpy.html#var-cumprod">cumprod</a> </li><li> <a href="python.numpy.html#var-cumproduct">cumproduct</a> </li><li> <a href="python.numpy.html#var-cumsum">cumsum</a> </li><li> <a href="python.numpy.html#var-DataSource">DataSource</a> </li><li> <a href="python.numpy.html#var-datetime64">datetime64</a> </li><li> <a href="python.numpy.html#var-datetime_as_string">datetime_as_string</a> </li><li> <a href="python.numpy.html#var-datetime_data">datetime_data</a> </li><li> <a href="python.numpy.html#var-deg2rad">deg2rad</a> </li><li> <a href="python.numpy.html#var-degrees">degrees</a> </li><li> <a href="python.numpy.html#var-delete">delete</a> </li><li> <a href="python.numpy.html#var-deprecate">deprecate</a> </li><li> <a href="python.numpy.html#var-deprecate_with_doc">deprecate_with_doc</a> </li><li> <a href="python.numpy.html#var-diag">diag</a> </li><li> <a href="python.numpy.html#var-diag_indices">diag_indices</a> </li><li> <a href="python.numpy.html#var-diag_indices_from">diag_indices_from</a> </li><li> <a href="python.numpy.html#var-diagflat">diagflat</a> </li><li> <a href="python.numpy.html#var-diagonal">diagonal</a> </li><li> <a href="python.numpy.html#var-diff">diff</a> </li><li> <a href="python.numpy.html#var-digitize">digitize</a> </li><li> <a href="python.numpy.html#var-disp">disp</a> </li><li> <a href="python.numpy.html#var-divide">divide</a> </li><li> <a href="python.numpy.html#var-division">division</a> </li><li> <a href="python.numpy.html#var-divmod">divmod</a> </li><li> <a href="python.numpy.html#var-dot">dot</a> </li><li> <a href="python.numpy.html#var-double">double</a> </li><li> <a href="python.numpy.html#var-dsplit">dsplit</a> </li><li> <a href="python.numpy.html#var-dstack">dstack</a> </li><li> <a href="python.numpy.html#var-dtype">dtype</a> </li><li> <a href="python.numpy.html#var-e">e</a> </li><li> <a href="python.numpy.html#var-ediff1d">ediff1d</a> </li><li> <a href="python.numpy.html#var-einsum">einsum</a> </li><li> <a href="python.numpy.html#var-einsum_path">einsum_path</a> </li><li> <a href="python.numpy.html#var-emath">emath</a> </li><li> <a href="python.numpy.html#var-empty">empty</a> </li><li> <a href="python.numpy.html#var-empty_like">empty_like</a> </li><li> <a href="python.numpy.html#var-equal">equal</a> </li><li> <a href="python.numpy.html#var-ERR_CALL">ERR_CALL</a> </li><li> <a href="python.numpy.html#var-ERR_DEFAULT">ERR_DEFAULT</a> </li><li> <a href="python.numpy.html#var-ERR_IGNORE">ERR_IGNORE</a> </li><li> <a href="python.numpy.html#var-ERR_LOG">ERR_LOG</a> </li><li> <a href="python.numpy.html#var-ERR_PRINT">ERR_PRINT</a> </li><li> <a href="python.numpy.html#var-ERR_RAISE">ERR_RAISE</a> </li><li> <a href="python.numpy.html#var-ERR_WARN">ERR_WARN</a> </li><li> <a href="python.numpy.html#var-errstate">errstate</a> </li><li> <a href="python.numpy.html#var-euler_gamma">euler_gamma</a> </li><li> <a href="python.numpy.html#var-exp">exp</a> </li><li> <a href="python.numpy.html#var-exp2">exp2</a> </li><li> <a href="python.numpy.html#var-expand_dims">expand_dims</a> </li><li> <a href="python.numpy.html#var-expm1">expm1</a> </li><li> <a href="python.numpy.html#var-extract">extract</a> </li><li> <a href="python.numpy.html#var-eye">eye</a> </li><li> <a href="python.numpy.html#var-fabs">fabs</a> </li><li> <a href="python.numpy.html#var-fastCopyAndTranspose">fastCopyAndTranspose</a> </li><li> <a href="python.numpy.html#var-fft">fft</a> </li><li> <a href="python.numpy.html#var-fill_diagonal">fill_diagonal</a> </li><li> <a href="python.numpy.html#var-find_common_type">find_common_type</a> </li><li> <a href="python.numpy.html#var-finfo">finfo</a> </li><li> <a href="python.numpy.html#var-fix">fix</a> </li><li> <a href="python.numpy.html#var-flatiter">flatiter</a> </li><li> <a href="python.numpy.html#var-flatnonzero">flatnonzero</a> </li><li> <a href="python.numpy.html#var-flexible">flexible</a> </li><li> <a href="python.numpy.html#var-flip">flip</a> </li><li> <a href="python.numpy.html#var-fliplr">fliplr</a> </li><li> <a href="python.numpy.html#var-flipud">flipud</a> </li><li> <a href="python.numpy.html#var-float">float</a> </li><li> <a href="python.numpy.html#var-float128">float128</a> </li><li> <a href="python.numpy.html#var-float16">float16</a> </li><li> <a href="python.numpy.html#var-float32">float32</a> </li><li> <a href="python.numpy.html#var-float64">float64</a> </li><li> <a href="python.numpy.html#var-float_">float_</a> </li><li> <a href="python.numpy.html#var-float_power">float_power</a> </li><li> <a href="python.numpy.html#var-floating">floating</a> </li><li> <a href="python.numpy.html#var-FLOATING_POINT_SUPPORT">FLOATING_POINT_SUPPORT</a> </li><li> <a href="python.numpy.html#var-floor">floor</a> </li><li> <a href="python.numpy.html#var-floor_divide">floor_divide</a> </li><li> <a href="python.numpy.html#var-fmax">fmax</a> </li><li> <a href="python.numpy.html#var-fmin">fmin</a> </li><li> <a href="python.numpy.html#var-fmod">fmod</a> </li><li> <a href="python.numpy.html#var-format_float_positional">format_float_positional</a> </li><li> <a href="python.numpy.html#var-format_float_scientific">format_float_scientific</a> </li><li> <a href="python.numpy.html#var-format_parser">format_parser</a> </li><li> <a href="python.numpy.html#var-FPE_DIVIDEBYZERO">FPE_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-FPE_INVALID">FPE_INVALID</a> </li><li> <a href="python.numpy.html#var-FPE_OVERFLOW">FPE_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-FPE_UNDERFLOW">FPE_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-frexp">frexp</a> </li><li> <a href="python.numpy.html#var-frombuffer">frombuffer</a> </li><li> <a href="python.numpy.html#var-fromfile">fromfile</a> </li><li> <a href="python.numpy.html#var-fromfunction">fromfunction</a> </li><li> <a href="python.numpy.html#var-fromiter">fromiter</a> </li><li> <a href="python.numpy.html#var-frompyfunc">frompyfunc</a> </li><li> <a href="python.numpy.html#var-fromregex">fromregex</a> </li><li> <a href="python.numpy.html#var-fromstring">fromstring</a> </li><li> <a href="python.numpy.html#var-full">full</a> </li><li> <a href="python.numpy.html#var-full_like">full_like</a> </li><li> <a href="python.numpy.html#var-fv">fv</a> </li><li> <a href="python.numpy.html#var-gcd">gcd</a> </li><li> <a href="python.numpy.html#var-generic">generic</a> </li><li> <a href="python.numpy.html#var-genfromtxt">genfromtxt</a> </li><li> <a href="python.numpy.html#var-geomspace">geomspace</a> </li><li> <a href="python.numpy.html#var-get_array_wrap">get_array_wrap</a> </li><li> <a href="python.numpy.html#var-get_include">get_include</a> </li><li> <a href="python.numpy.html#var-get_printoptions">get_printoptions</a> </li><li> <a href="python.numpy.html#var-getbufsize">getbufsize</a> </li><li> <a href="python.numpy.html#var-geterr">geterr</a> </li><li> <a href="python.numpy.html#var-geterrcall">geterrcall</a> </li><li> <a href="python.numpy.html#var-geterrobj">geterrobj</a> </li><li> <a href="python.numpy.html#var-gradient">gradient</a> </li><li> <a href="python.numpy.html#var-greater">greater</a> </li><li> <a href="python.numpy.html#var-greater_equal">greater_equal</a> </li><li> <a href="python.numpy.html#var-half">half</a> </li><li> <a href="python.numpy.html#var-hamming">hamming</a> </li><li> <a href="python.numpy.html#var-hanning">hanning</a> </li><li> <a href="python.numpy.html#var-heaviside">heaviside</a> </li><li> <a href="python.numpy.html#var-histogram">histogram</a> </li><li> <a href="python.numpy.html#var-histogram2d">histogram2d</a> </li><li> <a href="python.numpy.html#var-histogram_bin_edges">histogram_bin_edges</a> </li><li> <a href="python.numpy.html#var-histogramdd">histogramdd</a> </li><li> <a href="python.numpy.html#var-hsplit">hsplit</a> </li><li> <a href="python.numpy.html#var-hstack">hstack</a> </li><li> <a href="python.numpy.html#var-hypot">hypot</a> </li><li> <a href="python.numpy.html#var-i0">i0</a> </li><li> <a href="python.numpy.html#var-identity">identity</a> </li><li> <a href="python.numpy.html#var-iinfo">iinfo</a> </li><li> <a href="python.numpy.html#var-imag">imag</a> </li><li> <a href="python.numpy.html#var-in1d">in1d</a> </li><li> <a href="python.numpy.html#var-index_exp">index_exp</a> </li><li> <a href="python.numpy.html#var-indices">indices</a> </li><li> <a href="python.numpy.html#var-inexact">inexact</a> </li><li> <a href="python.numpy.html#var-Inf">Inf</a> </li><li> <a href="python.numpy.html#var-inf">inf</a> </li><li> <a href="python.numpy.html#var-Infinity">Infinity</a> </li><li> <a href="python.numpy.html#var-info">info</a> </li><li> <a href="python.numpy.html#var-infty">infty</a> </li><li> <a href="python.numpy.html#var-inner">inner</a> </li><li> <a href="python.numpy.html#var-insert">insert</a> </li><li> <a href="python.numpy.html#var-int">int</a> </li><li> <a href="python.numpy.html#var-int0">int0</a> </li><li> <a href="python.numpy.html#var-int16">int16</a> </li><li> <a href="python.numpy.html#var-int32">int32</a> </li><li> <a href="python.numpy.html#var-int64">int64</a> </li><li> <a href="python.numpy.html#var-int8">int8</a> </li><li> <a href="python.numpy.html#var-int_">int_</a> </li><li> <a href="python.numpy.html#var-int_asbuffer">int_asbuffer</a> </li><li> <a href="python.numpy.html#var-intc">intc</a> </li><li> <a href="python.numpy.html#var-integer">integer</a> </li><li> <a href="python.numpy.html#var-interp">interp</a> </li><li> <a href="python.numpy.html#var-intersect1d">intersect1d</a> </li><li> <a href="python.numpy.html#var-intp">intp</a> </li><li> <a href="python.numpy.html#var-invert">invert</a> </li><li> <a href="python.numpy.html#var-ipmt">ipmt</a> </li><li> <a href="python.numpy.html#var-irr">irr</a> </li><li> <a href="python.numpy.html#var-is_busday">is_busday</a> </li><li> <a href="python.numpy.html#var-isclose">isclose</a> </li><li> <a href="python.numpy.html#var-iscomplex">iscomplex</a> </li><li> <a href="python.numpy.html#var-iscomplexobj">iscomplexobj</a> </li><li> <a href="python.numpy.html#var-isfinite">isfinite</a> </li><li> <a href="python.numpy.html#var-isfortran">isfortran</a> </li><li> <a href="python.numpy.html#var-isin">isin</a> </li><li> <a href="python.numpy.html#var-isinf">isinf</a> </li><li> <a href="python.numpy.html#var-isnan">isnan</a> </li><li> <a href="python.numpy.html#var-isnat">isnat</a> </li><li> <a href="python.numpy.html#var-isneginf">isneginf</a> </li><li> <a href="python.numpy.html#var-isposinf">isposinf</a> </li><li> <a href="python.numpy.html#var-isreal">isreal</a> </li><li> <a href="python.numpy.html#var-isrealobj">isrealobj</a> </li><li> <a href="python.numpy.html#var-isscalar">isscalar</a> </li><li> <a href="python.numpy.html#var-issctype">issctype</a> </li><li> <a href="python.numpy.html#var-issubclass_">issubclass_</a> </li><li> <a href="python.numpy.html#var-issubdtype">issubdtype</a> </li><li> <a href="python.numpy.html#var-issubsctype">issubsctype</a> </li><li> <a href="python.numpy.html#var-iterable">iterable</a> </li><li> <a href="python.numpy.html#var-ix_">ix_</a> </li><li> <a href="python.numpy.html#var-kaiser">kaiser</a> </li><li> <a href="python.numpy.html#var-kron">kron</a> </li><li> <a href="python.numpy.html#var-lcm">lcm</a> </li><li> <a href="python.numpy.html#var-ldexp">ldexp</a> </li><li> <a href="python.numpy.html#var-left_shift">left_shift</a> </li><li> <a href="python.numpy.html#var-less">less</a> </li><li> <a href="python.numpy.html#var-less_equal">less_equal</a> </li><li> <a href="python.numpy.html#var-lexsort">lexsort</a> </li><li> <a href="python.numpy.html#var-lib">lib</a> </li><li> <a href="python.numpy.html#var-linalg">linalg</a> </li><li> <a href="python.numpy.html#var-linspace">linspace</a> </li><li> <a href="python.numpy.html#var-little_endian">little_endian</a> </li><li> <a href="python.numpy.html#var-load">load</a> </li><li> <a href="python.numpy.html#var-loads">loads</a> </li><li> <a href="python.numpy.html#var-loadtxt">loadtxt</a> </li><li> <a href="python.numpy.html#var-log">log</a> </li><li> <a href="python.numpy.html#var-log10">log10</a> </li><li> <a href="python.numpy.html#var-log1p">log1p</a> </li><li> <a href="python.numpy.html#var-log2">log2</a> </li><li> <a href="python.numpy.html#var-logaddexp">logaddexp</a> </li><li> <a href="python.numpy.html#var-logaddexp2">logaddexp2</a> </li><li> <a href="python.numpy.html#var-logical_and">logical_and</a> </li><li> <a href="python.numpy.html#var-logical_not">logical_not</a> </li><li> <a href="python.numpy.html#var-logical_or">logical_or</a> </li><li> <a href="python.numpy.html#var-logical_xor">logical_xor</a> </li><li> <a href="python.numpy.html#var-logspace">logspace</a> </li><li> <a href="python.numpy.html#var-long">long</a> </li><li> <a href="python.numpy.html#var-longcomplex">longcomplex</a> </li><li> <a href="python.numpy.html#var-longdouble">longdouble</a> </li><li> <a href="python.numpy.html#var-longfloat">longfloat</a> </li><li> <a href="python.numpy.html#var-longlong">longlong</a> </li><li> <a href="python.numpy.html#var-lookfor">lookfor</a> </li><li> <a href="python.numpy.html#var-ma">ma</a> </li><li> <a href="python.numpy.html#var-MachAr">MachAr</a> </li><li> <a href="python.numpy.html#var-mafromtxt">mafromtxt</a> </li><li> <a href="python.numpy.html#var-mask_indices">mask_indices</a> </li><li> <a href="python.numpy.html#var-mat">mat</a> </li><li> <a href="python.numpy.html#var-math">math</a> </li><li> <a href="python.numpy.html#var-matmul">matmul</a> </li><li> <a href="python.numpy.html#var-matrix">matrix</a> </li><li> <a href="python.numpy.html#var-matrixlib">matrixlib</a> </li><li> <a href="python.numpy.html#var-max">max</a> </li><li> <a href="python.numpy.html#var-MAXDIMS">MAXDIMS</a> </li><li> <a href="python.numpy.html#var-maximum">maximum</a> </li><li> <a href="python.numpy.html#var-maximum_sctype">maximum_sctype</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_BOUNDS">MAY_SHARE_BOUNDS</a> </li><li> <a href="python.numpy.html#var-MAY_SHARE_EXACT">MAY_SHARE_EXACT</a> </li><li> <a href="python.numpy.html#var-may_share_memory">may_share_memory</a> </li><li> <a href="python.numpy.html#var-mean">mean</a> </li><li> <a href="python.numpy.html#var-median">median</a> </li><li> <a href="python.numpy.html#var-memmap">memmap</a> </li><li> <a href="python.numpy.html#var-meshgrid">meshgrid</a> </li><li> <a href="python.numpy.html#var-mgrid">mgrid</a> </li><li> <a href="python.numpy.html#var-min">min</a> </li><li> <a href="python.numpy.html#var-min_scalar_type">min_scalar_type</a> </li><li> <a href="python.numpy.html#var-minimum">minimum</a> </li><li> <a href="python.numpy.html#var-mintypecode">mintypecode</a> </li><li> <a href="python.numpy.html#var-mirr">mirr</a> </li><li> <a href="python.numpy.html#var-mod">mod</a> </li><li> <a href="python.numpy.html#var-modf">modf</a> </li><li> <a href="python.numpy.html#var-ModuleDeprecationWarning">ModuleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-moveaxis">moveaxis</a> </li><li> <a href="python.numpy.html#var-msort">msort</a> </li><li> <a href="python.numpy.html#var-multiply">multiply</a> </li><li> <a href="python.numpy.html#var-NAN">NAN</a> </li><li> <a href="python.numpy.html#var-NaN">NaN</a> </li><li> <a href="python.numpy.html#var-nan">nan</a> </li><li> <a href="python.numpy.html#var-nan_to_num">nan_to_num</a> </li><li> <a href="python.numpy.html#var-nanargmax">nanargmax</a> </li><li> <a href="python.numpy.html#var-nanargmin">nanargmin</a> </li><li> <a href="python.numpy.html#var-nancumprod">nancumprod</a> </li><li> <a href="python.numpy.html#var-nancumsum">nancumsum</a> </li><li> <a href="python.numpy.html#var-nanmax">nanmax</a> </li><li> <a href="python.numpy.html#var-nanmean">nanmean</a> </li><li> <a href="python.numpy.html#var-nanmedian">nanmedian</a> </li><li> <a href="python.numpy.html#var-nanmin">nanmin</a> </li><li> <a href="python.numpy.html#var-nanpercentile">nanpercentile</a> </li><li> <a href="python.numpy.html#var-nanprod">nanprod</a> </li><li> <a href="python.numpy.html#var-nanquantile">nanquantile</a> </li><li> <a href="python.numpy.html#var-nanstd">nanstd</a> </li><li> <a href="python.numpy.html#var-nansum">nansum</a> </li><li> <a href="python.numpy.html#var-nanvar">nanvar</a> </li><li> <a href="python.numpy.html#var-nbytes">nbytes</a> </li><li> <a href="python.numpy.html#var-ndarray">ndarray</a> </li><li> <a href="python.numpy.html#var-ndenumerate">ndenumerate</a> </li><li> <a href="python.numpy.html#var-ndfromtxt">ndfromtxt</a> </li><li> <a href="python.numpy.html#var-ndim">ndim</a> </li><li> <a href="python.numpy.html#var-ndindex">ndindex</a> </li><li> <a href="python.numpy.html#var-nditer">nditer</a> </li><li> <a href="python.numpy.html#var-negative">negative</a> </li><li> <a href="python.numpy.html#var-nested_iters">nested_iters</a> </li><li> <a href="python.numpy.html#var-nextafter">nextafter</a> </li><li> <a href="python.numpy.html#var-NINF">NINF</a> </li><li> <a href="python.numpy.html#var-nonzero">nonzero</a> </li><li> <a href="python.numpy.html#var-not_equal">not_equal</a> </li><li> <a href="python.numpy.html#var-nper">nper</a> </li><li> <a href="python.numpy.html#var-npv">npv</a> </li><li> <a href="python.numpy.html#var-numarray">numarray</a> </li><li> <a href="python.numpy.html#var-number">number</a> </li><li> <a href="python.numpy.html#var-NZERO">NZERO</a> </li><li> <a href="python.numpy.html#var-obj2sctype">obj2sctype</a> </li><li> <a href="python.numpy.html#var-object">object</a> </li><li> <a href="python.numpy.html#var-object0">object0</a> </li><li> <a href="python.numpy.html#var-object_">object_</a> </li><li> <a href="python.numpy.html#var-ogrid">ogrid</a> </li><li> <a href="python.numpy.html#var-oldnumeric">oldnumeric</a> </li><li> <a href="python.numpy.html#var-ones">ones</a> </li><li> <a href="python.numpy.html#var-ones_like">ones_like</a> </li><li> <a href="python.numpy.html#var-outer">outer</a> </li><li> <a href="python.numpy.html#var-packbits">packbits</a> </li><li> <a href="python.numpy.html#var-pad">pad</a> </li><li> <a href="python.numpy.html#var-partition">partition</a> </li><li> <a href="python.numpy.html#var-percentile">percentile</a> </li><li> <a href="python.numpy.html#var-pi">pi</a> </li><li> <a href="python.numpy.html#var-piecewise">piecewise</a> </li><li> <a href="python.numpy.html#var-PINF">PINF</a> </li><li> <a href="python.numpy.html#var-place">place</a> </li><li> <a href="python.numpy.html#var-pmt">pmt</a> </li><li> <a href="python.numpy.html#var-poly">poly</a> </li><li> <a href="python.numpy.html#var-poly1d">poly1d</a> </li><li> <a href="python.numpy.html#var-polyadd">polyadd</a> </li><li> <a href="python.numpy.html#var-polyder">polyder</a> </li><li> <a href="python.numpy.html#var-polydiv">polydiv</a> </li><li> <a href="python.numpy.html#var-polyfit">polyfit</a> </li><li> <a href="python.numpy.html#var-polyint">polyint</a> </li><li> <a href="python.numpy.html#var-polymul">polymul</a> </li><li> <a href="python.numpy.html#var-polynomial">polynomial</a> </li><li> <a href="python.numpy.html#var-polysub">polysub</a> </li><li> <a href="python.numpy.html#var-polyval">polyval</a> </li><li> <a href="python.numpy.html#var-positive">positive</a> </li><li> <a href="python.numpy.html#var-power">power</a> </li><li> <a href="python.numpy.html#var-ppmt">ppmt</a> </li><li> <a href="python.numpy.html#var-print_function">print_function</a> </li><li> <a href="python.numpy.html#var-printoptions">printoptions</a> </li><li> <a href="python.numpy.html#var-prod">prod</a> </li><li> <a href="python.numpy.html#var-product">product</a> </li><li> <a href="python.numpy.html#var-promote_types">promote_types</a> </li><li> <a href="python.numpy.html#var-ptp">ptp</a> </li><li> <a href="python.numpy.html#var-put">put</a> </li><li> <a href="python.numpy.html#var-put_along_axis">put_along_axis</a> </li><li> <a href="python.numpy.html#var-putmask">putmask</a> </li><li> <a href="python.numpy.html#var-pv">pv</a> </li><li> <a href="python.numpy.html#var-PZERO">PZERO</a> </li><li> <a href="python.numpy.html#var-quantile">quantile</a> </li><li> <a href="python.numpy.html#var-r_">r_</a> </li><li> <a href="python.numpy.html#var-rad2deg">rad2deg</a> </li><li> <a href="python.numpy.html#var-radians">radians</a> </li><li> <a href="python.numpy.html#var-RAISE">RAISE</a> </li><li> <a href="python.numpy.html#var-random">random</a> </li><li> <a href="python.numpy.html#var-RankWarning">RankWarning</a> </li><li> <a href="python.numpy.html#var-rate">rate</a> </li><li> <a href="python.numpy.html#var-ravel">ravel</a> </li><li> <a href="python.numpy.html#var-ravel_multi_index">ravel_multi_index</a> </li><li> <a href="python.numpy.html#var-real">real</a> </li><li> <a href="python.numpy.html#var-real_if_close">real_if_close</a> </li><li> <a href="python.numpy.html#var-rec">rec</a> </li><li> <a href="python.numpy.html#var-recarray">recarray</a> </li><li> <a href="python.numpy.html#var-recfromcsv">recfromcsv</a> </li><li> <a href="python.numpy.html#var-recfromtxt">recfromtxt</a> </li><li> <a href="python.numpy.html#var-reciprocal">reciprocal</a> </li><li> <a href="python.numpy.html#var-record">record</a> </li><li> <a href="python.numpy.html#var-remainder">remainder</a> </li><li> <a href="python.numpy.html#var-repeat">repeat</a> </li><li> <a href="python.numpy.html#var-require">require</a> </li><li> <a href="python.numpy.html#var-reshape">reshape</a> </li><li> <a href="python.numpy.html#var-resize">resize</a> </li><li> <a href="python.numpy.html#var-result_type">result_type</a> </li><li> <a href="python.numpy.html#var-right_shift">right_shift</a> </li><li> <a href="python.numpy.html#var-rint">rint</a> </li><li> <a href="python.numpy.html#var-roll">roll</a> </li><li> <a href="python.numpy.html#var-rollaxis">rollaxis</a> </li><li> <a href="python.numpy.html#var-roots">roots</a> </li><li> <a href="python.numpy.html#var-rot90">rot90</a> </li><li> <a href="python.numpy.html#var-round">round</a> </li><li> <a href="python.numpy.html#var-round_">round_</a> </li><li> <a href="python.numpy.html#var-row_stack">row_stack</a> </li><li> <a href="python.numpy.html#var-s_">s_</a> </li><li> <a href="python.numpy.html#var-safe_eval">safe_eval</a> </li><li> <a href="python.numpy.html#var-save">save</a> </li><li> <a href="python.numpy.html#var-savetxt">savetxt</a> </li><li> <a href="python.numpy.html#var-savez">savez</a> </li><li> <a href="python.numpy.html#var-savez_compressed">savez_compressed</a> </li><li> <a href="python.numpy.html#var-ScalarType">ScalarType</a> </li><li> <a href="python.numpy.html#var-sctype2char">sctype2char</a> </li><li> <a href="python.numpy.html#var-sctypeDict">sctypeDict</a> </li><li> <a href="python.numpy.html#var-sctypeNA">sctypeNA</a> </li><li> <a href="python.numpy.html#var-sctypes">sctypes</a> </li><li> <a href="python.numpy.html#var-searchsorted">searchsorted</a> </li><li> <a href="python.numpy.html#var-select">select</a> </li><li> <a href="python.numpy.html#var-set_numeric_ops">set_numeric_ops</a> </li><li> <a href="python.numpy.html#var-set_printoptions">set_printoptions</a> </li><li> <a href="python.numpy.html#var-set_string_function">set_string_function</a> </li><li> <a href="python.numpy.html#var-setbufsize">setbufsize</a> </li><li> <a href="python.numpy.html#var-setdiff1d">setdiff1d</a> </li><li> <a href="python.numpy.html#var-seterr">seterr</a> </li><li> <a href="python.numpy.html#var-seterrcall">seterrcall</a> </li><li> <a href="python.numpy.html#var-seterrobj">seterrobj</a> </li><li> <a href="python.numpy.html#var-setxor1d">setxor1d</a> </li><li> <a href="python.numpy.html#var-shape">shape</a> </li><li> <a href="python.numpy.html#var-shares_memory">shares_memory</a> </li><li> <a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO">SHIFT_DIVIDEBYZERO</a> </li><li> <a href="python.numpy.html#var-SHIFT_INVALID">SHIFT_INVALID</a> </li><li> <a href="python.numpy.html#var-SHIFT_OVERFLOW">SHIFT_OVERFLOW</a> </li><li> <a href="python.numpy.html#var-SHIFT_UNDERFLOW">SHIFT_UNDERFLOW</a> </li><li> <a href="python.numpy.html#var-short">short</a> </li><li> <a href="python.numpy.html#var-show_config">show_config</a> </li><li> <a href="python.numpy.html#var-sign">sign</a> </li><li> <a href="python.numpy.html#var-signbit">signbit</a> </li><li> <a href="python.numpy.html#var-signedinteger">signedinteger</a> </li><li> <a href="python.numpy.html#var-sin">sin</a> </li><li> <a href="python.numpy.html#var-sinc">sinc</a> </li><li> <a href="python.numpy.html#var-single">single</a> </li><li> <a href="python.numpy.html#var-singlecomplex">singlecomplex</a> </li><li> <a href="python.numpy.html#var-sinh">sinh</a> </li><li> <a href="python.numpy.html#var-size">size</a> </li><li> <a href="python.numpy.html#var-sometrue">sometrue</a> </li><li> <a href="python.numpy.html#var-sort">sort</a> </li><li> <a href="python.numpy.html#var-sort_complex">sort_complex</a> </li><li> <a href="python.numpy.html#var-source">source</a> </li><li> <a href="python.numpy.html#var-spacing">spacing</a> </li><li> <a href="python.numpy.html#var-split">split</a> </li><li> <a href="python.numpy.html#var-sqrt">sqrt</a> </li><li> <a href="python.numpy.html#var-square">square</a> </li><li> <a href="python.numpy.html#var-squeeze">squeeze</a> </li><li> <a href="python.numpy.html#var-stack">stack</a> </li><li> <a href="python.numpy.html#var-std">std</a> </li><li> <a href="python.numpy.html#var-str">str</a> </li><li> <a href="python.numpy.html#var-str0">str0</a> </li><li> <a href="python.numpy.html#var-str_">str_</a> </li><li> <a href="python.numpy.html#var-string_">string_</a> </li><li> <a href="python.numpy.html#var-subtract">subtract</a> </li><li> <a href="python.numpy.html#var-sum">sum</a> </li><li> <a href="python.numpy.html#var-swapaxes">swapaxes</a> </li><li> <a href="python.numpy.html#var-sys">sys</a> </li><li> <a href="python.numpy.html#var-take">take</a> </li><li> <a href="python.numpy.html#var-take_along_axis">take_along_axis</a> </li><li> <a href="python.numpy.html#var-tan">tan</a> </li><li> <a href="python.numpy.html#var-tanh">tanh</a> </li><li> <a href="python.numpy.html#var-tensordot">tensordot</a> </li><li> <a href="python.numpy.html#var-test">test</a> </li><li> <a href="python.numpy.html#var-tile">tile</a> </li><li> <a href="python.numpy.html#var-timedelta64">timedelta64</a> </li><li> <a href="python.numpy.html#var-TooHardError">TooHardError</a> </li><li> <a href="python.numpy.html#var-trace">trace</a> </li><li> <a href="python.numpy.html#var-tracemalloc_domain">tracemalloc_domain</a> </li><li> <a href="python.numpy.html#var-transpose">transpose</a> </li><li> <a href="python.numpy.html#var-trapz">trapz</a> </li><li> <a href="python.numpy.html#var-tri">tri</a> </li><li> <a href="python.numpy.html#var-tril">tril</a> </li><li> <a href="python.numpy.html#var-tril_indices">tril_indices</a> </li><li> <a href="python.numpy.html#var-tril_indices_from">tril_indices_from</a> </li><li> <a href="python.numpy.html#var-trim_zeros">trim_zeros</a> </li><li> <a href="python.numpy.html#var-triu">triu</a> </li><li> <a href="python.numpy.html#var-triu_indices">triu_indices</a> </li><li> <a href="python.numpy.html#var-triu_indices_from">triu_indices_from</a> </li><li> <a href="python.numpy.html#var-True_">True_</a> </li><li> <a href="python.numpy.html#var-true_divide">true_divide</a> </li><li> <a href="python.numpy.html#var-trunc">trunc</a> </li><li> <a href="python.numpy.html#var-typecodes">typecodes</a> </li><li> <a href="python.numpy.html#var-typeDict">typeDict</a> </li><li> <a href="python.numpy.html#var-typeNA">typeNA</a> </li><li> <a href="python.numpy.html#var-typename">typename</a> </li><li> <a href="python.numpy.html#var-ubyte">ubyte</a> </li><li> <a href="python.numpy.html#var-ufunc">ufunc</a> </li><li> <a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT">UFUNC_BUFSIZE_DEFAULT</a> </li><li> <a href="python.numpy.html#var-UFUNC_PYVALS_NAME">UFUNC_PYVALS_NAME</a> </li><li> <a href="python.numpy.html#var-uint">uint</a> </li><li> <a href="python.numpy.html#var-uint0">uint0</a> </li><li> <a href="python.numpy.html#var-uint16">uint16</a> </li><li> <a href="python.numpy.html#var-uint32">uint32</a> </li><li> <a href="python.numpy.html#var-uint64">uint64</a> </li><li> <a href="python.numpy.html#var-uint8">uint8</a> </li><li> <a href="python.numpy.html#var-uintc">uintc</a> </li><li> <a href="python.numpy.html#var-uintp">uintp</a> </li><li> <a href="python.numpy.html#var-ulonglong">ulonglong</a> </li><li> <a href="python.numpy.html#var-unicode">unicode</a> </li><li> <a href="python.numpy.html#var-unicode_">unicode_</a> </li><li> <a href="python.numpy.html#var-union1d">union1d</a> </li><li> <a href="python.numpy.html#var-unique">unique</a> </li><li> <a href="python.numpy.html#var-unpackbits">unpackbits</a> </li><li> <a href="python.numpy.html#var-unravel_index">unravel_index</a> </li><li> <a href="python.numpy.html#var-unsignedinteger">unsignedinteger</a> </li><li> <a href="python.numpy.html#var-unwrap">unwrap</a> </li><li> <a href="python.numpy.html#var-ushort">ushort</a> </li><li> <a href="python.numpy.html#var-vander">vander</a> </li><li> <a href="python.numpy.html#var-var">var</a> </li><li> <a href="python.numpy.html#var-vdot">vdot</a> </li><li> <a href="python.numpy.html#var-vectorize">vectorize</a> </li><li> <a href="python.numpy.html#var-version">version</a> </li><li> <a href="python.numpy.html#var-VisibleDeprecationWarning">VisibleDeprecationWarning</a> </li><li> <a href="python.numpy.html#var-void">void</a> </li><li> <a href="python.numpy.html#var-void0">void0</a> </li><li> <a href="python.numpy.html#var-vsplit">vsplit</a> </li><li> <a href="python.numpy.html#var-vstack">vstack</a> </li><li> <a href="python.numpy.html#var-warnings">warnings</a> </li><li> <a href="python.numpy.html#var-where">where</a> </li><li> <a href="python.numpy.html#var-who">who</a> </li><li> <a href="python.numpy.html#var-WRAP">WRAP</a> </li><li> <a href="python.numpy.html#var-zeros">zeros</a> </li><li> <a href="python.numpy.html#var-zeros_like">zeros_like</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-20</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 2b71127..fddad9a 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
@@ -34,4 +34,4 @@
         (.add 1)
         (.add 2))
 [1, 2]
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/codegen.clj#L103">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/codegen.clj#L102">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index e352991..0af1bc7 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 9152d70..f3d8571 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -48,7 +48,7 @@
 2
 user&gt; c
 3
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L631">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L633">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -68,11 +68,11 @@
 <p>Options:</p>
 <ul>
   <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L608">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L610">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L497">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L519">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L490">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L499">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L521">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L490">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -82,7 +82,7 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L554">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L273">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L556">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L273">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 3c13a53..8bcfd77 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index a805cb2..9616d3f 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 23f9fa0..7826bcc 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/python.builtins.html b/docs/python.builtins.html
deleted file mode 100644
index 2d4956d..0000000
--- a/docs/python.builtins.html
+++ /dev/null
@@ -1,151 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>python.builtins documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch current"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.builtins.html#var-__build_class__"><div class="inner"><span>__build_class__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__debug__"><div class="inner"><span>__debug__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__import__"><div class="inner"><span>__import__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ArithmeticError"><div class="inner"><span>ArithmeticError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ascii"><div class="inner"><span>ascii</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-AttributeError"><div class="inner"><span>AttributeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BaseException"><div class="inner"><span>BaseException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bin"><div class="inner"><span>bin</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BlockingIOError"><div class="inner"><span>BlockingIOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-breakpoint"><div class="inner"><span>breakpoint</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BrokenPipeError"><div class="inner"><span>BrokenPipeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BufferError"><div class="inner"><span>BufferError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytearray"><div class="inner"><span>bytearray</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-bytes"><div class="inner"><span>bytes</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-BytesWarning"><div class="inner"><span>BytesWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-callable"><div class="inner"><span>callable</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ChildProcessError"><div class="inner"><span>ChildProcessError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-chr"><div class="inner"><span>chr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-classmethod"><div class="inner"><span>classmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-compile"><div class="inner"><span>compile</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionAbortedError"><div class="inner"><span>ConnectionAbortedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionError"><div class="inner"><span>ConnectionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionRefusedError"><div class="inner"><span>ConnectionRefusedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ConnectionResetError"><div class="inner"><span>ConnectionResetError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-copyright"><div class="inner"><span>copyright</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-credits"><div class="inner"><span>credits</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-delattr"><div class="inner"><span>delattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-DeprecationWarning"><div class="inner"><span>DeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dict"><div class="inner"><span>dict</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Ellipsis"><div class="inner"><span>Ellipsis</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-enumerate"><div class="inner"><span>enumerate</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EnvironmentError"><div class="inner"><span>EnvironmentError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-EOFError"><div class="inner"><span>EOFError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-eval"><div class="inner"><span>eval</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exec"><div class="inner"><span>exec</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-exit"><div class="inner"><span>exit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileExistsError"><div class="inner"><span>FileExistsError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FileNotFoundError"><div class="inner"><span>FileNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-filter"><div class="inner"><span>filter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FloatingPointError"><div class="inner"><span>FloatingPointError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-format"><div class="inner"><span>format</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-frozenset"><div class="inner"><span>frozenset</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-FutureWarning"><div class="inner"><span>FutureWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-GeneratorExit"><div class="inner"><span>GeneratorExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-getattr"><div class="inner"><span>getattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-globals"><div class="inner"><span>globals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hasattr"><div class="inner"><span>hasattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hash"><div class="inner"><span>hash</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-help"><div class="inner"><span>help</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-hex"><div class="inner"><span>hex</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-id"><div class="inner"><span>id</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportError"><div class="inner"><span>ImportError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ImportWarning"><div class="inner"><span>ImportWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndentationError"><div class="inner"><span>IndentationError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IndexError"><div class="inner"><span>IndexError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-input"><div class="inner"><span>input</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-InterruptedError"><div class="inner"><span>InterruptedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IOError"><div class="inner"><span>IOError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-IsADirectoryError"><div class="inner"><span>IsADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-isinstance"><div class="inner"><span>isinstance</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-issubclass"><div class="inner"><span>issubclass</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-iter"><div class="inner"><span>iter</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyboardInterrupt"><div class="inner"><span>KeyboardInterrupt</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-KeyError"><div class="inner"><span>KeyError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-len"><div class="inner"><span>len</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-license"><div class="inner"><span>license</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-list"><div class="inner"><span>list</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-locals"><div class="inner"><span>locals</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-LookupError"><div class="inner"><span>LookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-map"><div class="inner"><span>map</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-MemoryError"><div class="inner"><span>MemoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-memoryview"><div class="inner"><span>memoryview</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ModuleNotFoundError"><div class="inner"><span>ModuleNotFoundError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NameError"><div class="inner"><span>NameError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-next"><div class="inner"><span>next</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotADirectoryError"><div class="inner"><span>NotADirectoryError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplemented"><div class="inner"><span>NotImplemented</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-NotImplementedError"><div class="inner"><span>NotImplementedError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-oct"><div class="inner"><span>oct</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-open"><div class="inner"><span>open</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ord"><div class="inner"><span>ord</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OSError"><div class="inner"><span>OSError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-OverflowError"><div class="inner"><span>OverflowError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PendingDeprecationWarning"><div class="inner"><span>PendingDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PermissionError"><div class="inner"><span>PermissionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-pow"><div class="inner"><span>pow</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-print"><div class="inner"><span>print</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ProcessLookupError"><div class="inner"><span>ProcessLookupError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-property"><div class="inner"><span>property</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyAssertionError"><div class="inner"><span>PyAssertionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-PyException"><div class="inner"><span>PyException</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-quit"><div class="inner"><span>quit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-range"><div class="inner"><span>range</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RecursionError"><div class="inner"><span>RecursionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ReferenceError"><div class="inner"><span>ReferenceError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-repr"><div class="inner"><span>repr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ResourceWarning"><div class="inner"><span>ResourceWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-reversed"><div class="inner"><span>reversed</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeError"><div class="inner"><span>RuntimeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-RuntimeWarning"><div class="inner"><span>RuntimeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-set"><div class="inner"><span>set</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-setattr"><div class="inner"><span>setattr</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-slice"><div class="inner"><span>slice</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sorted"><div class="inner"><span>sorted</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-staticmethod"><div class="inner"><span>staticmethod</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopAsyncIteration"><div class="inner"><span>StopAsyncIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-StopIteration"><div class="inner"><span>StopIteration</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-super"><div class="inner"><span>super</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxError"><div class="inner"><span>SyntaxError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SyntaxWarning"><div class="inner"><span>SyntaxWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemError"><div class="inner"><span>SystemError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-SystemExit"><div class="inner"><span>SystemExit</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TabError"><div class="inner"><span>TabError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TimeoutError"><div class="inner"><span>TimeoutError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-True"><div class="inner"><span>True</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-tuple"><div class="inner"><span>tuple</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-type"><div class="inner"><span>type</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-TypeError"><div class="inner"><span>TypeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnboundLocalError"><div class="inner"><span>UnboundLocalError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeDecodeError"><div class="inner"><span>UnicodeDecodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeEncodeError"><div class="inner"><span>UnicodeEncodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeError"><div class="inner"><span>UnicodeError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeTranslateError"><div class="inner"><span>UnicodeTranslateError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UnicodeWarning"><div class="inner"><span>UnicodeWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-UserWarning"><div class="inner"><span>UserWarning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ValueError"><div class="inner"><span>ValueError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-vars"><div class="inner"><span>vars</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-Warning"><div class="inner"><span>Warning</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-ZeroDivisionError"><div class="inner"><span>ZeroDivisionError</span></div></a></li><li class="depth-1"><a href="python.builtins.html#var-zip"><div class="inner"><span>zip</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.builtins</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__build_class__"><h3>__build_class__</h3><div class="usage"><code>(__build_class__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>build_class</strong>(func, name, /, *bases, [metaclass], **kwds) -&gt; class</p>
-<p>Internal helper function used by the class statement.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L594">view source</a></div></div><div class="public anchor" id="var-__debug__"><h3>__debug__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L538">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L846">view source</a></div></div><div class="public anchor" id="var-__import__"><h3>__import__</h3><div class="usage"><code>(__import__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p><strong>import</strong>(name, globals=None, locals=None, fromlist=(), level=0) -&gt; module</p>
-<p>Import a module. Because this function is meant for use by the Python interpreter and not for general use, it is better to use importlib.import_module() to programmatically import a module.</p>
-<p>The globals argument is only used to determine the context; they are not modified. The locals argument is unused. The fromlist should be a list of names to emulate <code>from name import ...'', or an
-empty list to emulate</code>import name’’. When importing a module from a package, note that <strong>import</strong>(‘A.B’, …) returns package A when fromlist is empty, but its submodule B when fromlist is not empty. The level argument is used to determine whether to perform absolute or relative imports: 0 is absolute, while a positive number is the number of parent directories to search relative to the current module.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L848">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"><code>(__loader__ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Meta path import for built-in modules.</p>
-<p>All methods are either class or static methods to avoid the need to instantiate the class.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L232">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L886">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L933">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
-<p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
-<p><code>name</code> is the absolute name of the module. <code>loader</code> is the loader to use when loading the module. <code>parent</code> is the name of the package the module is in. The parent is derived from the name.</p>
-<p><code>is_package</code> determines if the module is considered a package or not. On modules this is reflected by the <code>__path__</code> attribute.</p>
-<p><code>origin</code> is the specific location used by the loader from which to load the module, if that information is available. When filename is set, origin will match.</p>
-<p><code>has_location</code> indicates that a spec’s “origin” reflects a location. When this is True, <code>__file__</code> attribute of the module is set.</p>
-<p><code>cached</code> is the location of the cached bytecode file, if any. It corresponds to the <code>__cached__</code> attribute.</p>
-<p><code>submodule_search_locations</code> is the sequence of path entries to search when importing submodules. If set, is_package should be True–and False otherwise.</p>
-<p>Packages are simply modules that (may) have submodules. If a spec has a non-None value in <code>submodule_search_locations</code>, the import system will consider modules loaded from the spec as packages.</p>
-<p>Only finders (see importlib.abc.MetaPathFinder and importlib.abc.PathEntryFinder) should modify ModuleSpec instances.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L432">view source</a></div></div><div class="public anchor" id="var-abs"><h3>abs</h3><div class="usage"><code>(abs x)</code></div><div class="doc"><div class="markdown"><p>Return the absolute value of the argument.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L623">view source</a></div></div><div class="public anchor" id="var-all"><h3>all</h3><div class="usage"><code>(all iterable)</code></div><div class="doc"><div class="markdown"><p>Return True if bool(x) is True for all values x in the iterable.</p>
-<p>If the iterable is empty, return True.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L687">view source</a></div></div><div class="public anchor" id="var-any"><h3>any</h3><div class="usage"><code>(any iterable)</code></div><div class="doc"><div class="markdown"><p>Return True if bool(x) is True for any x in the iterable.</p>
-<p>If the iterable is empty, return False.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L312">view source</a></div></div><div class="public anchor" id="var-ArithmeticError"><h3>ArithmeticError</h3><div class="usage"><code>(ArithmeticError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for arithmetic errors.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L121">view source</a></div></div><div class="public anchor" id="var-ascii"><h3>ascii</h3><div class="usage"><code>(ascii obj)</code></div><div class="doc"><div class="markdown"><p>Return an ASCII-only representation of an object.</p>
-<p>As repr(), return a string containing a printable representation of an object, but escape the non-ASCII characters in the string returned by repr() using \x, \u or \U escapes. This generates a string similar to that returned by repr() in Python 2.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L101">view source</a></div></div><div class="public anchor" id="var-AttributeError"><h3>AttributeError</h3><div class="usage"><code>(AttributeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Attribute not found.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L958">view source</a></div></div><div class="public anchor" id="var-BaseException"><h3>BaseException</h3><div class="usage"><code>(BaseException self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Common base class for all exceptions</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L583">view source</a></div></div><div class="public anchor" id="var-bin"><h3>bin</h3><div class="usage"><code>(bin number)</code></div><div class="doc"><div class="markdown"><p>Return the binary representation of an integer.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>bin(2796202) ‘0b1010101010101010101010’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L426">view source</a></div></div><div class="public anchor" id="var-BlockingIOError"><h3>BlockingIOError</h3><div class="usage"><code>(BlockingIOError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>I/O operation would block.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L124">view source</a></div></div><div class="public anchor" id="var-bool"><h3>bool</h3><div class="usage"><code>(bool self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bool(x) -&gt; bool</p>
-<p>Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L386">view source</a></div></div><div class="public anchor" id="var-breakpoint"><h3>breakpoint</h3><div class="usage"><code>(breakpoint self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>breakpoint(*args, **kws)</p>
-<p>Call sys.breakpointhook(*args, **kws). sys.breakpointhook() must accept whatever arguments are passed.</p>
-<p>By default, this drops you into the pdb debugger.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L213">view source</a></div></div><div class="public anchor" id="var-BrokenPipeError"><h3>BrokenPipeError</h3><div class="usage"><code>(BrokenPipeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Broken pipe.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L684">view source</a></div></div><div class="public anchor" id="var-BufferError"><h3>BufferError</h3><div class="usage"><code>(BufferError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Buffer error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L543">view source</a></div></div><div class="public anchor" id="var-bytearray"><h3>bytearray</h3><div class="usage"><code>(bytearray self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bytearray(iterable_of_ints) -&gt; bytearray bytearray(string, encoding[, errors]) -&gt; bytearray bytearray(bytes_or_buffer) -&gt; mutable copy of bytes_or_buffer bytearray(int) -&gt; bytes array of size given by the parameter initialized with null bytes bytearray() -&gt; empty bytes array</p>
-<p>Construct a mutable bytearray object from:  - an iterable yielding integers in range(256)  - a text string encoded using the specified encoding  - a bytes or a buffer object  - any object implementing the buffer API.  - an integer</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L546">view source</a></div></div><div class="public anchor" id="var-bytes"><h3>bytes</h3><div class="usage"><code>(bytes self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bytes(iterable_of_ints) -&gt; bytes bytes(string, encoding[, errors]) -&gt; bytes bytes(bytes_or_buffer) -&gt; immutable copy of bytes_or_buffer bytes(int) -&gt; bytes object of size given by the parameter initialized with null bytes bytes() -&gt; empty bytes object</p>
-<p>Construct an immutable array of bytes from:  - an iterable yielding integers in range(256)  - a text string encoded using the specified encoding  - any object implementing the buffer API.  - an integer</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L468">view source</a></div></div><div class="public anchor" id="var-BytesWarning"><h3>BytesWarning</h3><div class="usage"><code>(BytesWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about bytes and buffer related problems, mostly related to conversion from str or comparing to str.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L72">view source</a></div></div><div class="public anchor" id="var-callable"><h3>callable</h3><div class="usage"><code>(callable obj)</code></div><div class="doc"><div class="markdown"><p>Return whether the object is callable (i.e., some kind of function).</p>
-<p>Note that classes are callable, as are instances of classes with a <strong>call</strong>() method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L402">view source</a></div></div><div class="public anchor" id="var-ChildProcessError"><h3>ChildProcessError</h3><div class="usage"><code>(ChildProcessError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Child process error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L704">view source</a></div></div><div class="public anchor" id="var-chr"><h3>chr</h3><div class="usage"><code>(chr i)</code></div><div class="doc"><div class="markdown"><p>Return a Unicode string of one character with ordinal i; 0 &lt;= i &lt;= 0x10ffff.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L118">view source</a></div></div><div class="public anchor" id="var-classmethod"><h3>classmethod</h3><div class="usage"><code>(classmethod self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>classmethod(function) -&gt; method</p>
-<p>Convert a function to be a class method.</p>
-<p>A class method receives the class as implicit first argument, just like an instance method receives the instance. To declare a class method, use this idiom:</p>
-<p>class C:  @classmethod  def f(cls, arg1, arg2, …):  …</p>
-<p>It can be called either on the class (e.g. C.f()) or on an instance (e.g. C().f()). The instance is ignored except for its class. If a class method is called for a derived class, the derived class object is passed as the implied first argument.</p>
-<p>Class methods are different than C++ or Java static methods. If you want those, see the staticmethod builtin.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L157">view source</a></div></div><div class="public anchor" id="var-compile"><h3>compile</h3><div class="usage"><code>(compile source filename mode &amp; [{flags :flags, dont_inherit :dont_inherit, optimize :optimize, _feature_version :_feature_version}])</code><code>(compile source filename mode &amp; [{flags :flags, dont_inherit :dont_inherit, _feature_version :_feature_version}])</code><code>(compile source filename mode &amp; [{flags :flags, _feature_version :_feature_version}])</code><code>(compile source filename mode &amp; [{_feature_version :_feature_version}])</code></div><div class="doc"><div class="markdown"><p>Compile source into a code object that can be executed by exec() or eval().</p>
-<p>The source code may represent a Python module, statement or expression. The filename will be used for run-time error messages. The mode must be ‘exec’ to compile a module, ‘single’ to compile a single (interactive) statement, or ‘eval’ to compile an expression. The flags argument, if present, controls which future statements influence the compilation of the code. The dont_inherit argument, if true, stops the compilation inheriting the effects of any future statements in effect in the code calling compile; if absent or false these statements do influence the compilation, in addition to any features explicitly specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L560">view source</a></div></div><div class="public anchor" id="var-complex"><h3>complex</h3><div class="usage"><code>(complex self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create a complex number from a real part and an optional imaginary part.</p>
-<p>This is equivalent to (real + imag*1j) where imag defaults to 0.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L877">view source</a></div></div><div class="public anchor" id="var-ConnectionAbortedError"><h3>ConnectionAbortedError</h3><div class="usage"><code>(ConnectionAbortedError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Connection aborted.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L291">view source</a></div></div><div class="public anchor" id="var-ConnectionError"><h3>ConnectionError</h3><div class="usage"><code>(ConnectionError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Connection error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L868">view source</a></div></div><div class="public anchor" id="var-ConnectionRefusedError"><h3>ConnectionRefusedError</h3><div class="usage"><code>(ConnectionRefusedError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Connection refused.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L626">view source</a></div></div><div class="public anchor" id="var-ConnectionResetError"><h3>ConnectionResetError</h3><div class="usage"><code>(ConnectionResetError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Connection reset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L13">view source</a></div></div><div class="public anchor" id="var-copyright"><h3>copyright</h3><div class="usage"><code>(copyright self name data &amp; [{files :files, dirs :dirs}])</code><code>(copyright self name data &amp; [{files :files}])</code><code>(copyright self name data)</code></div><div class="doc"><div class="markdown"><p>interactive prompt objects for printing the license text, a list of contributors and the copyright notice.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L599">view source</a></div></div><div class="public anchor" id="var-credits"><h3>credits</h3><div class="usage"><code>(credits self name data &amp; [{files :files, dirs :dirs}])</code><code>(credits self name data &amp; [{files :files}])</code><code>(credits self name data)</code></div><div class="doc"><div class="markdown"><p>interactive prompt objects for printing the license text, a list of contributors and the copyright notice.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L942">view source</a></div></div><div class="public anchor" id="var-delattr"><h3>delattr</h3><div class="usage"><code>(delattr obj name)</code></div><div class="doc"><div class="markdown"><p>Deletes the named attribute from the given object.</p>
-<p>delattr(x, ‘y’) is equivalent to ``del x.y’’</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L280">view source</a></div></div><div class="public anchor" id="var-DeprecationWarning"><h3>DeprecationWarning</h3><div class="usage"><code>(DeprecationWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about deprecated features.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L420">view source</a></div></div><div class="public anchor" id="var-dict"><h3>dict</h3><div class="usage"><code>(dict self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L348">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>dir([object]) -&gt; list of strings</p>
-<p>If called without an argument, return the names in the current scope. Else, return an alphabetized list of names comprising (some of) the attributes of the given object, and of attributes reachable from it. If the object supplies a method named <strong>dir</strong>, it will be used; otherwise the default dir() logic is used and returns:  for a module object: the module’s attributes.  for a class object: its attributes, and recursively the attributes  of its bases.  for any other object: its attributes, its class’s attributes, and  recursively the attributes of its class’s base classes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L481">view source</a></div></div><div class="public anchor" id="var-divmod"><h3>divmod</h3><div class="usage"><code>(divmod x y)</code></div><div class="doc"><div class="markdown"><p>Return the tuple (x//y, x%y). Invariant: div*y + mod == x.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L309">view source</a></div></div><div class="public anchor" id="var-Ellipsis"><h3>Ellipsis</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L724">view source</a></div></div><div class="public anchor" id="var-enumerate"><h3>enumerate</h3><div class="usage"><code>(enumerate self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an enumerate object.</p>
-<p>iterable  an object supporting iteration</p>
-<p>The enumerate object yields pairs containing a count (from start, which defaults to zero) and a value yielded by the iterable argument.</p>
-<p>enumerate is useful for obtaining an indexed list:  (0, seq[0]), (1, seq[1]), (2, seq[2]), …</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L336">view source</a></div></div><div class="public anchor" id="var-EnvironmentError"><h3>EnvironmentError</h3><div class="usage"><code>(EnvironmentError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for I/O related errors.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L408">view source</a></div></div><div class="public anchor" id="var-EOFError"><h3>EOFError</h3><div class="usage"><code>(EOFError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Read beyond end of file.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L664">view source</a></div></div><div class="public anchor" id="var-eval"><h3>eval</h3><div class="usage"><code>(eval source &amp; [{globals :globals, locals :locals}])</code><code>(eval source &amp; [{globals :globals}])</code><code>(eval source)</code></div><div class="doc"><div class="markdown"><p>Evaluate the given source in the context of globals and locals.</p>
-<p>The source may be a string representing a Python expression or a code object as returned by compile(). The globals must be a dictionary and locals can be any mapping, defaulting to the current globals and locals. If only globals is given, locals defaults to it.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L377">view source</a></div></div><div class="public anchor" id="var-exec"><h3>exec</h3><div class="usage"><code>(exec source &amp; [{globals :globals, locals :locals}])</code><code>(exec source &amp; [{globals :globals}])</code><code>(exec source)</code></div><div class="doc"><div class="markdown"><p>Execute the given source in the context of globals and locals.</p>
-<p>The source may be a string representing one or more Python statements or a code object as returned by compile(). The globals must be a dictionary and locals can be any mapping, defaulting to the current globals and locals. If only globals is given, locals defaults to it.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L300">view source</a></div></div><div class="public anchor" id="var-exit"><h3>exit</h3><div class="usage"><code>(exit self name eof)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L661">view source</a></div></div><div class="public anchor" id="var-FileExistsError"><h3>FileExistsError</h3><div class="usage"><code>(FileExistsError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>File already exists.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L368">view source</a></div></div><div class="public anchor" id="var-FileNotFoundError"><h3>FileNotFoundError</h3><div class="usage"><code>(FileNotFoundError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>File not found.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L85">view source</a></div></div><div class="public anchor" id="var-filter"><h3>filter</h3><div class="usage"><code>(filter self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>filter(function or None, iterable) –&gt; filter object</p>
-<p>Return an iterator yielding those items of iterable for which function(item) is true. If function is None, return the items that are true.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L495">view source</a></div></div><div class="public anchor" id="var-float"><h3>float</h3><div class="usage"><code>(float self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Convert a string or number to a floating point number, if possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L10">view source</a></div></div><div class="public anchor" id="var-FloatingPointError"><h3>FloatingPointError</h3><div class="usage"><code>(FloatingPointError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Floating point operation failed.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L285">view source</a></div></div><div class="public anchor" id="var-format"><h3>format</h3><div class="usage"><code>(format value &amp; [{format_spec :format_spec}])</code><code>(format value)</code></div><div class="doc"><div class="markdown"><p>Return value.__format__(format_spec)</p>
-<p>format_spec defaults to the empty string. See the Format Specification Mini-Language section of help(‘FORMATTING’) for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L935">view source</a></div></div><div class="public anchor" id="var-frozenset"><h3>frozenset</h3><div class="usage"><code>(frozenset self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>frozenset() -&gt; empty frozenset object frozenset(iterable) -&gt; frozenset object</p>
-<p>Build an immutable unordered collection of unique elements.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L952">view source</a></div></div><div class="public anchor" id="var-FutureWarning"><h3>FutureWarning</h3><div class="usage"><code>(FutureWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about constructs that will change semantically in the future.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L150">view source</a></div></div><div class="public anchor" id="var-GeneratorExit"><h3>GeneratorExit</h3><div class="usage"><code>(GeneratorExit self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Request that a generator exit.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L288">view source</a></div></div><div class="public anchor" id="var-getattr"><h3>getattr</h3><div class="usage"><code>(getattr self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>getattr(object, name[, default]) -&gt; value</p>
-<p>Get a named attribute from an object; getattr(x, ‘y’) is equivalent to x.y. When a default argument is given, it is returned when the attribute doesn’t exist; without it, an exception is raised in that case.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L904">view source</a></div></div><div class="public anchor" id="var-globals"><h3>globals</h3><div class="usage"><code>(globals)</code></div><div class="doc"><div class="markdown"><p>Return the dictionary containing the current scope’s global variables.</p>
-<p>NOTE: Updates to this dictionary <em>will</em> affect name lookups in the current global scope and vice-versa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L614">view source</a></div></div><div class="public anchor" id="var-hasattr"><h3>hasattr</h3><div class="usage"><code>(hasattr obj name)</code></div><div class="doc"><div class="markdown"><p>Return whether the object has an attribute with the given name.</p>
-<p>This is done by calling getattr(obj, name) and catching AttributeError.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L670">view source</a></div></div><div class="public anchor" id="var-hash"><h3>hash</h3><div class="usage"><code>(hash obj)</code></div><div class="doc"><div class="markdown"><p>Return the hash value for the given object.</p>
-<p>Two objects that compare equal must also have the same hash value, but the reverse is not necessarily true.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L207">view source</a></div></div><div class="public anchor" id="var-help"><h3>help</h3><div class="usage"><code>(help self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Define the builtin ‘help’.</p>
-<p>This is a wrapper around pydoc.help that provides a helpful message when ‘help’ is typed at the Python interactive prompt.</p>
-<p>Calling help() at the Python prompt starts an interactive help session. Calling help(thing) prints help for the python object ‘thing’.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L629">view source</a></div></div><div class="public anchor" id="var-hex"><h3>hex</h3><div class="usage"><code>(hex number)</code></div><div class="doc"><div class="markdown"><p>Return the hexadecimal representation of an integer.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>hex(12648430) ‘0xc0ffee’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L182">view source</a></div></div><div class="public anchor" id="var-id"><h3>id</h3><div class="usage"><code>(id obj)</code></div><div class="doc"><div class="markdown"><p>Return the identity of an object.</p>
-<p>This is guaranteed to be unique among simultaneously existing objects. (CPython uses the object’s memory address.)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L265">view source</a></div></div><div class="public anchor" id="var-ImportError"><h3>ImportError</h3><div class="usage"><code>(ImportError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Import can’t find module, or can’t find name in module.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L586">view source</a></div></div><div class="public anchor" id="var-ImportWarning"><h3>ImportWarning</h3><div class="usage"><code>(ImportWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about probable mistakes in module imports</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L147">view source</a></div></div><div class="public anchor" id="var-IndentationError"><h3>IndentationError</h3><div class="usage"><code>(IndentationError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Improper indentation.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L927">view source</a></div></div><div class="public anchor" id="var-IndexError"><h3>IndexError</h3><div class="usage"><code>(IndexError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Sequence index out of range.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L179">view source</a></div></div><div class="public anchor" id="var-input"><h3>input</h3><div class="usage"><code>(input &amp; [{prompt :prompt}])</code><code>(input)</code></div><div class="doc"><div class="markdown"><p>Read a string from standard input. The trailing newline is stripped.</p>
-<p>The prompt string, if given, is printed to standard output without a trailing newline before reading input.</p>
-<p>If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError. On *nix systems, readline is used if available.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L574">view source</a></div></div><div class="public anchor" id="var-int"><h3>int</h3><div class="usage"><code>(int self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>int([x]) -&gt; integer int(x, base=10) -&gt; integer</p>
-<p>Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.</p>
-<p>If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by ‘+’ or ‘-’ and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>int(‘0b100’, base=0) 4</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L25">view source</a></div></div><div class="public anchor" id="var-InterruptedError"><h3>InterruptedError</h3><div class="usage"><code>(InterruptedError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Interrupted by signal.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L371">view source</a></div></div><div class="public anchor" id="var-IOError"><h3>IOError</h3><div class="usage"><code>(IOError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for I/O related errors.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L540">view source</a></div></div><div class="public anchor" id="var-IsADirectoryError"><h3>IsADirectoryError</h3><div class="usage"><code>(IsADirectoryError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Operation doesn’t work on directories.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L967">view source</a></div></div><div class="public anchor" id="var-isinstance"><h3>isinstance</h3><div class="usage"><code>(isinstance obj class_or_tuple)</code></div><div class="doc"><div class="markdown"><p>Return whether an object is an instance of a class or of a subclass thereof.</p>
-<p>A tuple, as in <code>isinstance(x, (A, B, ...))</code>, may be given as the target to check against. This is equivalent to <code>isinstance(x, A) or isinstance(x, B)
-or ...</code> etc.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L258">view source</a></div></div><div class="public anchor" id="var-issubclass"><h3>issubclass</h3><div class="usage"><code>(issubclass cls class_or_tuple)</code></div><div class="doc"><div class="markdown"><p>Return whether ‘cls’ is a derived from another class or is the same class.</p>
-<p>A tuple, as in <code>issubclass(x, (A, B, ...))</code>, may be given as the target to check against. This is equivalent to <code>issubclass(x, A) or issubclass(x, B)
-or ...</code> etc.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L970">view source</a></div></div><div class="public anchor" id="var-iter"><h3>iter</h3><div class="usage"><code>(iter self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>iter(iterable) -&gt; iterator iter(callable, sentinel) -&gt; iterator</p>
-<p>Get an iterator from an object. In the first form, the argument must supply its own iterator, or be a sequence. In the second form, the callable is called until it returns the sentinel.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L716">view source</a></div></div><div class="public anchor" id="var-KeyboardInterrupt"><h3>KeyboardInterrupt</h3><div class="usage"><code>(KeyboardInterrupt self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Program interrupted by user.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L69">view source</a></div></div><div class="public anchor" id="var-KeyError"><h3>KeyError</h3><div class="usage"><code>(KeyError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Mapping key not found.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L535">view source</a></div></div><div class="public anchor" id="var-len"><h3>len</h3><div class="usage"><code>(len obj)</code></div><div class="doc"><div class="markdown"><p>Return the number of items in a container.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L675">view source</a></div></div><div class="public anchor" id="var-license"><h3>license</h3><div class="usage"><code>(license self name data &amp; [{files :files, dirs :dirs}])</code><code>(license self name data &amp; [{files :files}])</code><code>(license self name data)</code></div><div class="doc"><div class="markdown"><p>interactive prompt objects for printing the license text, a list of contributors and the copyright notice.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L97">view source</a></div></div><div class="public anchor" id="var-list"><h3>list</h3><div class="usage"><code>(list self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
-<p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L91">view source</a></div></div><div class="public anchor" id="var-locals"><h3>locals</h3><div class="usage"><code>(locals)</code></div><div class="doc"><div class="markdown"><p>Return a dictionary containing the current scope’s local variables.</p>
-<p>NOTE: Whether or not updates to this dictionary will affect name lookups in the local scope and vice-versa is <em>implementation dependent</em> and not covered by any backwards compatibility guarantees.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L894">view source</a></div></div><div class="public anchor" id="var-LookupError"><h3>LookupError</h3><div class="usage"><code>(LookupError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for lookup errors.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L608">view source</a></div></div><div class="public anchor" id="var-map"><h3>map</h3><div class="usage"><code>(map self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>map(func, *iterables) –&gt; map object</p>
-<p>Make an iterator that computes the function using arguments from each of the iterables. Stops when the shortest iterable is exhausted.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L16">view source</a></div></div><div class="public anchor" id="var-max"><h3>max</h3><div class="usage"><code>(max self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>max(iterable, *[, default=obj, key=func]) -&gt; value max(arg1, arg2, *args, *[, key=func]) -&gt; value</p>
-<p>With a single iterable argument, return its biggest item. The default keyword-only argument specifies an object to return if the provided iterable is empty. With two or more arguments, return the largest argument.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L243">view source</a></div></div><div class="public anchor" id="var-MemoryError"><h3>MemoryError</h3><div class="usage"><code>(MemoryError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Out of memory.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L66">view source</a></div></div><div class="public anchor" id="var-memoryview"><h3>memoryview</h3><div class="usage"><code>(memoryview self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create a new memoryview object which references the given object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L333">view source</a></div></div><div class="public anchor" id="var-min"><h3>min</h3><div class="usage"><code>(min self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>min(iterable, *[, default=obj, key=func]) -&gt; value min(arg1, arg2, *args, *[, key=func]) -&gt; value</p>
-<p>With a single iterable argument, return its smallest item. The default keyword-only argument specifies an object to return if the provided iterable is empty. With two or more arguments, return the smallest argument.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L76">view source</a></div></div><div class="public anchor" id="var-ModuleNotFoundError"><h3>ModuleNotFoundError</h3><div class="usage"><code>(ModuleNotFoundError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Module not found.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L710">view source</a></div></div><div class="public anchor" id="var-NameError"><h3>NameError</h3><div class="usage"><code>(NameError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Name not found globally.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L417">view source</a></div></div><div class="public anchor" id="var-next"><h3>next</h3><div class="usage"><code>(next self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>next(iterator[, default])</p>
-<p>Return the next item from the iterator. If default is given and the iterator is exhausted, it is returned instead of raising StopIteration.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L109">view source</a></div></div><div class="public anchor" id="var-NotADirectoryError"><h3>NotADirectoryError</h3><div class="usage"><code>(NotADirectoryError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Operation only works on directories.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L240">view source</a></div></div><div class="public anchor" id="var-NotImplemented"><h3>NotImplemented</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L48">view source</a></div></div><div class="public anchor" id="var-NotImplementedError"><h3>NotImplementedError</h3><div class="usage"><code>(NotImplementedError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Method or function hasn’t been implemented yet.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L901">view source</a></div></div><div class="public anchor" id="var-object"><h3>object</h3><div class="usage"><code>(object self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>The base class of the class hierarchy.</p>
-<p>When called, it accepts no arguments and returns a new featureless instance that has no instance attributes and cannot be given any.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L41">view source</a></div></div><div class="public anchor" id="var-oct"><h3>oct</h3><div class="usage"><code>(oct number)</code></div><div class="doc"><div class="markdown"><p>Return the octal representation of an integer.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>oct(342391) ‘0o1234567’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L888">view source</a></div></div><div class="public anchor" id="var-open"><h3>open</h3><div class="usage"><code>(open file &amp; [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline, closefd :closefd, opener :opener}])</code><code>(open file &amp; [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline, closefd :closefd}])</code><code>(open file &amp; [{mode :mode, buffering :buffering, encoding :encoding, errors :errors, newline :newline}])</code><code>(open file &amp; [{mode :mode, buffering :buffering, encoding :encoding, errors :errors}])</code><code>(open file &amp; [{mode :mode, buffering :buffering, encoding :encoding}])</code><code>(open file &amp; [{mode :mode, buffering :buffering}])</code><code>(open file &amp; [{mode :mode}])</code><code>(open file)</code></div><div class="doc"><div class="markdown"><p>Open file and return a stream. Raise OSError upon failure.</p>
-<p>file is either a text or byte string giving the name (and the path if the file isn’t in the current working directory) of the file to be opened or an integer file descriptor of the file to be wrapped. (If a file descriptor is given, it is closed when the returned I/O object is closed, unless closefd is set to False.)</p>
-<p>mode is an optional string that specifies the mode in which the file is opened. It defaults to ‘r’ which means open for reading in text mode. Other common values are ‘w’ for writing (truncating the file if it already exists), ‘x’ for creating and writing to a new file, and ‘a’ for appending (which on some Unix systems, means that all writes append to the end of the file regardless of the current seek position). In text mode, if encoding is not specified the encoding used is platform dependent: locale.getpreferredencoding(False) is called to get the current locale encoding. (For reading and writing raw bytes use binary mode and leave encoding unspecified.) The available modes are:</p>
-<p>========= =============================================================== Character Meaning ——— ————————————————————— ‘r’ open for reading (default) ‘w’ open for writing, truncating the file first ‘x’ create a new file and open it for writing ‘a’ open for writing, appending to the end of the file if it exists ‘b’ binary mode ‘t’ text mode (default) ‘+’ open a disk file for updating (reading and writing) ‘U’ universal newline mode (deprecated) ========= ===============================================================</p>
-<p>The default mode is ‘rt’ (open for reading text). For binary random access, the mode ‘w+b’ opens and truncates the file to 0 bytes, while ‘r+b’ opens the file without truncation. The ‘x’ mode implies ‘w’ and raises an <code>FileExistsError</code> if the file already exists.</p>
-<p>Python distinguishes between files opened in binary and text modes, even when the underlying operating system doesn’t. Files opened in binary mode (appending ‘b’ to the mode argument) return contents as bytes objects without any decoding. In text mode (the default, or when ‘t’ is appended to the mode argument), the contents of the file are returned as strings, the bytes having been first decoded using a platform-dependent encoding or using the specified encoding if given.</p>
-<p>‘U’ mode is deprecated and will raise an exception in future versions of Python. It has no effect in Python 3. Use newline to control universal newlines mode.</p>
-<p>buffering is an optional integer used to set the buffering policy. Pass 0 to switch buffering off (only allowed in binary mode), 1 to select line buffering (only usable in text mode), and an integer &gt; 1 to indicate the size of a fixed-size chunk buffer. When no buffering argument is given, the default buffering policy works as follows:</p>
-<ul>
-  <li>
-  <p>Binary files are buffered in fixed-size chunks; the size of the buffer  is chosen using a heuristic trying to determine the underlying device’s  “block size” and falling back on <code>io.DEFAULT_BUFFER_SIZE</code>.  On many systems, the buffer will typically be 4096 or 8192 bytes long.</p></li>
-  <li>
-  <p>“Interactive” text files (files for which isatty() returns True)  use line buffering. Other text files use the policy described above  for binary files.</p></li>
-</ul>
-<p>encoding is the name of the encoding used to decode or encode the file. This should only be used in text mode. The default encoding is platform dependent, but any encoding supported by Python can be passed. See the codecs module for the list of supported encodings.</p>
-<p>errors is an optional string that specifies how encoding errors are to be handled—this argument should not be used in binary mode. Pass ‘strict’ to raise a ValueError exception if there is an encoding error (the default of None has the same effect), or pass ‘ignore’ to ignore errors. (Note that ignoring encoding errors can lead to data loss.) See the documentation for codecs.register or run ‘help(codecs.Codec)’ for a list of the permitted encoding error strings.</p>
-<p>newline controls how universal newlines works (it only applies to text mode). It can be None, ’‘, ’\n’, ‘\r’, and ‘\r\n’. It works as follows:</p>
-<ul>
-  <li>
-  <p>On input, if newline is None, universal newlines mode is  enabled. Lines in the input can end in ‘\n’, ‘\r’, or ‘\r\n’, and  these are translated into ‘\n’ before being returned to the  caller. If it is ’’, universal newline mode is enabled, but line  endings are returned to the caller untranslated. If it has any of  the other legal values, input lines are only terminated by the given  string, and the line ending is returned to the caller untranslated.</p></li>
-  <li>
-  <p>On output, if newline is None, any ‘\n’ characters written are  translated to the system default line separator, os.linesep. If  newline is ’‘ or ’\n’, no translation takes place. If newline is any  of the other legal values, any ‘\n’ characters written are translated  to the given string.</p></li>
-</ul>
-<p>If closefd is False, the underlying file descriptor will be kept open when the file is closed. This does not work when a file name is given and must be True in that case.</p>
-<p>A custom opener can be used by passing a callable as <em>opener</em>. The underlying file descriptor for the file object is then obtained by calling <em>opener</em> with (*file*, <em>flags</em>). <em>opener</em> must return an open file descriptor (passing os.open as <em>opener</em> results in functionality similar to passing None).</p>
-<p>open() returns a file object whose type depends on the mode, and through which the standard file operations such as reading and writing are performed. When open() is used to open a file in a text mode (‘w’, ‘r’, ‘wt’, ‘rt’, etc.), it returns a TextIOWrapper. When used to open a file in a binary mode, the returned class varies: in read binary mode, it returns a BufferedReader; in write binary and append binary modes, it returns a BufferedWriter, and in read/write mode, it returns a BufferedRandom.</p>
-<p>It is also possible to use a string or bytearray as a file for both reading and writing. For strings StringIO can be used like a file opened in a text mode, and for bytes a BytesIO can be used like a file opened in a binary mode.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L726">view source</a></div></div><div class="public anchor" id="var-ord"><h3>ord</h3><div class="usage"><code>(ord c)</code></div><div class="doc"><div class="markdown"><p>Return the Unicode code point for a one-character string.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L399">view source</a></div></div><div class="public anchor" id="var-OSError"><h3>OSError</h3><div class="usage"><code>(OSError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for I/O related errors.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L359">view source</a></div></div><div class="public anchor" id="var-OverflowError"><h3>OverflowError</h3><div class="usage"><code>(OverflowError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Result too large to be represented.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L620">view source</a></div></div><div class="public anchor" id="var-PendingDeprecationWarning"><h3>PendingDeprecationWarning</h3><div class="usage"><code>(PendingDeprecationWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about features which will be deprecated in the future.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L692">view source</a></div></div><div class="public anchor" id="var-PermissionError"><h3>PermissionError</h3><div class="usage"><code>(PermissionError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Not enough permissions.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L63">view source</a></div></div><div class="public anchor" id="var-pow"><h3>pow</h3><div class="usage"><code>(pow base exp &amp; [{mod :mod}])</code><code>(pow base exp)</code></div><div class="doc"><div class="markdown"><p>Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments</p>
-<p>Some types, such as ints, are able to use a more efficient algorithm when invoked using the three argument form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L271">view source</a></div></div><div class="public anchor" id="var-print"><h3>print</h3><div class="usage"><code>(print self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>print(value, …, sep=‘ ’, end=‘\n’, file=sys.stdout, flush=False)</p>
-<p>Prints the values to a stream, or to sys.stdout by default. Optional keyword arguments: file: a file-like object (stream); defaults to the current sys.stdout. sep: string inserted between values, default a space. end: string appended after the last value, default a newline. flush: whether to forcibly flush the stream.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L651">view source</a></div></div><div class="public anchor" id="var-ProcessLookupError"><h3>ProcessLookupError</h3><div class="usage"><code>(ProcessLookupError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Process not found.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L423">view source</a></div></div><div class="public anchor" id="var-property"><h3>property</h3><div class="usage"><code>(property self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Property attribute.</p>
-<p>fget  function to be used for getting an attribute value  fset  function to be used for setting an attribute value  fdel  function to be used for del’ing an attribute  doc  docstring</p>
-<p>Typical use is to define a managed attribute x:</p>
-<p>class C(object):  def getx(self): return self._x  def setx(self, value): self._x = value  def delx(self): del self._x  x = property(getx, setx, delx, “I’m the ‘x’ property.”)</p>
-<p>Decorators make defining new properties or modifying existing ones easy:</p>
-<p>class C(object):  @property  def x(self):  “I am the ‘x’ property.”  return self._x  @x.setter  def x(self, value):  self._x = value  @x.deleter  def x(self):  del self._x</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L501">view source</a></div></div><div class="public anchor" id="var-PyAssertionError"><h3>PyAssertionError</h3><div class="usage"><code>(PyAssertionError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Assertion failed.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L667">view source</a></div></div><div class="public anchor" id="var-PyException"><h3>PyException</h3><div class="usage"><code>(PyException self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Common base class for all non-exit exceptions.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L924">view source</a></div></div><div class="public anchor" id="var-quit"><h3>quit</h3><div class="usage"><code>(quit self name eof)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L414">view source</a></div></div><div class="public anchor" id="var-range"><h3>range</h3><div class="usage"><code>(range self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>range(stop) -&gt; range object range(start, stop[, step]) -&gt; range object</p>
-<p>Return an object that produces a sequence of integers from start (inclusive) to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, …, j-1. start defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3. These are exactly the valid indices for a list of 4 elements. When step is given, it specifies the increment (or decrement).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L50">view source</a></div></div><div class="public anchor" id="var-RecursionError"><h3>RecursionError</h3><div class="usage"><code>(RecursionError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Recursion limit exceeded.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L22">view source</a></div></div><div class="public anchor" id="var-ReferenceError"><h3>ReferenceError</h3><div class="usage"><code>(ReferenceError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Weak ref proxy used after referent went away.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L362">view source</a></div></div><div class="public anchor" id="var-repr"><h3>repr</h3><div class="usage"><code>(repr obj)</code></div><div class="doc"><div class="markdown"><p>Return the canonical string representation of the object.</p>
-<p>For many object types, including most builtins, eval(repr(obj)) == obj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L227">view source</a></div></div><div class="public anchor" id="var-ResourceWarning"><h3>ResourceWarning</h3><div class="usage"><code>(ResourceWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about resource usage.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L154">view source</a></div></div><div class="public anchor" id="var-reversed"><h3>reversed</h3><div class="usage"><code>(reversed self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a reverse iterator over the values of the given sequence.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L88">view source</a></div></div><div class="public anchor" id="var-round"><h3>round</h3><div class="usage"><code>(round number &amp; [{ndigits :ndigits}])</code><code>(round number)</code></div><div class="doc"><div class="markdown"><p>Round a number to a given precision in decimal digits.</p>
-<p>The return value is an integer if ndigits is omitted or None. Otherwise the return value has the same type as the number. ndigits may be negative.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L871">view source</a></div></div><div class="public anchor" id="var-RuntimeError"><h3>RuntimeError</h3><div class="usage"><code>(RuntimeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unspecified run-time error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L930">view source</a></div></div><div class="public anchor" id="var-RuntimeWarning"><h3>RuntimeWarning</h3><div class="usage"><code>(RuntimeWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about dubious runtime behavior.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L411">view source</a></div></div><div class="public anchor" id="var-set"><h3>set</h3><div class="usage"><code>(set self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>set() -&gt; new empty set object set(iterable) -&gt; new set object</p>
-<p>Build an unordered collection of unique elements.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L678">view source</a></div></div><div class="public anchor" id="var-setattr"><h3>setattr</h3><div class="usage"><code>(setattr obj name value)</code></div><div class="doc"><div class="markdown"><p>Sets the named attribute on the given object to the specified value.</p>
-<p>setattr(x, ‘y’, v) is equivalent to ``x.y = v’’</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L589">view source</a></div></div><div class="public anchor" id="var-slice"><h3>slice</h3><div class="usage"><code>(slice self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>slice(stop) slice(start, stop[, step])</p>
-<p>Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L642">view source</a></div></div><div class="public anchor" id="var-sorted"><h3>sorted</h3><div class="usage"><code>(sorted iterable &amp; [{key :key, reverse :reverse}])</code></div><div class="doc"><div class="markdown"><p>Return a new list containing all items from the iterable in ascending order.</p>
-<p>A custom key function can be supplied to customize the sort order, and the reverse flag can be set to request the result in descending order.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L221">view source</a></div></div><div class="public anchor" id="var-staticmethod"><h3>staticmethod</h3><div class="usage"><code>(staticmethod self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>staticmethod(function) -&gt; method</p>
-<p>Convert a function to be a static method.</p>
-<p>A static method does not receive an implicit first argument. To declare a static method, use this idiom:</p>
-<pre><code> class C:
-     @staticmethod
-     def f(arg1, arg2, ...):
-         ...
-</code></pre>
-<p>It can be called either on the class (e.g. C.f()) or on an instance (e.g. C().f()). Both the class and the instance are ignored, and neither is passed implicitly as the first argument to the method.</p>
-<p>Static methods in Python are similar to those found in Java or C++. For a more advanced concept, see the classmethod builtin.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L127">view source</a></div></div><div class="public anchor" id="var-StopAsyncIteration"><h3>StopAsyncIteration</h3><div class="usage"><code>(StopAsyncIteration self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signal the end from iterator.__anext__().</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L949">view source</a></div></div><div class="public anchor" id="var-StopIteration"><h3>StopIteration</h3><div class="usage"><code>(StopIteration self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signal the end from iterator.__next__().</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L946">view source</a></div></div><div class="public anchor" id="var-str"><h3>str</h3><div class="usage"><code>(str self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>str(object=’’) -&gt; str str(bytes_or_buffer[, encoding[, errors]]) -&gt; str</p>
-<p>Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to ‘strict’.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L195">view source</a></div></div><div class="public anchor" id="var-sum"><h3>sum</h3><div class="usage"><code>(sum iterable &amp; [{start :start}])</code><code>(sum iterable)</code></div><div class="doc"><div class="markdown"><p>Return the sum of a ‘start’ value (default: 0) plus an iterable of numbers</p>
-<p>When the iterable is empty, return the start value. This function is intended specifically for use with numeric values and may reject non-numeric types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L188">view source</a></div></div><div class="public anchor" id="var-super"><h3>super</h3><div class="usage"><code>(super self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>super() -&gt; same as super(__class__, <first argument="">) super(type) -&gt; unbound super object super(type, obj) -&gt; bound super object; requires isinstance(obj, type) super(type, type2) -&gt; bound super object; requires issubclass(type2, type) Typical use to call a cooperative superclass method: class C(B):  def meth(self, arg):  super().meth(arg) This works for class methods too: class C(B):  @classmethod  def cmeth(cls, arg):  super().cmeth(arg)</first></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L317">view source</a></div></div><div class="public anchor" id="var-SyntaxError"><h3>SyntaxError</h3><div class="usage"><code>(SyntaxError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Invalid syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L393">view source</a></div></div><div class="public anchor" id="var-SyntaxWarning"><h3>SyntaxWarning</h3><div class="usage"><code>(SyntaxWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about dubious syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L115">view source</a></div></div><div class="public anchor" id="var-SystemError"><h3>SystemError</h3><div class="usage"><code>(SystemError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Internal error in the Python interpreter.</p>
-<p>Please report this to the Python maintainer, along with the traceback, the Python version, and the hardware/OS platform and version.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L252">view source</a></div></div><div class="public anchor" id="var-SystemExit"><h3>SystemExit</h3><div class="usage"><code>(SystemExit self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Request to exit from the interpreter.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L865">view source</a></div></div><div class="public anchor" id="var-TabError"><h3>TabError</h3><div class="usage"><code>(TabError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Improper mixture of spaces and tabs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L648">view source</a></div></div><div class="public anchor" id="var-TimeoutError"><h3>TimeoutError</h3><div class="usage"><code>(TimeoutError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Timeout expired.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L277">view source</a></div></div><div class="public anchor" id="var-True"><h3>True</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L911">view source</a></div></div><div class="public anchor" id="var-tuple"><h3>tuple</h3><div class="usage"><code>(tuple self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Built-in immutable sequence.</p>
-<p>If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.</p>
-<p>If the argument is a tuple, the return value is the same object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L696">view source</a></div></div><div class="public anchor" id="var-type"><h3>type</h3><div class="usage"><code>(type self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>type(object_or_name, bases, dict) type(object) -&gt; the object’s type type(name, bases, dict) -&gt; a new type</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L603">view source</a></div></div><div class="public anchor" id="var-TypeError"><h3>TypeError</h3><div class="usage"><code>(TypeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Inappropriate argument type.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L60">view source</a></div></div><div class="public anchor" id="var-UnboundLocalError"><h3>UnboundLocalError</h3><div class="usage"><code>(UnboundLocalError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Local name referenced but not bound to a value.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L707">view source</a></div></div><div class="public anchor" id="var-UnicodeDecodeError"><h3>UnicodeDecodeError</h3><div class="usage"><code>(UnicodeDecodeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unicode decoding error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L297">view source</a></div></div><div class="public anchor" id="var-UnicodeEncodeError"><h3>UnicodeEncodeError</h3><div class="usage"><code>(UnicodeEncodeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unicode encoding error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L396">view source</a></div></div><div class="public anchor" id="var-UnicodeError"><h3>UnicodeError</h3><div class="usage"><code>(UnicodeError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unicode related error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L365">view source</a></div></div><div class="public anchor" id="var-UnicodeTranslateError"><h3>UnicodeTranslateError</h3><div class="usage"><code>(UnicodeTranslateError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unicode translation error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L294">view source</a></div></div><div class="public anchor" id="var-UnicodeWarning"><h3>UnicodeWarning</h3><div class="usage"><code>(UnicodeWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings about Unicode related problems, mostly related to conversion problems.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L882">view source</a></div></div><div class="public anchor" id="var-UserWarning"><h3>UserWarning</h3><div class="usage"><code>(UserWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warnings generated by user code.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L639">view source</a></div></div><div class="public anchor" id="var-ValueError"><h3>ValueError</h3><div class="usage"><code>(ValueError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Inappropriate argument value (of correct type).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L713">view source</a></div></div><div class="public anchor" id="var-vars"><h3>vars</h3><div class="usage"><code>(vars self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>vars([object]) -&gt; dictionary</p>
-<p>Without arguments, equivalent to locals(). With an argument, equivalent to object.__dict__.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L961">view source</a></div></div><div class="public anchor" id="var-Warning"><h3>Warning</h3><div class="usage"><code>(Warning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for warning categories.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L374">view source</a></div></div><div class="public anchor" id="var-ZeroDivisionError"><h3>ZeroDivisionError</h3><div class="usage"><code>(ZeroDivisionError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Second argument to a division or modulo operation was zero.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L611">view source</a></div></div><div class="public anchor" id="var-zip"><h3>zip</h3><div class="usage"><code>(zip self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>zip(*iterables) –&gt; A zip object yielding tuples until an input is exhausted.</p>
-<p>&gt;&gt;&gt; list(zip(‘abcdefg’, range(3), range(4)))  [(‘a’, 0, 0), (‘b’, 1, 1), (‘c’, 2, 2)]</p>
-<p>The zip object yields n-length tuples, where n is the number of iterables passed as positional arguments to zip(). The i-th element in every tuple comes from the i-th iterable argument to zip(). This continues until the shortest argument is exhausted.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/builtins.clj#L913">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/python.numpy.html b/docs/python.numpy.html
deleted file mode 100644
index e510ef4..0000000
--- a/docs/python.numpy.html
+++ /dev/null
@@ -1,12587 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>python.numpy documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2 current"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="python.numpy.html#var-__all__"><div class="inner"><span>__all__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__builtins__"><div class="inner"><span>__builtins__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__cached__"><div class="inner"><span>__cached__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__config__"><div class="inner"><span>__config__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__dir__"><div class="inner"><span>__dir__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__doc__"><div class="inner"><span>__doc__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__file__"><div class="inner"><span>__file__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__getattr__"><div class="inner"><span>__getattr__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__git_revision__"><div class="inner"><span>__git_revision__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__loader__"><div class="inner"><span>__loader__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__name__"><div class="inner"><span>__name__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__package__"><div class="inner"><span>__package__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__path__"><div class="inner"><span>__path__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__spec__"><div class="inner"><span>__spec__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-__version__"><div class="inner"><span>__version__</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_add_newdoc_ufunc"><div class="inner"><span>_add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_distributor_init"><div class="inner"><span>_distributor_init</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_globals"><div class="inner"><span>_globals</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_mat"><div class="inner"><span>_mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_NoValue"><div class="inner"><span>_NoValue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_pytesttester"><div class="inner"><span>_pytesttester</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-_UFUNC_API"><div class="inner"><span>_UFUNC_API</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-abs"><div class="inner"><span>abs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute"><div class="inner"><span>absolute</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-absolute_import"><div class="inner"><span>absolute_import</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add"><div class="inner"><span>add</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_docstring"><div class="inner"><span>add_docstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc"><div class="inner"><span>add_newdoc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-add_newdoc_ufunc"><div class="inner"><span>add_newdoc_ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alen"><div class="inner"><span>alen</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-all"><div class="inner"><span>all</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-allclose"><div class="inner"><span>allclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ALLOW_THREADS"><div class="inner"><span>ALLOW_THREADS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-alltrue"><div class="inner"><span>alltrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amax"><div class="inner"><span>amax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-amin"><div class="inner"><span>amin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-angle"><div class="inner"><span>angle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-any"><div class="inner"><span>any</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-append"><div class="inner"><span>append</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_along_axis"><div class="inner"><span>apply_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-apply_over_axes"><div class="inner"><span>apply_over_axes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arange"><div class="inner"><span>arange</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccos"><div class="inner"><span>arccos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arccosh"><div class="inner"><span>arccosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsin"><div class="inner"><span>arcsin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arcsinh"><div class="inner"><span>arcsinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan"><div class="inner"><span>arctan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctan2"><div class="inner"><span>arctan2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-arctanh"><div class="inner"><span>arctanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmax"><div class="inner"><span>argmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argmin"><div class="inner"><span>argmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argpartition"><div class="inner"><span>argpartition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argsort"><div class="inner"><span>argsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-argwhere"><div class="inner"><span>argwhere</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-around"><div class="inner"><span>around</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array"><div class="inner"><span>array</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array2string"><div class="inner"><span>array2string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equal"><div class="inner"><span>array_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_equiv"><div class="inner"><span>array_equiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_repr"><div class="inner"><span>array_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_split"><div class="inner"><span>array_split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-array_str"><div class="inner"><span>array_str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asanyarray"><div class="inner"><span>asanyarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray"><div class="inner"><span>asarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asarray_chkfinite"><div class="inner"><span>asarray_chkfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ascontiguousarray"><div class="inner"><span>ascontiguousarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfarray"><div class="inner"><span>asfarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asfortranarray"><div class="inner"><span>asfortranarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asmatrix"><div class="inner"><span>asmatrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-asscalar"><div class="inner"><span>asscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_1d"><div class="inner"><span>atleast_1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_2d"><div class="inner"><span>atleast_2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-atleast_3d"><div class="inner"><span>atleast_3d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-average"><div class="inner"><span>average</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-AxisError"><div class="inner"><span>AxisError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bartlett"><div class="inner"><span>bartlett</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-base_repr"><div class="inner"><span>base_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-binary_repr"><div class="inner"><span>binary_repr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bincount"><div class="inner"><span>bincount</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_and"><div class="inner"><span>bitwise_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_not"><div class="inner"><span>bitwise_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_or"><div class="inner"><span>bitwise_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bitwise_xor"><div class="inner"><span>bitwise_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-blackman"><div class="inner"><span>blackman</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-block"><div class="inner"><span>block</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bmat"><div class="inner"><span>bmat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool"><div class="inner"><span>bool</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool8"><div class="inner"><span>bool8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bool_"><div class="inner"><span>bool_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast"><div class="inner"><span>broadcast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_arrays"><div class="inner"><span>broadcast_arrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-broadcast_to"><div class="inner"><span>broadcast_to</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-BUFSIZE"><div class="inner"><span>BUFSIZE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_count"><div class="inner"><span>busday_count</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busday_offset"><div class="inner"><span>busday_offset</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-busdaycalendar"><div class="inner"><span>busdaycalendar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte"><div class="inner"><span>byte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-byte_bounds"><div class="inner"><span>byte_bounds</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes0"><div class="inner"><span>bytes0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-bytes_"><div class="inner"><span>bytes_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-c_"><div class="inner"><span>c_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-can_cast"><div class="inner"><span>can_cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cast"><div class="inner"><span>cast</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cbrt"><div class="inner"><span>cbrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cdouble"><div class="inner"><span>cdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ceil"><div class="inner"><span>ceil</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cfloat"><div class="inner"><span>cfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-char"><div class="inner"><span>char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-character"><div class="inner"><span>character</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-chararray"><div class="inner"><span>chararray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-choose"><div class="inner"><span>choose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-CLIP"><div class="inner"><span>CLIP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clip"><div class="inner"><span>clip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongdouble"><div class="inner"><span>clongdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-clongfloat"><div class="inner"><span>clongfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-column_stack"><div class="inner"><span>column_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-common_type"><div class="inner"><span>common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compare_chararrays"><div class="inner"><span>compare_chararrays</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compat"><div class="inner"><span>compat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex"><div class="inner"><span>complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex128"><div class="inner"><span>complex128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex256"><div class="inner"><span>complex256</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex64"><div class="inner"><span>complex64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complex_"><div class="inner"><span>complex_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-complexfloating"><div class="inner"><span>complexfloating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ComplexWarning"><div class="inner"><span>ComplexWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-compress"><div class="inner"><span>compress</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-concatenate"><div class="inner"><span>concatenate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conj"><div class="inner"><span>conj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-conjugate"><div class="inner"><span>conjugate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-convolve"><div class="inner"><span>convolve</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copy"><div class="inner"><span>copy</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copysign"><div class="inner"><span>copysign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-copyto"><div class="inner"><span>copyto</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-core"><div class="inner"><span>core</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-corrcoef"><div class="inner"><span>corrcoef</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-correlate"><div class="inner"><span>correlate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cos"><div class="inner"><span>cos</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cosh"><div class="inner"><span>cosh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-count_nonzero"><div class="inner"><span>count_nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cov"><div class="inner"><span>cov</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cross"><div class="inner"><span>cross</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-csingle"><div class="inner"><span>csingle</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ctypeslib"><div class="inner"><span>ctypeslib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumprod"><div class="inner"><span>cumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumproduct"><div class="inner"><span>cumproduct</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-cumsum"><div class="inner"><span>cumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-DataSource"><div class="inner"><span>DataSource</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime64"><div class="inner"><span>datetime64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_as_string"><div class="inner"><span>datetime_as_string</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-datetime_data"><div class="inner"><span>datetime_data</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deg2rad"><div class="inner"><span>deg2rad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-degrees"><div class="inner"><span>degrees</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-delete"><div class="inner"><span>delete</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate"><div class="inner"><span>deprecate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-deprecate_with_doc"><div class="inner"><span>deprecate_with_doc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag"><div class="inner"><span>diag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices"><div class="inner"><span>diag_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diag_indices_from"><div class="inner"><span>diag_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagflat"><div class="inner"><span>diagflat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diagonal"><div class="inner"><span>diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-diff"><div class="inner"><span>diff</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-digitize"><div class="inner"><span>digitize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-disp"><div class="inner"><span>disp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divide"><div class="inner"><span>divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-division"><div class="inner"><span>division</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-divmod"><div class="inner"><span>divmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dot"><div class="inner"><span>dot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-double"><div class="inner"><span>double</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dsplit"><div class="inner"><span>dsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dstack"><div class="inner"><span>dstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-dtype"><div class="inner"><span>dtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-e"><div class="inner"><span>e</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ediff1d"><div class="inner"><span>ediff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum"><div class="inner"><span>einsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-einsum_path"><div class="inner"><span>einsum_path</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-emath"><div class="inner"><span>emath</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty"><div class="inner"><span>empty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-empty_like"><div class="inner"><span>empty_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-equal"><div class="inner"><span>equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_CALL"><div class="inner"><span>ERR_CALL</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_DEFAULT"><div class="inner"><span>ERR_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_IGNORE"><div class="inner"><span>ERR_IGNORE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_LOG"><div class="inner"><span>ERR_LOG</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_PRINT"><div class="inner"><span>ERR_PRINT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_RAISE"><div class="inner"><span>ERR_RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ERR_WARN"><div class="inner"><span>ERR_WARN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-errstate"><div class="inner"><span>errstate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-euler_gamma"><div class="inner"><span>euler_gamma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp"><div class="inner"><span>exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-exp2"><div class="inner"><span>exp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expand_dims"><div class="inner"><span>expand_dims</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-expm1"><div class="inner"><span>expm1</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-extract"><div class="inner"><span>extract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-eye"><div class="inner"><span>eye</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fabs"><div class="inner"><span>fabs</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fastCopyAndTranspose"><div class="inner"><span>fastCopyAndTranspose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fft"><div class="inner"><span>fft</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fill_diagonal"><div class="inner"><span>fill_diagonal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-find_common_type"><div class="inner"><span>find_common_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-finfo"><div class="inner"><span>finfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fix"><div class="inner"><span>fix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatiter"><div class="inner"><span>flatiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flatnonzero"><div class="inner"><span>flatnonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flexible"><div class="inner"><span>flexible</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flip"><div class="inner"><span>flip</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fliplr"><div class="inner"><span>fliplr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-flipud"><div class="inner"><span>flipud</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float"><div class="inner"><span>float</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float128"><div class="inner"><span>float128</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float16"><div class="inner"><span>float16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float32"><div class="inner"><span>float32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float64"><div class="inner"><span>float64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_"><div class="inner"><span>float_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-float_power"><div class="inner"><span>float_power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floating"><div class="inner"><span>floating</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FLOATING_POINT_SUPPORT"><div class="inner"><span>FLOATING_POINT_SUPPORT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor"><div class="inner"><span>floor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-floor_divide"><div class="inner"><span>floor_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmax"><div class="inner"><span>fmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmin"><div class="inner"><span>fmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fmod"><div class="inner"><span>fmod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_positional"><div class="inner"><span>format_float_positional</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_float_scientific"><div class="inner"><span>format_float_scientific</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-format_parser"><div class="inner"><span>format_parser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_DIVIDEBYZERO"><div class="inner"><span>FPE_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_INVALID"><div class="inner"><span>FPE_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_OVERFLOW"><div class="inner"><span>FPE_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-FPE_UNDERFLOW"><div class="inner"><span>FPE_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frexp"><div class="inner"><span>frexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frombuffer"><div class="inner"><span>frombuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfile"><div class="inner"><span>fromfile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromfunction"><div class="inner"><span>fromfunction</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromiter"><div class="inner"><span>fromiter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-frompyfunc"><div class="inner"><span>frompyfunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromregex"><div class="inner"><span>fromregex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fromstring"><div class="inner"><span>fromstring</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full"><div class="inner"><span>full</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-full_like"><div class="inner"><span>full_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-fv"><div class="inner"><span>fv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gcd"><div class="inner"><span>gcd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-generic"><div class="inner"><span>generic</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-genfromtxt"><div class="inner"><span>genfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geomspace"><div class="inner"><span>geomspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_array_wrap"><div class="inner"><span>get_array_wrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_include"><div class="inner"><span>get_include</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-get_printoptions"><div class="inner"><span>get_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-getbufsize"><div class="inner"><span>getbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterr"><div class="inner"><span>geterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrcall"><div class="inner"><span>geterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-geterrobj"><div class="inner"><span>geterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-gradient"><div class="inner"><span>gradient</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater"><div class="inner"><span>greater</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-greater_equal"><div class="inner"><span>greater_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-half"><div class="inner"><span>half</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hamming"><div class="inner"><span>hamming</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hanning"><div class="inner"><span>hanning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-heaviside"><div class="inner"><span>heaviside</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram"><div class="inner"><span>histogram</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram2d"><div class="inner"><span>histogram2d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogram_bin_edges"><div class="inner"><span>histogram_bin_edges</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-histogramdd"><div class="inner"><span>histogramdd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hsplit"><div class="inner"><span>hsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hstack"><div class="inner"><span>hstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-hypot"><div class="inner"><span>hypot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-i0"><div class="inner"><span>i0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-identity"><div class="inner"><span>identity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iinfo"><div class="inner"><span>iinfo</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-imag"><div class="inner"><span>imag</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-in1d"><div class="inner"><span>in1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-index_exp"><div class="inner"><span>index_exp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-indices"><div class="inner"><span>indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inexact"><div class="inner"><span>inexact</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Inf"><div class="inner"><span>Inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inf"><div class="inner"><span>inf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-Infinity"><div class="inner"><span>Infinity</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-info"><div class="inner"><span>info</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-infty"><div class="inner"><span>infty</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-inner"><div class="inner"><span>inner</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-insert"><div class="inner"><span>insert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int"><div class="inner"><span>int</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int0"><div class="inner"><span>int0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int16"><div class="inner"><span>int16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int32"><div class="inner"><span>int32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int64"><div class="inner"><span>int64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int8"><div class="inner"><span>int8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_"><div class="inner"><span>int_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-int_asbuffer"><div class="inner"><span>int_asbuffer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intc"><div class="inner"><span>intc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-integer"><div class="inner"><span>integer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-interp"><div class="inner"><span>interp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intersect1d"><div class="inner"><span>intersect1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-intp"><div class="inner"><span>intp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-invert"><div class="inner"><span>invert</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ipmt"><div class="inner"><span>ipmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-irr"><div class="inner"><span>irr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-is_busday"><div class="inner"><span>is_busday</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isclose"><div class="inner"><span>isclose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplex"><div class="inner"><span>iscomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iscomplexobj"><div class="inner"><span>iscomplexobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfinite"><div class="inner"><span>isfinite</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isfortran"><div class="inner"><span>isfortran</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isin"><div class="inner"><span>isin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isinf"><div class="inner"><span>isinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnan"><div class="inner"><span>isnan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isnat"><div class="inner"><span>isnat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isneginf"><div class="inner"><span>isneginf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isposinf"><div class="inner"><span>isposinf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isreal"><div class="inner"><span>isreal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isrealobj"><div class="inner"><span>isrealobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-isscalar"><div class="inner"><span>isscalar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issctype"><div class="inner"><span>issctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubclass_"><div class="inner"><span>issubclass_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubdtype"><div class="inner"><span>issubdtype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-issubsctype"><div class="inner"><span>issubsctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-iterable"><div class="inner"><span>iterable</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ix_"><div class="inner"><span>ix_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kaiser"><div class="inner"><span>kaiser</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-kron"><div class="inner"><span>kron</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lcm"><div class="inner"><span>lcm</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ldexp"><div class="inner"><span>ldexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-left_shift"><div class="inner"><span>left_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less"><div class="inner"><span>less</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-less_equal"><div class="inner"><span>less_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lexsort"><div class="inner"><span>lexsort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lib"><div class="inner"><span>lib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linalg"><div class="inner"><span>linalg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-linspace"><div class="inner"><span>linspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-little_endian"><div class="inner"><span>little_endian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-load"><div class="inner"><span>load</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loads"><div class="inner"><span>loads</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-loadtxt"><div class="inner"><span>loadtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log"><div class="inner"><span>log</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log10"><div class="inner"><span>log10</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log1p"><div class="inner"><span>log1p</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-log2"><div class="inner"><span>log2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp"><div class="inner"><span>logaddexp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logaddexp2"><div class="inner"><span>logaddexp2</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_and"><div class="inner"><span>logical_and</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_not"><div class="inner"><span>logical_not</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_or"><div class="inner"><span>logical_or</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logical_xor"><div class="inner"><span>logical_xor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-logspace"><div class="inner"><span>logspace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-long"><div class="inner"><span>long</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longcomplex"><div class="inner"><span>longcomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longdouble"><div class="inner"><span>longdouble</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longfloat"><div class="inner"><span>longfloat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-longlong"><div class="inner"><span>longlong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-lookfor"><div class="inner"><span>lookfor</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ma"><div class="inner"><span>ma</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MachAr"><div class="inner"><span>MachAr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mafromtxt"><div class="inner"><span>mafromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mask_indices"><div class="inner"><span>mask_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mat"><div class="inner"><span>mat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-math"><div class="inner"><span>math</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matmul"><div class="inner"><span>matmul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrix"><div class="inner"><span>matrix</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-matrixlib"><div class="inner"><span>matrixlib</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-max"><div class="inner"><span>max</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAXDIMS"><div class="inner"><span>MAXDIMS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum"><div class="inner"><span>maximum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-maximum_sctype"><div class="inner"><span>maximum_sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_BOUNDS"><div class="inner"><span>MAY_SHARE_BOUNDS</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-MAY_SHARE_EXACT"><div class="inner"><span>MAY_SHARE_EXACT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-may_share_memory"><div class="inner"><span>may_share_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mean"><div class="inner"><span>mean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-median"><div class="inner"><span>median</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-memmap"><div class="inner"><span>memmap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-meshgrid"><div class="inner"><span>meshgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mgrid"><div class="inner"><span>mgrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min"><div class="inner"><span>min</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-min_scalar_type"><div class="inner"><span>min_scalar_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-minimum"><div class="inner"><span>minimum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mintypecode"><div class="inner"><span>mintypecode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mirr"><div class="inner"><span>mirr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-mod"><div class="inner"><span>mod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-modf"><div class="inner"><span>modf</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ModuleDeprecationWarning"><div class="inner"><span>ModuleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-moveaxis"><div class="inner"><span>moveaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-msort"><div class="inner"><span>msort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-multiply"><div class="inner"><span>multiply</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NAN"><div class="inner"><span>NAN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NaN"><div class="inner"><span>NaN</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan"><div class="inner"><span>nan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nan_to_num"><div class="inner"><span>nan_to_num</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmax"><div class="inner"><span>nanargmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanargmin"><div class="inner"><span>nanargmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumprod"><div class="inner"><span>nancumprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nancumsum"><div class="inner"><span>nancumsum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmax"><div class="inner"><span>nanmax</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmean"><div class="inner"><span>nanmean</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmedian"><div class="inner"><span>nanmedian</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanmin"><div class="inner"><span>nanmin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanpercentile"><div class="inner"><span>nanpercentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanprod"><div class="inner"><span>nanprod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanquantile"><div class="inner"><span>nanquantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanstd"><div class="inner"><span>nanstd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nansum"><div class="inner"><span>nansum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nanvar"><div class="inner"><span>nanvar</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nbytes"><div class="inner"><span>nbytes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndarray"><div class="inner"><span>ndarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndenumerate"><div class="inner"><span>ndenumerate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndfromtxt"><div class="inner"><span>ndfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndim"><div class="inner"><span>ndim</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ndindex"><div class="inner"><span>ndindex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nditer"><div class="inner"><span>nditer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-negative"><div class="inner"><span>negative</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nested_iters"><div class="inner"><span>nested_iters</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nextafter"><div class="inner"><span>nextafter</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NINF"><div class="inner"><span>NINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nonzero"><div class="inner"><span>nonzero</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-not_equal"><div class="inner"><span>not_equal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-nper"><div class="inner"><span>nper</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-npv"><div class="inner"><span>npv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-numarray"><div class="inner"><span>numarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-number"><div class="inner"><span>number</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-NZERO"><div class="inner"><span>NZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-obj2sctype"><div class="inner"><span>obj2sctype</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object"><div class="inner"><span>object</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object0"><div class="inner"><span>object0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-object_"><div class="inner"><span>object_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ogrid"><div class="inner"><span>ogrid</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-oldnumeric"><div class="inner"><span>oldnumeric</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones"><div class="inner"><span>ones</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ones_like"><div class="inner"><span>ones_like</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-outer"><div class="inner"><span>outer</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-packbits"><div class="inner"><span>packbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pad"><div class="inner"><span>pad</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-partition"><div class="inner"><span>partition</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-percentile"><div class="inner"><span>percentile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pi"><div class="inner"><span>pi</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-piecewise"><div class="inner"><span>piecewise</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PINF"><div class="inner"><span>PINF</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-place"><div class="inner"><span>place</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pmt"><div class="inner"><span>pmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly"><div class="inner"><span>poly</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-poly1d"><div class="inner"><span>poly1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyadd"><div class="inner"><span>polyadd</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyder"><div class="inner"><span>polyder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polydiv"><div class="inner"><span>polydiv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyfit"><div class="inner"><span>polyfit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyint"><div class="inner"><span>polyint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polymul"><div class="inner"><span>polymul</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polynomial"><div class="inner"><span>polynomial</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polysub"><div class="inner"><span>polysub</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-polyval"><div class="inner"><span>polyval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-positive"><div class="inner"><span>positive</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-power"><div class="inner"><span>power</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ppmt"><div class="inner"><span>ppmt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-print_function"><div class="inner"><span>print_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-printoptions"><div class="inner"><span>printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-prod"><div class="inner"><span>prod</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-product"><div class="inner"><span>product</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-promote_types"><div class="inner"><span>promote_types</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ptp"><div class="inner"><span>ptp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put"><div class="inner"><span>put</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-put_along_axis"><div class="inner"><span>put_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-putmask"><div class="inner"><span>putmask</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-pv"><div class="inner"><span>pv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-PZERO"><div class="inner"><span>PZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-quantile"><div class="inner"><span>quantile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-r_"><div class="inner"><span>r_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rad2deg"><div class="inner"><span>rad2deg</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-radians"><div class="inner"><span>radians</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RAISE"><div class="inner"><span>RAISE</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-random"><div class="inner"><span>random</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-RankWarning"><div class="inner"><span>RankWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rate"><div class="inner"><span>rate</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel"><div class="inner"><span>ravel</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ravel_multi_index"><div class="inner"><span>ravel_multi_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real"><div class="inner"><span>real</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-real_if_close"><div class="inner"><span>real_if_close</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rec"><div class="inner"><span>rec</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recarray"><div class="inner"><span>recarray</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromcsv"><div class="inner"><span>recfromcsv</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-recfromtxt"><div class="inner"><span>recfromtxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reciprocal"><div class="inner"><span>reciprocal</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-record"><div class="inner"><span>record</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-remainder"><div class="inner"><span>remainder</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-repeat"><div class="inner"><span>repeat</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-require"><div class="inner"><span>require</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-reshape"><div class="inner"><span>reshape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-resize"><div class="inner"><span>resize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-result_type"><div class="inner"><span>result_type</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-right_shift"><div class="inner"><span>right_shift</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rint"><div class="inner"><span>rint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roll"><div class="inner"><span>roll</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rollaxis"><div class="inner"><span>rollaxis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-roots"><div class="inner"><span>roots</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-rot90"><div class="inner"><span>rot90</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round"><div class="inner"><span>round</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-round_"><div class="inner"><span>round_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-row_stack"><div class="inner"><span>row_stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-s_"><div class="inner"><span>s_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-safe_eval"><div class="inner"><span>safe_eval</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-save"><div class="inner"><span>save</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savetxt"><div class="inner"><span>savetxt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez"><div class="inner"><span>savez</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-savez_compressed"><div class="inner"><span>savez_compressed</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ScalarType"><div class="inner"><span>ScalarType</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctype2char"><div class="inner"><span>sctype2char</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeDict"><div class="inner"><span>sctypeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypeNA"><div class="inner"><span>sctypeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sctypes"><div class="inner"><span>sctypes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-searchsorted"><div class="inner"><span>searchsorted</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-select"><div class="inner"><span>select</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_numeric_ops"><div class="inner"><span>set_numeric_ops</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_printoptions"><div class="inner"><span>set_printoptions</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-set_string_function"><div class="inner"><span>set_string_function</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setbufsize"><div class="inner"><span>setbufsize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setdiff1d"><div class="inner"><span>setdiff1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterr"><div class="inner"><span>seterr</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrcall"><div class="inner"><span>seterrcall</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-seterrobj"><div class="inner"><span>seterrobj</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-setxor1d"><div class="inner"><span>setxor1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shape"><div class="inner"><span>shape</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-shares_memory"><div class="inner"><span>shares_memory</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_DIVIDEBYZERO"><div class="inner"><span>SHIFT_DIVIDEBYZERO</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_INVALID"><div class="inner"><span>SHIFT_INVALID</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_OVERFLOW"><div class="inner"><span>SHIFT_OVERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-SHIFT_UNDERFLOW"><div class="inner"><span>SHIFT_UNDERFLOW</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-short"><div class="inner"><span>short</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-show_config"><div class="inner"><span>show_config</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sign"><div class="inner"><span>sign</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signbit"><div class="inner"><span>signbit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-signedinteger"><div class="inner"><span>signedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sin"><div class="inner"><span>sin</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinc"><div class="inner"><span>sinc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-single"><div class="inner"><span>single</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-singlecomplex"><div class="inner"><span>singlecomplex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sinh"><div class="inner"><span>sinh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-size"><div class="inner"><span>size</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sometrue"><div class="inner"><span>sometrue</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort"><div class="inner"><span>sort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sort_complex"><div class="inner"><span>sort_complex</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-source"><div class="inner"><span>source</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-spacing"><div class="inner"><span>spacing</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-split"><div class="inner"><span>split</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sqrt"><div class="inner"><span>sqrt</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-square"><div class="inner"><span>square</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-squeeze"><div class="inner"><span>squeeze</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-stack"><div class="inner"><span>stack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-std"><div class="inner"><span>std</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str"><div class="inner"><span>str</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str0"><div class="inner"><span>str0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-str_"><div class="inner"><span>str_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-string_"><div class="inner"><span>string_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-subtract"><div class="inner"><span>subtract</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sum"><div class="inner"><span>sum</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-swapaxes"><div class="inner"><span>swapaxes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-sys"><div class="inner"><span>sys</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take"><div class="inner"><span>take</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-take_along_axis"><div class="inner"><span>take_along_axis</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tan"><div class="inner"><span>tan</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tanh"><div class="inner"><span>tanh</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tensordot"><div class="inner"><span>tensordot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-test"><div class="inner"><span>test</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tile"><div class="inner"><span>tile</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-timedelta64"><div class="inner"><span>timedelta64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-TooHardError"><div class="inner"><span>TooHardError</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trace"><div class="inner"><span>trace</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tracemalloc_domain"><div class="inner"><span>tracemalloc_domain</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-transpose"><div class="inner"><span>transpose</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trapz"><div class="inner"><span>trapz</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tri"><div class="inner"><span>tri</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril"><div class="inner"><span>tril</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices"><div class="inner"><span>tril_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-tril_indices_from"><div class="inner"><span>tril_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trim_zeros"><div class="inner"><span>trim_zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu"><div class="inner"><span>triu</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices"><div class="inner"><span>triu_indices</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-triu_indices_from"><div class="inner"><span>triu_indices_from</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-True_"><div class="inner"><span>True_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-true_divide"><div class="inner"><span>true_divide</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-trunc"><div class="inner"><span>trunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typecodes"><div class="inner"><span>typecodes</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeDict"><div class="inner"><span>typeDict</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typeNA"><div class="inner"><span>typeNA</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-typename"><div class="inner"><span>typename</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ubyte"><div class="inner"><span>ubyte</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ufunc"><div class="inner"><span>ufunc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_BUFSIZE_DEFAULT"><div class="inner"><span>UFUNC_BUFSIZE_DEFAULT</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-UFUNC_PYVALS_NAME"><div class="inner"><span>UFUNC_PYVALS_NAME</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint"><div class="inner"><span>uint</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint0"><div class="inner"><span>uint0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint16"><div class="inner"><span>uint16</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint32"><div class="inner"><span>uint32</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint64"><div class="inner"><span>uint64</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uint8"><div class="inner"><span>uint8</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintc"><div class="inner"><span>uintc</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-uintp"><div class="inner"><span>uintp</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ulonglong"><div class="inner"><span>ulonglong</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode"><div class="inner"><span>unicode</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unicode_"><div class="inner"><span>unicode_</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-union1d"><div class="inner"><span>union1d</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unique"><div class="inner"><span>unique</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unpackbits"><div class="inner"><span>unpackbits</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unravel_index"><div class="inner"><span>unravel_index</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unsignedinteger"><div class="inner"><span>unsignedinteger</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-unwrap"><div class="inner"><span>unwrap</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-ushort"><div class="inner"><span>ushort</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vander"><div class="inner"><span>vander</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-var"><div class="inner"><span>var</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vdot"><div class="inner"><span>vdot</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vectorize"><div class="inner"><span>vectorize</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-version"><div class="inner"><span>version</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-VisibleDeprecationWarning"><div class="inner"><span>VisibleDeprecationWarning</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void"><div class="inner"><span>void</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-void0"><div class="inner"><span>void0</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vsplit"><div class="inner"><span>vsplit</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-vstack"><div class="inner"><span>vstack</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-warnings"><div class="inner"><span>warnings</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-where"><div class="inner"><span>where</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-who"><div class="inner"><span>who</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-WRAP"><div class="inner"><span>WRAP</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros"><div class="inner"><span>zeros</span></div></a></li><li class="depth-1"><a href="python.numpy.html#var-zeros_like"><div class="inner"><span>zeros_like</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">python.numpy</h1><div class="doc"><div class="markdown"><p>No documentation provided</p></div></div><div class="public anchor" id="var-__all__"><h3>__all__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
-<p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9546">view source</a></div></div><div class="public anchor" id="var-__builtins__"><h3>__builtins__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20341">view source</a></div></div><div class="public anchor" id="var-__cached__"><h3>__cached__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1128">view source</a></div></div><div class="public anchor" id="var-__config__"><h3>__config__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1397">view source</a></div></div><div class="public anchor" id="var-__dir__"><h3>__dir__</h3><div class="usage"><code>(__dir__)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15418">view source</a></div></div><div class="public anchor" id="var-__doc__"><h3>__doc__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24488">view source</a></div></div><div class="public anchor" id="var-__file__"><h3>__file__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12395">view source</a></div></div><div class="public anchor" id="var-__getattr__"><h3>__getattr__</h3><div class="usage"><code>(__getattr__ attr)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11936">view source</a></div></div><div class="public anchor" id="var-__git_revision__"><h3>__git_revision__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21934">view source</a></div></div><div class="public anchor" id="var-__loader__"><h3>__loader__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Concrete implementation of SourceLoader using the file system.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8866">view source</a></div></div><div class="public anchor" id="var-__name__"><h3>__name__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25727">view source</a></div></div><div class="public anchor" id="var-__package__"><h3>__package__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27881">view source</a></div></div><div class="public anchor" id="var-__path__"><h3>__path__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in mutable sequence.</p>
-<p>If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13526">view source</a></div></div><div class="public anchor" id="var-__spec__"><h3>__spec__</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>The specification for a module, used for loading.</p>
-<p>A module’s spec is the source for information about the module. For data associated with the module, including source, use the spec’s loader.</p>
-<p><code>name</code> is the absolute name of the module. <code>loader</code> is the loader to use when loading the module. <code>parent</code> is the name of the package the module is in. The parent is derived from the name.</p>
-<p><code>is_package</code> determines if the module is considered a package or not. On modules this is reflected by the <code>__path__</code> attribute.</p>
-<p><code>origin</code> is the specific location used by the loader from which to load the module, if that information is available. When filename is set, origin will match.</p>
-<p><code>has_location</code> indicates that a spec’s “origin” reflects a location. When this is True, <code>__file__</code> attribute of the module is set.</p>
-<p><code>cached</code> is the location of the cached bytecode file, if any. It corresponds to the <code>__cached__</code> attribute.</p>
-<p><code>submodule_search_locations</code> is the sequence of path entries to search when importing submodules. If set, is_package should be True–and False otherwise.</p>
-<p>Packages are simply modules that (may) have submodules. If a spec has a non-None value in <code>submodule_search_locations</code>, the import system will consider modules loaded from the spec as packages.</p>
-<p>Only finders (see importlib.abc.MetaPathFinder and importlib.abc.PathEntryFinder) should modify ModuleSpec instances.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18000">view source</a></div></div><div class="public anchor" id="var-__version__"><h3>__version__</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21898">view source</a></div></div><div class="public anchor" id="var-_add_newdoc_ufunc"><h3>_add_newdoc_ufunc</h3><div class="usage"><code>(_add_newdoc_ufunc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>add_ufunc_docstring(ufunc, new_docstring)</p>
-<p>Replace the docstring for a ufunc with new_docstring. This method will only work if the current docstring for the ufunc is NULL. (At the C level, i.e. when ufunc-&gt;doc is NULL.)</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>ufunc : numpy.ufunc  A ufunc whose current doc is NULL. new_docstring : string  The new docstring for the ufunc.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This method allocates memory for new_docstring on the heap. Technically this creates a mempory leak, since this memory will not be reclaimed until the end of the program even if the ufunc itself is removed. However this will only be a problem if the user is repeatedly creating ufuncs with no documentation, adding documentation via add_newdoc_ufunc, and then throwing away the ufunc.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21334">view source</a></div></div><div class="public anchor" id="var-_distributor_init"><h3>_distributor_init</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Distributor init file</p>
-<p>Distributors: you can add custom code here to support particular distributions of numpy.</p>
-<p>For example, this is a good place to put any checks for hardware requirements.</p>
-<p>The numpy standard source distribution will not put code in this file, so you can safely replace this file with your own version.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28970">view source</a></div></div><div class="public anchor" id="var-_globals"><h3>_globals</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Module defining global singleton classes.</p>
-<p>This module raises a RuntimeError if an attempt to reload it is made. In that way the identities of the classes defined here are fixed and will remain so even if numpy itself is reloaded. In particular, a function like the following will still work correctly after numpy is reloaded::</p>
-<pre><code>def foo(arg=np._NoValue):
-    if arg is np._NoValue:
-        ...
-</code></pre>
-<p>That was not the case when the singleton classes were defined in the numpy <code>__init__.py</code> file. See gh-7844 for a discussion of the reload problem that motivated this module.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20801">view source</a></div></div><div class="public anchor" id="var-_mat"><h3>_mat</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Sub-package containing the matrix class and related functions.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3786">view source</a></div></div><div class="public anchor" id="var-_NoValue"><h3>_NoValue</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Special keyword value.</p>
-<p>The instance of this class may be used as the default value assigned to a deprecated keyword in order to check if it has been given a user defined value.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13726">view source</a></div></div><div class="public anchor" id="var-_pytesttester"><h3>_pytesttester</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Pytest test running.</p>
-<p>This module implements the <code>test()</code> function for NumPy modules. The usual boiler plate for doing that is to put the following in the module <code>__init__.py</code> file::</p>
-<pre><code>from numpy._pytesttester import PytestTester
-test = PytestTester(__name__).test
-del PytestTester
-</code></pre>
-<p>Warnings filtering and other runtime settings should be dealt with in the <code>pytest.ini</code> file in the numpy repo root. The behavior of the test depends on whether or not that file is found as follows:</p>
-<ul>
-  <li><code>pytest.ini</code> is present (develop mode) All warnings except those explicily filtered out are raised as error.</li>
-  <li><code>pytest.ini</code> is absent (release mode) DeprecationWarnings and PendingDeprecationWarnings are ignored, other warnings are passed through.</li>
-</ul>
-<p>In practice, tests run from the numpy repo are run in develop mode. That includes the standard <code>python runtests.py</code> invocation.</p>
-<p>This module is imported by every numpy subpackage, so lies at the top level to simplify circular import issues. For the same reason, it contains no numpy imports at module scope, instead importing numpy within function calls.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14837">view source</a></div></div><div class="public anchor" id="var-_UFUNC_API"><h3>_UFUNC_API</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Capsule objects let you wrap a C "void *" pointer in a Python object. They’re a way of passing data through the Python interpreter without creating your own custom type.</p>
-<p>Capsules are used for communication between extension modules. They provide a way for an extension module to export a C interface to other extension modules, so that extension modules can use the Python import mechanism to link to one another.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8207">view source</a></div></div><div class="public anchor" id="var-abs"><h3>abs</h3><div class="usage"><code>(abs self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>absolute(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Calculate the absolute value element-wise.</p>
-<p><code>np.abs</code> is a shorthand for this function.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>absolute : ndarray  An ndarray containing the absolute value of  each element in <code>x</code>. For complex input, <code>a + ib</code>, the  absolute value is :math:<code>\sqrt{ a^2 + b^2 }</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([-1.2, 1.2]) np.absolute(x) array([ 1.2, 1.2]) np.absolute(1.2 + 1j) 1.5620499351813308</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot the function over <code>[-10, 10]</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt</p>
-      <p>x = np.linspace(start=-10, stop=10, num=101) plt.plot(x, np.absolute(x)) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot the function over the complex plane:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>xx = x + 1j * x[:, np.newaxis] plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap=‘gray’) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20709">view source</a></div></div><div class="public anchor" id="var-absolute"><h3>absolute</h3><div class="usage"><code>(absolute self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>absolute(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Calculate the absolute value element-wise.</p>
-<p><code>np.abs</code> is a shorthand for this function.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>absolute : ndarray  An ndarray containing the absolute value of  each element in <code>x</code>. For complex input, <code>a + ib</code>, the  absolute value is :math:<code>\sqrt{ a^2 + b^2 }</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([-1.2, 1.2]) np.absolute(x) array([ 1.2, 1.2]) np.absolute(1.2 + 1j) 1.5620499351813308</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot the function over <code>[-10, 10]</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt</p>
-      <p>x = np.linspace(start=-10, stop=10, num=101) plt.plot(x, np.absolute(x)) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot the function over the complex plane:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>xx = x + 1j * x[:, np.newaxis] plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap=‘gray’) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27150">view source</a></div></div><div class="public anchor" id="var-absolute_import"><h3>absolute_import</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3784">view source</a></div></div><div class="public anchor" id="var-add"><h3>add</h3><div class="usage"><code>(add self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>add(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Add arguments element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  The arrays to be added. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>add : ndarray or scalar  The sum of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Equivalent to <code>x1</code> + <code>x2</code> in terms of array broadcasting.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.add(1.0, 4.0) 5.0 x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.add(x1, x2) array(<a href="null">  0.,   2.,   4.],
-       [  3.,   5.,   7.],
-       [  6.,   8.,  10.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22784">view source</a></div></div><div class="public anchor" id="var-add_docstring"><h3>add_docstring</h3><div class="usage"><code>(add_docstring self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>add_docstring(obj, docstring)</p>
-<p>Add a docstring to a built-in obj if possible. If the obj already has a docstring raise a RuntimeError If this routine does not know how to add a docstring to the object raise a TypeError</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28981">view source</a></div></div><div class="public anchor" id="var-add_newdoc"><h3>add_newdoc</h3><div class="usage"><code>(add_newdoc place obj doc &amp; [{warn_on_python :warn_on_python}])</code><code>(add_newdoc place obj doc)</code></div><div class="doc"><div class="markdown"><p>Add documentation to an existing object, typically one defined in C</p>
-<p>The purpose is to allow easier editing of the docstrings without requiring a re-compile. This exists primarily for internal use within numpy itself.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>place : str  The absolute name of the module to import from obj : str  The name of the object to add documentation to, typically a class or  function name doc : {str, Tuple[str, str], List[Tuple[str, str]]}  If a string, the documentation to apply to <code>obj</code></p>
-<pre><code>If a tuple, then the first element is interpreted as an attribute of
-`obj` and the second as the docstring to apply - ``(method, docstring)``
-
-If a list, then each element of the list should be a tuple of length
-two - ``[(method1, docstring1), (method2, docstring2), ...]``
-</code></pre>
-<p>warn_on_python : bool  If True, the default, emit <code>UserWarning</code> if this is used to attach  documentation to a pure-python object.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This routine never raises an error if the docstring can’t be written, but will raise an error if the object being documented does not exist.</p>
-<p>This routine cannot modify read-only docstrings, as appear in new-style classes or built-in functions. Because this routine never raises an error the caller must check manually that the docstrings were changed.</p>
-<p>Since this function grabs the <code>char *</code> from a c-level str object and puts it into the <code>tp_doc</code> slot of the type of <code>obj</code>, it violates a number of C-API best-practices, by:</p>
-<ul>
-  <li>modifying a <code>PyTypeObject</code> after calling <code>PyType_Ready</code></li>
-  <li>calling <code>Py_INCREF</code> on the str and losing the reference, so the str  will never be released</li>
-</ul>
-<p>If possible it should be avoided.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3737">view source</a></div></div><div class="public anchor" id="var-add_newdoc_ufunc"><h3>add_newdoc_ufunc</h3><div class="usage"><code>(add_newdoc_ufunc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>add_ufunc_docstring(ufunc, new_docstring)</p>
-<p>Replace the docstring for a ufunc with new_docstring. This method will only work if the current docstring for the ufunc is NULL. (At the C level, i.e. when ufunc-&gt;doc is NULL.)</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>ufunc : numpy.ufunc  A ufunc whose current doc is NULL. new_docstring : string  The new docstring for the ufunc.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This method allocates memory for new_docstring on the heap. Technically this creates a mempory leak, since this memory will not be reclaimed until the end of the program even if the ufunc itself is removed. However this will only be a problem if the user is repeatedly creating ufuncs with no documentation, adding documentation via add_newdoc_ufunc, and then throwing away the ufunc.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8568">view source</a></div></div><div class="public anchor" id="var-alen"><h3>alen</h3><div class="usage"><code>(alen &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the length of the first dimension of the input array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>alen : int  Length of the first dimension of <code>a</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>shape, size</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.zeros((7,4,5)) a.shape[0] 7 np.alen(a) 7</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1399">view source</a></div></div><div class="public anchor" id="var-all"><h3>all</h3><div class="usage"><code>(all &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Test whether all array elements along a given axis evaluate to True.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array or object that can be converted to an array. axis : None or int or tuple of ints, optional  Axis or axes along which a logical AND reduction is performed.  The default (<code>axis=None</code>) is to perform a logical AND over all  the dimensions of the input array. <code>axis</code> may be negative, in  which case it counts from the last to the first axis.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If this is a tuple of ints, a reduction is performed on multiple
-axes, instead of a single axis or all the axes as before.
-</code></pre>
-<p>out : ndarray, optional  Alternate output array in which to place the result.  It must have the same shape as the expected output and its  type is preserved (e.g., if <code>dtype(out)</code> is float, the result  will consist of 0.0’s and 1.0’s). See <code>ufuncs-output-type</code> for more  details.</p>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `all` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>all : ndarray, bool  A new boolean or array is returned unless <code>out</code> is specified,  in which case a reference to <code>out</code> is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.all : equivalent method</p>
-<p>any : Test whether any element along a given axis evaluates to True.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Not a Number (NaN), positive infinity and negative infinity evaluate to <code>True</code> because these are not equal to zero.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.all(<a href="null">True,False],[True,True</a>) False</p>
-      <p>np.all(<a href="null">True,False],[True,True</a>, axis=0) array([ True, False])</p>
-      <p>np.all([-1, 4, 5]) True</p>
-      <p>np.all([1.0, np.nan]) True</p>
-      <p>o=np.array(False) z=np.all([-1, 4, 5], out=o) id(z), id(o), z (28293632, 28293632, array(True)) # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23411">view source</a></div></div><div class="public anchor" id="var-allclose"><h3>allclose</h3><div class="usage"><code>(allclose &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns True if two arrays are element-wise equal within a tolerance.</p>
-<p>The tolerance values are positive, typically very small numbers. The relative difference (<code>rtol</code> * abs(<code>b</code>)) and the absolute difference <code>atol</code> are added together to compare against the absolute difference between <code>a</code> and <code>b</code>.</p>
-<p>NaNs are treated as equal if they are in the same place and if <code>equal_nan=True</code>. Infs are treated as equal if they are in the same place and of the same sign in both arrays.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a, b : array_like  Input arrays to compare. rtol : float  The relative tolerance parameter (see Notes). atol : float  The absolute tolerance parameter (see Notes). equal_nan : bool  Whether to compare NaN’s as equal. If True, NaN’s in <code>a</code> will be  considered equal to NaN’s in <code>b</code> in the output array.</p>
-<pre><code>.. versionadded:: 1.10.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>allclose : bool  Returns True if the two arrays are equal within the given  tolerance; False otherwise.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>isclose, all, any, equal</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If the following equation is element-wise True, then allclose returns True.</p>
-<p>absolute(<code>a</code> - <code>b</code>) &lt;= (<code>atol</code> + <code>rtol</code> * absolute(<code>b</code>))</p>
-<p>The above equation is not symmetric in <code>a</code> and <code>b</code>, so that <code>allclose(a, b)</code> might be different from <code>allclose(b, a)</code> in some rare cases.</p>
-<p>The comparison of <code>a</code> and <code>b</code> uses standard broadcasting, which means that <code>a</code> and <code>b</code> need not have the same shape in order for <code>allclose(a, b)</code> to evaluate to True. The same is true for <code>equal</code> but not <code>array_equal</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.allclose([1e10,1e-7], [1.00001e10,1e-8]) False np.allclose([1e10,1e-8], [1.00001e10,1e-9]) True np.allclose([1e10,1e-8], [1.0001e10,1e-9]) False np.allclose([1.0, np.nan], [1.0, np.nan]) False np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23992">view source</a></div></div><div class="public anchor" id="var-ALLOW_THREADS"><h3>ALLOW_THREADS</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16466">view source</a></div></div><div class="public anchor" id="var-alltrue"><h3>alltrue</h3><div class="usage"><code>(alltrue &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Check if all elements of input array are true.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.all : Equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6907">view source</a></div></div><div class="public anchor" id="var-amax"><h3>amax</h3><div class="usage"><code>(amax &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the maximum of an array or maximum along an axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  Axis or axes along which to operate. By default, flattened input is  used.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If this is a tuple of ints, the maximum is selected over multiple axes,
-instead of a single axis or all the axes as before.
-</code></pre>
-<p>out : ndarray, optional  Alternative output array in which to place the result. Must  be of the same shape and buffer length as the expected output.  See <code>ufuncs-output-type</code> for more details.</p>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `amax` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<p>initial : scalar, optional  The minimum value of an output element. Must be present to allow  computation on empty slice. See <code>~numpy.ufunc.reduce</code> for details.</p>
-<pre><code>.. versionadded:: 1.15.0
-</code></pre>
-<p>where : array_like of bool, optional  Elements to compare for the maximum. See <code>~numpy.ufunc.reduce</code>  for details.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>amax : ndarray or scalar  Maximum of <code>a</code>. If <code>axis</code> is None, the result is a scalar value.  If <code>axis</code> is given, the result is an array of dimension  <code>a.ndim - 1</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>amin :  The minimum value of an array along a given axis, propagating any NaNs. nanmax :  The maximum value of an array along a given axis, ignoring any NaNs. maximum :  Element-wise maximum of two arrays, propagating any NaNs. fmax :  Element-wise maximum of two arrays, ignoring any NaNs. argmax :  Return the indices of the maximum values.</p>
-<p>nanmin, minimum, fmin</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>NaN values are propagated, that is if at least one item is NaN, the corresponding max value will be NaN as well. To ignore NaN values (MATLAB behavior), please use nanmax.</p>
-<p>Don’t use <code>amax</code> for element-wise comparison of 2 arrays; when <code>a.shape[0]</code> is 2, <code>maximum(a[0], a[1])</code> is faster than <code>amax(a, axis=0)</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(4).reshape((2,2)) a array(<a href="null">0, 1],
-       [2, 3</a>) np.amax(a) # Maximum of the flattened array 3 np.amax(a, axis=0) # Maxima along the first axis array([2, 3]) np.amax(a, axis=1) # Maxima along the second axis array([1, 3]) np.amax(a, where=[False, True], initial=-1, axis=0) array([-1, 3]) b = np.arange(5, dtype=float) b[2] = np.NaN np.amax(b) nan np.amax(b, where=~np.isnan(b), initial=-1) 4.0 np.nanmax(b) 4.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>You can use an initial value to compute the maximum of an empty slice, or to initialize it to a different value:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.max(<a href="null">-50], [10</a>, axis=-1, initial=0) array([ 0, 10])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Notice that the initial value is used as one of the elements for which the maximum is determined, unlike for the default argument Python’s max function, which is only used for empty iterables.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.max([5], initial=6) 6 max([5], default=6) 5</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23296">view source</a></div></div><div class="public anchor" id="var-amin"><h3>amin</h3><div class="usage"><code>(amin &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the minimum of an array or minimum along an axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  Axis or axes along which to operate. By default, flattened input is  used.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If this is a tuple of ints, the minimum is selected over multiple axes,
-instead of a single axis or all the axes as before.
-</code></pre>
-<p>out : ndarray, optional  Alternative output array in which to place the result. Must  be of the same shape and buffer length as the expected output.  See <code>ufuncs-output-type</code> for more details.</p>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `amin` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<p>initial : scalar, optional  The maximum value of an output element. Must be present to allow  computation on empty slice. See <code>~numpy.ufunc.reduce</code> for details.</p>
-<pre><code>.. versionadded:: 1.15.0
-</code></pre>
-<p>where : array_like of bool, optional  Elements to compare for the minimum. See <code>~numpy.ufunc.reduce</code>  for details.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>amin : ndarray or scalar  Minimum of <code>a</code>. If <code>axis</code> is None, the result is a scalar value.  If <code>axis</code> is given, the result is an array of dimension  <code>a.ndim - 1</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>amax :  The maximum value of an array along a given axis, propagating any NaNs. nanmin :  The minimum value of an array along a given axis, ignoring any NaNs. minimum :  Element-wise minimum of two arrays, propagating any NaNs. fmin :  Element-wise minimum of two arrays, ignoring any NaNs. argmin :  Return the indices of the minimum values.</p>
-<p>nanmax, maximum, fmax</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>NaN values are propagated, that is if at least one item is NaN, the corresponding min value will be NaN as well. To ignore NaN values (MATLAB behavior), please use nanmin.</p>
-<p>Don’t use <code>amin</code> for element-wise comparison of 2 arrays; when <code>a.shape[0]</code> is 2, <code>minimum(a[0], a[1])</code> is faster than <code>amin(a, axis=0)</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(4).reshape((2,2)) a array(<a href="null">0, 1],
-       [2, 3</a>) np.amin(a) # Minimum of the flattened array 0 np.amin(a, axis=0) # Minima along the first axis array([0, 1]) np.amin(a, axis=1) # Minima along the second axis array([0, 2]) np.amin(a, where=[False, True], initial=10, axis=0) array([10, 1])</p>
-      <p>b = np.arange(5, dtype=float) b[2] = np.NaN np.amin(b) nan np.amin(b, where=~np.isnan(b), initial=10) 0.0 np.nanmin(b) 0.0</p>
-      <p>np.min(<a href="null">-50], [10</a>, axis=-1, initial=0) array([-50, 0])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Notice that the initial value is used as one of the elements for which the minimum is determined, unlike for the default argument Python’s max function, which is only used for empty iterables.</p>
-<p>Notice that this isn’t the same as Python’s <code>default</code> argument.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.min([6], initial=5) 5 min([6], default=5) 6</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24071">view source</a></div></div><div class="public anchor" id="var-angle"><h3>angle</h3><div class="usage"><code>(angle &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the angle of the complex argument.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>z : array_like  A complex number or sequence of complex numbers. deg : bool, optional  Return angle in degrees if True, radians if False (default).</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>angle : ndarray or scalar  The counterclockwise angle from the positive real axis on the complex  plane in the range <code>(-pi, pi]</code>, with dtype as numpy.float64.</p>
-<pre><code>..versionchanged:: 1.16.0
-    This function works on subclasses of ndarray like `ma.array`.
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>arctan2 absolute</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.angle([1.0, 1.0j, 1+1j]) # in radians array([ 0. , 1.57079633, 0.78539816]) # may vary np.angle(1+1j, deg=True) # in degrees 45.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13817">view source</a></div></div><div class="public anchor" id="var-any"><h3>any</h3><div class="usage"><code>(any &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Test whether any array element along a given axis evaluates to True.</p>
-<p>Returns single boolean unless <code>axis</code> is not <code>None</code></p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array or object that can be converted to an array. axis : None or int or tuple of ints, optional  Axis or axes along which a logical OR reduction is performed.  The default (<code>axis=None</code>) is to perform a logical OR over all  the dimensions of the input array. <code>axis</code> may be negative, in  which case it counts from the last to the first axis.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If this is a tuple of ints, a reduction is performed on multiple
-axes, instead of a single axis or all the axes as before.
-</code></pre>
-<p>out : ndarray, optional  Alternate output array in which to place the result. It must have  the same shape as the expected output and its type is preserved  (e.g., if it is of type float, then it will remain so, returning  1.0 for True and 0.0 for False, regardless of the type of <code>a</code>).  See <code>ufuncs-output-type</code> for more details.</p>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `any` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>any : bool or ndarray  A new boolean or <code>ndarray</code> is returned unless <code>out</code> is specified,  in which case a reference to <code>out</code> is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.any : equivalent method</p>
-<p>all : Test whether all elements along a given axis evaluate to True.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Not a Number (NaN), positive infinity and negative infinity evaluate to <code>True</code> because these are not equal to zero.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.any(<a href="null">True, False], [True, True</a>) True</p>
-      <p>np.any(<a href="null">True, False], [False, False</a>, axis=0) array([ True, False])</p>
-      <p>np.any([-1, 0, 5]) True</p>
-      <p>np.any(np.nan) True</p>
-      <p>o=np.array(False) z=np.any([-1, 4, 5], out=o) z, o (array(True), array(True))</p>
-      <h1><a href="#check-now-that-z-is-a-reference-to-o" name="check-now-that-z-is-a-reference-to-o"></a>Check now that z is a reference to o</h1>
-      <p>z is o True id(z), id(o) # identity of z and o # doctest: +SKIP (191614240, 191614240)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13736">view source</a></div></div><div class="public anchor" id="var-append"><h3>append</h3><div class="usage"><code>(append &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Append values to the end of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr : array_like  Values are appended to a copy of this array. values : array_like  These values are appended to a copy of <code>arr</code>. It must be of the  correct shape (the same shape as <code>arr</code>, excluding <code>axis</code>). If  <code>axis</code> is not specified, <code>values</code> can be any shape and will be  flattened before use. axis : int, optional  The axis along which <code>values</code> are appended. If <code>axis</code> is not  given, both <code>arr</code> and <code>values</code> are flattened before use.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>append : ndarray  A copy of <code>arr</code> with <code>values</code> appended to <code>axis</code>. Note that  <code>append</code> does not occur in-place: a new array is allocated and  filled. If <code>axis</code> is None, <code>out</code> is a flattened array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>insert : Insert elements into an array. delete : Delete elements from an array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.append([1, 2, 3], <a href="null">4, 5, 6], [7, 8, 9</a>) array([1, 2, 3, …, 7, 8, 9])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>When <code>axis</code> is specified, <code>values</code> must have the correct shape.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.append(<a href="null">1, 2, 3], [4, 5, 6</a>, <a href="null">7, 8, 9</a>, axis=0) array(<a href="null">1, 2, 3],
-       [4, 5, 6],
-       [7, 8, 9</a>) np.append(<a href="null">1, 2, 3], [4, 5, 6</a>, [7, 8, 9], axis=0) Traceback (most recent call last):  … ValueError: all the input arrays must have same number of dimensions</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21358">view source</a></div></div><div class="public anchor" id="var-apply_along_axis"><h3>apply_along_axis</h3><div class="usage"><code>(apply_along_axis &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Apply a function to 1-D slices along the given axis.</p>
-<p>Execute <code>func1d(a, *args)</code> where <code>func1d</code> operates on 1-D arrays and <code>a</code> is a 1-D slice of <code>arr</code> along <code>axis</code>.</p>
-<p>This is equivalent to (but faster than) the following use of <code>ndindex</code> and <code>s_</code>, which sets each of <code>ii</code>, <code>jj</code>, and <code>kk</code> to a tuple of indices::</p>
-<pre><code>Ni, Nk = a.shape[:axis], a.shape[axis+1:]
-for ii in ndindex(Ni):
-    for kk in ndindex(Nk):
-        f = func1d(arr[ii + s_[:,] + kk])
-        Nj = f.shape
-        for jj in ndindex(Nj):
-            out[ii + jj + kk] = f[jj]
-</code></pre>
-<p>Equivalently, eliminating the inner loop, this can be expressed as::</p>
-<pre><code>Ni, Nk = a.shape[:axis], a.shape[axis+1:]
-for ii in ndindex(Ni):
-    for kk in ndindex(Nk):
-        out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])
-</code></pre>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>func1d : function (M,) -&gt; (Nj…)  This function should accept 1-D arrays. It is applied to 1-D  slices of <code>arr</code> along the specified axis. axis : integer  Axis along which <code>arr</code> is sliced. arr : ndarray (Ni…, M, Nk…)  Input array. args : any  Additional arguments to <code>func1d</code>. kwargs : any  Additional named arguments to <code>func1d</code>.</p>
-<pre><code>.. versionadded:: 1.9.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray (Ni…, Nj…, Nk…)  The output array. The shape of <code>out</code> is identical to the shape of  <code>arr</code>, except along the <code>axis</code> dimension. This axis is removed, and  replaced with new dimensions equal to the shape of the return value  of <code>func1d</code>. So if <code>func1d</code> returns a scalar <code>out</code> will have one  fewer dimensions than <code>arr</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>apply_over_axes : Apply a function repeatedly over multiple axes.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>def my_func(a): … ""“Average first and last element of a 1-D array”"" … return (a[0] + a[-1]) * 0.5 b = np.array(<a href="null">1,2,3], [4,5,6], [7,8,9</a>) np.apply_along_axis(my_func, 0, b) array([4., 5., 6.]) np.apply_along_axis(my_func, 1, b) array([2., 5., 8.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>For a function that returns a 1D array, the number of dimensions in <code>outarr</code> is the same as <code>arr</code>.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>b = np.array(<a href="null">8,1,7], [4,3,9], [5,2,6</a>) np.apply_along_axis(sorted, 1, b) array(<a href="null">1, 7, 8],
-       [3, 4, 9],
-       [2, 5, 6</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>For a function that returns a higher dimensional array, those dimensions are inserted in place of the <code>axis</code> dimension.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>b = np.array(<a href="null">1,2,3], [4,5,6], [7,8,9</a>) np.apply_along_axis(np.diag, -1, b) array(<a href="null">[1, 0, 0],
-        [0, 2, 0],
-        [0, 0, 3</a>,  <a href="null">4, 0, 0],
-        [0, 5, 0],
-        [0, 0, 6</a>,  <a href="null">7, 0, 0],
-        [0, 8, 0],
-        [0, 0, 9</a>])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25038">view source</a></div></div><div class="public anchor" id="var-apply_over_axes"><h3>apply_over_axes</h3><div class="usage"><code>(apply_over_axes &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Apply a function repeatedly over multiple axes.</p>
-<p><code>func</code> is called as <code>res = func(a, axis)</code>, where <code>axis</code> is the first element of <code>axes</code>. The result <code>res</code> of the function call must have either the same dimensions as <code>a</code> or one less dimension. If <code>res</code> has one less dimension than <code>a</code>, a dimension is inserted before <code>axis</code>. The call to <code>func</code> is then repeated for each axis in <code>axes</code>, with <code>res</code> as the first argument.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>func : function  This function must take two arguments, <code>func(a, axis)</code>. a : array_like  Input array. axes : array_like  Axes over which <code>func</code> is applied; the elements must be integers.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>apply_over_axis : ndarray  The output array. The number of dimensions is the same as <code>a</code>,  but the shape can be different. This depends on whether <code>func</code>  changes the shape of its output with respect to its input.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>apply_along_axis :  Apply a function to 1-D slices of an array along the given axis.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This function is equivalent to tuple axis arguments to reorderable ufuncs with keepdims=True. Tuple axis arguments to ufuncs have been available since version 1.7.0.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(24).reshape(2,3,4) a array(<a href="null">[ 0,  1,  2,  3],
-        [ 4,  5,  6,  7],
-        [ 8,  9, 10, 11</a>,  <a href="null">12, 13, 14, 15],
-        [16, 17, 18, 19],
-        [20, 21, 22, 23</a>])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Sum over axes 0 and 2. The result has same number of dimensions as the original array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.apply_over_axes(np.sum, a, [0,2]) array(<a href="null">[ 60],
-        [ 92],
-        [124</a>])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Tuple axis arguments to ufuncs are equivalent:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sum(a, axis=(0,2), keepdims=True) array(<a href="null">[ 60],
-        [ 92],
-        [124</a>])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26809">view source</a></div></div><div class="public anchor" id="var-arange"><h3>arange</h3><div class="usage"><code>(arange self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arange([start,] stop[, step,], dtype=None)</p>
-<p>Return evenly spaced values within a given interval.</p>
-<p>Values are generated within the half-open interval <code>[start, stop)</code> (in other words, the interval including <code>start</code> but excluding <code>stop</code>). For integer arguments the function is equivalent to the Python built-in <code>range</code> function, but returns an ndarray rather than a list.</p>
-<p>When using a non-integer step, such as 0.1, the results will often not be consistent. It is better to use <code>numpy.linspace</code> for these cases.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>start : number, optional  Start of interval. The interval includes this value. The default  start value is 0. stop : number  End of interval. The interval does not include this value, except  in some cases where <code>step</code> is not an integer and floating point  round-off affects the length of <code>out</code>. step : number, optional  Spacing between values. For any output <code>out</code>, this is the distance  between two adjacent values, <code>out[i+1] - out[i]</code>. The default  step size is 1. If <code>step</code> is specified as a position argument,  <code>start</code> must also be given. dtype : dtype  The type of the output array. If <code>dtype</code> is not given, infer the data  type from the other input arguments.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>arange : ndarray  Array of evenly spaced values.</p>
-<pre><code>For floating point arguments, the length of the result is
-``ceil((stop - start)/step)``.  Because of floating point overflow,
-this rule may result in the last element of `out` being greater
-than `stop`.
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.linspace : Evenly spaced numbers with careful handling of endpoints. numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions. numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.arange(3) array([0, 1, 2]) np.arange(3.0) array([ 0., 1., 2.]) np.arange(3,7) array([3, 4, 5, 6]) np.arange(3,7,2) array([3, 5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20949">view source</a></div></div><div class="public anchor" id="var-arccos"><h3>arccos</h3><div class="usage"><code>(arccos self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arccos(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Trigonometric inverse cosine, element-wise.</p>
-<p>The inverse of <code>cos</code> so that, if <code>y = cos(x)</code>, then <code>x = arccos(y)</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  <code>x</code>-coordinate on the unit circle.  For real arguments, the domain is [-1, 1]. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>angle : ndarray  The angle of the ray intersecting the unit circle at the given  <code>x</code>-coordinate in radians [0, pi].  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>cos, arctan, arcsin, emath.arccos</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>arccos</code> is a multivalued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that <code>cos(z) = x</code>. The convention is to return the angle <code>z</code> whose real part lies in <code>[0, pi]</code>.</p>
-<p>For real-valued input data types, <code>arccos</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
-<p>For complex-valued input, <code>arccos</code> is a complex analytic function that has branch cuts <code>[-inf, -1]</code> and <code>[1, inf]</code> and is continuous from above on the former and from below on the latter.</p>
-<p>The inverse <code>cos</code> is also known as <code>acos</code> or cos^-1.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”, 10th printing, 1964, pp. 79. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>We expect the arccos of 1 to be 0, and of -1 to be pi:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.arccos([1, -1]) array([ 0. , 3.14159265])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot arccos:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt x = np.linspace(-1, 1, num=100) plt.plot(x, np.arccos(x)) plt.axis(‘tight’) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26611">view source</a></div></div><div class="public anchor" id="var-arccosh"><h3>arccosh</h3><div class="usage"><code>(arccosh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arccosh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Inverse hyperbolic cosine, element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>arccosh : ndarray  Array of the same shape as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>cosh, arcsinh, sinh, arctanh, tanh</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>arccosh</code> is a multivalued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that <code>cosh(z) = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi, pi]</code> and the real part in <code>[0, inf]</code>.</p>
-<p>For real-valued input data types, <code>arccosh</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
-<p>For complex-valued input, <code>arccosh</code> is a complex analytical function that has a branch cut <code>[-inf, 1]</code> and is continuous from above on it.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 86. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Inverse hyperbolic function”,  <a href="https://en.wikipedia.org/wiki/Arccosh">https://en.wikipedia.org/wiki/Arccosh</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.arccosh([np.e, 10.0]) array([ 1.65745445, 2.99322285]) np.arccosh(1) 0.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26745">view source</a></div></div><div class="public anchor" id="var-arcsin"><h3>arcsin</h3><div class="usage"><code>(arcsin self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arcsin(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Inverse sine, element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  <code>y</code>-coordinate on the unit circle. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>angle : ndarray  The inverse sine of each element in <code>x</code>, in radians and in the  closed interval <code>[-pi/2, pi/2]</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>sin, cos, arccos, tan, arctan, arctan2, emath.arcsin</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>arcsin</code> is a multivalued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that :math:<code>sin(z) = x</code>. The convention is to return the angle <code>z</code> whose real part lies in [-pi/2, pi/2].</p>
-<p>For real-valued input data types, <em>arcsin</em> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
-<p>For complex-valued input, <code>arcsin</code> is a complex analytic function that has, by convention, the branch cuts [-inf, -1] and [1, inf] and is continuous from above on the former and from below on the latter.</p>
-<p>The inverse sine is also known as <code>asin</code> or sin^{-1}.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>Abramowitz, M. and Stegun, I. A., <em>Handbook of Mathematical Functions</em>, 10th printing, New York: Dover, 1964, pp. 79ff. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.arcsin(1) # pi/2 1.5707963267948966 np.arcsin(-1) # -pi/2 -1.5707963267948966 np.arcsin(0) 0.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28429">view source</a></div></div><div class="public anchor" id="var-arcsinh"><h3>arcsinh</h3><div class="usage"><code>(arcsinh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arcsinh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Inverse hyperbolic sine element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Array of the same shape as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>arcsinh</code> is a multivalued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that <code>sinh(z) = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi/2, pi/2]</code>.</p>
-<p>For real-valued input data types, <code>arcsinh</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it returns <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
-<p>For complex-valued input, <code>arccos</code> is a complex analytical function that has branch cuts <code>[1j, infj]</code> and <code>[-1j, -infj]</code> and is continuous from the right on the former and from the left on the latter.</p>
-<p>The inverse hyperbolic sine is also known as <code>asinh</code> or <code>sinh^-1</code>.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 86. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Inverse hyperbolic function”,  <a href="https://en.wikipedia.org/wiki/Arcsinh">https://en.wikipedia.org/wiki/Arcsinh</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.arcsinh(np.array([np.e, 10.0])) array([ 1.72538256, 2.99822295])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18038">view source</a></div></div><div class="public anchor" id="var-arctan"><h3>arctan</h3><div class="usage"><code>(arctan self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arctan(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Trigonometric inverse tangent, element-wise.</p>
-<p>The inverse of tan, so that if <code>y = tan(x)</code> then <code>x = arctan(y)</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Out has the same shape as <code>x</code>. Its real part is in  <code>[-pi/2, pi/2]</code> (<code>arctan(+/-inf)</code> returns <code>+/-pi/2</code>).  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>arctan2 : The “four quadrant” arctan of the angle formed by (<code>x</code>, <code>y</code>)  and the positive <code>x</code>-axis. angle : Argument of complex values.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>arctan</code> is a multi-valued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that tan(<code>z</code>) = <code>x</code>. The convention is to return the angle <code>z</code> whose real part lies in [-pi/2, pi/2].</p>
-<p>For real-valued input data types, <code>arctan</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
-<p>For complex-valued input, <code>arctan</code> is a complex analytic function that has [<code>1j, infj</code>] and [<code>-1j, -infj</code>] as branch cuts, and is continuous from the left on the former and from the right on the latter.</p>
-<p>The inverse tangent is also known as <code>atan</code> or tan^{-1}.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>Abramowitz, M. and Stegun, I. A., <em>Handbook of Mathematical Functions</em>, 10th printing, New York: Dover, 1964, pp. 79. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>We expect the arctan of 0 to be 0, and of 1 to be pi/4:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.arctan([0, 1]) array([ 0. , 0.78539816])</p>
-      <p>np.pi/4 0.78539816339744828</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot arctan:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt x = np.linspace(-10, 10) plt.plot(x, np.arctan(x)) plt.axis(‘tight’) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13590">view source</a></div></div><div class="public anchor" id="var-arctan2"><h3>arctan2</h3><div class="usage"><code>(arctan2 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arctan2(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Element-wise arc tangent of <code>x1/x2</code> choosing the quadrant correctly.</p>
-<p>The quadrant (i.e., branch) is chosen so that <code>arctan2(x1, x2)</code> is the signed angle in radians between the ray ending at the origin and passing through the point (1,0), and the ray ending at the origin and passing through the point (<code>x2</code>, <code>x1</code>). (Note the role reversal: the “<code>y</code>-coordinate” is the first function parameter, the “<code>x</code>-coordinate” is the second.) By IEEE convention, this function is defined for <code>x2</code> = +/-0 and for either or both of <code>x1</code> and <code>x2</code> = +/-inf (see Notes for specific values).</p>
-<p>This function is not defined for complex-valued arguments; for the so-called argument of complex values, use <code>angle</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like, real-valued  <code>y</code>-coordinates. x2 : array_like, real-valued  <code>x</code>-coordinates. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>angle : ndarray  Array of angles in radians, in the range <code>[-pi, pi]</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>arctan, tan, angle</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><em>arctan2</em> is identical to the <code>atan2</code> function of the underlying C library. The following special values are defined in the C standard: [1]_</p>
-<p>====== ====== ================ <code>x1</code> <code>x2</code> <code>arctan2(x1,x2)</code> ====== ====== ================ +/- 0 +0 +/- 0 +/- 0 -0 +/- pi  &gt; 0 +/-inf +0 / +pi  &lt; 0 +/-inf -0 / -pi +/-inf +inf +/- (pi/4) +/-inf -inf +/- (3*pi/4) ====== ====== ================</p>
-<p>Note that +0 and -0 are distinct floating point numbers, as are +inf and -inf.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] ISO/IEC standard 9899:1999, “Programming language C.”</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Consider four points in different quadrants:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([-1, +1, +1, -1]) y = np.array([-1, -1, +1, +1]) np.arctan2(y, x) * 180 / np.pi array([-135., -45., 45., 135.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note the order of the parameters. <code>arctan2</code> is defined also when <code>x2</code> = 0 and at several other special points, obtaining values in the range <code>[-pi, pi]</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.arctan2([1., -1.], [0., 0.]) array([ 1.57079633, -1.57079633]) np.arctan2([0., 0., np.inf], [+0., -0., np.inf]) array([ 0. , 3.14159265, 0.78539816])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L575">view source</a></div></div><div class="public anchor" id="var-arctanh"><h3>arctanh</h3><div class="usage"><code>(arctanh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>arctanh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Inverse hyperbolic tangent element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Array of the same shape as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>emath.arctanh</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>arctanh</code> is a multivalued function: for each <code>x</code> there are infinitely many numbers <code>z</code> such that <code>tanh(z) = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi/2, pi/2]</code>.</p>
-<p>For real-valued input data types, <code>arctanh</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
-<p>For complex-valued input, <code>arctanh</code> is a complex analytical function that has branch cuts <code>[-1, -inf]</code> and <code>[1, inf]</code> and is continuous from above on the former and from below on the latter.</p>
-<p>The inverse hyperbolic tangent is also known as <code>atanh</code> or <code>tanh^-1</code>.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 86. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Inverse hyperbolic function”,  <a href="https://en.wikipedia.org/wiki/Arctanh">https://en.wikipedia.org/wiki/Arctanh</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.arctanh([0, -0.5]) array([ 0. , -0.54930614])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11725">view source</a></div></div><div class="public anchor" id="var-argmax"><h3>argmax</h3><div class="usage"><code>(argmax &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the indices of the maximum values along an axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. axis : int, optional  By default, the index is into the flattened array, otherwise  along the specified axis. out : array, optional  If provided, the result will be inserted into this array. It should  be of the appropriate shape and dtype.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>index_array : ndarray of ints  Array of indices into the array. It has the same shape as <code>a.shape</code>  with the dimension along <code>axis</code> removed.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.argmax, argmin amax : The maximum value along a given axis. unravel_index : Convert a flat index into an index tuple. take_along_axis : Apply <code>np.expand_dims(index_array, axis)</code>  from argmax to an array as if by calling max.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>In case of multiple occurrences of the maximum values, the indices corresponding to the first occurrence are returned.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(6).reshape(2,3) + 10 a array(<a href="null">10, 11, 12],
-       [13, 14, 15</a>) np.argmax(a) 5 np.argmax(a, axis=0) array([1, 1, 1]) np.argmax(a, axis=1) array([2, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Indexes of the maximal elements of a N-dimensional array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>ind = np.unravel_index(np.argmax(a, axis=None), a.shape) ind (1, 2) a[ind] 15</p>
-      <p>b = np.arange(6) b[1] = 5 b array([0, 5, 2, 3, 4, 5]) np.argmax(b) # Only the first occurrence is returned. 1</p>
-      <p>x = np.array(<a href="null">4,2,3], [1,0,3</a>) index_array = np.argmax(x, axis=-1)</p>
-      <h1><a href="#same-as-np-max-x-axis-1-keepdims-true-" name="same-as-np-max-x-axis-1-keepdims-true-"></a>Same as np.max(x, axis=-1, keepdims=True)</h1>
-      <p>np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) array(<a href="null">4],
-       [3</a>)</p>
-      <h1><a href="#same-as-np-max-x-axis-1-" name="same-as-np-max-x-axis-1-"></a>Same as np.max(x, axis=-1)</h1>
-      <p>np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1) array([4, 3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6499">view source</a></div></div><div class="public anchor" id="var-argmin"><h3>argmin</h3><div class="usage"><code>(argmin &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the indices of the minimum values along an axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. axis : int, optional  By default, the index is into the flattened array, otherwise  along the specified axis. out : array, optional  If provided, the result will be inserted into this array. It should  be of the appropriate shape and dtype.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>index_array : ndarray of ints  Array of indices into the array. It has the same shape as <code>a.shape</code>  with the dimension along <code>axis</code> removed.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.argmin, argmax amin : The minimum value along a given axis. unravel_index : Convert a flat index into an index tuple. take_along_axis : Apply <code>np.expand_dims(index_array, axis)</code>  from argmin to an array as if by calling min.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>In case of multiple occurrences of the minimum values, the indices corresponding to the first occurrence are returned.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(6).reshape(2,3) + 10 a array(<a href="null">10, 11, 12],
-       [13, 14, 15</a>) np.argmin(a) 0 np.argmin(a, axis=0) array([0, 0, 0]) np.argmin(a, axis=1) array([0, 0])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Indices of the minimum elements of a N-dimensional array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>ind = np.unravel_index(np.argmin(a, axis=None), a.shape) ind (0, 0) a[ind] 10</p>
-      <p>b = np.arange(6) + 10 b[4] = 10 b array([10, 11, 12, 13, 10, 15]) np.argmin(b) # Only the first occurrence is returned. 0</p>
-      <p>x = np.array(<a href="null">4,2,3], [1,0,3</a>) index_array = np.argmin(x, axis=-1)</p>
-      <h1><a href="#same-as-np-min-x-axis-1-keepdims-true-" name="same-as-np-min-x-axis-1-keepdims-true-"></a>Same as np.min(x, axis=-1, keepdims=True)</h1>
-      <p>np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1) array(<a href="null">2],
-       [0</a>)</p>
-      <h1><a href="#same-as-np-max-x-axis-1-" name="same-as-np-max-x-axis-1-"></a>Same as np.max(x, axis=-1)</h1>
-      <p>np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1) array([2, 0])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11197">view source</a></div></div><div class="public anchor" id="var-argpartition"><h3>argpartition</h3><div class="usage"><code>(argpartition &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Perform an indirect partition along the given axis using the algorithm specified by the <code>kind</code> keyword. It returns an array of indices of the same shape as <code>a</code> that index data along the given axis in partitioned order.</p>
-<p>.. versionadded:: 1.8.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array to sort. kth : int or sequence of ints  Element index to partition by. The k-th element will be in its  final sorted position and all smaller elements will be moved  before it and all larger elements behind it. The order all  elements in the partitions is undefined. If provided with a  sequence of k-th it will partition all of them into their sorted  position at once. axis : int or None, optional  Axis along which to sort. The default is -1 (the last axis). If  None, the flattened array is used. kind : {‘introselect’}, optional  Selection algorithm. Default is ‘introselect’ order : str or list of str, optional  When <code>a</code> is an array with fields defined, this argument  specifies which fields to compare first, second, etc. A single  field can be specified as a string, and not all fields need be  specified, but unspecified fields will still be used, in the  order in which they come up in the dtype, to break ties.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>index_array : ndarray, int  Array of indices that partition <code>a</code> along the specified axis.  If <code>a</code> is one-dimensional, <code>a[index_array]</code> yields a partitioned <code>a</code>.  More generally, <code>np.take_along_axis(a, index_array, axis=a)</code> always  yields the partitioned <code>a</code>, irrespective of dimensionality.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>partition : Describes partition algorithms used. ndarray.partition : Inplace partition. argsort : Full indirect sort. take_along_axis : Apply <code>index_array</code> from argpartition  to an array as if by calling partition.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>See <code>partition</code> for notes on the different selection algorithms.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>One dimensional array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([3, 4, 2, 1]) x[np.argpartition(x, 3)] array([2, 1, 3, 4]) x[np.argpartition(x, (1, 3))] array([1, 2, 3, 4])</p>
-      <p>x = [3, 4, 2, 1] np.array(x)[np.argpartition(x, 3)] array([2, 1, 3, 4])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Multi-dimensional array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">3, 4, 2], [1, 3, 1</a>) index_array = np.argpartition(x, kth=1, axis=-1) np.take_along_axis(x, index_array, axis=-1) # same as np.partition(x, kth=1) array(<a href="null">2, 3, 4],
-       [1, 1, 3</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20870">view source</a></div></div><div class="public anchor" id="var-argsort"><h3>argsort</h3><div class="usage"><code>(argsort &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the indices that would sort an array.</p>
-<p>Perform an indirect sort along the given axis using the algorithm specified by the <code>kind</code> keyword. It returns an array of indices of the same shape as <code>a</code> that index data along the given axis in sorted order.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array to sort. axis : int or None, optional  Axis along which to sort. The default is -1 (the last axis). If None,  the flattened array is used. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, optional  Sorting algorithm. The default is ‘quicksort’. Note that both ‘stable’  and ‘mergesort’ use timsort under the covers and, in general, the  actual implementation will vary with data type. The ‘mergesort’ option  is retained for backwards compatibility.</p>
-<pre><code>.. versionchanged:: 1.15.0.
-   The 'stable' option was added.
-</code></pre>
-<p>order : str or list of str, optional  When <code>a</code> is an array with fields defined, this argument specifies  which fields to compare first, second, etc. A single field can  be specified as a string, and not all fields need be specified,  but unspecified fields will still be used, in the order in which  they come up in the dtype, to break ties.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>index_array : ndarray, int  Array of indices that sort <code>a</code> along the specified <code>axis</code>.  If <code>a</code> is one-dimensional, <code>a[index_array]</code> yields a sorted <code>a</code>.  More generally, <code>np.take_along_axis(a, index_array, axis=axis)</code>  always yields the sorted <code>a</code>, irrespective of dimensionality.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>sort : Describes sorting algorithms used. lexsort : Indirect stable sort with multiple keys. ndarray.sort : Inplace sort. argpartition : Indirect partial sort. take_along_axis : Apply <code>index_array</code> from argsort  to an array as if by calling sort.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>See <code>sort</code> for notes on the different sorting algorithms.</p>
-<p>As of NumPy 1.4.0 <code>argsort</code> works with real/complex arrays containing nan values. The enhanced sort order is documented in <code>sort</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>One dimensional array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([3, 1, 2]) np.argsort(x) array([1, 2, 0])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Two-dimensional array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">0, 3], [2, 2</a>) x array(<a href="null">0, 3],
-       [2, 2</a>)</p>
-      <p>ind = np.argsort(x, axis=0) # sorts along first axis (down) ind array(<a href="null">0, 1],
-       [1, 0</a>) np.take_along_axis(x, ind, axis=0) # same as np.sort(x, axis=0) array(<a href="null">0, 2],
-       [2, 3</a>)</p>
-      <p>ind = np.argsort(x, axis=1) # sorts along last axis (across) ind array(<a href="null">0, 1],
-       [0, 1</a>) np.take_along_axis(x, ind, axis=1) # same as np.sort(x, axis=1) array(<a href="null">0, 3],
-       [2, 2</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Indices of the sorted elements of a N-dimensional array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>ind = np.unravel_index(np.argsort(x, axis=None), x.shape) ind (array([0, 1, 1, 0]), array([0, 0, 1, 1])) x[ind] # same as np.sort(x, axis=None) array([0, 2, 2, 3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Sorting with keys:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([(1, 0), (0, 1)], dtype=[(‘x’, ‘&lt;i4’), (‘y’, ‘&lt;i4’)]) x array([(1, 0), (0, 1)],  dtype=[(‘x’, ‘&lt;i4’), (‘y’, ‘&lt;i4’)])</p>
-      <p>np.argsort(x, order=(‘x’,‘y’)) array([1, 0])</p>
-      <p>np.argsort(x, order=(‘y’,‘x’)) array([0, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19413">view source</a></div></div><div class="public anchor" id="var-argwhere"><h3>argwhere</h3><div class="usage"><code>(argwhere &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the indices of array elements that are non-zero, grouped by element.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>index_array : (N, a.ndim) ndarray  Indices of elements that are non-zero. Indices are grouped by element.  This array will have shape <code>(N, a.ndim)</code> where <code>N</code> is the number of  non-zero items.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>where, nonzero</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>np.argwhere(a)</code> is almost the same as <code>np.transpose(np.nonzero(a))</code>, but produces a result of the correct shape for a 0D array.</p>
-<p>The output of <code>argwhere</code> is not suitable for indexing arrays. For this purpose use <code>nonzero(a)</code> instead.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(6).reshape(2,3) x array(<a href="null">0, 1, 2],
-       [3, 4, 5</a>) np.argwhere(x&gt;1) array(<a href="null">0, 2],
-       [1, 0],
-       [1, 1],
-       [1, 2</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21267">view source</a></div></div><div class="public anchor" id="var-around"><h3>around</h3><div class="usage"><code>(around &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Evenly round to the given number of decimals.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. decimals : int, optional  Number of decimal places to round to (default: 0). If  decimals is negative, it specifies the number of positions to  the left of the decimal point. out : ndarray, optional  Alternative output array in which to place the result. It must have  the same shape as the expected output, but the type of the output  values will be cast if necessary. See <code>ufuncs-output-type</code> for more  details.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>rounded_array : ndarray  An array of the same type as <code>a</code>, containing the rounded values.  Unless <code>out</code> was specified, a new array is created. A reference to  the result is returned.</p>
-<pre><code>The real and imaginary parts of complex numbers are rounded
-separately.  The result of rounding a float is a float.
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.round : equivalent method</p>
-<p>ceil, fix, floor, rint, trunc</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>For values exactly halfway between rounded decimal values, NumPy rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0, -0.5 and 0.5 round to 0.0, etc.</p>
-<p><code>np.around</code> uses a fast but sometimes inexact algorithm to round floating-point datatypes. For positive <code>decimals</code> it is equivalent to <code>np.true_divide(np.rint(a * 10**decimals), 10**decimals)</code>, which has error due to the inexact representation of decimal fractions in the IEEE floating point standard [1]_ and errors introduced when scaling by powers of ten. For instance, note the extra “1” in the following:</p>
-<pre><code>&gt;&gt;&gt; np.round(56294995342131.5, 3)
-56294995342131.51
-</code></pre>
-<p>If your goal is to print such values with a fixed number of decimals, it is preferable to use numpy’s float printing routines to limit the number of printed decimals:</p>
-<pre><code>&gt;&gt;&gt; np.format_float_positional(56294995342131.5, precision=3)
-'56294995342131.5'
-</code></pre>
-<p>The float printing routines use an accurate but much more computationally demanding algorithm to compute the number of digits after the decimal point.</p>
-<p>Alternatively, Python’s builtin <code>round</code> function uses a more accurate but slower algorithm for 64-bit floating point values:</p>
-<pre><code>&gt;&gt;&gt; round(56294995342131.5, 3)
-56294995342131.5
-&gt;&gt;&gt; np.round(16.055, 2), round(16.055, 2)  # equals 16.0549999999999997
-(16.06, 16.05)
-</code></pre>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] “Lecture Notes on the Status of IEEE 754”, William Kahan,  <a href="https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF">https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF</a> .. [2] “How Futile are Mindless Assessments of  Roundoff in Floating-Point Computation?”, William Kahan,  <a href="https://people.eecs.berkeley.edu/~wkahan/Mindless.pdf">https://people.eecs.berkeley.edu/~wkahan/Mindless.pdf</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.around([0.37, 1.64]) array([0., 2.]) np.around([0.37, 1.64], decimals=1) array([0.4, 1.6]) np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value array([0., 2., 2., 4., 4.]) np.around([1,2,3,11], decimals=1) # ndarray of ints is returned array([ 1, 2, 3, 11]) np.around([1,2,3,11], decimals=-1) array([ 0, 0, 0, 10])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22592">view source</a></div></div><div class="public anchor" id="var-array"><h3>array</h3><div class="usage"><code>(array self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>array(object, dtype=None, copy=True, order=‘K’, subok=False, ndmin=0)</p>
-<p>Create an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>object : array_like  An array, any object exposing the array interface, an object whose  <strong>array</strong> method returns an array, or any (nested) sequence. dtype : data-type, optional  The desired data-type for the array. If not given, then the type will  be determined as the minimum type required to hold the objects in the  sequence. copy : bool, optional  If true (default), then the object is copied. Otherwise, a copy will  only be made if <strong>array</strong> returns a copy, if obj is a nested sequence,  or if a copy is needed to satisfy any of the other requirements  (<code>dtype</code>, <code>order</code>, etc.). order : {‘K’, ‘A’, ‘C’, ‘F’}, optional  Specify the memory layout of the array. If object is not an array, the  newly created array will be in C order (row major) unless ‘F’ is  specified, in which case it will be in Fortran order (column major).  If object is an array the following holds.</p>
-<pre><code>===== ========= ===================================================
-order  no copy                     copy=True
-===== ========= ===================================================
-'K'   unchanged F &amp; C order preserved, otherwise most similar order
-'A'   unchanged F order if input is F and not C, otherwise C order
-'C'   C order   C order
-'F'   F order   F order
-===== ========= ===================================================
-
-When ``copy=False`` and a copy is made for other reasons, the result is
-the same as if ``copy=True``, with some exceptions for `A`, see the
-Notes section. The default order is 'K'.
-</code></pre>
-<p>subok : bool, optional  If True, then sub-classes will be passed-through, otherwise  the returned array will be forced to be a base-class array (default). ndmin : int, optional  Specifies the minimum number of dimensions that the resulting  array should have. Ones will be pre-pended to the shape as  needed to meet this requirement.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  An array object satisfying the specified requirements.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>empty_like : Return an empty array with shape and type of input. ones_like : Return an array of ones with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. full_like : Return a new array with shape of input filled with value. empty : Return a new uninitialized array. ones : Return a new array setting values to one. zeros : Return a new array setting values to zero. full : Return a new array of given shape filled with value.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>When order is ‘A’ and <code>object</code> is an array in neither ‘C’ nor ‘F’ order, and a copy is forced by a change in dtype, then the order of the result is not necessarily ‘C’ as expected. This is likely a bug.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array([1, 2, 3]) array([1, 2, 3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Upcasting:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array([1, 2, 3.0]) array([ 1., 2., 3.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>More than one dimension:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array(<a href="null">1, 2], [3, 4</a>) array(<a href="null">1, 2],
-       [3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Minimum dimensions 2:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array([1, 2, 3], ndmin=2) array(<a href="null">1, 2, 3</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Type provided:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array([1, 2, 3], dtype=complex) array([ 1.+0.j, 2.+0.j, 3.+0.j])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Data-type consisting of more than one element:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([(1,2),(3,4)],dtype=[(‘a’,‘&lt;i4’),(‘b’,‘&lt;i4’)]) x[‘a’] array([1, 3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Creating an array from sub-classes:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array(np.mat(‘1 2; 3 4’)) array(<a href="null">1, 2],
-       [3, 4</a>)</p>
-      <p>np.array(np.mat(‘1 2; 3 4’), subok=True) matrix(<a href="null">1, 2],
-        [3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26260">view source</a></div></div><div class="public anchor" id="var-array2string"><h3>array2string</h3><div class="usage"><code>(array2string &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a string representation of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. max_line_width : int, optional  Inserts newlines if text is longer than <code>max_line_width</code>.  Defaults to <code>numpy.get_printoptions()['linewidth']</code>. precision : int or None, optional  Floating point precision.  Defaults to <code>numpy.get_printoptions()['precision']</code>. suppress_small : bool, optional  Represent numbers “very close” to zero as zero; default is False.  Very close is defined by precision: if the precision is 8, e.g.,  numbers smaller (in absolute value) than 5e-9 are represented as  zero.  Defaults to <code>numpy.get_printoptions()['suppress']</code>. separator : str, optional  Inserted between elements. prefix : str, optional suffix: str, optional  The length of the prefix and suffix strings are used to respectively  align and wrap the output. An array is typically printed as::</p>
-<pre><code>  prefix + array2string(a) + suffix
-
-The output is left-padded by the length of the prefix string, and
-wrapping is forced at the column ``max_line_width - len(suffix)``.
-It should be noted that the content of prefix and suffix strings are
-not included in the output.
-</code></pre>
-<p>style : _NoValue, optional  Has no effect, do not use.</p>
-<pre><code>.. deprecated:: 1.14.0
-</code></pre>
-<p>formatter : dict of callables, optional  If not None, the keys should indicate the type(s) that the respective  formatting function applies to. Callables should return a string.  Types that are not specified (by their corresponding keys) are handled  by the default formatters. Individual types for which a formatter  can be set are:</p>
-<pre><code>- 'bool'
-- 'int'
-- 'timedelta' : a `numpy.timedelta64`
-- 'datetime' : a `numpy.datetime64`
-- 'float'
-- 'longfloat' : 128-bit floats
-- 'complexfloat'
-- 'longcomplexfloat' : composed of two 128-bit floats
-- 'void' : type `numpy.void`
-- 'numpystr' : types `numpy.string_` and `numpy.unicode_`
-- 'str' : all other strings
-
-Other keys that can be used to set a group of types at once are:
-
-- 'all' : sets all types
-- 'int_kind' : sets 'int'
-- 'float_kind' : sets 'float' and 'longfloat'
-- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
-- 'str_kind' : sets 'str' and 'numpystr'
-</code></pre>
-<p>threshold : int, optional  Total number of array elements which trigger summarization  rather than full repr.  Defaults to <code>numpy.get_printoptions()['threshold']</code>. edgeitems : int, optional  Number of array items in summary at beginning and end of  each dimension.  Defaults to <code>numpy.get_printoptions()['edgeitems']</code>. sign : string, either ‘-’, ‘+’, or ‘ ’, optional  Controls printing of the sign of floating-point types. If ‘+’, always  print the sign of positive values. If ‘ ’, always prints a space  (whitespace character) in the sign position of positive values. If  ‘-’, omit the sign character of positive values.  Defaults to <code>numpy.get_printoptions()['sign']</code>. floatmode : str, optional  Controls the interpretation of the <code>precision</code> option for  floating-point types.  Defaults to <code>numpy.get_printoptions()['floatmode']</code>.  Can take the following values:</p>
-<pre><code>- 'fixed': Always print exactly `precision` fractional digits,
-  even if this would print more or fewer digits than
-  necessary to specify the value uniquely.
-- 'unique': Print the minimum number of fractional digits necessary
-  to represent each value uniquely. Different elements may
-  have a different number of digits.  The value of the
-  `precision` option is ignored.
-- 'maxprec': Print at most `precision` fractional digits, but if
-  an element can be uniquely represented with fewer digits
-  only print it with that many.
-- 'maxprec_equal': Print at most `precision` fractional digits,
-  but if every element in the array can be uniquely
-  represented with an equal number of fewer digits, use that
-  many digits for all elements.
-</code></pre>
-<p>legacy : string or <code>False</code>, optional  If set to the string <code>'1.13'</code> enables 1.13 legacy printing mode. This  approximates numpy 1.13 print output by including a space in the sign  position of floats and different behavior for 0d arrays. If set to  <code>False</code>, disables legacy mode. Unrecognized strings will be ignored  with a warning for forward compatibility.</p>
-<pre><code>.. versionadded:: 1.14.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>array_str : str  String representation of the array.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>TypeError  if a callable in <code>formatter</code> does not return a string.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>array_str, array_repr, set_printoptions, get_printoptions</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If a formatter is specified for a certain type, the <code>precision</code> keyword is ignored for that type.</p>
-<p>This is a very flexible function; <code>array_repr</code> and <code>array_str</code> are using <code>array2string</code> internally so keywords with the same name should work identically in all three functions.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([1e-16,1,2,3]) np.array2string(x, precision=2, separator=‘,’, … suppress_small=True) ‘[0.,1.,2.,3.]’</p>
-      <p>x = np.arange(3.) np.array2string(x, formatter={‘float_kind’:lambda x: “%.2f” % x}) ‘[0.00 1.00 2.00]’</p>
-      <p>x = np.arange(3) np.array2string(x, formatter={‘int’:lambda x: hex(x)}) ‘[0x0 0x1 0x2]’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14133">view source</a></div></div><div class="public anchor" id="var-array_equal"><h3>array_equal</h3><div class="usage"><code>(array_equal &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>True if two arrays have the same shape and elements, False otherwise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a1, a2 : array_like  Input arrays.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>b : bool  Returns True if the arrays are equal.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>allclose: Returns True if two arrays are element-wise equal within a  tolerance. array_equiv: Returns True if input arrays are shape consistent and all  elements equal.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array_equal([1, 2], [1, 2]) True np.array_equal(np.array([1, 2]), np.array([1, 2])) True np.array_equal([1, 2], [1, 2, 3]) False np.array_equal([1, 2], [1, 4]) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9298">view source</a></div></div><div class="public anchor" id="var-array_equiv"><h3>array_equiv</h3><div class="usage"><code>(array_equiv &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns True if input arrays are shape consistent and all elements equal.</p>
-<p>Shape consistent means they are either the same shape, or one input array can be broadcasted to create the same shape as the other one.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a1, a2 : array_like  Input arrays.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : bool  True if equivalent, False otherwise.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array_equiv([1, 2], [1, 2]) True np.array_equiv([1, 2], [1, 3]) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Showing the shape equivalence:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array_equiv([1, 2], <a href="null">1, 2], [1, 2</a>) True np.array_equiv([1, 2], <a href="null">1, 2, 1, 2], [1, 2, 1, 2</a>) False</p>
-      <p>np.array_equiv([1, 2], <a href="null">1, 2], [1, 3</a>) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27883">view source</a></div></div><div class="public anchor" id="var-array_repr"><h3>array_repr</h3><div class="usage"><code>(array_repr &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the string representation of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr : ndarray  Input array. max_line_width : int, optional  Inserts newlines if text is longer than <code>max_line_width</code>.  Defaults to <code>numpy.get_printoptions()['linewidth']</code>. precision : int, optional  Floating point precision.  Defaults to <code>numpy.get_printoptions()['precision']</code>. suppress_small : bool, optional  Represent numbers “very close” to zero as zero; default is False.  Very close is defined by precision: if the precision is 8, e.g.,  numbers smaller (in absolute value) than 5e-9 are represented as  zero.  Defaults to <code>numpy.get_printoptions()['suppress']</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>string : str  The string representation of an array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>array_str, array2string, set_printoptions</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array_repr(np.array([1,2])) ‘array([1, 2])’ np.array_repr(np.ma.array([0.])) ‘MaskedArray([0.])’ np.array_repr(np.array([], np.int32)) ‘array([], dtype=int32)’</p>
-      <p>x = np.array([1e-6, 4e-7, 2, 3]) np.array_repr(x, precision=6, suppress_small=True) ‘array([0.000001, 0. , 2. , 3. ])’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21936">view source</a></div></div><div class="public anchor" id="var-array_split"><h3>array_split</h3><div class="usage"><code>(array_split &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Split an array into multiple sub-arrays.</p>
-<p>Please refer to the <code>split</code> documentation. The only difference between these functions is that <code>array_split</code> allows <code>indices_or_sections</code> to be an integer that does <em>not</em> equally divide the axis. For an array of length l that should be split into n sections, it returns l % n sub-arrays of size l//n + 1 and the rest of size l//n.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>split : Split array into multiple sub-arrays of equal size.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(8.0) np.array_split(x, 3)  [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])]</p>
-      <p>x = np.arange(7.0) np.array_split(x, 3)  [array([0., 1., 2.]), array([3., 4.]), array([5., 6.])]</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1221">view source</a></div></div><div class="public anchor" id="var-array_str"><h3>array_str</h3><div class="usage"><code>(array_str &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a string representation of the data in an array.</p>
-<p>The data in the array is returned as a single string. This function is similar to <code>array_repr</code>, the difference being that <code>array_repr</code> also returns information on the kind of array and its data type.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : ndarray  Input array. max_line_width : int, optional  Inserts newlines if text is longer than <code>max_line_width</code>.  Defaults to <code>numpy.get_printoptions()['linewidth']</code>. precision : int, optional  Floating point precision.  Defaults to <code>numpy.get_printoptions()['precision']</code>. suppress_small : bool, optional  Represent numbers “very close” to zero as zero; default is False.  Very close is defined by precision: if the precision is 8, e.g.,  numbers smaller (in absolute value) than 5e-9 are represented as  zero.  Defaults to <code>numpy.get_printoptions()['suppress']</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>array2string, array_repr, set_printoptions</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array_str(np.arange(3)) ‘[0 1 2]’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2036">view source</a></div></div><div class="public anchor" id="var-asanyarray"><h3>asanyarray</h3><div class="usage"><code>(asanyarray a &amp; [{dtype :dtype, order :order}])</code><code>(asanyarray a &amp; [{dtype :dtype}])</code><code>(asanyarray a)</code></div><div class="doc"><div class="markdown"><p>Convert the input to an ndarray, but pass ndarray subclasses through.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data, in any form that can be converted to an array. This  includes scalars, lists, lists of tuples, tuples, tuples of tuples,  tuples of lists, and ndarrays. dtype : data-type, optional  By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional  Whether to use row-major (C-style) or column-major  (Fortran-style) memory representation. Defaults to ‘C’.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or an ndarray subclass  Array interpretation of <code>a</code>. If <code>a</code> is an ndarray or a subclass  of ndarray, it is returned as-is and no copy is performed.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>asarray : Similar function which always returns ndarrays. ascontiguousarray : Convert input to a contiguous array. asfarray : Convert input to a floating point ndarray. asfortranarray : Convert input to an ndarray with column-major  memory order. asarray_chkfinite : Similar function which checks input for NaNs and  Infs. fromiter : Create an array from an iterator. fromfunction : Construct an array by executing a function on grid  positions.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Convert a list into an array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = [1, 2] np.asanyarray(a) array([1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Instances of <code>ndarray</code> subclasses are passed through as-is:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([(1.0, 2), (3.0, 4)], dtype=‘f4,i4’).view(np.recarray) np.asanyarray(a) is a True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21617">view source</a></div></div><div class="public anchor" id="var-asarray"><h3>asarray</h3><div class="usage"><code>(asarray a &amp; [{dtype :dtype, order :order}])</code><code>(asarray a &amp; [{dtype :dtype}])</code><code>(asarray a)</code></div><div class="doc"><div class="markdown"><p>Convert the input to an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data, in any form that can be converted to an array. This  includes lists, lists of tuples, tuples, tuples of tuples, tuples  of lists and ndarrays. dtype : data-type, optional  By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional  Whether to use row-major (C-style) or  column-major (Fortran-style) memory representation.  Defaults to ‘C’.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Array interpretation of <code>a</code>. No copy is performed if the input  is already an ndarray with matching dtype and order. If <code>a</code> is a  subclass of ndarray, a base class ndarray is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>asanyarray : Similar function which passes through subclasses. ascontiguousarray : Convert input to a contiguous array. asfarray : Convert input to a floating point ndarray. asfortranarray : Convert input to an ndarray with column-major  memory order. asarray_chkfinite : Similar function which checks input for NaNs and Infs. fromiter : Create an array from an iterator. fromfunction : Construct an array by executing a function on grid  positions.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Convert a list into an array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = [1, 2] np.asarray(a) array([1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Existing arrays are not copied:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1, 2]) np.asarray(a) is a True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>If <code>dtype</code> is set, array is copied only if dtype does not match:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1, 2], dtype=np.float32) np.asarray(a, dtype=np.float32) is a True np.asarray(a, dtype=np.float64) is a False</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Contrary to <code>asanyarray</code>, ndarray subclasses are not passed through:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>issubclass(np.recarray, np.ndarray) True a = np.array([(1.0, 2), (3.0, 4)], dtype=‘f4,i4’).view(np.recarray) np.asarray(a) is a False np.asanyarray(a) is a True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22285">view source</a></div></div><div class="public anchor" id="var-asarray_chkfinite"><h3>asarray_chkfinite</h3><div class="usage"><code>(asarray_chkfinite a &amp; [{dtype :dtype, order :order}])</code><code>(asarray_chkfinite a &amp; [{dtype :dtype}])</code><code>(asarray_chkfinite a)</code></div><div class="doc"><div class="markdown"><p>Convert the input to an array, checking for NaNs or Infs.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data, in any form that can be converted to an array. This  includes lists, lists of tuples, tuples, tuples of tuples, tuples  of lists and ndarrays. Success requires no NaNs or Infs. dtype : data-type, optional  By default, the data-type is inferred from the input data. order : {‘C’, ‘F’}, optional  Whether to use row-major (C-style) or  column-major (Fortran-style) memory representation.  Defaults to ‘C’.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Array interpretation of <code>a</code>. No copy is performed if the input  is already an ndarray. If <code>a</code> is a subclass of ndarray, a base  class ndarray is returned.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  Raises ValueError if <code>a</code> contains NaN (Not a Number) or Inf (Infinity).</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>asarray : Create and array. asanyarray : Similar function which passes through subclasses. ascontiguousarray : Convert input to a contiguous array. asfarray : Convert input to a floating point ndarray. asfortranarray : Convert input to an ndarray with column-major  memory order. fromiter : Create an array from an iterator. fromfunction : Construct an array by executing a function on grid  positions.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Convert a list into an array. If all elements are finite <code>asarray_chkfinite</code> is identical to <code>asarray</code>.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = [1, 2] np.asarray_chkfinite(a, dtype=float) array([1., 2.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Raises ValueError if array_like contains Nans or Infs.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = [1, 2, np.inf] try: … np.asarray_chkfinite(a) … except ValueError: … print(‘ValueError’) … ValueError</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26550">view source</a></div></div><div class="public anchor" id="var-ascontiguousarray"><h3>ascontiguousarray</h3><div class="usage"><code>(ascontiguousarray a &amp; [{dtype :dtype}])</code><code>(ascontiguousarray a)</code></div><div class="doc"><div class="markdown"><p>Return a contiguous array (ndim &gt;= 1) in memory (C order).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. dtype : str or dtype object, optional  Data-type of returned array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Contiguous array of same shape and content as <code>a</code>, with type <code>dtype</code>  if specified.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>asfortranarray : Convert input to an ndarray with column-major  memory order. require : Return an ndarray that satisfies requirements. ndarray.flags : Information about the memory layout of the array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(6).reshape(2,3) np.ascontiguousarray(x, dtype=np.float32) array(<a href="null">0., 1., 2.],
-       [3., 4., 5.</a>, dtype=float32) x.flags[‘C_CONTIGUOUS’] True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note: This function returns an array with at least one-dimension (1-d) so it will not preserve 0-d arrays. </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27630">view source</a></div></div><div class="public anchor" id="var-asfarray"><h3>asfarray</h3><div class="usage"><code>(asfarray &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an array converted to a float type.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  The input array. dtype : str or dtype object, optional  Float type code to coerce input array <code>a</code>. If <code>dtype</code> is one of the  ‘int’ dtypes, it is replaced with float64.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  The input <code>a</code> as a float ndarray.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.asfarray([2, 3]) array([2., 3.]) np.asfarray([2, 3], dtype=‘float’) array([2., 3.]) np.asfarray([2, 3], dtype=‘int8’) array([2., 3.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17279">view source</a></div></div><div class="public anchor" id="var-asfortranarray"><h3>asfortranarray</h3><div class="usage"><code>(asfortranarray a &amp; [{dtype :dtype}])</code><code>(asfortranarray a)</code></div><div class="doc"><div class="markdown"><p>Return an array (ndim &gt;= 1) laid out in Fortran order in memory.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. dtype : str or dtype object, optional  By default, the data-type is inferred from the input data.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  The input <code>a</code> in Fortran, or column-major, order.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ascontiguousarray : Convert input to a contiguous (C order) array. asanyarray : Convert input to an ndarray with either row or  column-major memory order. require : Return an ndarray that satisfies requirements. ndarray.flags : Information about the memory layout of the array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(6).reshape(2,3) y = np.asfortranarray(x) x.flags[‘F_CONTIGUOUS’] False y.flags[‘F_CONTIGUOUS’] True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note: This function returns an array with at least one-dimension (1-d) so it will not preserve 0-d arrays. </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L726">view source</a></div></div><div class="public anchor" id="var-asmatrix"><h3>asmatrix</h3><div class="usage"><code>(asmatrix data &amp; [{dtype :dtype}])</code><code>(asmatrix data)</code></div><div class="doc"><div class="markdown"><p>Interpret the input as a matrix.</p>
-<p>Unlike <code>matrix</code>, <code>asmatrix</code> does not make a copy if the input is already a matrix or an ndarray. Equivalent to <code>matrix(data, copy=False)</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>data : array_like  Input data. dtype : data-type  Data-type of the output matrix.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>mat : matrix  <code>data</code> interpreted as a matrix.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">1, 2], [3, 4</a>)</p>
-      <p>m = np.asmatrix(x)</p>
-      <p>x[0,0] = 5</p>
-      <p>m matrix(<a href="null">5, 2],
-        [3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6635">view source</a></div></div><div class="public anchor" id="var-asscalar"><h3>asscalar</h3><div class="usage"><code>(asscalar &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Convert an array of size 1 to its scalar equivalent.</p>
-<p>.. deprecated:: 1.16</p>
-<pre><code>Deprecated, use `numpy.ndarray.item()` instead.
-</code></pre>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : ndarray  Input array of size 1.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : scalar  Scalar representation of <code>a</code>. The output data type is the same type  returned by the input’s <code>item</code> method.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.asscalar(np.array([24])) 24</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16835">view source</a></div></div><div class="public anchor" id="var-atleast_1d"><h3>atleast_1d</h3><div class="usage"><code>(atleast_1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Convert inputs to arrays with at least one dimension.</p>
-<p>Scalar inputs are converted to 1-dimensional arrays, whilst higher-dimensional inputs are preserved.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arys1, arys2, … : array_like  One or more input arrays.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>ret : ndarray  An array, or list of arrays, each with <code>a.ndim &gt;= 1</code>.  Copies are made only if necessary.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>atleast_2d, atleast_3d</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.atleast_1d(1.0) array([1.])</p>
-      <p>x = np.arange(9.0).reshape(3,3) np.atleast_1d(x) array(<a href="null">0., 1., 2.],
-       [3., 4., 5.],
-       [6., 7., 8.</a>) np.atleast_1d(x) is x True</p>
-      <p>np.atleast_1d(1, [3, 4]) [array([1]), array([3, 4])]</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21575">view source</a></div></div><div class="public anchor" id="var-atleast_2d"><h3>atleast_2d</h3><div class="usage"><code>(atleast_2d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>View inputs as arrays with at least two dimensions.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arys1, arys2, … : array_like  One or more array-like sequences. Non-array inputs are converted  to arrays. Arrays that already have two or more dimensions are  preserved.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>res, res2, … : ndarray  An array, or list of arrays, each with <code>a.ndim &gt;= 2</code>.  Copies are avoided where possible, and views with two or more  dimensions are returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>atleast_1d, atleast_3d</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.atleast_2d(3.0) array(<a href="null">3.</a>)</p>
-      <p>x = np.arange(3.0) np.atleast_2d(x) array(<a href="null">0., 1., 2.</a>) np.atleast_2d(x).base is x True</p>
-      <p>np.atleast_2d(1, [1, 2], <a href="null">1, 2</a>) [array([[1]]), array([[1, 2]]), array([[1, 2]])]</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16632">view source</a></div></div><div class="public anchor" id="var-atleast_3d"><h3>atleast_3d</h3><div class="usage"><code>(atleast_3d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>View inputs as arrays with at least three dimensions.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arys1, arys2, … : array_like  One or more array-like sequences. Non-array inputs are converted to  arrays. Arrays that already have three or more dimensions are  preserved.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>res1, res2, … : ndarray  An array, or list of arrays, each with <code>a.ndim &gt;= 3</code>. Copies are  avoided where possible, and views with three or more dimensions are  returned. For example, a 1-D array of shape <code>(N,)</code> becomes a view  of shape <code>(1, N, 1)</code>, and a 2-D array of shape <code>(M, N)</code> becomes a  view of shape <code>(M, N, 1)</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>atleast_1d, atleast_2d</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.atleast_3d(3.0) array(<a href="null">[3.</a>])</p>
-      <p>x = np.arange(3.0) np.atleast_3d(x).shape (1, 3, 1)</p>
-      <p>x = np.arange(12.0).reshape(4,3) np.atleast_3d(x).shape (4, 3, 1) np.atleast_3d(x).base is x.base # x is a reshape, so not base itself True</p>
-      <p>for arr in np.atleast_3d([1, 2], <a href="null">1, 2</a>, <a href="null">[1, 2</a>]): … print(arr, arr.shape) # doctest: +SKIP … <a href="null">[1]
-  [2</a>] (1, 2, 1) <a href="null">[1]
-  [2</a>] (1, 2, 1) <a href="null">[1 2</a>] (1, 1, 2)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13347">view source</a></div></div><div class="public anchor" id="var-average"><h3>average</h3><div class="usage"><code>(average &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the weighted average along the specified axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array containing data to be averaged. If <code>a</code> is not an array, a  conversion is attempted. axis : None or int or tuple of ints, optional  Axis or axes along which to average <code>a</code>. The default,  axis=None, will average over all of the elements of the input array.  If axis is negative it counts from the last to the first axis.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If axis is a tuple of ints, averaging is performed on all of the axes
-specified in the tuple instead of a single axis or all the axes as
-before.
-</code></pre>
-<p>weights : array_like, optional  An array of weights associated with the values in <code>a</code>. Each value in  <code>a</code> contributes to the average according to its associated weight.  The weights array can either be 1-D (in which case its length must be  the size of <code>a</code> along the given axis) or of the same shape as <code>a</code>.  If <code>weights=None</code>, then all data in <code>a</code> are assumed to have a  weight equal to one. The 1-D calculation is::</p>
-<pre><code>    avg = sum(a * weights) / sum(weights)
-
-The only constraint on `weights` is that `sum(weights)` must not be 0.
-</code></pre>
-<p>returned : bool, optional  Default is <code>False</code>. If <code>True</code>, the tuple (<code>average</code>, <code>sum_of_weights</code>)  is returned, otherwise only the average is returned.  If <code>weights=None</code>, <code>sum_of_weights</code> is equivalent to the number of  elements over which the average is taken.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>retval, [sum_of_weights] : array_type or double  Return the average along the specified axis. When <code>returned</code> is <code>True</code>,  return a tuple with the average as the first element and the sum  of the weights as the second element. <code>sum_of_weights</code> is of the  same type as <code>retval</code>. The result dtype follows a genereal pattern.  If <code>weights</code> is None, the result dtype will be that of <code>a</code> , or <code>float64</code>  if <code>a</code> is integral. Otherwise, if <code>weights</code> is not None and <code>a</code> is non-  integral, the result type will be the type of lowest precision capable of  representing values of both <code>a</code> and <code>weights</code>. If <code>a</code> happens to be  integral, the previous rules still applies but the result dtype will  at least be <code>float64</code>.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ZeroDivisionError  When all weights along axis are zero. See <code>numpy.ma.average</code> for a  version robust to this type of error. TypeError  When the length of 1D <code>weights</code> is not the same as the shape of <code>a</code>  along axis.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>mean</p>
-<p>ma.average : average for masked arrays – useful if your data contains  “missing” values numpy.result_type : Returns the type that results from applying the  numpy type promotion rules to the arguments.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>data = np.arange(1, 5) data array([1, 2, 3, 4]) np.average(data) 2.5 np.average(np.arange(1, 11), weights=np.arange(10, 0, -1)) 4.0</p>
-      <p>data = np.arange(6).reshape((3,2)) data array(<a href="null">0, 1],
-       [2, 3],
-       [4, 5</a>) np.average(data, axis=1, weights=[1./4, 3./4]) array([0.75, 2.75, 4.75]) np.average(data, weights=[1./4, 3./4]) Traceback (most recent call last):  … TypeError: Axis must be specified when shapes of a and weights differ.</p>
-      <p>a = np.ones(5, dtype=np.float128) w = np.ones(5, dtype=np.complex64) avg = np.average(a, weights=w) print(avg.dtype) complex256</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5179">view source</a></div></div><div class="public anchor" id="var-AxisError"><h3>AxisError</h3><div class="usage"><code>(AxisError self axis &amp; [{ndim :ndim, msg_prefix :msg_prefix}])</code><code>(AxisError self axis &amp; [{ndim :ndim}])</code><code>(AxisError self axis)</code></div><div class="doc"><div class="markdown"><p>Axis supplied was invalid. </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25035">view source</a></div></div><div class="public anchor" id="var-bartlett"><h3>bartlett</h3><div class="usage"><code>(bartlett M)</code></div><div class="doc"><div class="markdown"><p>Return the Bartlett window.</p>
-<p>The Bartlett window is very similar to a triangular window, except that the end points are at zero. It is often used in signal processing for tapering a signal, without generating too much ripple in the frequency domain.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>M : int  Number of points in the output window. If zero or less, an  empty array is returned.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : array  The triangular window, with the maximum value normalized to one  (the value one appears only if the number of samples is odd), with  the first and last samples equal to zero.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>blackman, hamming, hanning, kaiser</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The Bartlett window is defined as</p>
-<p>.. math:: w(n) = \frac{2}{M-1} \left(  \frac{M-1}{2} - \left|n - \frac{M-1}{2}\right|  \right)</p>
-<p>Most references to the Bartlett window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. Note that convolution with this window produces linear interpolation. It is also known as an apodization (which means“removing the foot”, i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function. The fourier transform of the Bartlett is the product of two sinc functions. Note the excellent discussion in Kanasewich.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] M.S. Bartlett, “Periodogram Analysis and Continuous Spectra”,  Biometrika 37, 1-16, 1950. .. [2] E.R. Kanasewich, “Time Sequence Analysis in Geophysics”,  The University of Alberta Press, 1975, pp. 109-110. .. [3] A.V. Oppenheim and R.W. Schafer, “Discrete-Time Signal  Processing”, Prentice-Hall, 1999, pp. 468-471. .. [4] Wikipedia, “Window function”,  <a href="https://en.wikipedia.org/wiki/Window_function">https://en.wikipedia.org/wiki/Window_function</a> .. [5] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,  “Numerical Recipes”, Cambridge University Press, 1986, page 429.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt np.bartlett(12) array([ 0. , 0.18181818, 0.36363636, 0.54545455, 0.72727273, # may vary  0.90909091, 0.90909091, 0.72727273, 0.54545455, 0.36363636,  0.18181818, 0. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot the window and its frequency response (requires SciPy and matplotlib):</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from numpy.fft import fft, fftshift window = np.bartlett(51) plt.plot(window) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Bartlett window”) Text(0.5, 1.0, ‘Bartlett window’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“Sample”) Text(0.5, 0, ‘Sample’) plt.show()</p>
-      <p>plt.figure() </p><figure size="" 640x480="" with="" 0="" axes=""> A = fft(window, 2048) / 25.5 mag = np.abs(fftshift(A)) freq = np.linspace(-0.5, 0.5, len(A)) with np.errstate(divide=‘ignore’, invalid=‘ignore’): … response = 20 * np.log10(mag) … response = np.clip(response, -100, 100) plt.plot(freq, response) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Frequency response of Bartlett window”) Text(0.5, 1.0, ‘Frequency response of Bartlett window’) plt.ylabel(“Magnitude [dB]”) Text(0, 0.5, ‘Magnitude [dB]’) plt.xlabel(“Normalized frequency [cycles per sample]”) Text(0.5, 0, ‘Normalized frequency [cycles per sample]’) _ = plt.axis(‘tight’) plt.show()<p></p>
-    </figure></blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25236">view source</a></div></div><div class="public anchor" id="var-base_repr"><h3>base_repr</h3><div class="usage"><code>(base_repr number &amp; [{base :base, padding :padding}])</code><code>(base_repr number &amp; [{base :base}])</code><code>(base_repr number)</code></div><div class="doc"><div class="markdown"><p>Return a string representation of a number in the given base system.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>number : int  The value to convert. Positive and negative values are handled. base : int, optional  Convert <code>number</code> to the <code>base</code> number system. The valid range is 2-36,  the default value is 2. padding : int, optional  Number of zeros padded on the left. Default is 0 (no padding).</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : str  String representation of <code>number</code> in <code>base</code> system.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>binary_repr : Faster version of <code>base_repr</code> for base 2.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.base_repr(5) ‘101’ np.base_repr(6, 5) ‘11’ np.base_repr(7, base=5, padding=3) ‘00012’</p>
-      <p>np.base_repr(10, base=16) ‘A’ np.base_repr(32, base=16) ‘20’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22830">view source</a></div></div><div class="public anchor" id="var-binary_repr"><h3>binary_repr</h3><div class="usage"><code>(binary_repr num &amp; [{width :width}])</code><code>(binary_repr num)</code></div><div class="doc"><div class="markdown"><p>Return the binary representation of the input number as a string.</p>
-<p>For negative numbers, if width is not given, a minus sign is added to the front. If width is given, the two’s complement of the number is returned, with respect to that width.</p>
-<p>In a two’s-complement system negative numbers are represented by the two’s complement of the absolute value. This is the most common method of representing signed integers on computers [1]_. A N-bit two’s-complement system can represent every integer in the range :math:<code>-2^{N-1}</code> to :math:<code>+2^{N-1}-1</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>num : int  Only an integer decimal number can be used. width : int, optional  The length of the returned string if <code>num</code> is positive, or the length  of the two’s complement if <code>num</code> is negative, provided that <code>width</code> is  at least a sufficient number of bits for <code>num</code> to be represented in the  designated form.</p>
-<pre><code>If the `width` value is insufficient, it will be ignored, and `num` will
-be returned in binary (`num` &gt; 0) or two's complement (`num` &lt; 0) form
-with its width equal to the minimum number of bits needed to represent
-the number in the designated form. This behavior is deprecated and will
-later raise an error.
-
-.. deprecated:: 1.12.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>bin : str  Binary representation of <code>num</code> or two’s complement of <code>num</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>base_repr: Return a string representation of a number in the given base  system. bin: Python’s built-in binary representation generator of an integer.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>binary_repr</code> is equivalent to using <code>base_repr</code> with base 2, but about 25x faster.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Wikipedia, “Two’s complement”,  <a href="https://en.wikipedia.org/wiki/Two's_complement">https://en.wikipedia.org/wiki/Two's_complement</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.binary_repr(3) ‘11’ np.binary_repr(-3) ‘-11’ np.binary_repr(3, width=4) ‘0011’</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The two’s complement is returned when the input number is negative and width is specified:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.binary_repr(-3, width=3) ‘101’ np.binary_repr(-3, width=5) ‘11101’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21132">view source</a></div></div><div class="public anchor" id="var-bincount"><h3>bincount</h3><div class="usage"><code>(bincount &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bincount(x, weights=None, minlength=0)</p>
-<p>Count number of occurrences of each value in array of non-negative ints.</p>
-<p>The number of bins (of size 1) is one larger than the largest value in <code>x</code>. If <code>minlength</code> is specified, there will be at least this number of bins in the output array (though it will be longer if necessary, depending on the contents of <code>x</code>). Each bin gives the number of occurrences of its index value in <code>x</code>. If <code>weights</code> is specified the input array is weighted by it, i.e. if a value <code>n</code> is found at position <code>i</code>, <code>out[n] += weight[i]</code> instead of <code>out[n] += 1</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like, 1 dimension, nonnegative ints  Input array. weights : array_like, optional  Weights, array of the same shape as <code>x</code>. minlength : int, optional  A minimum number of bins for the output array.</p>
-<pre><code>.. versionadded:: 1.6.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray of ints  The result of binning the input array.  The length of <code>out</code> is equal to <code>np.amax(x)+1</code>.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If the input is not 1-dimensional, or contains elements with negative  values, or if <code>minlength</code> is negative. TypeError  If the type of the input is float or complex.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>histogram, digitize, unique</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.bincount(np.arange(5)) array([1, 1, 1, 1, 1]) np.bincount(np.array([0, 1, 1, 3, 2, 1, 7])) array([1, 3, 1, 1, 0, 0, 0, 1])</p>
-      <p>x = np.array([0, 1, 1, 3, 2, 1, 7, 23]) np.bincount(x).size == np.amax(x)+1 True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The input array needs to be of integer dtype, otherwise a TypeError is raised:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.bincount(np.arange(5, dtype=float)) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> TypeError: array cannot be safely cast to required type</module></stdin></p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>A possible use of <code>bincount</code> is to perform sums over variable-size chunks of an array, using the <code>weights</code> keyword.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights x = np.array([0, 1, 1, 2, 2, 2]) np.bincount(x, weights=w) array([ 0.3, 0.7, 1.1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18870">view source</a></div></div><div class="public anchor" id="var-bitwise_and"><h3>bitwise_and</h3><div class="usage"><code>(bitwise_and self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bitwise_and(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute the bit-wise AND of two arrays element-wise.</p>
-<p>Computes the bit-wise AND of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>&amp;</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Only integer and boolean types are handled. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Result.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>logical_and bitwise_or bitwise_xor binary_repr :  Return the binary representation of the input number as a string.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>The number 13 is represented by <code>00001101</code>. Likewise, 17 is represented by <code>00010001</code>. The bit-wise AND of 13 and 17 is therefore <code>000000001</code>, or 1:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.bitwise_and(13, 17) 1</p>
-      <p>np.bitwise_and(14, 13) 12 np.binary_repr(12) ‘1100’ np.bitwise_and([14,3], 13) array([12, 1])</p>
-      <p>np.bitwise_and([11,7], [4,25]) array([0, 1]) np.bitwise_and(np.array([2,5,255]), np.array([3,14,16])) array([ 2, 4, 16]) np.bitwise_and([True, True], [False, True]) array([False, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15171">view source</a></div></div><div class="public anchor" id="var-bitwise_not"><h3>bitwise_not</h3><div class="usage"><code>(bitwise_not self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>invert(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute bit-wise inversion, or bit-wise NOT, element-wise.</p>
-<p>Computes the bit-wise NOT of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>~</code>.</p>
-<p>For signed integer inputs, the two’s complement is returned. In a two’s-complement system negative numbers are represented by the two’s complement of the absolute value. This is the most common method of representing signed integers on computers [1]_. A N-bit two’s-complement system can represent every integer in the range :math:<code>-2^{N-1}</code> to :math:<code>+2^{N-1}-1</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Only integer and boolean types are handled. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Result.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>bitwise_and, bitwise_or, bitwise_xor logical_not binary_repr :  Return the binary representation of the input number as a string.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>bitwise_not</code> is an alias for <code>invert</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.bitwise_not is np.invert True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Wikipedia, “Two’s complement”,  <a href="https://en.wikipedia.org/wiki/Two's_complement">https://en.wikipedia.org/wiki/Two's_complement</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>We’ve seen that 13 is represented by <code>00001101</code>. The invert or bit-wise NOT of 13 is then:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.invert(np.array(13, dtype=np.uint8)) x 242 np.binary_repr(x, width=8) ‘11110010’</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The result depends on the bit-width:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.invert(np.array(13, dtype=np.uint16)) x 65522 np.binary_repr(x, width=16) ‘1111111111110010’</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>When using signed integer types the result is the two’s complement of the result for the unsigned type:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.invert(np.array([13], dtype=np.int8)) array([-14], dtype=int8) np.binary_repr(-14, width=8) ‘11110010’</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Booleans are accepted as well:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.invert(np.array([True, False])) array([False, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22436">view source</a></div></div><div class="public anchor" id="var-bitwise_or"><h3>bitwise_or</h3><div class="usage"><code>(bitwise_or self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bitwise_or(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute the bit-wise OR of two arrays element-wise.</p>
-<p>Computes the bit-wise OR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>|</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Only integer and boolean types are handled. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Result.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>logical_or bitwise_and bitwise_xor binary_repr :  Return the binary representation of the input number as a string.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>The number 13 has the binaray representation <code>00001101</code>. Likewise, 16 is represented by <code>00010000</code>. The bit-wise OR of 13 and 16 is then <code>000111011</code>, or 29:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.bitwise_or(13, 16) 29 np.binary_repr(29) ‘11101’</p>
-      <p>np.bitwise_or(32, 2) 34 np.bitwise_or([33, 4], 1) array([33, 5]) np.bitwise_or([33, 4], [1, 2]) array([33, 6])</p>
-      <p>np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4])) array([ 6, 5, 255]) np.array([2, 5, 255]) | np.array([4, 4, 4]) array([ 6, 5, 255]) np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32), … np.array([4, 4, 4, 2147483647], dtype=np.int32)) array([ 6, 5, 255, 2147483647]) np.bitwise_or([True, True], [False, True]) array([ True, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6197">view source</a></div></div><div class="public anchor" id="var-bitwise_xor"><h3>bitwise_xor</h3><div class="usage"><code>(bitwise_xor self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bitwise_xor(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute the bit-wise XOR of two arrays element-wise.</p>
-<p>Computes the bit-wise XOR of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>^</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Only integer and boolean types are handled. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Result.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>logical_xor bitwise_and bitwise_or binary_repr :  Return the binary representation of the input number as a string.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>The number 13 is represented by <code>00001101</code>. Likewise, 17 is represented by <code>00010001</code>. The bit-wise XOR of 13 and 17 is therefore <code>00011100</code>, or 28:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.bitwise_xor(13, 17) 28 np.binary_repr(28) ‘11100’</p>
-      <p>np.bitwise_xor(31, 5) 26 np.bitwise_xor([31,3], 5) array([26, 6])</p>
-      <p>np.bitwise_xor([31,3], [5,6]) array([26, 5]) np.bitwise_xor([True, True], [False, True]) array([ True, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L29071">view source</a></div></div><div class="public anchor" id="var-blackman"><h3>blackman</h3><div class="usage"><code>(blackman M)</code></div><div class="doc"><div class="markdown"><p>Return the Blackman window.</p>
-<p>The Blackman window is a taper formed by using the first three terms of a summation of cosines. It was designed to have close to the minimal leakage possible. It is close to optimal, only slightly worse than a Kaiser window.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>M : int  Number of points in the output window. If zero or less, an empty  array is returned.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  The window, with the maximum value normalized to one (the value one  appears only if the number of samples is odd).</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>bartlett, hamming, hanning, kaiser</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The Blackman window is defined as</p>
-<p>.. math:: w(n) = 0.42 - 0.5 \cos(2\pi n/M) + 0.08 \cos(4\pi n/M)</p>
-<p>Most references to the Blackman window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means “removing the foot”, i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function. It is known as a “near optimal” tapering function, almost as good (by some measures) as the kaiser window.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra, Dover Publications, New York.</p>
-<p>Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing. Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt np.blackman(12) array([-1.38777878e-17, 3.26064346e-02, 1.59903635e-01, # may vary  4.14397981e-01, 7.36045180e-01, 9.67046769e-01,  9.67046769e-01, 7.36045180e-01, 4.14397981e-01,  1.59903635e-01, 3.26064346e-02, -1.38777878e-17])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot the window and the frequency response:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from numpy.fft import fft, fftshift window = np.blackman(51) plt.plot(window) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Blackman window”) Text(0.5, 1.0, ‘Blackman window’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“Sample”) Text(0.5, 0, ‘Sample’) plt.show()</p>
-      <p>plt.figure() </p><figure size="" 640x480="" with="" 0="" axes=""> A = fft(window, 2048) / 25.5 mag = np.abs(fftshift(A)) freq = np.linspace(-0.5, 0.5, len(A)) with np.errstate(divide=‘ignore’, invalid=‘ignore’): … response = 20 * np.log10(mag) … response = np.clip(response, -100, 100) plt.plot(freq, response) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Frequency response of Blackman window”) Text(0.5, 1.0, ‘Frequency response of Blackman window’) plt.ylabel(“Magnitude [dB]”) Text(0, 0.5, ‘Magnitude [dB]’) plt.xlabel(“Normalized frequency [cycles per sample]”) Text(0.5, 0, ‘Normalized frequency [cycles per sample]’) _ = plt.axis(‘tight’) plt.show()<p></p>
-    </figure></blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16060">view source</a></div></div><div class="public anchor" id="var-block"><h3>block</h3><div class="usage"><code>(block &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Assemble an nd-array from nested lists of blocks.</p>
-<p>Blocks in the innermost lists are concatenated (see <code>concatenate</code>) along the last dimension (-1), then these are concatenated along the second-last dimension (-2), and so on until the outermost list is reached.</p>
-<p>Blocks can be of any dimension, but will not be broadcasted using the normal rules. Instead, leading axes of size 1 are inserted, to make <code>block.ndim</code> the same for all blocks. This is primarily useful for working with scalars, and means that code like <code>np.block([v, 1])</code> is valid, where <code>v.ndim == 1</code>.</p>
-<p>When the nested list is two levels deep, this allows block matrices to be constructed from their components.</p>
-<p>.. versionadded:: 1.13.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arrays : nested list of array_like or scalars (but not tuples)  If passed a single ndarray or scalar (a nested list of depth 0), this  is returned unmodified (and not copied).</p>
-<pre><code>Elements shapes must match along the appropriate axes (without
-broadcasting), but leading 1s will be prepended to the shape as
-necessary to make the dimensions match.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>block_array : ndarray  The array assembled from the given blocks.</p>
-<pre><code>The dimensionality of the output is equal to the greatest of:
-* the dimensionality of all the inputs
-* the depth to which the input list is nested
-</code></pre>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  * If list depths are mismatched - for instance, <code>[[a, b], c]</code> is  illegal, and should be spelt <code>[[a, b], [c]]</code>  * If lists are empty - for instance, <code>[[a, b], []]</code></p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>concatenate : Join a sequence of arrays together. stack : Stack arrays in sequence along a new dimension. hstack : Stack arrays in sequence horizontally (column wise). vstack : Stack arrays in sequence vertically (row wise). dstack : Stack arrays in sequence depth wise (along third dimension). vsplit : Split array into a list of multiple sub-arrays vertically.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>When called with only scalars, <code>np.block</code> is equivalent to an ndarray call. So <code>np.block([[1, 2], [3, 4]])</code> is equivalent to <code>np.array([[1, 2], [3, 4]])</code>.</p>
-<p>This function does not enforce that the blocks lie on a fixed grid. <code>np.block([[a, b], [c, d]])</code> is not restricted to arrays of the form::</p>
-<pre><code>AAAbb
-AAAbb
-cccDD
-</code></pre>
-<p>But is also allowed to produce, for some <code>a, b, c, d</code>::</p>
-<pre><code>AAAbb
-AAAbb
-cDDDD
-</code></pre>
-<p>Since concatenation happens along the last axis first, <code>block</code> is <em>not</em> capable of producing the following directly::</p>
-<pre><code>AAAbb
-cccbb
-cccDD
-</code></pre>
-<p>Matlab’s “square bracket stacking”, <code>[A, B, ...; p, q, ...]</code>, is equivalent to <code>np.block([[A, B, ...], [p, q, ...]])</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>The most common use of this function is to build a block matrix</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>A = np.eye(2) * 2 B = np.eye(3) * 3 np.block([ … [A, np.zeros((2, 3))], … [np.ones((3, 2)), B ] … ]) array(<a href="null">2., 0., 0., 0., 0.],
-       [0., 2., 0., 0., 0.],
-       [1., 1., 3., 0., 0.],
-       [1., 1., 0., 3., 0.],
-       [1., 1., 0., 0., 3.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>With a list of depth 1, <code>block</code> can be used as <code>hstack</code></p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.block([1, 2, 3]) # hstack([1, 2, 3]) array([1, 2, 3])</p>
-      <p>a = np.array([1, 2, 3]) b = np.array([2, 3, 4]) np.block([a, b, 10]) # hstack([a, b, 10]) array([ 1, 2, 3, 2, 3, 4, 10])</p>
-      <p>A = np.ones((2, 2), int) B = 2 * A np.block([A, B]) # hstack([A, B]) array(<a href="null">1, 1, 2, 2],
-       [1, 1, 2, 2</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>With a list of depth 2, <code>block</code> can be used in place of <code>vstack</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1, 2, 3]) b = np.array([2, 3, 4]) np.block(<a href="null">a], [b</a>) # vstack([a, b]) array(<a href="null">1, 2, 3],
-       [2, 3, 4</a>)</p>
-      <p>A = np.ones((2, 2), int) B = 2 * A np.block(<a href="null">A], [B</a>) # vstack([A, B]) array(<a href="null">1, 1],
-       [1, 1],
-       [2, 2],
-       [2, 2</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>It can also be used in places of <code>atleast_1d</code> and <code>atleast_2d</code></p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(0) b = np.array([1]) np.block([a]) # atleast_1d(a) array([0]) np.block([b]) # atleast_1d(b) array([1])</p>
-      <p>np.block(<a href="null">a</a>) # atleast_2d(a) array(<a href="null">0</a>) np.block(<a href="null">b</a>) # atleast_2d(b) array(<a href="null">1</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11534">view source</a></div></div><div class="public anchor" id="var-bmat"><h3>bmat</h3><div class="usage"><code>(bmat obj &amp; [{ldict :ldict, gdict :gdict}])</code><code>(bmat obj &amp; [{ldict :ldict}])</code><code>(bmat obj)</code></div><div class="doc"><div class="markdown"><p>Build a matrix object from a string, nested sequence, or array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>obj : str or array_like  Input data. If a string, variables in the current scope may be  referenced by name. ldict : dict, optional  A dictionary that replaces local operands in current frame.  Ignored if <code>obj</code> is not a string or <code>gdict</code> is None. gdict : dict, optional  A dictionary that replaces global operands in current frame.  Ignored if <code>obj</code> is not a string.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : matrix  Returns a matrix object, which is a specialized 2-D array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>block :  A generalization of this function for N-d arrays, that returns normal  ndarrays.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>A = np.mat(‘1 1; 1 1’) B = np.mat(‘2 2; 2 2’) C = np.mat(‘3 4; 5 6’) D = np.mat(‘7 8; 9 0’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>All the following expressions construct the same block matrix:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.bmat(<a href="null">A, B], [C, D</a>) matrix(<a href="null">1, 1, 2, 2],
-        [1, 1, 2, 2],
-        [3, 4, 7, 8],
-        [5, 6, 9, 0</a>) np.bmat(np.r_[np.c_[A, B], np.c_[C, D]]) matrix(<a href="null">1, 1, 2, 2],
-        [1, 1, 2, 2],
-        [3, 4, 7, 8],
-        [5, 6, 9, 0</a>) np.bmat(‘A,B; C,D’) matrix(<a href="null">1, 1, 2, 2],
-        [1, 1, 2, 2],
-        [3, 4, 7, 8],
-        [5, 6, 9, 0</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4204">view source</a></div></div><div class="public anchor" id="var-bool"><h3>bool</h3><div class="usage"><code>(bool self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>bool(x) -&gt; bool</p>
-<p>Returns True when the argument x is true, False otherwise. The builtins True and False are the only two instances of the class bool. The class bool is a subclass of the class int, and cannot be subclassed.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16053">view source</a></div></div><div class="public anchor" id="var-bool8"><h3>bool8</h3><div class="usage"><code>(bool8 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Boolean type (True or False), stored as a byte. Character code: <code>'?'</code>. Alias: <code>np.bool8</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25337">view source</a></div></div><div class="public anchor" id="var-bool_"><h3>bool_</h3><div class="usage"><code>(bool_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Boolean type (True or False), stored as a byte. Character code: <code>'?'</code>. Alias: <code>np.bool8</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2336">view source</a></div></div><div class="public anchor" id="var-broadcast"><h3>broadcast</h3><div class="usage"><code>(broadcast self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Produce an object that mimics broadcasting.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>in1, in2, … : array_like  Input parameters.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>b : broadcast object  Broadcast the input parameters against one another, and  return an object that encapsulates the result.  Amongst others, it has <code>shape</code> and <code>nd</code> properties, and  may be used as an iterator.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>broadcast_arrays broadcast_to</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Manually adding two vectors, using broadcasting:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">1], [2], [3</a>) y = np.array([4, 5, 6]) b = np.broadcast(x, y)</p>
-      <p>out = np.empty(b.shape) out.flat = [u+v for (u,v) in b] out array(<a href="null">5.,  6.,  7.],
-       [6.,  7.,  8.],
-       [7.,  8.,  9.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Compare against built-in broadcasting:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x + y array(<a href="null">5, 6, 7],
-       [6, 7, 8],
-       [7, 8, 9</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16237">view source</a></div></div><div class="public anchor" id="var-broadcast_arrays"><h3>broadcast_arrays</h3><div class="usage"><code>(broadcast_arrays &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Broadcast any number of arrays against each other.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p><code>*args</code> : array_likes  The arrays to broadcast.</p>
-<p>subok : bool, optional  If True, then sub-classes will be passed-through, otherwise  the returned arrays will be forced to be a base-class array (default).</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>broadcasted : list of arrays  These arrays are views on the original arrays. They are typically  not contiguous. Furthermore, more than one element of a  broadcasted array may refer to a single memory location. If you need  to write to the arrays, make copies first. While you can set the  <code>writable</code> flag True, writing to a single output value may end up  changing more than one location in the output array.</p>
-<pre><code>.. deprecated:: 1.17
-    The output is currently marked so that if written to, a deprecation
-    warning will be emitted. A future version will set the
-    ``writable`` flag False so writing to it will raise an error.
-</code></pre>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">1,2,3</a>) y = np.array(<a href="null">4],[5</a>) np.broadcast_arrays(x, y) [array([[1, 2, 3],  [1, 2, 3]]), array([[4, 4, 4],  [5, 5, 5]])]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Here is a useful idiom for getting contiguous copies instead of non-contiguous views.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>[np.array(a) for a in np.broadcast_arrays(x, y)]
-[array([[1, 2, 3],  [1, 2, 3]]), array([[4, 4, 4],  [5, 5, 5]])]</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19994">view source</a></div></div><div class="public anchor" id="var-broadcast_to"><h3>broadcast_to</h3><div class="usage"><code>(broadcast_to &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Broadcast an array to a new shape.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>array : array_like  The array to broadcast. shape : tuple  The shape of the desired array. subok : bool, optional  If True, then sub-classes will be passed-through, otherwise  the returned array will be forced to be a base-class array (default).</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>broadcast : array  A readonly view on the original array with the given shape. It is  typically not contiguous. Furthermore, more than one element of a  broadcasted array may refer to a single memory location.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If the array is not compatible with the new shape according to NumPy’s  broadcasting rules.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.10.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([1, 2, 3]) np.broadcast_to(x, (3, 3)) array(<a href="null">1, 2, 3],
-       [1, 2, 3],
-       [1, 2, 3</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24634">view source</a></div></div><div class="public anchor" id="var-BUFSIZE"><h3>BUFSIZE</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7966">view source</a></div></div><div class="public anchor" id="var-busday_count"><h3>busday_count</h3><div class="usage"><code>(busday_count &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>busday_count(begindates, enddates, weekmask=‘1111100’, holidays=[], busdaycal=None, out=None)</p>
-<p>Counts the number of valid days between <code>begindates</code> and <code>enddates</code>, not including the day of <code>enddates</code>.</p>
-<p>If <code>enddates</code> specifies a date value that is earlier than the corresponding <code>begindates</code> date value, the count will be negative.</p>
-<p>.. versionadded:: 1.7.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>begindates : array_like of datetime64[D]  The array of the first dates for counting. enddates : array_like of datetime64[D]  The array of the end dates for counting, which are excluded  from the count themselves. weekmask : str or array_like of bool, optional  A seven-element array indicating which of Monday through Sunday are  valid days. May be specified as a length-seven list or array, like  [1,1,1,1,1,0,0]; a length-seven string, like ‘1111100’; or a string  like “Mon Tue Wed Thu Fri”, made up of 3-character abbreviations for  weekdays, optionally separated by white space. Valid abbreviations  are: Mon Tue Wed Thu Fri Sat Sun holidays : array_like of datetime64[D], optional  An array of dates to consider as invalid dates. They may be  specified in any order, and NaT (not-a-time) dates are ignored.  This list is saved in a normalized form that is suited for  fast calculations of valid days. busdaycal : busdaycalendar, optional  A <code>busdaycalendar</code> object which specifies the valid days. If this  parameter is provided, neither weekmask nor holidays may be  provided. out : array of int, optional  If provided, this array is filled with the result.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : array of int  An array with a shape from broadcasting <code>begindates</code> and <code>enddates</code>  together, containing the number of valid days between  the begin and end dates.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>busdaycalendar: An object that specifies a custom set of valid days. is_busday : Returns a boolean array indicating valid days. busday_offset : Applies an offset counted in valid days.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <h1><a href="#number-of-weekdays-in-january-2011" name="number-of-weekdays-in-january-2011"></a>Number of weekdays in January 2011</h1>
-      <p>… np.busday_count(‘2011-01’, ‘2011-02’) 21</p>
-      <h1><a href="#number-of-weekdays-in-2011" name="number-of-weekdays-in-2011"></a>Number of weekdays in 2011</h1>
-      <p>np.busday_count(‘2011’, ‘2012’) 260</p>
-      <h1><a href="#number-of-saturdays-in-2011" name="number-of-saturdays-in-2011"></a>Number of Saturdays in 2011</h1>
-      <p>… np.busday_count(‘2011’, ‘2012’, weekmask=‘Sat’) 53</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9551">view source</a></div></div><div class="public anchor" id="var-busday_offset"><h3>busday_offset</h3><div class="usage"><code>(busday_offset &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>busday_offset(dates, offsets, roll=‘raise’, weekmask=‘1111100’, holidays=None, busdaycal=None, out=None)</p>
-<p>First adjusts the date to fall on a valid day according to the <code>roll</code> rule, then applies offsets to the given dates counted in valid days.</p>
-<p>.. versionadded:: 1.7.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>dates : array_like of datetime64[D]  The array of dates to process. offsets : array_like of int  The array of offsets, which is broadcast with <code>dates</code>. roll : {‘raise’, ‘nat’, ‘forward’, ‘following’, ‘backward’, ‘preceding’, ‘modifiedfollowing’, ‘modifiedpreceding’}, optional  How to treat dates that do not fall on a valid day. The default  is ‘raise’.</p>
-<pre><code>  * 'raise' means to raise an exception for an invalid day.
-  * 'nat' means to return a NaT (not-a-time) for an invalid day.
-  * 'forward' and 'following' mean to take the first valid day
-    later in time.
-  * 'backward' and 'preceding' mean to take the first valid day
-    earlier in time.
-  * 'modifiedfollowing' means to take the first valid day
-    later in time unless it is across a Month boundary, in which
-    case to take the first valid day earlier in time.
-  * 'modifiedpreceding' means to take the first valid day
-    earlier in time unless it is across a Month boundary, in which
-    case to take the first valid day later in time.
-</code></pre>
-<p>weekmask : str or array_like of bool, optional  A seven-element array indicating which of Monday through Sunday are  valid days. May be specified as a length-seven list or array, like  [1,1,1,1,1,0,0]; a length-seven string, like ‘1111100’; or a string  like “Mon Tue Wed Thu Fri”, made up of 3-character abbreviations for  weekdays, optionally separated by white space. Valid abbreviations  are: Mon Tue Wed Thu Fri Sat Sun holidays : array_like of datetime64[D], optional  An array of dates to consider as invalid dates. They may be  specified in any order, and NaT (not-a-time) dates are ignored.  This list is saved in a normalized form that is suited for  fast calculations of valid days. busdaycal : busdaycalendar, optional  A <code>busdaycalendar</code> object which specifies the valid days. If this  parameter is provided, neither weekmask nor holidays may be  provided. out : array of datetime64[D], optional  If provided, this array is filled with the result.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : array of datetime64[D]  An array with a shape from broadcasting <code>dates</code> and <code>offsets</code>  together, containing the dates with offsets applied.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>busdaycalendar: An object that specifies a custom set of valid days. is_busday : Returns a boolean array indicating valid days. busday_count : Counts how many valid days are in a half-open date range.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <h1><a href="#first-business-day-in-october-2011-not-accounting-for-holidays-" name="first-business-day-in-october-2011-not-accounting-for-holidays-"></a>First business day in October 2011 (not accounting for holidays)</h1>
-      <p>… np.busday_offset(‘2011-10’, 0, roll=‘forward’) numpy.datetime64(‘2011-10-03’)</p>
-      <h1><a href="#last-business-day-in-february-2012-not-accounting-for-holidays-" name="last-business-day-in-february-2012-not-accounting-for-holidays-"></a>Last business day in February 2012 (not accounting for holidays)</h1>
-      <p>… np.busday_offset(‘2012-03’, -1, roll=‘forward’) numpy.datetime64(‘2012-02-29’)</p>
-      <h1><a href="#third-wednesday-in-january-2011" name="third-wednesday-in-january-2011"></a>Third Wednesday in January 2011</h1>
-      <p>… np.busday_offset(‘2011-01’, 2, roll=‘forward’, weekmask=‘Wed’) numpy.datetime64(‘2011-01-19’)</p>
-      <h1><a href="#2012-mothers-day-in-canada-and-the-u-s-" name="2012-mothers-day-in-canada-and-the-u-s-"></a>2012 Mother’s Day in Canada and the U.S.</h1>
-      <p>… np.busday_offset(‘2012-05’, 1, roll=‘forward’, weekmask=‘Sun’) numpy.datetime64(‘2012-05-13’)</p>
-      <h1><a href="#first-business-day-on-or-after-a-date" name="first-business-day-on-or-after-a-date"></a>First business day on or after a date</h1>
-      <p>… np.busday_offset(‘2011-03-20’, 0, roll=‘forward’) numpy.datetime64(‘2011-03-21’) np.busday_offset(‘2011-03-22’, 0, roll=‘forward’) numpy.datetime64(‘2011-03-22’)</p>
-      <h1><a href="#first-business-day-after-a-date" name="first-business-day-after-a-date"></a>First business day after a date</h1>
-      <p>… np.busday_offset(‘2011-03-20’, 1, roll=‘backward’) numpy.datetime64(‘2011-03-21’) np.busday_offset(‘2011-03-22’, 1, roll=‘backward’) numpy.datetime64(‘2011-03-23’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17066">view source</a></div></div><div class="public anchor" id="var-busdaycalendar"><h3>busdaycalendar</h3><div class="usage"><code>(busdaycalendar self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>busdaycalendar(weekmask=‘1111100’, holidays=None)</p>
-<p>A business day calendar object that efficiently stores information defining valid days for the busday family of functions.</p>
-<p>The default valid days are Monday through Friday (“business days”). A busdaycalendar object can be specified with any set of weekly valid days, plus an optional “holiday” dates that always will be invalid.</p>
-<p>Once a busdaycalendar object is created, the weekmask and holidays cannot be modified.</p>
-<p>.. versionadded:: 1.7.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>weekmask : str or array_like of bool, optional  A seven-element array indicating which of Monday through Sunday are  valid days. May be specified as a length-seven list or array, like  [1,1,1,1,1,0,0]; a length-seven string, like ‘1111100’; or a string  like “Mon Tue Wed Thu Fri”, made up of 3-character abbreviations for  weekdays, optionally separated by white space. Valid abbreviations  are: Mon Tue Wed Thu Fri Sat Sun holidays : array_like of datetime64[D], optional  An array of dates to consider as invalid dates, no matter which  weekday they fall upon. Holiday dates may be specified in any  order, and NaT (not-a-time) dates are ignored. This list is  saved in a normalized form that is suited for fast calculations  of valid days.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : busdaycalendar  A business day calendar object containing the specified  weekmask and holidays values.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>is_busday : Returns a boolean array indicating valid days. busday_offset : Applies an offset counted in valid days. busday_count : Counts how many valid days are in a half-open date range.</p>
-<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
-<p>Note: once a busdaycalendar object is created, you cannot modify the weekmask or holidays. The attributes return copies of internal data. weekmask : (copy) seven-element array of bool holidays : (copy) sorted array of datetime64[D]</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <h1><a href="#some-important-days-in-july" name="some-important-days-in-july"></a>Some important days in July</h1>
-      <p>… bdd = np.busdaycalendar( … holidays=[‘2011-07-01’, ‘2011-07-04’, ‘2011-07-17’])</p>
-      <h1><a href="#default-is-monday-to-friday-weekdays" name="default-is-monday-to-friday-weekdays"></a>Default is Monday to Friday weekdays</h1>
-      <p>… bdd.weekmask array([ True, True, True, True, True, False, False])</p>
-      <h1><a href="#any-holidays-already-on-the-weekend-are-removed" name="any-holidays-already-on-the-weekend-are-removed"></a>Any holidays already on the weekend are removed</h1>
-      <p>… bdd.holidays array([‘2011-07-01’, ‘2011-07-04’], dtype=‘datetime64[D]’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28855">view source</a></div></div><div class="public anchor" id="var-byte"><h3>byte</h3><div class="usage"><code>(byte self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>char</code>. Character code: <code>'b'</code>. Canonical name: <code>np.byte</code>. Alias <em>on this platform</em>: <code>np.int8</code>: 8-bit signed integer (-128 to 127).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27450">view source</a></div></div><div class="public anchor" id="var-byte_bounds"><h3>byte_bounds</h3><div class="usage"><code>(byte_bounds a)</code></div><div class="doc"><div class="markdown"><p>Returns pointers to the end-points of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : ndarray  Input array. It must conform to the Python-side of the array  interface.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>(low, high) : tuple of 2 integers  The first integer is the first byte of the array, the second  integer is just past the last byte of the array. If <code>a</code> is not  contiguous it will not use every byte between the (<code>low</code>, <code>high</code>)  values.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>I = np.eye(2, dtype=‘f’); I.dtype dtype(‘float32’) low, high = np.byte_bounds(I) high - low == I.size*I.itemsize True I = np.eye(2); I.dtype dtype(‘float64’) low, high = np.byte_bounds(I) high - low == I.size*I.itemsize True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28496">view source</a></div></div><div class="public anchor" id="var-bytes0"><h3>bytes0</h3><div class="usage"><code>(bytes0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25021">view source</a></div></div><div class="public anchor" id="var-bytes_"><h3>bytes_</h3><div class="usage"><code>(bytes_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2344">view source</a></div></div><div class="public anchor" id="var-c_"><h3>c_</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Translates slice objects to concatenation along the second axis.</p>
-<p>This is short-hand for <code>np.r_['-1,2,0', index expression]</code>, which is useful because of its common occurrence. In particular, arrays will be stacked along their last axis after being upgraded to at least 2-D with 1’s post-pended to the shape (column vectors made out of 1-D arrays).</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>column_stack : Stack 1-D arrays as columns into a 2-D array. r_ : For more detailed documentation.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.c_[np.array([1,2,3]), np.array([4,5,6])] array(<a href="null">1, 4],
-       [2, 5],
-       [3, 6</a>) np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])] array(<a href="null">1, 2, 3, ..., 4, 5, 6</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4973">view source</a></div></div><div class="public anchor" id="var-can_cast"><h3>can_cast</h3><div class="usage"><code>(can_cast &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>can_cast(from_, to, casting=‘safe’)</p>
-<p>Returns True if cast between data types can occur according to the casting rule. If from is a scalar or array scalar, also returns True if the scalar value can be cast without overflow or truncation to an integer.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>from_ : dtype, dtype specifier, scalar, or array  Data type, scalar, or array to cast from. to : dtype or dtype specifier  Data type to cast to. casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional  Controls what kind of data casting may occur.</p>
-<pre><code>  * 'no' means the data types should not be cast at all.
-  * 'equiv' means only byte-order changes are allowed.
-  * 'safe' means only casts which can preserve values are allowed.
-  * 'same_kind' means only safe casts or casts within a kind,
-    like float64 to float32, are allowed.
-  * 'unsafe' means any data conversions may be done.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : bool  True if cast can occur according to the casting rule.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionchanged:: 1.17.0  Casting between a simple data type and a structured one is possible only  for “unsafe” casting. Casting to multiple fields is allowed, but  casting from multiple fields is not.</p>
-<p>.. versionchanged:: 1.9.0  Casting from numeric to string types in ‘safe’ casting mode requires  that the string dtype length is long enough to store the maximum  integer/float value converted.</p>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>dtype, result_type</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Basic examples</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.can_cast(np.int32, np.int64) True np.can_cast(np.float64, complex) True np.can_cast(complex, float) False</p>
-      <p>np.can_cast(‘i8’, ‘f8’) True np.can_cast(‘i8’, ‘f4’) False np.can_cast(‘i4’, ‘S4’) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Casting scalars</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.can_cast(100, ‘i1’) True np.can_cast(150, ‘i1’) False np.can_cast(150, ‘u1’) True</p>
-      <p>np.can_cast(3.5e100, np.float32) False np.can_cast(1000.0, np.float32) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Array scalar checks the value, array does not</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.can_cast(np.array(1000.0), np.float32) True np.can_cast(np.array([1000.0]), np.float32) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using the casting rules</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.can_cast(‘i8’, ‘i8’, ‘no’) True np.can_cast(‘&lt;i8’, ‘&gt;i8’, ‘no’) False</p>
-      <p>np.can_cast(‘&lt;i8’, ‘&gt;i8’, ‘equiv’) True np.can_cast(‘&lt;i4’, ‘&gt;i8’, ‘equiv’) False</p>
-      <p>np.can_cast(‘&lt;i4’, ‘&gt;i8’, ‘safe’) True np.can_cast(‘&lt;i8’, ‘&gt;i4’, ‘safe’) False</p>
-      <p>np.can_cast(‘&lt;i8’, ‘&gt;i4’, ‘same_kind’) True np.can_cast(‘&lt;i8’, ‘&gt;u4’, ‘same_kind’) False</p>
-      <p>np.can_cast(‘&lt;i8’, ‘&gt;u4’, ‘unsafe’) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12142">view source</a></div></div><div class="public anchor" id="var-cast"><h3>cast</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Base object for a dictionary for look-up with any alias for an array dtype.</p>
-<p>Instances of <code>_typedict</code> can not be used as dictionaries directly, first they have to be populated.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4010">view source</a></div></div><div class="public anchor" id="var-cbrt"><h3>cbrt</h3><div class="usage"><code>(cbrt self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>cbrt(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the cube-root of an array, element-wise.</p>
-<p>.. versionadded:: 1.10.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  The values whose cube-roots are required. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  An array of the same shape as <code>x</code>, containing the cube  cube-root of each element in <code>x</code>.  If <code>out</code> was provided, <code>y</code> is a reference to it.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.cbrt([1,8,27]) array([ 1., 2., 3.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8004">view source</a></div></div><div class="public anchor" id="var-cdouble"><h3>cdouble</h3><div class="usage"><code>(cdouble self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two double-precision floating-point numbers, compatible with Python <code>complex</code>. Character code: <code>'D'</code>. Canonical name: <code>np.cdouble</code>. Alias: <code>np.cfloat</code>. Alias: <code>np.complex_</code>. Alias <em>on this platform</em>: <code>np.complex128</code>: Complex number type composed of 2 64-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15237">view source</a></div></div><div class="public anchor" id="var-ceil"><h3>ceil</h3><div class="usage"><code>(ceil self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>ceil(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the ceiling of the input, element-wise.</p>
-<p>The ceil of the scalar <code>x</code> is the smallest integer <code>i</code>, such that <code>i &gt;= x</code>. It is often denoted as :math:<code>\lceil x \rceil</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input data. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  The ceiling of each element in <code>x</code>, with <code>float</code> dtype.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>floor, trunc, rint</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.ceil(a) array([-1., -1., -0., 1., 2., 2., 2.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L666">view source</a></div></div><div class="public anchor" id="var-cfloat"><h3>cfloat</h3><div class="usage"><code>(cfloat self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two double-precision floating-point numbers, compatible with Python <code>complex</code>. Character code: <code>'D'</code>. Canonical name: <code>np.cdouble</code>. Alias: <code>np.cfloat</code>. Alias: <code>np.complex_</code>. Alias <em>on this platform</em>: <code>np.complex128</code>: Complex number type composed of 2 64-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25767">view source</a></div></div><div class="public anchor" id="var-char"><h3>char</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>This module contains a set of functions for vectorized string operations and methods.</p>
-<p>.. note::  The <code>chararray</code> class exists for backwards compatibility with  Numarray, it is not recommended for new development. Starting from numpy  1.4, if one needs arrays of strings, it is recommended to use arrays of  <code>dtype</code> <code>object_</code>, <code>string_</code> or <code>unicode_</code>, and use the free functions  in the <code>numpy.char</code> module for fast vectorized string operations.</p>
-<p>Some methods will only be available if the corresponding string method is available in your version of Python.</p>
-<p>The preferred alias for <code>defchararray</code> is <code>numpy.char</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16152">view source</a></div></div><div class="public anchor" id="var-character"><h3>character</h3><div class="usage"><code>(character self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all character string scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15907">view source</a></div></div><div class="public anchor" id="var-chararray"><h3>chararray</h3><div class="usage"><code>(chararray self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,  strides=None, order=None)</p>
-<p>Provides a convenient view on arrays of string and unicode values.</p>
-<p>.. note::  The <code>chararray</code> class exists for backwards compatibility with  Numarray, it is not recommended for new development. Starting from numpy  1.4, if one needs arrays of strings, it is recommended to use arrays of  <code>dtype</code> <code>object_</code>, <code>string_</code> or <code>unicode_</code>, and use the free functions  in the <code>numpy.char</code> module for fast vectorized string operations.</p>
-<p>Versus a regular NumPy array of type <code>str</code> or <code>unicode</code>, this class adds the following functionality:</p>
-<p>1) values automatically have whitespace removed from the end  when indexed</p>
-<p>2) comparison operators automatically remove whitespace from the  end when comparing values</p>
-<p>3) vectorized string operations are provided as methods  (e.g. <code>.endswith</code>) and infix operators (e.g. <code>"+", "*", "%"</code>)</p>
-<p>chararrays should be created using <code>numpy.char.array</code> or <code>numpy.char.asarray</code>, rather than this constructor directly.</p>
-<p>This constructor creates the array, using <code>buffer</code> (with <code>offset</code> and <code>strides</code>) if it is not <code>None</code>. If <code>buffer</code> is <code>None</code>, then constructs a new array with <code>strides</code> in “C order”, unless both <code>len(shape) &gt;= 2</code> and <code>order='F'</code>, in which case <code>strides</code> is in “Fortran order”.</p>
-<h2><a href="#methods" name="methods"></a>Methods</h2>
-<p>astype argsort copy count decode dump dumps encode endswith expandtabs fill find flatten getfield index isalnum isalpha isdecimal isdigit islower isnumeric isspace istitle isupper item join ljust lower lstrip nonzero put ravel repeat replace reshape resize rfind rindex rjust rsplit rstrip searchsorted setfield setflags sort split splitlines squeeze startswith strip swapaxes swapcase take title tofile tolist tostring translate transpose upper view zfill</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>shape : tuple  Shape of the array. itemsize : int, optional  Length of each array element, in number of characters. Default is 1. unicode : bool, optional  Are the array elements of type unicode (True) or string (False).  Default is False. buffer : int, optional  Memory address of the start of the array data. Default is None,  in which case a new array is created. offset : int, optional  Fixed stride displacement from the beginning of an axis?  Default is 0. Needs to be &gt;=0. strides : array_like of ints, optional  Strides for the array (see <code>ndarray.strides</code> for full description).  Default is None. order : {‘C’, ‘F’}, optional  The order in which the array data is stored in memory: ‘C’ -&gt;  “row major” order (the default), ‘F’ -&gt; “column major”  (Fortran) order.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>charar = np.chararray((3, 3)) charar[:] = ‘a’ charar chararray(<a href="null">b'a', b'a', b'a'],
-           [b'a', b'a', b'a'],
-           [b'a', b'a', b'a'</a>, dtype=‘|S1’)</p>
-      <p>charar = np.chararray(charar.shape, itemsize=5) charar[:] = ‘abc’ charar chararray(<a href="null">b'abc', b'abc', b'abc'],
-           [b'abc', b'abc', b'abc'],
-           [b'abc', b'abc', b'abc'</a>, dtype=‘|S5’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11271">view source</a></div></div><div class="public anchor" id="var-choose"><h3>choose</h3><div class="usage"><code>(choose &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Construct an array from an index array and a set of arrays to choose from.</p>
-<p>First of all, if confused or uncertain, definitely look at the Examples - in its full generality, this function is less simple than it might seem from the following code description (below ndi = <code>numpy.lib.index_tricks</code>):</p>
-<p><code>np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])</code>.</p>
-<p>But this omits some subtleties. Here is a fully general summary:</p>
-<p>Given an “index” array (<code>a</code>) of integers and a sequence of <code>n</code> arrays (<code>choices</code>), <code>a</code> and each choice array are first broadcast, as necessary, to arrays of a common shape; calling these <em>Ba</em> and <em>Bchoices[i], i = 0,…,n-1</em> we have that, necessarily, <code>Ba.shape == Bchoices[i].shape</code> for each <code>i</code>. Then, a new array with shape <code>Ba.shape</code> is created as follows:</p>
-<ul>
-  <li>
-  <p>if <code>mode=raise</code> (the default), then, first of all, each element of  <code>a</code> (and thus <code>Ba</code>) must be in the range <code>[0, n-1]</code>; now, suppose that  <code>i</code> (in that range) is the value at the <code>(j0, j1, ..., jm)</code> position  in <code>Ba</code> - then the value at the same position in the new array is the  value in <code>Bchoices[i]</code> at that same position;</p></li>
-  <li>
-  <p>if <code>mode=wrap</code>, values in <code>a</code> (and thus <code>Ba</code>) may be any (signed)  integer; modular arithmetic is used to map integers outside the range  <code>[0, n-1]</code> back into that range; and then the new array is constructed  as above;</p></li>
-  <li>
-  <p>if <code>mode=clip</code>, values in <code>a</code> (and thus <code>Ba</code>) may be any (signed)  integer; negative integers are mapped to 0; values greater than <code>n-1</code>  are mapped to <code>n-1</code>; and then the new array is constructed as above.</p></li>
-</ul>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : int array  This array must contain integers in <code>[0, n-1]</code>, where <code>n</code> is the number  of choices, unless <code>mode=wrap</code> or <code>mode=clip</code>, in which cases any  integers are permissible. choices : sequence of arrays  Choice arrays. <code>a</code> and all of the choices must be broadcastable to the  same shape. If <code>choices</code> is itself an array (not recommended), then  its outermost dimension (i.e., the one corresponding to  <code>choices.shape[0]</code>) is taken as defining the “sequence”. out : array, optional  If provided, the result will be inserted into this array. It should  be of the appropriate shape and dtype. Note that <code>out</code> is always  buffered if <code>mode='raise'</code>; use other modes for better performance. mode : {‘raise’ (default), ‘wrap’, ‘clip’}, optional  Specifies how indices outside <code>[0, n-1]</code> will be treated:</p>
-<pre><code>  * 'raise' : an exception is raised
-  * 'wrap' : value becomes value mod `n`
-  * 'clip' : values &lt; 0 are mapped to 0, values &gt; n-1 are mapped to n-1
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>merged_array : array  The merged result.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError: shape mismatch  If <code>a</code> and each choice array are not all broadcastable to the same  shape.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.choose : equivalent method numpy.take_along_axis : Preferable if <code>choices</code> is an array</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>To reduce the chance of misinterpretation, even though the following “abuse” is nominally supported, <code>choices</code> should neither be, nor be thought of as, a single array, i.e., the outermost sequence-like container should be either a list or a tuple.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>choices = <a href="null">0, 1, 2, 3], [10, 11, 12, 13],
-...   [20, 21, 22, 23], [30, 31, 32, 33</a> np.choose([2, 3, 1, 0], choices … # the first element of the result will be the first element of the … # third (2+1) “array” in choices, namely, 20; the second element … # will be the second element of the fourth (3+1) choice array, i.e., … # 31, etc. … ) array([20, 31, 12, 3]) np.choose([2, 4, 1, 0], choices, mode=‘clip’) # 4 goes to 3 (4-1) array([20, 31, 12, 3])</p>
-      <h1><a href="#because-there-are-4-choice-arrays" name="because-there-are-4-choice-arrays"></a>because there are 4 choice arrays</h1>
-      <p>np.choose([2, 4, 1, 0], choices, mode=‘wrap’) # 4 goes to (4 mod 4) array([20, 1, 12, 3])</p>
-      <h1><a href="#i-e-0" name="i-e-0"></a>i.e., 0</h1>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>A couple examples illustrating how choose broadcasts:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = <a href="null">1, 0, 1], [0, 1, 0], [1, 0, 1</a> choices = [-10, 10] np.choose(a, choices) array(<a href="null"> 10, -10,  10],
-       [-10,  10, -10],
-       [ 10, -10,  10</a>)</p>
-      <h1><a href="#with-thanks-to-anne-archibald" name="with-thanks-to-anne-archibald"></a>With thanks to Anne Archibald</h1>
-      <p>a = np.array([0, 1]).reshape((2,1,1)) c1 = np.array([1, 2, 3]).reshape((1,3,1)) c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5)) np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2 array(<a href="null">[ 1,  1,  1,  1,  1],
-        [ 2,  2,  2,  2,  2],
-        [ 3,  3,  3,  3,  3</a>,  <a href="null">-1, -2, -3, -4, -5],
-        [-1, -2, -3, -4, -5],
-        [-1, -2, -3, -4, -5</a>])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18539">view source</a></div></div><div class="public anchor" id="var-CLIP"><h3>CLIP</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24632">view source</a></div></div><div class="public anchor" id="var-clip"><h3>clip</h3><div class="usage"><code>(clip &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Clip (limit) the values in an array.</p>
-<p>Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of <code>[0, 1]</code> is specified, values smaller than 0 become 0, and values larger than 1 become 1.</p>
-<p>Equivalent to but faster than <code>np.maximum(a_min, np.minimum(a, a_max))</code>. No check is performed to ensure <code>a_min &lt; a_max</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array containing elements to clip. a_min : scalar or array_like or None  Minimum value. If None, clipping is not performed on lower  interval edge. Not more than one of <code>a_min</code> and <code>a_max</code> may be  None. a_max : scalar or array_like or None  Maximum value. If None, clipping is not performed on upper  interval edge. Not more than one of <code>a_min</code> and <code>a_max</code> may be  None. If <code>a_min</code> or <code>a_max</code> are array_like, then the three  arrays will be broadcasted to match their shapes. out : ndarray, optional  The results will be placed in this array. It may be the input  array for in-place clipping. <code>out</code> must be of the right shape  to hold the output. Its type is preserved. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>clipped_array : ndarray  An array with the elements of <code>a</code>, but where values  &lt; <code>a_min</code> are replaced with <code>a_min</code>, and those &gt; <code>a_max</code>  with <code>a_max</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ufuncs-output-type</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(10) np.clip(a, 1, 8) array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8]) a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) np.clip(a, 3, 6, out=a) array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6]) a = np.arange(10) a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8) array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6424">view source</a></div></div><div class="public anchor" id="var-clongdouble"><h3>clongdouble</h3><div class="usage"><code>(clongdouble self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two extended-precision floating-point numbers. Character code: <code>'G'</code>. Canonical name: <code>np.clongdouble</code>. Alias: <code>np.clongfloat</code>. Alias: <code>np.longcomplex</code>. Alias <em>on this platform</em>: <code>np.complex256</code>: Complex number type composed of 2 128-bit extended-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L970">view source</a></div></div><div class="public anchor" id="var-clongfloat"><h3>clongfloat</h3><div class="usage"><code>(clongfloat self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two extended-precision floating-point numbers. Character code: <code>'G'</code>. Canonical name: <code>np.clongdouble</code>. Alias: <code>np.clongfloat</code>. Alias: <code>np.longcomplex</code>. Alias <em>on this platform</em>: <code>np.complex256</code>: Complex number type composed of 2 128-bit extended-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10250">view source</a></div></div><div class="public anchor" id="var-column_stack"><h3>column_stack</h3><div class="usage"><code>(column_stack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Stack 1-D arrays as columns into a 2-D array.</p>
-<p>Take a sequence of 1-D arrays and stack them as columns to make a single 2-D array. 2-D arrays are stacked as-is, just like with <code>hstack</code>. 1-D arrays are turned into 2-D columns first.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>tup : sequence of 1-D or 2-D arrays.  Arrays to stack. All of them must have the same first dimension.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>stacked : 2-D array  The array formed by stacking the given arrays.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>stack, hstack, vstack, concatenate</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array((1,2,3)) b = np.array((2,3,4)) np.column_stack((a,b)) array(<a href="null">1, 2],
-       [2, 3],
-       [3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23064">view source</a></div></div><div class="public anchor" id="var-common_type"><h3>common_type</h3><div class="usage"><code>(common_type &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a scalar type which is common to the input arrays.</p>
-<p>The return type will always be an inexact (i.e. floating point) scalar type, even if all the arrays are integer arrays. If one of the inputs is an integer array, the minimum precision type that is returned is a 64-bit floating point dtype.</p>
-<p>All input arrays except int64 and uint64 can be safely cast to the returned dtype without loss of information.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>array1, array2, … : ndarrays  Input arrays.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : data type code  Data type code.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>dtype, mintypecode</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.common_type(np.arange(2, dtype=np.float32)) &lt;class ‘numpy.float32’&gt; np.common_type(np.arange(2, dtype=np.float32), np.arange(2)) &lt;class ‘numpy.float64’&gt; np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0])) &lt;class ‘numpy.complex128’&gt;</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L933">view source</a></div></div><div class="public anchor" id="var-compare_chararrays"><h3>compare_chararrays</h3><div class="usage"><code>(compare_chararrays self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>compare_chararrays(a, b, cmp_op, rstrip)</p>
-<p>Performs element-wise comparison of two string arrays using the comparison operator specified by <code>cmp_op</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a, b : array_like  Arrays to be compared. cmp_op : {“&lt;”, “&lt;=”, “==”, “&gt;=”, “&gt;”, “!=”}  Type of comparison. rstrip : Boolean  If True, the spaces at the end of Strings are removed before the comparison.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  The output array of type Boolean with the same shape as a and b.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If <code>cmp_op</code> is not valid. TypeError  If at least one of <code>a</code> or <code>b</code> is a non-string array</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([“a”, “b”, “cde”]) b = np.array([“a”, “a”, “dec”]) np.compare_chararrays(a, b, “&gt;”, True) array([False, True, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21900">view source</a></div></div><div class="public anchor" id="var-compat"><h3>compat</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Compatibility module.</p>
-<p>This module contains duplicated code from Python itself or 3rd party extensions, which may be included for the following reasons:</p>
-<ul>
-  <li>compatibility</li>
-  <li>we may only need a small subset of the copied library/module</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9212">view source</a></div></div><div class="public anchor" id="var-complex"><h3>complex</h3><div class="usage"><code>(complex self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create a complex number from a real part and an optional imaginary part.</p>
-<p>This is equivalent to (real + imag*1j) where imag defaults to 0.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25685">view source</a></div></div><div class="public anchor" id="var-complex128"><h3>complex128</h3><div class="usage"><code>(complex128 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two double-precision floating-point numbers, compatible with Python <code>complex</code>. Character code: <code>'D'</code>. Canonical name: <code>np.cdouble</code>. Alias: <code>np.cfloat</code>. Alias: <code>np.complex_</code>. Alias <em>on this platform</em>: <code>np.complex128</code>: Complex number type composed of 2 64-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13027">view source</a></div></div><div class="public anchor" id="var-complex256"><h3>complex256</h3><div class="usage"><code>(complex256 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two extended-precision floating-point numbers. Character code: <code>'G'</code>. Canonical name: <code>np.clongdouble</code>. Alias: <code>np.clongfloat</code>. Alias: <code>np.longcomplex</code>. Alias <em>on this platform</em>: <code>np.complex256</code>: Complex number type composed of 2 128-bit extended-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26980">view source</a></div></div><div class="public anchor" id="var-complex64"><h3>complex64</h3><div class="usage"><code>(complex64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two single-precision floating-point numbers. Character code: <code>'F'</code>. Canonical name: <code>np.csingle</code>. Alias: <code>np.singlecomplex</code>. Alias <em>on this platform</em>: <code>np.complex64</code>: Complex number type composed of 2 32-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26737">view source</a></div></div><div class="public anchor" id="var-complex_"><h3>complex_</h3><div class="usage"><code>(complex_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two double-precision floating-point numbers, compatible with Python <code>complex</code>. Character code: <code>'D'</code>. Canonical name: <code>np.cdouble</code>. Alias: <code>np.cfloat</code>. Alias: <code>np.complex_</code>. Alias <em>on this platform</em>: <code>np.complex128</code>: Complex number type composed of 2 64-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4964">view source</a></div></div><div class="public anchor" id="var-complexfloating"><h3>complexfloating</h3><div class="usage"><code>(complexfloating self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all complex number scalar types that are made up of floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20502">view source</a></div></div><div class="public anchor" id="var-ComplexWarning"><h3>ComplexWarning</h3><div class="usage"><code>(ComplexWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>The warning raised when casting a complex dtype to a real dtype.</p>
-<p>As implemented, casting a complex number to a real discards its imaginary part, but this behavior may not be what the user actually wants.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18140">view source</a></div></div><div class="public anchor" id="var-compress"><h3>compress</h3><div class="usage"><code>(compress &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return selected slices of an array along given axis.</p>
-<p>When working along a given axis, a slice along that axis is returned in <code>output</code> for each index where <code>condition</code> evaluates to True. When working on a 1-D array, <code>compress</code> is equivalent to <code>extract</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>condition : 1-D array of bools  Array that selects which entries to return. If len(condition)  is less than the size of <code>a</code> along the given axis, then output is  truncated to the length of the condition array. a : array_like  Array from which to extract a part. axis : int, optional  Axis along which to take slices. If None (default), work on the  flattened array. out : ndarray, optional  Output array. Its type is preserved and it must be of the right  shape to hold the output.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>compressed_array : ndarray  A copy of <code>a</code> without the slices along axis for which <code>condition</code>  is false.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>take, choose, diag, diagonal, select ndarray.compress : Equivalent method in ndarray np.extract: Equivalent method when working on 1-D arrays ufuncs-output-type</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 2], [3, 4], [5, 6</a>) a array(<a href="null">1, 2],
-       [3, 4],
-       [5, 6</a>) np.compress([0, 1], a, axis=0) array(<a href="null">3, 4</a>) np.compress([False, True, True], a, axis=0) array(<a href="null">3, 4],
-       [5, 6</a>) np.compress([False, True], a, axis=1) array(<a href="null">2],
-       [4],
-       [6</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Working on the flattened array does not return slices along an axis but selects elements.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.compress([False, True], a) array([2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L438">view source</a></div></div><div class="public anchor" id="var-concatenate"><h3>concatenate</h3><div class="usage"><code>(concatenate &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>concatenate((a1, a2, …), axis=0, out=None)</p>
-<p>Join a sequence of arrays along an existing axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a1, a2, … : sequence of array_like  The arrays must have the same shape, except in the dimension  corresponding to <code>axis</code> (the first, by default). axis : int, optional  The axis along which the arrays will be joined. If axis is None,  arrays are flattened before use. Default is 0. out : ndarray, optional  If provided, the destination to place the result. The shape must be  correct, matching that of what concatenate would have returned if no  out argument were specified.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>res : ndarray  The concatenated array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ma.concatenate : Concatenate function that preserves input masks. array_split : Split an array into multiple sub-arrays of equal or  near-equal size. split : Split array into a list of multiple sub-arrays of equal size. hsplit : Split array into multiple sub-arrays horizontally (column wise) vsplit : Split array into multiple sub-arrays vertically (row wise) dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). stack : Stack a sequence of arrays along a new axis. hstack : Stack arrays in sequence horizontally (column wise) vstack : Stack arrays in sequence vertically (row wise) dstack : Stack arrays in sequence depth wise (along third dimension) block : Assemble arrays from blocks.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>When one or more of the arrays to be concatenated is a MaskedArray, this function will return a MaskedArray object instead of an ndarray, but the input masks are <em>not</em> preserved. In cases where a MaskedArray is expected as input, use the ma.concatenate function from the masked array module instead.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 2], [3, 4</a>) b = np.array(<a href="null">5, 6</a>) np.concatenate((a, b), axis=0) array(<a href="null">1, 2],
-       [3, 4],
-       [5, 6</a>) np.concatenate((a, b.T), axis=1) array(<a href="null">1, 2, 5],
-       [3, 4, 6</a>) np.concatenate((a, b), axis=None) array([1, 2, 3, 4, 5, 6])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>This function will not preserve masking of MaskedArray inputs.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.ma.arange(3) a[1] = np.ma.masked b = np.arange(2, 5) a masked_array(data=[0, –, 2],  mask=[False, True, False],  fill_value=999999) b array([2, 3, 4]) np.concatenate([a, b]) masked_array(data=[0, 1, 2, 2, 3, 4],  mask=False,  fill_value=999999) np.ma.concatenate([a, b]) masked_array(data=[0, –, 2, 2, 3, 4],  mask=[False, True, False, False, False, False],  fill_value=999999)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28243">view source</a></div></div><div class="public anchor" id="var-conj"><h3>conj</h3><div class="usage"><code>(conj self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>conjugate(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the complex conjugate, element-wise.</p>
-<p>The complex conjugate of a complex number is obtained by changing the sign of its imaginary part.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input value. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The complex conjugate of <code>x</code>, with same dtype as <code>y</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>conj</code> is an alias for <code>conjugate</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.conj is np.conjugate True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.conjugate(1+2j) (1-2j)</p>
-      <p>x = np.eye(2) + 1j * np.eye(2) np.conjugate(x) array(<a href="null"> 1.-1.j,  0.-0.j],
-       [ 0.-0.j,  1.-1.j</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20819">view source</a></div></div><div class="public anchor" id="var-conjugate"><h3>conjugate</h3><div class="usage"><code>(conjugate self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>conjugate(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the complex conjugate, element-wise.</p>
-<p>The complex conjugate of a complex number is obtained by changing the sign of its imaginary part.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input value. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The complex conjugate of <code>x</code>, with same dtype as <code>y</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>conj</code> is an alias for <code>conjugate</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.conj is np.conjugate True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.conjugate(1+2j) (1-2j)</p>
-      <p>x = np.eye(2) + 1j * np.eye(2) np.conjugate(x) array(<a href="null"> 1.-1.j,  0.-0.j],
-       [ 0.-0.j,  1.-1.j</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11885">view source</a></div></div><div class="public anchor" id="var-convolve"><h3>convolve</h3><div class="usage"><code>(convolve &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the discrete, linear convolution of two one-dimensional sequences.</p>
-<p>The convolution operator is often seen in signal processing, where it models the effect of a linear time-invariant system on a signal [1]_. In probability theory, the sum of two independent random variables is distributed according to the convolution of their individual distributions.</p>
-<p>If <code>v</code> is longer than <code>a</code>, the arrays are swapped before computation.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : (N,) array_like  First one-dimensional input array. v : (M,) array_like  Second one-dimensional input array. mode : {‘full’, ‘valid’, ‘same’}, optional  ‘full’:  By default, mode is ‘full’. This returns the convolution  at each point of overlap, with an output shape of (N+M-1,). At  the end-points of the convolution, the signals do not overlap  completely, and boundary effects may be seen.</p>
-<pre><code>'same':
-  Mode 'same' returns output of length ``max(M, N)``.  Boundary
-  effects are still visible.
-
-'valid':
-  Mode 'valid' returns output of length
-  ``max(M, N) - min(M, N) + 1``.  The convolution product is only given
-  for points where the signals overlap completely.  Values outside
-  the signal boundary have no effect.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Discrete, linear convolution of <code>a</code> and <code>v</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier  Transform. scipy.linalg.toeplitz : Used to construct the convolution operator. polymul : Polynomial multiplication. Same output as convolve, but also  accepts poly1d objects as input.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The discrete convolution operation is defined as</p>
-<p>.. math:: (a * v)[n] = \sum_{m = -\infty}^{\infty} a[m] v[n - m]</p>
-<p>It can be shown that a convolution :math:<code>x(t) * y(t)</code> in time/space is equivalent to the multiplication :math:<code>X(f) Y(f)</code> in the Fourier domain, after appropriate padding (padding is necessary to prevent circular convolution). Since multiplication is more efficient (faster) than convolution, the function <code>scipy.signal.fftconvolve</code> exploits the FFT to calculate the convolution of large data-sets.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Wikipedia, “Convolution”,  <a href="https://en.wikipedia.org/wiki/Convolution">https://en.wikipedia.org/wiki/Convolution</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Note how the convolution operator flips the second array before “sliding” the two across one another:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.convolve([1, 2, 3], [0, 1, 0.5]) array([0. , 1. , 2.5, 4. , 1.5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Only return the middle values of the convolution. Contains boundary effects, where zeros are taken into account:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.convolve([1,2,3],[0,1,0.5], ‘same’) array([1. , 2.5, 4. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The two arrays are of the same length, so there is only one position where they completely overlap:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.convolve([1,2,3],[0,1,0.5], ‘valid’) array([2.5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22686">view source</a></div></div><div class="public anchor" id="var-copy"><h3>copy</h3><div class="usage"><code>(copy &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an array copy of the given object.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. order : {‘C’, ‘F’, ‘A’, ‘K’}, optional  Controls the memory layout of the copy. ‘C’ means C-order,  ‘F’ means F-order, ‘A’ means ‘F’ if <code>a</code> is Fortran contiguous,  ‘C’ otherwise. ‘K’ means match the layout of <code>a</code> as closely  as possible. (Note that this function and :meth:<code>ndarray.copy</code> are very  similar, but have different default values for their order=  arguments.)</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>arr : ndarray  Array interpretation of <code>a</code>.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This is equivalent to:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.array(a, copy=True) #doctest: +SKIP</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Create an array x, with a reference y and a copy z:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([1, 2, 3]) y = x z = np.copy(x)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that, when we modify x, y changes, but not z:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x[0] = 10 x[0] == y[0] True x[0] == z[0] False</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4853">view source</a></div></div><div class="public anchor" id="var-copysign"><h3>copysign</h3><div class="usage"><code>(copysign self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>copysign(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Change the sign of x1 to that of x2, element-wise.</p>
-<p>If <code>x2</code> is a scalar, its sign will be copied to all elements of <code>x1</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  Values to change the sign of. x2 : array_like  The sign of <code>x2</code> is copied to <code>x1</code>. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  The values of <code>x1</code> with the sign of <code>x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.copysign(1.3, -1) -1.3 1/np.copysign(0, 1) inf 1/np.copysign(0, -1) -inf</p>
-      <p>np.copysign([-1, 0, 1], -1.1) array([-1., -0., -1.]) np.copysign([-1, 0, 1], np.arange(3)-1) array([-1., 0., 1.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5653">view source</a></div></div><div class="public anchor" id="var-copyto"><h3>copyto</h3><div class="usage"><code>(copyto &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>copyto(dst, src, casting=‘same_kind’, where=True)</p>
-<p>Copies values from one array to another, broadcasting as necessary.</p>
-<p>Raises a TypeError if the <code>casting</code> rule is violated, and if <code>where</code> is provided, it selects which elements to copy.</p>
-<p>.. versionadded:: 1.7.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>dst : ndarray  The array into which values are copied. src : array_like  The array from which values are copied. casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional  Controls what kind of data casting may occur when copying.</p>
-<pre><code>  * 'no' means the data types should not be cast at all.
-  * 'equiv' means only byte-order changes are allowed.
-  * 'safe' means only casts which can preserve values are allowed.
-  * 'same_kind' means only safe casts or casts within a kind,
-    like float64 to float32, are allowed.
-  * 'unsafe' means any data conversions may be done.
-</code></pre>
-<p>where : array_like of bool, optional  A boolean array which is broadcasted to match the dimensions  of <code>dst</code>, and selects elements to copy from <code>src</code> to <code>dst</code>  wherever it contains the value True.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28722">view source</a></div></div><div class="public anchor" id="var-core"><h3>core</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Contains the core of NumPy: ndarray, ufuncs, dtypes, etc.</p>
-<p>Please note that this module is private. All functions and objects are available in the main <code>numpy</code> namespace - use that instead.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26729">view source</a></div></div><div class="public anchor" id="var-corrcoef"><h3>corrcoef</h3><div class="usage"><code>(corrcoef &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return Pearson product-moment correlation coefficients.</p>
-<p>Please refer to the documentation for <code>cov</code> for more detail. The relationship between the correlation coefficient matrix, <code>R</code>, and the covariance matrix, <code>C</code>, is</p>
-<p>.. math:: R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} * C_{jj} } }</p>
-<p>The values of <code>R</code> are between -1 and 1, inclusive.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  A 1-D or 2-D array containing multiple variables and observations.  Each row of <code>x</code> represents a variable, and each column a single  observation of all those variables. Also see <code>rowvar</code> below. y : array_like, optional  An additional set of variables and observations. <code>y</code> has the same  shape as <code>x</code>. rowvar : bool, optional  If <code>rowvar</code> is True (default), then each row represents a  variable, with observations in the columns. Otherwise, the relationship  is transposed: each column represents a variable, while the rows  contain observations. bias : _NoValue, optional  Has no effect, do not use.</p>
-<pre><code>.. deprecated:: 1.10.0
-</code></pre>
-<p>ddof : _NoValue, optional  Has no effect, do not use.</p>
-<pre><code>.. deprecated:: 1.10.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>R : ndarray  The correlation coefficient matrix of the variables.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>cov : Covariance matrix</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Due to floating point rounding the resulting array may not be Hermitian, the diagonal elements may not be 1, and the elements may not satisfy the inequality abs(a) &lt;= 1. The real and imaginary parts are clipped to the interval [-1, 1] in an attempt to improve on that situation but is not much help in the complex case.</p>
-<p>This function accepts but discards arguments <code>bias</code> and <code>ddof</code>. This is for backwards compatibility with previous versions of this function. These arguments had no effect on the return values of the function and can be safely ignored in this and previous versions of numpy.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6106">view source</a></div></div><div class="public anchor" id="var-correlate"><h3>correlate</h3><div class="usage"><code>(correlate &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Cross-correlation of two 1-dimensional sequences.</p>
-<p>This function computes the correlation as generally defined in signal processing texts::</p>
-<pre><code>c_{av}[k] = sum_n a[n+k] * conj(v[n])
-</code></pre>
-<p>with a and v sequences being zero-padded where necessary and conj being the conjugate.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a, v : array_like  Input sequences. mode : {‘valid’, ‘same’, ‘full’}, optional  Refer to the <code>convolve</code> docstring. Note that the default  is ‘valid’, unlike <code>convolve</code>, which uses ‘full’. old_behavior : bool  <code>old_behavior</code> was removed in NumPy 1.10. If you need the old  behavior, use <code>multiarray.correlate</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Discrete cross-correlation of <code>a</code> and <code>v</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>convolve : Discrete, linear convolution of two one-dimensional sequences. multiarray.correlate : Old, no conjugate, version of correlate.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The definition of correlation above is not unique and sometimes correlation may be defined differently. Another common definition is::</p>
-<pre><code>c'_{av}[k] = sum_n a[n] conj(v[n+k])
-</code></pre>
-<p>which is related to <code>c_{av}[k]</code> by <code>c'_{av}[k] = c_{av}[-k]</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.correlate([1, 2, 3], [0, 1, 0.5]) array([3.5]) np.correlate([1, 2, 3], [0, 1, 0.5], “same”) array([2. , 3.5, 3. ]) np.correlate([1, 2, 3], [0, 1, 0.5], “full”) array([0.5, 2. , 3.5, 3. , 0. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using complex sequences:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], ‘full’) array([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that you get the time reversed, complex conjugated result when the two input sequences change places, i.e., <code>c_{va}[k] = c^{*}_{av}[-k]</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], ‘full’) array([ 0.0+0.j , 3.0+1.j , 1.5+1.5j, 1.0+0.j , 0.5+0.5j])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17805">view source</a></div></div><div class="public anchor" id="var-cos"><h3>cos</h3><div class="usage"><code>(cos self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>cos(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Cosine element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array in radians. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The corresponding cosine values.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If <code>out</code> is provided, the function writes the result into it, and returns a reference to <code>out</code>. (See Examples)</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. New York, NY: Dover, 1972.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.cos(np.array([0, np.pi/2, np.pi])) array([ 1.00000000e+00, 6.12303177e-17, -1.00000000e+00])</p>
-      <h1><a href="#example-of-providing-the-optional-output-parameter" name="example-of-providing-the-optional-output-parameter"></a>Example of providing the optional output parameter</h1>
-      <p>out1 = np.array([0], dtype=‘d’) out2 = np.cos([0.1], out1) out2 is out1 True</p>
-      <h1><a href="#example-of-valueerror-due-to-provision-of-shape-mis-matched" name="example-of-valueerror-due-to-provision-of-shape-mis-matched"></a>Example of ValueError due to provision of shape mis-matched <code>out</code></h1>
-      <p>np.cos(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> ValueError: operands could not be broadcast together with shapes (3,3) (2,2)</module></stdin></p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19177">view source</a></div></div><div class="public anchor" id="var-cosh"><h3>cosh</h3><div class="usage"><code>(cosh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>cosh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Hyperbolic cosine, element-wise.</p>
-<p>Equivalent to <code>1/2 * (np.exp(x) + np.exp(-x))</code> and <code>np.cos(1j*x)</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Output array of same shape as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.cosh(0) 1.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The hyperbolic cosine describes the shape of a hanging cable:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt x = np.linspace(-4, 4, 1000) plt.plot(x, np.cosh(x)) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1488">view source</a></div></div><div class="public anchor" id="var-count_nonzero"><h3>count_nonzero</h3><div class="usage"><code>(count_nonzero &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Counts the number of non-zero values in the array <code>a</code>.</p>
-<p>The word “non-zero” is in reference to the Python 2.x built-in method <code>__nonzero__()</code> (renamed <code>__bool__()</code> in Python 3.x) of Python objects that tests an object’s “truthfulness”. For example, any number is considered truthful if it is nonzero, whereas any string is considered truthful if it is not the empty string. Thus, this function (recursively) counts how many elements in <code>a</code> (and in sub-arrays thereof) have their <code>__nonzero__()</code> or <code>__bool__()</code> method evaluated to <code>True</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  The array for which to count non-zeros. axis : int or tuple, optional  Axis or tuple of axes along which to count non-zeros.  Default is None, meaning that non-zeros will be counted  along a flattened version of <code>a</code>.</p>
-<pre><code>.. versionadded:: 1.12.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>count : int or array of int  Number of non-zero values in the array along a given axis.  Otherwise, the total number of non-zero values in the array  is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>nonzero : Return the coordinates of all the non-zero values.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.count_nonzero(np.eye(4)) 4 np.count_nonzero(<a href="null">0,1,7,0,0],[3,0,0,2,19</a>) 5 np.count_nonzero(<a href="null">0,1,7,0,0],[3,0,0,2,19</a>, axis=0) array([1, 1, 1, 1, 1]) np.count_nonzero(<a href="null">0,1,7,0,0],[3,0,0,2,19</a>, axis=1) array([2, 3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12537">view source</a></div></div><div class="public anchor" id="var-cov"><h3>cov</h3><div class="usage"><code>(cov &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Estimate a covariance matrix, given data and weights.</p>
-<p>Covariance indicates the level to which two variables vary together. If we examine N-dimensional samples, :math:<code>X = [x_1, x_2, ... x_N]^T</code>, then the covariance matrix element :math:<code>C_{ij}</code> is the covariance of :math:<code>x_i</code> and :math:<code>x_j</code>. The element :math:<code>C_{ii}</code> is the variance of :math:<code>x_i</code>.</p>
-<p>See the notes for an outline of the algorithm.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>m : array_like  A 1-D or 2-D array containing multiple variables and observations.  Each row of <code>m</code> represents a variable, and each column a single  observation of all those variables. Also see <code>rowvar</code> below. y : array_like, optional  An additional set of variables and observations. <code>y</code> has the same form  as that of <code>m</code>. rowvar : bool, optional  If <code>rowvar</code> is True (default), then each row represents a  variable, with observations in the columns. Otherwise, the relationship  is transposed: each column represents a variable, while the rows  contain observations. bias : bool, optional  Default normalization (False) is by <code>(N - 1)</code>, where <code>N</code> is the  number of observations given (unbiased estimate). If <code>bias</code> is True,  then normalization is by <code>N</code>. These values can be overridden by using  the keyword <code>ddof</code> in numpy versions &gt;= 1.5. ddof : int, optional  If not <code>None</code> the default value implied by <code>bias</code> is overridden.  Note that <code>ddof=1</code> will return the unbiased estimate, even if both  <code>fweights</code> and <code>aweights</code> are specified, and <code>ddof=0</code> will return  the simple average. See the notes for the details. The default value  is <code>None</code>.</p>
-<pre><code>.. versionadded:: 1.5
-</code></pre>
-<p>fweights : array_like, int, optional  1-D array of integer frequency weights; the number of times each  observation vector should be repeated.</p>
-<pre><code>.. versionadded:: 1.10
-</code></pre>
-<p>aweights : array_like, optional  1-D array of observation vector weights. These relative weights are  typically large for observations considered “important” and smaller for  observations considered less “important”. If <code>ddof=0</code> the array of  weights can be used to assign probabilities to observation vectors.</p>
-<pre><code>.. versionadded:: 1.10
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  The covariance matrix of the variables.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>corrcoef : Normalized covariance matrix</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Assume that the observations are in the columns of the observation array <code>m</code> and let <code>f = fweights</code> and <code>a = aweights</code> for brevity. The steps to compute the weighted covariance are as follows::</p>
-<pre><code>&gt;&gt;&gt; m = np.arange(10, dtype=np.float64)
-&gt;&gt;&gt; f = np.arange(10) * 2
-&gt;&gt;&gt; a = np.arange(10) ** 2.
-&gt;&gt;&gt; ddof = 1
-&gt;&gt;&gt; w = f * a
-&gt;&gt;&gt; v1 = np.sum(w)
-&gt;&gt;&gt; v2 = np.sum(w * a)
-&gt;&gt;&gt; m -= np.sum(m * w, axis=None, keepdims=True) / v1
-&gt;&gt;&gt; cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)
-</code></pre>
-<p>Note that when <code>a == 1</code>, the normalization factor <code>v1 / (v1**2 - ddof * v2)</code> goes over to <code>1 / (np.sum(f) - ddof)</code> as it should.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Consider two variables, :math:<code>x_0</code> and :math:<code>x_1</code>, which correlate perfectly, but in opposite directions:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">0, 2], [1, 1], [2, 0</a>).T x array(<a href="null">0, 1, 2],
-       [2, 1, 0</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note how :math:<code>x_0</code> increases while :math:<code>x_1</code> decreases. The covariance matrix shows this clearly:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.cov(x) array(<a href="null"> 1., -1.],
-       [-1.,  1.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that element :math:<code>C_{0,1}</code>, which shows the correlation between :math:<code>x_0</code> and :math:<code>x_1</code>, is negative.</p>
-<p>Further, note how <code>x</code> and <code>y</code> are combined:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = [-2.1, -1, 4.3] y = [3, 1.1, 0.12] X = np.stack((x, y), axis=0) np.cov(X) array(<a href="null">11.71      , -4.286     ], # may vary
-       [-4.286     ,  2.144133</a>) np.cov(x, y) array(<a href="null">11.71      , -4.286     ], # may vary
-       [-4.286     ,  2.144133</a>) np.cov(x) array(11.71)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23098">view source</a></div></div><div class="public anchor" id="var-cross"><h3>cross</h3><div class="usage"><code>(cross &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cross product of two (arrays of) vectors.</p>
-<p>The cross product of <code>a</code> and <code>b</code> in :math:<code>R^3</code> is a vector perpendicular to both <code>a</code> and <code>b</code>. If <code>a</code> and <code>b</code> are arrays of vectors, the vectors are defined by the last axis of <code>a</code> and <code>b</code> by default, and these axes can have dimensions 2 or 3. Where the dimension of either <code>a</code> or <code>b</code> is 2, the third component of the input vector is assumed to be zero and the cross product calculated accordingly. In cases where both input vectors have dimension 2, the z-component of the cross product is returned.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Components of the first vector(s). b : array_like  Components of the second vector(s). axisa : int, optional  Axis of <code>a</code> that defines the vector(s). By default, the last axis. axisb : int, optional  Axis of <code>b</code> that defines the vector(s). By default, the last axis. axisc : int, optional  Axis of <code>c</code> containing the cross product vector(s). Ignored if  both input vectors have dimension 2, as the return is scalar.  By default, the last axis. axis : int, optional  If defined, the axis of <code>a</code>, <code>b</code> and <code>c</code> that defines the vector(s)  and cross product(s). Overrides <code>axisa</code>, <code>axisb</code> and <code>axisc</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>c : ndarray  Vector cross product(s).</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  When the dimension of the vector(s) in <code>a</code> and/or <code>b</code> does not  equal 2 or 3.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>inner : Inner product outer : Outer product. ix_ : Construct index arrays.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.9.0</p>
-<p>Supports full broadcasting of the inputs.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Vector cross-product.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = [1, 2, 3] y = [4, 5, 6] np.cross(x, y) array([-3, 6, -3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>One vector with dimension 2.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = [1, 2] y = [4, 5, 6] np.cross(x, y) array([12, -6, -3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Equivalently:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = [1, 2, 0] y = [4, 5, 6] np.cross(x, y) array([12, -6, -3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Both vectors with dimension 2.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = [1,2] y = [4,5] np.cross(x, y) array(-3)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Multiple vector cross-products. Note that the direction of the cross product vector is defined by the <code>right-hand rule</code>.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">1,2,3], [4,5,6</a>) y = np.array(<a href="null">4,5,6], [1,2,3</a>) np.cross(x, y) array(<a href="null">-3,  6, -3],
-       [ 3, -6,  3</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The orientation of <code>c</code> can be changed using the <code>axisc</code> keyword.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.cross(x, y, axisc=0) array(<a href="null">-3,  3],
-       [ 6, -6],
-       [-3,  3</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Change the vector definition of <code>x</code> and <code>y</code> using <code>axisa</code> and <code>axisb</code>.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">1,2,3], [4,5,6], [7, 8, 9</a>) y = np.array(<a href="null">7, 8, 9], [4,5,6], [1,2,3</a>) np.cross(x, y) array(<a href="null"> -6,  12,  -6],
-       [  0,   0,   0],
-       [  6, -12,   6</a>) np.cross(x, y, axisa=0, axisb=0) array(<a href="null">-24,  48, -24],
-       [-30,  60, -30],
-       [-36,  72, -36</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8093">view source</a></div></div><div class="public anchor" id="var-csingle"><h3>csingle</h3><div class="usage"><code>(csingle self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two single-precision floating-point numbers. Character code: <code>'F'</code>. Canonical name: <code>np.csingle</code>. Alias: <code>np.singlecomplex</code>. Alias <em>on this platform</em>: <code>np.complex64</code>: Complex number type composed of 2 32-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6189">view source</a></div></div><div class="public anchor" id="var-ctypeslib"><h3>ctypeslib</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>============================</p>
-<h1><a href="#utility-functions" name="utility-functions"></a><code>ctypes</code> Utility Functions</h1>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>load_library : Load a C library. ndpointer : Array restype/argtype with verification. as_ctypes : Create a ctypes array from an ndarray. as_array : Create an ndarray from a ctypes array.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] “SciPy Cookbook: ctypes”, <a href="https://scipy-cookbook.readthedocs.io/items/Ctypes.html">https://scipy-cookbook.readthedocs.io/items/Ctypes.html</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Load the C library:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>_lib = np.ctypeslib.load_library(‘libmystuff’, ‘.’) #doctest: +SKIP</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Our result type, an ndarray that must be of type double, be 1-dimensional and is C-contiguous in memory:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>array_1d_double = np.ctypeslib.ndpointer( … dtype=np.double, … ndim=1, flags=‘CONTIGUOUS’) #doctest: +SKIP</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Our C-function typically takes an array and updates its values in-place. For example::</p>
-<pre><code>void foo_func(double* x, int length)
-{
-    int i;
-    for (i = 0; i &lt; length; i++) {
-        x[i] = i*i;
-    }
-}
-</code></pre>
-<p>We wrap it using:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>_lib.foo_func.restype = None #doctest: +SKIP _lib.foo_func.argtypes = [array_1d_double, c_int] #doctest: +SKIP</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Then, we’re ready to call <code>foo_func</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>out = np.empty(15, dtype=np.double) _lib.foo_func(out, len(out)) #doctest: +SKIP</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2284">view source</a></div></div><div class="public anchor" id="var-cumprod"><h3>cumprod</h3><div class="usage"><code>(cumprod &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cumulative product of elements along a given axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. axis : int, optional  Axis along which the cumulative product is computed. By default  the input is flattened. dtype : dtype, optional  Type of the returned array, as well as of the accumulator in which  the elements are multiplied. If <em>dtype</em> is not specified, it  defaults to the dtype of <code>a</code>, unless <code>a</code> has an integer dtype with  a precision less than that of the default platform integer. In  that case, the default platform integer is used instead. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output  but the type of the resulting values will be cast if necessary.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>cumprod : ndarray  A new array holding the result is returned unless <code>out</code> is  specified, in which case a reference to out is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ufuncs-output-type</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Arithmetic is modular when using integer types, and no error is raised on overflow.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1,2,3]) np.cumprod(a) # intermediate results 1, 1*2 … # total product 1*2*3 = 6 array([1, 2, 6]) a = np.array(<a href="null">1, 2, 3], [4, 5, 6</a>) np.cumprod(a, dtype=float) # specify type of output array([ 1., 2., 6., 24., 120., 720.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The cumulative product for each column (i.e., over the rows) of <code>a</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.cumprod(a, axis=0) array(<a href="null"> 1,  2,  3],
-       [ 4, 10, 18</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The cumulative product for each row (i.e. over the columns) of <code>a</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.cumprod(a,axis=1) array(<a href="null">  1,   2,   6],
-       [  4,  20, 120</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8261">view source</a></div></div><div class="public anchor" id="var-cumproduct"><h3>cumproduct</h3><div class="usage"><code>(cumproduct &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cumulative product over the given axis.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>cumprod : equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24062">view source</a></div></div><div class="public anchor" id="var-cumsum"><h3>cumsum</h3><div class="usage"><code>(cumsum &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cumulative sum of the elements along a given axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. axis : int, optional  Axis along which the cumulative sum is computed. The default  (None) is to compute the cumsum over the flattened array. dtype : dtype, optional  Type of the returned array and of the accumulator in which the  elements are summed. If <code>dtype</code> is not specified, it defaults  to the dtype of <code>a</code>, unless <code>a</code> has an integer dtype with a  precision less than that of the default platform integer. In  that case, the default platform integer is used. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output  but the type will be cast if necessary. See <code>ufuncs-output-type</code> for  more details.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>cumsum_along_axis : ndarray.  A new array holding the result is returned unless <code>out</code> is  specified, in which case a reference to <code>out</code> is returned. The  result has the same size as <code>a</code>, and the same shape as <code>a</code> if  <code>axis</code> is not None or <code>a</code> is a 1-d array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>sum : Sum array elements.</p>
-<p>trapz : Integration of array values using the composite trapezoidal rule.</p>
-<p>diff : Calculate the n-th discrete difference along given axis.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Arithmetic is modular when using integer types, and no error is raised on overflow.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1,2,3], [4,5,6</a>) a array(<a href="null">1, 2, 3],
-       [4, 5, 6</a>) np.cumsum(a) array([ 1, 3, 6, 10, 15, 21]) np.cumsum(a, dtype=float) # specifies type of output value(s) array([ 1., 3., 6., 10., 15., 21.])</p>
-      <p>np.cumsum(a,axis=0) # sum over rows for each of the 3 columns array(<a href="null">1, 2, 3],
-       [5, 7, 9</a>) np.cumsum(a,axis=1) # sum over columns for each of the 2 rows array(<a href="null"> 1,  3,  6],
-       [ 4,  9, 15</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25171">view source</a></div></div><div class="public anchor" id="var-DataSource"><h3>DataSource</h3><div class="usage"><code>(DataSource self &amp; [{destpath :destpath}])</code><code>(DataSource self)</code></div><div class="doc"><div class="markdown"><p>DataSource(destpath=‘.’)</p>
-<p>A generic data source file (file, http, ftp, …).</p>
-<p>DataSources can be local files or remote files/URLs. The files may also be compressed or uncompressed. DataSource hides some of the low-level details of downloading the file, allowing you to simply pass in a valid file path (or URL) and obtain a file object.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>destpath : str or None, optional  Path to the directory where the source file gets downloaded to for  use. If <code>destpath</code> is None, a temporary directory will be created.  The default path is the current directory.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>URLs require a scheme string (<code>http://</code>) to be used, without it they will fail::</p>
-<pre><code>&gt;&gt;&gt; repos = np.DataSource()
-&gt;&gt;&gt; repos.exists('www.google.com/index.html')
-False
-&gt;&gt;&gt; repos.exists('http://www.google.com/index.html')
-True
-</code></pre>
-<p>Temporary directories are deleted when the DataSource is deleted.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>::</p>
-<pre><code>&gt;&gt;&gt; ds = np.DataSource('/home/guido')
-&gt;&gt;&gt; urlname = 'http://www.google.com/'
-&gt;&gt;&gt; gfile = ds.open('http://www.google.com/')
-&gt;&gt;&gt; ds.abspath(urlname)
-'/home/guido/www.google.com/index.html'
-
-&gt;&gt;&gt; ds = np.DataSource(None)  # use with temporary file
-&gt;&gt;&gt; ds.open('/home/guido/foobar.txt')
-&lt;open file '/home/guido.foobar.txt', mode 'r' at 0x91d4430&gt;
-&gt;&gt;&gt; ds.abspath('/home/guido/foobar.txt')
-'/tmp/.../home/guido/foobar.txt'
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19364">view source</a></div></div><div class="public anchor" id="var-datetime64"><h3>datetime64</h3><div class="usage"><code>(datetime64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28719">view source</a></div></div><div class="public anchor" id="var-datetime_as_string"><h3>datetime_as_string</h3><div class="usage"><code>(datetime_as_string &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>datetime_as_string(arr, unit=None, timezone=‘naive’, casting=‘same_kind’)</p>
-<p>Convert an array of datetimes into an array of strings.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr : array_like of datetime64  The array of UTC timestamps to format. unit : str  One of None, ‘auto’, or a :ref:<code>datetime unit &lt;arrays.dtypes.dateunits&gt;</code>. timezone : {‘naive’, ‘UTC’, ‘local’} or tzinfo  Timezone information to use when displaying the datetime. If ‘UTC’, end  with a Z to indicate UTC time. If ‘local’, convert to the local timezone  first, and suffix with a +-#### timezone offset. If a tzinfo object,  then do as with ‘local’, but use the specified timezone. casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}  Casting to allow when changing between datetime units.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>str_arr : ndarray  An array of strings the same shape as <code>arr</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import pytz d = np.arange(‘2002-10-27T04:30’, 4*60, 60, dtype=‘M8[m]’) d array([‘2002-10-27T04:30’, ‘2002-10-27T05:30’, ‘2002-10-27T06:30’,  ‘2002-10-27T07:30’], dtype=‘datetime64[m]’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Setting the timezone to UTC shows the same information, but with a Z suffix</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.datetime_as_string(d, timezone=‘UTC’) array([‘2002-10-27T04:30Z’, ‘2002-10-27T05:30Z’, ‘2002-10-27T06:30Z’,  ‘2002-10-27T07:30Z’], dtype=‘&lt;U35’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that we picked datetimes that cross a DST boundary. Passing in a <code>pytz</code> timezone object will print the appropriate offset</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.datetime_as_string(d, timezone=pytz.timezone(‘US/Eastern’)) array([‘2002-10-27T00:30-0400’, ‘2002-10-27T01:30-0400’,  ‘2002-10-27T01:30-0500’, ‘2002-10-27T02:30-0500’], dtype=‘&lt;U39’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Passing in a unit will change the precision</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.datetime_as_string(d, unit=‘h’) array([‘2002-10-27T04’, ‘2002-10-27T05’, ‘2002-10-27T06’, ‘2002-10-27T07’],  dtype=‘&lt;U32’) np.datetime_as_string(d, unit=‘s’) array([‘2002-10-27T04:30:00’, ‘2002-10-27T05:30:00’, ‘2002-10-27T06:30:00’,  ‘2002-10-27T07:30:00’], dtype=‘&lt;U38’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>‘casting’ can be used to specify whether precision can be changed</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.datetime_as_string(d, unit=‘h’, casting=‘safe’) Traceback (most recent call last):  … TypeError: Cannot create a datetime string as units ‘h’ from a NumPy datetime with units ‘m’ according to the rule ‘safe’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12403">view source</a></div></div><div class="public anchor" id="var-datetime_data"><h3>datetime_data</h3><div class="usage"><code>(datetime_data self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>datetime_data(dtype, /)</p>
-<p>Get information about the step size of a date or time type.</p>
-<p>The returned tuple can be passed as the second argument of <code>numpy.datetime64</code> and <code>numpy.timedelta64</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>dtype : dtype  The dtype object, which must be a <code>datetime64</code> or <code>timedelta64</code> type.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>unit : str  The :ref:<code>datetime unit &lt;arrays.dtypes.dateunits&gt;</code> on which this dtype  is based. count : int  The number of base units in a step.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>dt_25s = np.dtype(‘timedelta64[25s]’) np.datetime_data(dt_25s) (‘s’, 25) np.array(10, dt_25s).astype(‘timedelta64[s]’) array(250, dtype=‘timedelta64[s]’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The result can be used to construct a datetime that uses the same units as a timedelta</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.datetime64(‘2010’, np.datetime_data(dt_25s)) numpy.datetime64(‘2010-01-01T00:00:00’,‘25s’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12467">view source</a></div></div><div class="public anchor" id="var-deg2rad"><h3>deg2rad</h3><div class="usage"><code>(deg2rad self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>deg2rad(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Convert angles from degrees to radians.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Angles in degrees. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The corresponding angle in radians.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>rad2deg : Convert angles from radians to degrees. unwrap : Remove large jumps in angle by wrapping.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.3.0</p>
-<p><code>deg2rad(x)</code> is <code>x * pi / 180</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.deg2rad(180) 3.1415926535897931</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28917">view source</a></div></div><div class="public anchor" id="var-degrees"><h3>degrees</h3><div class="usage"><code>(degrees self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>degrees(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Convert angles from radians to degrees.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array in radians. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray of floats  The corresponding degree values; if <code>out</code> was supplied this is a  reference to it.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>rad2deg : equivalent function</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Convert a radian array to degrees</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>rad = np.arange(12.)*np.pi/6 np.degrees(rad) array([ 0., 30., 60., 90., 120., 150., 180., 210., 240.,  270., 300., 330.])</p>
-      <p>out = np.zeros((rad.shape)) r = np.degrees(rad, out) np.all(r == out) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10964">view source</a></div></div><div class="public anchor" id="var-delete"><h3>delete</h3><div class="usage"><code>(delete &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a new array with sub-arrays along an axis deleted. For a one dimensional array, this returns those entries not returned by <code>arr[obj]</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr : array_like  Input array. obj : slice, int or array of ints  Indicate indices of sub-arrays to remove along the specified axis. axis : int, optional  The axis along which to delete the subarray defined by <code>obj</code>.  If <code>axis</code> is None, <code>obj</code> is applied to the flattened array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  A copy of <code>arr</code> with the elements specified by <code>obj</code> removed. Note  that <code>delete</code> does not occur in-place. If <code>axis</code> is None, <code>out</code> is  a flattened array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>insert : Insert elements into an array. append : Append elements at the end of an array.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Often it is preferable to use a boolean mask. For example:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>arr = np.arange(12) + 1 mask = np.ones(len(arr), dtype=bool) mask<a href="null">0,2,4</a> = False result = arr[mask,…]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Is equivalent to <code>np.delete(arr, [0,2,4], axis=0)</code>, but allows further use of <code>mask</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>arr = np.array(<a href="null">1,2,3,4], [5,6,7,8], [9,10,11,12</a>) arr array(<a href="null"> 1,  2,  3,  4],
-       [ 5,  6,  7,  8],
-       [ 9, 10, 11, 12</a>) np.delete(arr, 1, 0) array(<a href="null"> 1,  2,  3,  4],
-       [ 9, 10, 11, 12</a>)</p>
-      <p>np.delete(arr, np.s_[::2], 1) array(<a href="null"> 2,  4],
-       [ 6,  8],
-       [10, 12</a>) np.delete(arr, [1,3,5], None) array([ 1, 3, 5, 7, 8, 9, 10, 11, 12])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5708">view source</a></div></div><div class="public anchor" id="var-deprecate"><h3>deprecate</h3><div class="usage"><code>(deprecate &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Issues a DeprecationWarning, adds warning to <code>old_name</code>’s docstring, rebinds <code>old_name.__name__</code> and returns the new function object.</p>
-<p>This function may also be used as a decorator.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>func : function  The function to be deprecated. old_name : str, optional  The name of the function to be deprecated. Default is None, in  which case the name of <code>func</code> is used. new_name : str, optional  The new name for the function. Default is None, in which case the  deprecation message is that <code>old_name</code> is deprecated. If given, the  deprecation message is that <code>old_name</code> is deprecated and <code>new_name</code>  should be used instead. message : str, optional  Additional explanation of the deprecation. Displayed in the  docstring after the warning.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>old_func : function  The deprecated function.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Note that <code>olduint</code> returns a value after printing Deprecation Warning:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>olduint = np.deprecate(np.uint) DeprecationWarning: <code>uint64</code> is deprecated! # may vary olduint(6) 6</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2741">view source</a></div></div><div class="public anchor" id="var-deprecate_with_doc"><h3>deprecate_with_doc</h3><div class="usage"><code>(deprecate_with_doc msg)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6315">view source</a></div></div><div class="public anchor" id="var-diag"><h3>diag</h3><div class="usage"><code>(diag &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Extract a diagonal or construct a diagonal array.</p>
-<p>See the more detailed documentation for <code>numpy.diagonal</code> if you use this function to extract a diagonal and wish to write to the resulting array; whether it returns a copy or a view depends on what version of numpy you are using.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>v : array_like  If <code>v</code> is a 2-D array, return a copy of its <code>k</code>-th diagonal.  If <code>v</code> is a 1-D array, return a 2-D array with <code>v</code> on the <code>k</code>-th  diagonal. k : int, optional  Diagonal in question. The default is 0. Use <code>k&gt;0</code> for diagonals  above the main diagonal, and <code>k&lt;0</code> for diagonals below the main  diagonal.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  The extracted diagonal or constructed diagonal array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>diagonal : Return specified diagonals. diagflat : Create a 2-D array with the flattened input as a diagonal. trace : Sum along diagonals. triu : Upper triangle of an array. tril : Lower triangle of an array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(9).reshape((3,3)) x array(<a href="null">0, 1, 2],
-       [3, 4, 5],
-       [6, 7, 8</a>)</p>
-      <p>np.diag(x) array([0, 4, 8]) np.diag(x, k=1) array([1, 5]) np.diag(x, k=-1) array([3, 7])</p>
-      <p>np.diag(np.diag(x)) array(<a href="null">0, 0, 0],
-       [0, 4, 0],
-       [0, 0, 8</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L979">view source</a></div></div><div class="public anchor" id="var-diag_indices"><h3>diag_indices</h3><div class="usage"><code>(diag_indices n &amp; [{ndim :ndim}])</code><code>(diag_indices n)</code></div><div class="doc"><div class="markdown"><p>Return the indices to access the main diagonal of an array.</p>
-<p>This returns a tuple of indices that can be used to access the main diagonal of an array <code>a</code> with <code>a.ndim &gt;= 2</code> dimensions and shape (n, n, …, n). For <code>a.ndim = 2</code> this is the usual diagonal, for <code>a.ndim &gt; 2</code> this is the set of indices to access <code>a[i, i, ..., i]</code> for <code>i = [0..n-1]</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>n : int  The size, along each dimension, of the arrays for which the returned  indices can be used.</p>
-<p>ndim : int, optional  The number of dimensions.</p>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>diag_indices_from</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.4.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Create a set of indices to access the diagonal of a (4, 4) array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>di = np.diag_indices(4) di (array([0, 1, 2, 3]), array([0, 1, 2, 3])) a = np.arange(16).reshape(4, 4) a array(<a href="null"> 0,  1,  2,  3],
-       [ 4,  5,  6,  7],
-       [ 8,  9, 10, 11],
-       [12, 13, 14, 15</a>) a[di] = 100 a array(<a href="null">100,   1,   2,   3],
-       [  4, 100,   6,   7],
-       [  8,   9, 100,  11],
-       [ 12,  13,  14, 100</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Now, we create indices to manipulate a 3-D array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>d3 = np.diag_indices(2, 3) d3 (array([0, 1]), array([0, 1]), array([0, 1]))</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>And use it to set the diagonal of an array of zeros to 1:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.zeros((2, 2, 2), dtype=int) a[d3] = 1 a array(<a href="null">[1, 0],
-        [0, 0</a>,  <a href="null">0, 0],
-        [0, 1</a>])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24280">view source</a></div></div><div class="public anchor" id="var-diag_indices_from"><h3>diag_indices_from</h3><div class="usage"><code>(diag_indices_from &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices to access the main diagonal of an n-dimensional array.</p>
-<p>See <code>diag_indices</code> for full details.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr : array, at least 2-D</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>diag_indices</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.4.0</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13203">view source</a></div></div><div class="public anchor" id="var-diagflat"><h3>diagflat</h3><div class="usage"><code>(diagflat &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create a two-dimensional array with the flattened input as a diagonal.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>v : array_like  Input data, which is flattened and set as the <code>k</code>-th  diagonal of the output. k : int, optional  Diagonal to set; 0, the default, corresponds to the “main” diagonal,  a positive (negative) <code>k</code> giving the number of the diagonal above  (below) the main.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  The 2-D output array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>diag : MATLAB work-alike for 1-D and 2-D arrays. diagonal : Return specified diagonals. trace : Sum along diagonals.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.diagflat(<a href="null">1,2], [3,4</a>) array(<a href="null">1, 0, 0, 0],
-       [0, 2, 0, 0],
-       [0, 0, 3, 0],
-       [0, 0, 0, 4</a>)</p>
-      <p>np.diagflat([1,2], 1) array(<a href="null">0, 1, 0],
-       [0, 0, 2],
-       [0, 0, 0</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25645">view source</a></div></div><div class="public anchor" id="var-diagonal"><h3>diagonal</h3><div class="usage"><code>(diagonal &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return specified diagonals.</p>
-<p>If <code>a</code> is 2-D, returns the diagonal of <code>a</code> with the given offset, i.e., the collection of elements of the form <code>a[i, i+offset]</code>. If <code>a</code> has more than two dimensions, then the axes specified by <code>axis1</code> and <code>axis2</code> are used to determine the 2-D sub-array whose diagonal is returned. The shape of the resulting array can be determined by removing <code>axis1</code> and <code>axis2</code> and appending an index to the right equal to the size of the resulting diagonals.</p>
-<p>In versions of NumPy prior to 1.7, this function always returned a new, independent array containing a copy of the values in the diagonal.</p>
-<p>In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal, but depending on this fact is deprecated. Writing to the resulting array continues to work as it used to, but a FutureWarning is issued.</p>
-<p>Starting in NumPy 1.9 it returns a read-only view on the original array. Attempting to write to the resulting array will produce an error.</p>
-<p>In some future release, it will return a read/write view and writing to the returned array will alter your original array. The returned array will have the same type as the input array.</p>
-<p>If you don’t write to the array returned by this function, then you can just ignore all of the above.</p>
-<p>If you depend on the current behavior, then we suggest copying the returned array explicitly, i.e., use <code>np.diagonal(a).copy()</code> instead of just <code>np.diagonal(a)</code>. This will work with both past and future versions of NumPy.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array from which the diagonals are taken. offset : int, optional  Offset of the diagonal from the main diagonal. Can be positive or  negative. Defaults to main diagonal (0). axis1 : int, optional  Axis to be used as the first axis of the 2-D sub-arrays from which  the diagonals should be taken. Defaults to first axis (0). axis2 : int, optional  Axis to be used as the second axis of the 2-D sub-arrays from  which the diagonals should be taken. Defaults to second axis (1).</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>array_of_diagonals : ndarray  If <code>a</code> is 2-D, then a 1-D array containing the diagonal and of the  same type as <code>a</code> is returned unless <code>a</code> is a <code>matrix</code>, in which case  a 1-D array rather than a (2-D) <code>matrix</code> is returned in order to  maintain backward compatibility.</p>
-<pre><code>If ``a.ndim &gt; 2``, then the dimensions specified by `axis1` and `axis2`
-are removed, and a new axis inserted at the end corresponding to the
-diagonal.
-</code></pre>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If the dimension of <code>a</code> is less than 2.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>diag : MATLAB work-a-like for 1-D and 2-D arrays. diagflat : Create diagonal arrays. trace : Sum along diagonals.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(4).reshape(2,2) a array(<a href="null">0, 1],
-       [2, 3</a>) a.diagonal() array([0, 3]) a.diagonal(1) array([1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>A 3-D example:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(8).reshape(2,2,2); a array(<a href="null">[0, 1],
-        [2, 3</a>,  <a href="null">4, 5],
-        [6, 7</a>]) a.diagonal(0, # Main diagonals of two arrays created by skipping … 0, # across the outer(left)-most axis last and … 1) # the “middle” (row) axis first. array(<a href="null">0, 6],
-       [1, 7</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The sub-arrays whose main diagonals we just obtained; note that each corresponds to fixing the right-most (column) axis, and that the diagonals are “packed” in rows.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a[:,:,0] # main diagonal is [0 6] array(<a href="null">0, 2],
-       [4, 6</a>) a[:,:,1] # main diagonal is [1 7] array(<a href="null">1, 3],
-       [5, 7</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The anti-diagonal can be obtained by reversing the order of elements using either <code>numpy.flipud</code> or <code>numpy.fliplr</code>.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(9).reshape(3, 3) a array(<a href="null">0, 1, 2],
-       [3, 4, 5],
-       [6, 7, 8</a>) np.fliplr(a).diagonal() # Horizontal flip array([2, 4, 6]) np.flipud(a).diagonal() # Vertical flip array([6, 4, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that the order in which the diagonal is retrieved varies depending on the flip function.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9790">view source</a></div></div><div class="public anchor" id="var-diff"><h3>diff</h3><div class="usage"><code>(diff &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Calculate the n-th discrete difference along the given axis.</p>
-<p>The first difference is given by <code>out[i] = a[i+1] - a[i]</code> along the given axis, higher differences are calculated by using <code>diff</code> recursively.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array n : int, optional  The number of times values are differenced. If zero, the input  is returned as-is. axis : int, optional  The axis along which the difference is taken, default is the  last axis. prepend, append : array_like, optional  Values to prepend or append to <code>a</code> along axis prior to  performing the difference. Scalar values are expanded to  arrays with length 1 in the direction of axis and the shape  of the input array in along all other axes. Otherwise the  dimension and shape must match <code>a</code> except along axis.</p>
-<pre><code>.. versionadded:: 1.16.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>diff : ndarray  The n-th differences. The shape of the output is the same as <code>a</code>  except along <code>axis</code> where the dimension is smaller by <code>n</code>. The  type of the output is the same as the type of the difference  between any two elements of <code>a</code>. This is the same as the type of  <code>a</code> in most cases. A notable exception is <code>datetime64</code>, which  results in a <code>timedelta64</code> output array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>gradient, ediff1d, cumsum</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Type is preserved for boolean arrays, so the result will contain <code>False</code> when consecutive elements are the same and <code>True</code> when they differ.</p>
-<p>For unsigned integer arrays, the results will also be unsigned. This should not be surprising, as the result is consistent with calculating the difference directly:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>u8_arr = np.array([1, 0], dtype=np.uint8) np.diff(u8_arr) array([255], dtype=uint8) u8_arr[1,…] - u8_arr[0,…] 255</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>If this is not desirable, then the array should be cast to a larger integer type first:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>i16_arr = u8_arr.astype(np.int16) np.diff(i16_arr) array([-1], dtype=int16)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([1, 2, 4, 7, 0]) np.diff(x) array([ 1, 2, 3, -7]) np.diff(x, n=2) array([ 1, 1, -10])</p>
-      <p>x = np.array(<a href="null">1, 3, 6, 10], [0, 5, 6, 8</a>) np.diff(x) array(<a href="null">2, 3, 4],
-       [5, 1, 2</a>) np.diff(x, axis=0) array(<a href="null">-1,  2,  0, -2</a>)</p>
-      <p>x = np.arange(‘1066-10-13’, ‘1066-10-16’, dtype=np.datetime64) np.diff(x) array([1, 1], dtype=‘timedelta64[D]’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11016">view source</a></div></div><div class="public anchor" id="var-digitize"><h3>digitize</h3><div class="usage"><code>(digitize &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices of the bins to which each value in input array belongs.</p>
-<p>========= ============= ============================ <code>right</code> order of bins returned index <code>i</code> satisfies ========= ============= ============================ <code>False</code> increasing <code>bins[i-1] &lt;= x &lt; bins[i]</code> <code>True</code> increasing <code>bins[i-1] &lt; x &lt;= bins[i]</code> <code>False</code> decreasing <code>bins[i-1] &gt; x &gt;= bins[i]</code> <code>True</code> decreasing <code>bins[i-1] &gt;= x &gt; bins[i]</code> ========= ============= ============================</p>
-<p>If values in <code>x</code> are beyond the bounds of <code>bins</code>, 0 or <code>len(bins)</code> is returned as appropriate.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array to be binned. Prior to NumPy 1.10.0, this array had to  be 1-dimensional, but can now have any shape. bins : array_like  Array of bins. It has to be 1-dimensional and monotonic. right : bool, optional  Indicating whether the intervals include the right or the left bin  edge. Default behavior is (right==False) indicating that the interval  does not include the right edge. The left bin end is open in this  case, i.e., bins[i-1] &lt;= x &lt; bins[i] is the default behavior for  monotonically increasing bins.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>indices : ndarray of ints  Output array of indices, of same shape as <code>x</code>.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If <code>bins</code> is not monotonic. TypeError  If the type of the input is complex.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>bincount, histogram, unique, searchsorted</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If values in <code>x</code> are such that they fall outside the bin range, attempting to index <code>bins</code> with the indices that <code>digitize</code> returns will result in an IndexError.</p>
-<p>.. versionadded:: 1.10.0</p>
-<p><code>np.digitize</code> is implemented in terms of <code>np.searchsorted</code>. This means that a binary search is used to bin the values, which scales much better for larger number of bins than the previous linear search. It also removes the requirement for the input array to be 1-dimensional.</p>
-<p>For monotonically <em>increasing</em> <code>bins</code>, the following are equivalent::</p>
-<pre><code>np.digitize(x, bins, right=True)
-np.searchsorted(bins, x, side='left')
-</code></pre>
-<p>Note that as the order of the arguments are reversed, the side must be too. The <code>searchsorted</code> call is marginally faster, as it does not do any monotonicity checks. Perhaps more importantly, it supports all dtypes.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([0.2, 6.4, 3.0, 1.6]) bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0]) inds = np.digitize(x, bins) inds array([1, 4, 3, 2]) for n in range(x.size): … print(bins[inds[n]-1], “&lt;=”, x[n], “&lt;”, bins[inds[n]]) … 0.0 &lt;= 0.2 &lt; 1.0 4.0 &lt;= 6.4 &lt; 10.0 2.5 &lt;= 3.0 &lt; 4.0 1.0 &lt;= 1.6 &lt; 2.5</p>
-      <p>x = np.array([1.2, 10.0, 12.4, 15.5, 20.]) bins = np.array([0, 5, 10, 15, 20]) np.digitize(x,bins,right=True) array([1, 2, 3, 4, 4]) np.digitize(x,bins,right=False) array([1, 3, 3, 4, 5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1130">view source</a></div></div><div class="public anchor" id="var-disp"><h3>disp</h3><div class="usage"><code>(disp mesg &amp; [{device :device, linefeed :linefeed}])</code><code>(disp mesg &amp; [{device :device}])</code><code>(disp mesg)</code></div><div class="doc"><div class="markdown"><p>Display a message on a device.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>mesg : str  Message to display. device : object  Device to write message. If None, defaults to <code>sys.stdout</code> which is  very similar to <code>print</code>. <code>device</code> needs to have <code>write()</code> and  <code>flush()</code> methods. linefeed : bool, optional  Option whether to print a line feed or not. Defaults to True.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>AttributeError  If <code>device</code> does not have a <code>write()</code> or <code>flush()</code> method.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Besides <code>sys.stdout</code>, a file-like object can also be used as it has both required methods:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from io import StringIO buf = StringIO() np.disp(u’“Display” in a file’, device=buf) buf.getvalue() ‘“Display” in a file\n’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14279">view source</a></div></div><div class="public anchor" id="var-divide"><h3>divide</h3><div class="usage"><code>(divide self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>true_divide(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Returns a true division of the inputs, element-wise.</p>
-<p>Instead of the Python traditional ‘floor division’, this returns a true division. True division adjusts the output type to present the best answer, regardless of input types.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  Dividend array. x2 : array_like  Divisor array. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The floor division operator <code>//</code> was added in Python 2.2 making <code>//</code> and <code>/</code> equivalent operators. The default floor division operation of <code>/</code> can be replaced by true division with <code>from
-__future__ import division</code>.</p>
-<p>In Python 3.0, <code>//</code> is the floor division operator and <code>/</code> the true division operator. The <code>true_divide(x1, x2)</code> function is equivalent to true division in Python.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(5) np.true_divide(x, 4) array([ 0. , 0.25, 0.5 , 0.75, 1. ])</p>
-      <p>x//4 array([0, 0, 0, 0, 1])</p>
-      <p>from <strong>future</strong> import division x/4 array([ 0. , 0.25, 0.5 , 0.75, 1. ]) x//4 array([0, 0, 0, 0, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21713">view source</a></div></div><div class="public anchor" id="var-division"><h3>division</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13397">view source</a></div></div><div class="public anchor" id="var-divmod"><h3>divmod</h3><div class="usage"><code>(divmod self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return element-wise quotient and remainder simultaneously.</p>
-<p>.. versionadded:: 1.13.0</p>
-<p><code>np.divmod(x, y)</code> is equivalent to <code>(x // y, x % y)</code>, but faster because it avoids redundant work. It is used to implement the Python built-in function <code>divmod</code> on NumPy arrays.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  Dividend array. x2 : array_like  Divisor array. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out1 : ndarray  Element-wise quotient resulting from floor division.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars. out2 : ndarray  Element-wise remainder from floor division.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>floor_divide : Equivalent to Python’s <code>//</code> operator. remainder : Equivalent to Python’s <code>%</code> operator. modf : Equivalent to <code>divmod(x, 1)</code> for positive <code>x</code> with the return  values switched.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.divmod(np.arange(5), 3) (array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13147">view source</a></div></div><div class="public anchor" id="var-dot"><h3>dot</h3><div class="usage"><code>(dot &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>dot(a, b, out=None)</p>
-<p>Dot product of two arrays. Specifically,</p>
-<ul>
-  <li>
-  <p>If both <code>a</code> and <code>b</code> are 1-D arrays, it is inner product of vectors  (without complex conjugation).</p></li>
-  <li>
-  <p>If both <code>a</code> and <code>b</code> are 2-D arrays, it is matrix multiplication,  but using :func:<code>matmul</code> or <code>a @ b</code> is preferred.</p></li>
-  <li>
-  <p>If either <code>a</code> or <code>b</code> is 0-D (scalar), it is equivalent to :func:<code>multiply</code>  and using <code>numpy.multiply(a, b)</code> or <code>a * b</code> is preferred.</p></li>
-  <li>
-  <p>If <code>a</code> is an N-D array and <code>b</code> is a 1-D array, it is a sum product over  the last axis of <code>a</code> and <code>b</code>.</p></li>
-  <li>
-    <p>If <code>a</code> is an N-D array and <code>b</code> is an M-D array (where <code>M&gt;=2</code>), it is a  sum product over the last axis of <code>a</code> and the second-to-last axis of <code>b</code>::</p>
-    <p>dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])</p>
-  </li>
-</ul>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  First argument. b : array_like  Second argument. out : ndarray, optional  Output argument. This must have the exact kind that would be returned  if it was not used. In particular, it must have the right type, must be  C-contiguous, and its dtype must be the dtype that would be returned  for <code>dot(a,b)</code>. This is a performance feature. Therefore, if these  conditions are not met, an exception is raised, instead of attempting  to be flexible.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>output : ndarray  Returns the dot product of <code>a</code> and <code>b</code>. If <code>a</code> and <code>b</code> are both  scalars or both 1-D arrays then a scalar is returned; otherwise  an array is returned.  If <code>out</code> is given, then it is returned.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If the last dimension of <code>a</code> is not the same size as  the second-to-last dimension of <code>b</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>vdot : Complex-conjugating dot product. tensordot : Sum products over arbitrary axes. einsum : Einstein summation convention. matmul : ‘@’ operator as method with out parameter.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dot(3, 4) 12</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Neither argument is complex-conjugated:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dot([2j, 3j], [2j, 3j]) (-13+0j)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>For 2-D arrays it is the matrix product:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = <a href="null">1, 0], [0, 1</a> b = <a href="null">4, 1], [2, 2</a> np.dot(a, b) array(<a href="null">4, 1],
-       [2, 2</a>)</p>
-      <p>a = np.arange(3*4*5*6).reshape((3,4,5,6)) b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3)) np.dot(a, b)[2,3,2,1,2,2] 499128 sum(a[2,3,2,:] * b[1,2,:,2]) 499128</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7733">view source</a></div></div><div class="public anchor" id="var-double"><h3>double</h3><div class="usage"><code>(double self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Double-precision floating-point number type, compatible with Python <code>float</code> and C <code>double</code>. Character code: <code>'d'</code>. Canonical name: <code>np.double</code>. Alias: <code>np.float_</code>. Alias <em>on this platform</em>: <code>np.float64</code>: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21204">view source</a></div></div><div class="public anchor" id="var-dsplit"><h3>dsplit</h3><div class="usage"><code>(dsplit &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Split array into multiple sub-arrays along the 3rd axis (depth).</p>
-<p>Please refer to the <code>split</code> documentation. <code>dsplit</code> is equivalent to <code>split</code> with <code>axis=2</code>, the array is always split along the third axis provided the array dimension is greater than or equal to 3.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>split : Split an array into multiple sub-arrays of equal size.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(16.0).reshape(2, 2, 4) x array(<a href="null">[ 0.,   1.,   2.,   3.],
-        [ 4.,   5.,   6.,   7.</a>,  <a href="null"> 8.,   9.,  10.,  11.],
-        [12.,  13.,  14.,  15.</a>]) np.dsplit(x, 2) [array([[[ 0., 1.],  [ 4., 5.]],  [[ 8., 9.],  [12., 13.]]]), array([[[ 2., 3.],  [ 6., 7.]],  [[10., 11.],  [14., 15.]]])] np.dsplit(x, np.array([3, 6])) [array([[[ 0., 1., 2.],  [ 4., 5., 6.]],  [[ 8., 9., 10.],  [12., 13., 14.]]]),  array([[[ 3.],  [ 7.]],  [[11.],  [15.]]]), array([], shape=(2, 2, 0), dtype=float64)]</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24545">view source</a></div></div><div class="public anchor" id="var-dstack"><h3>dstack</h3><div class="usage"><code>(dstack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Stack arrays in sequence depth wise (along third axis).</p>
-<p>This is equivalent to concatenation along the third axis after 2-D arrays of shape <code>(M,N)</code> have been reshaped to <code>(M,N,1)</code> and 1-D arrays of shape <code>(N,)</code> have been reshaped to <code>(1,N,1)</code>. Rebuilds arrays divided by <code>dsplit</code>.</p>
-<p>This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions <code>concatenate</code>, <code>stack</code> and <code>block</code> provide more general stacking and concatenation operations.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>tup : sequence of arrays  The arrays must have the same shape along all but the third axis.  1-D or 2-D arrays must have the same shape.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>stacked : ndarray  The array formed by stacking the given arrays, will be at least 3-D.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>stack : Join a sequence of arrays along a new axis. vstack : Stack along first axis. hstack : Stack along second axis. concatenate : Join a sequence of arrays along an existing axis. dsplit : Split array along third axis.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array((1,2,3)) b = np.array((2,3,4)) np.dstack((a,b)) array(<a href="null">[1, 2],
-        [2, 3],
-        [3, 4</a>])</p>
-      <p>a = np.array(<a href="null">1],[2],[3</a>) b = np.array(<a href="null">2],[3],[4</a>) np.dstack((a,b)) array(<a href="null">[1, 2</a>,  <a href="null">2, 3</a>,  <a href="null">3, 4</a>])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22018">view source</a></div></div><div class="public anchor" id="var-dtype"><h3>dtype</h3><div class="usage"><code>(dtype self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>dtype(obj, align=False, copy=False)</p>
-<p>Create a data type object.</p>
-<p>A numpy array is homogeneous, and contains elements described by a dtype object. A dtype object can be constructed from different combinations of fundamental numeric types.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>obj  Object to be converted to a data type object. align : bool, optional  Add padding to the fields to match what a C compiler would output  for a similar C-struct. Can be <code>True</code> only if <code>obj</code> is a dictionary  or a comma-separated string. If a struct dtype is being created,  this also sets a sticky alignment flag <code>isalignedstruct</code>. copy : bool, optional  Make a new copy of the data-type object. If <code>False</code>, the result  may just be a reference to a built-in data-type object.</p>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>result_type</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Using array-scalar type:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dtype(np.int16) dtype(‘int16’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Structured type, one field name ‘f1’, containing int16:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dtype([(‘f1’, np.int16)]) dtype([(‘f1’, ‘&lt;i2’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Structured type, one field named ‘f1’, in itself containing a structured type with one field:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dtype([(‘f1’, [(‘f1’, np.int16)])]) dtype([(‘f1’, [(‘f1’, ‘&lt;i2’)])])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Structured type, two fields: the first field contains an unsigned int, the second an int32:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dtype([(‘f1’, np.uint64), (‘f2’, np.int32)]) dtype([(‘f1’, ‘&lt;u8’), (‘f2’, ‘&lt;i4’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using array-protocol type strings:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dtype([(‘a’,‘f8’),(‘b’,‘S10’)]) dtype([(‘a’, ‘&lt;f8’), (‘b’, ‘S10’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using comma-separated field formats. The shape is (2,3):</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dtype(“i4, (2,3)f8”) dtype([(‘f0’, ‘&lt;i4’), (‘f1’, ‘&lt;f8’, (2, 3))])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using tuples. <code>int</code> is a fixed type, 3 the field’s shape. <code>void</code> is a flexible type, here of size 10:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dtype([(‘hello’,(np.int64,3)),(‘world’,np.void,10)]) dtype([(‘hello’, ‘&lt;i8’, (3,)), (‘world’, ‘V10’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Subdivide <code>int16</code> into 2 <code>int8</code>’s, called x and y. 0 and 1 are the offsets in bytes:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dtype((np.int16, {‘x’:(np.int8,0), ‘y’:(np.int8,1)})) dtype((numpy.int16, [(‘x’, ‘i1’), (‘y’, ‘i1’)]))</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using dictionaries. Two fields named ‘gender’ and ‘age’:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dtype({‘names’:[‘gender’,‘age’], ‘formats’:[‘S1’,np.uint8]}) dtype([(‘gender’, ‘S1’), (‘age’, ‘u1’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Offsets in bytes, here 0 and 25:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.dtype({‘surname’:(‘S25’,0),‘age’:(np.uint8,25)}) dtype([(‘surname’, ‘S25’), (‘age’, ‘u1’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25417">view source</a></div></div><div class="public anchor" id="var-e"><h3>e</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4383">view source</a></div></div><div class="public anchor" id="var-ediff1d"><h3>ediff1d</h3><div class="usage"><code>(ediff1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>The differences between consecutive elements of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>ary : array_like  If necessary, will be flattened before the differences are taken. to_end : array_like, optional  Number(s) to append at the end of the returned differences. to_begin : array_like, optional  Number(s) to prepend at the beginning of the returned differences.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>ediff1d : ndarray  The differences. Loosely, this is <code>ary.flat[1:] - ary.flat[:-1]</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>diff, gradient</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>When applied to masked arrays, this function drops the mask information if the <code>to_begin</code> and/or <code>to_end</code> parameters are used.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([1, 2, 4, 7, 0]) np.ediff1d(x) array([ 1, 2, 3, -7])</p>
-      <p>np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99])) array([-99, 1, 2, …, -7, 88, 99])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The returned array is always 1D.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>y = <a href="null">1, 2, 4], [1, 6, 24</a> np.ediff1d(y) array([ 1, 2, -3, 5, 18])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5881">view source</a></div></div><div class="public anchor" id="var-einsum"><h3>einsum</h3><div class="usage"><code>(einsum &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>einsum(subscripts, *operands, out=None, dtype=None, order=‘K’,  casting=‘safe’, optimize=False)</p>
-<p>Evaluates the Einstein summation convention on the operands.</p>
-<p>Using the Einstein summation convention, many common multi-dimensional, linear algebraic array operations can be represented in a simple fashion. In <em>implicit</em> mode <code>einsum</code> computes these values.</p>
-<p>In <em>explicit</em> mode, <code>einsum</code> provides further flexibility to compute other array operations that might not be considered classical Einstein summation operations, by disabling, or forcing summation over specified subscript labels.</p>
-<p>See the notes and examples for clarification.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>subscripts : str  Specifies the subscripts for summation as comma separated list of  subscript labels. An implicit (classical Einstein summation)  calculation is performed unless the explicit indicator ‘-&gt;’ is  included as well as subscript labels of the precise output form. operands : list of array_like  These are the arrays for the operation. out : ndarray, optional  If provided, the calculation is done into this array. dtype : {data-type, None}, optional  If provided, forces the calculation to use the data type specified.  Note that you may have to also give a more liberal <code>casting</code>  parameter to allow the conversions. Default is None. order : {‘C’, ‘F’, ‘A’, ‘K’}, optional  Controls the memory layout of the output. ‘C’ means it should  be C contiguous. ‘F’ means it should be Fortran contiguous,  ‘A’ means it should be ‘F’ if the inputs are all ‘F’, ‘C’ otherwise.  ‘K’ means it should be as close to the layout as the inputs as  is possible, including arbitrarily permuted axes.  Default is ‘K’. casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional  Controls what kind of data casting may occur. Setting this to  ‘unsafe’ is not recommended, as it can adversely affect accumulations.</p>
-<pre><code>  * 'no' means the data types should not be cast at all.
-  * 'equiv' means only byte-order changes are allowed.
-  * 'safe' means only casts which can preserve values are allowed.
-  * 'same_kind' means only safe casts or casts within a kind,
-    like float64 to float32, are allowed.
-  * 'unsafe' means any data conversions may be done.
-
-Default is 'safe'.
-</code></pre>
-<p>optimize : {False, True, ‘greedy’, ‘optimal’}, optional  Controls if intermediate optimization should occur. No optimization  will occur if False and True will default to the ‘greedy’ algorithm.  Also accepts an explicit contraction list from the <code>np.einsum_path</code>  function. See <code>np.einsum_path</code> for more details. Defaults to False.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>output : ndarray  The calculation based on the Einstein summation convention.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>einsum_path, dot, inner, outer, tensordot, linalg.multi_dot</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.6.0</p>
-<p>The Einstein summation convention can be used to compute many multi-dimensional, linear algebraic array operations. <code>einsum</code> provides a succinct way of representing these.</p>
-<p>A non-exhaustive list of these operations, which can be computed by <code>einsum</code>, is shown below along with examples:</p>
-<ul>
-  <li>Trace of an array, :py:func:<code>numpy.trace</code>.</li>
-  <li>Return a diagonal, :py:func:<code>numpy.diag</code>.</li>
-  <li>Array axis summations, :py:func:<code>numpy.sum</code>.</li>
-  <li>Transpositions and permutations, :py:func:<code>numpy.transpose</code>.</li>
-  <li>Matrix multiplication and dot product, :py:func:<code>numpy.matmul</code> :py:func:<code>numpy.dot</code>.</li>
-  <li>Vector inner and outer products, :py:func:<code>numpy.inner</code> :py:func:<code>numpy.outer</code>.</li>
-  <li>Broadcasting, element-wise and scalar multiplication, :py:func:<code>numpy.multiply</code>.</li>
-  <li>Tensor contractions, :py:func:<code>numpy.tensordot</code>.</li>
-  <li>Chained array operations, in efficient calculation order, :py:func:<code>numpy.einsum_path</code>.</li>
-</ul>
-<p>The subscripts string is a comma-separated list of subscript labels, where each label refers to a dimension of the corresponding operand. Whenever a label is repeated it is summed, so <code>np.einsum('i,i', a, b)</code> is equivalent to :py:func:<code>np.inner(a,b) &lt;numpy.inner&gt;</code>. If a label appears only once, it is not summed, so <code>np.einsum('i', a)</code> produces a view of <code>a</code> with no changes. A further example <code>np.einsum('ij,jk', a, b)</code> describes traditional matrix multiplication and is equivalent to :py:func:<code>np.matmul(a,b) &lt;numpy.matmul&gt;</code>. Repeated subscript labels in one operand take the diagonal. For example, <code>np.einsum('ii', a)</code> is equivalent to :py:func:<code>np.trace(a) &lt;numpy.trace&gt;</code>.</p>
-<p>In <em>implicit mode</em>, the chosen subscripts are important since the axes of the output are reordered alphabetically. This means that <code>np.einsum('ij', a)</code> doesn’t affect a 2D array, while <code>np.einsum('ji', a)</code> takes its transpose. Additionally, <code>np.einsum('ij,jk', a, b)</code> returns a matrix multiplication, while, <code>np.einsum('ij,jh', a, b)</code> returns the transpose of the multiplication since subscript ‘h’ precedes subscript ‘i’.</p>
-<p>In <em>explicit mode</em> the output can be directly controlled by specifying output subscript labels. This requires the identifier ‘-&gt;’ as well as the list of output subscript labels. This feature increases the flexibility of the function since summing can be disabled or forced when required. The call <code>np.einsum('i-&gt;', a)</code> is like :py:func:<code>np.sum(a, axis=-1) &lt;numpy.sum&gt;</code>, and <code>np.einsum('ii-&gt;i', a)</code> is like :py:func:<code>np.diag(a) &lt;numpy.diag&gt;</code>. The difference is that <code>einsum</code> does not allow broadcasting by default. Additionally <code>np.einsum('ij,jh-&gt;ih', a, b)</code> directly specifies the order of the output subscript labels and therefore returns matrix multiplication, unlike the example above in implicit mode.</p>
-<p>To enable and control broadcasting, use an ellipsis. Default NumPy-style broadcasting is done by adding an ellipsis to the left of each term, like <code>np.einsum('...ii-&gt;...i', a)</code>. To take the trace along the first and last axes, you can do <code>np.einsum('i...i', a)</code>, or to do a matrix-matrix product with the left-most indices instead of rightmost, one can do <code>np.einsum('ij...,jk...-&gt;ik...', a, b)</code>.</p>
-<p>When there is only one operand, no axes are summed, and no output parameter is provided, a view into the operand is returned instead of a new array. Thus, taking the diagonal as <code>np.einsum('ii-&gt;i', a)</code> produces a view (changed in version 1.10.0).</p>
-<p><code>einsum</code> also provides an alternative way to provide the subscripts and operands as <code>einsum(op0, sublist0, op1, sublist1, ..., [sublistout])</code>. If the output shape is not provided in this format <code>einsum</code> will be calculated in implicit mode, otherwise it will be performed explicitly. The examples below have corresponding <code>einsum</code> calls with the two parameter methods.</p>
-<p>.. versionadded:: 1.10.0</p>
-<p>Views returned from einsum are now writeable whenever the input array is writeable. For example, <code>np.einsum('ijk...-&gt;kji...', a)</code> will now have the same effect as :py:func:<code>np.swapaxes(a, 0, 2) &lt;numpy.swapaxes&gt;</code> and <code>np.einsum('ii-&gt;i', a)</code> will return a writeable view of the diagonal of a 2D array.</p>
-<p>.. versionadded:: 1.12.0</p>
-<p>Added the <code>optimize</code> argument which will optimize the contraction order of an einsum expression. For a contraction with three or more operands this can greatly increase the computational efficiency at the cost of a larger memory footprint during computation.</p>
-<p>Typically a ‘greedy’ algorithm is applied which empirical tests have shown returns the optimal path in the majority of cases. In some cases ‘optimal’ will return the superlative path through a more expensive, exhaustive search. For iterative calculations it may be advisable to calculate the optimal path once and reuse that path by supplying it as an argument. An example is given below.</p>
-<p>See :py:func:<code>numpy.einsum_path</code> for more details.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(25).reshape(5,5) b = np.arange(5) c = np.arange(6).reshape(2,3)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Trace of a matrix:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.einsum(‘ii’, a) 60 np.einsum(a, [0,0]) 60 np.trace(a) 60</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Extract the diagonal (requires explicit form):</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.einsum(‘ii-&gt;i’, a) array([ 0, 6, 12, 18, 24]) np.einsum(a, [0,0], [0]) array([ 0, 6, 12, 18, 24]) np.diag(a) array([ 0, 6, 12, 18, 24])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Sum over an axis (requires explicit form):</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.einsum(‘ij-&gt;i’, a) array([ 10, 35, 60, 85, 110]) np.einsum(a, [0,1], [0]) array([ 10, 35, 60, 85, 110]) np.sum(a, axis=1) array([ 10, 35, 60, 85, 110])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>For higher dimensional arrays summing a single axis can be done with ellipsis:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.einsum(‘…j-&gt;…’, a) array([ 10, 35, 60, 85, 110]) np.einsum(a, [Ellipsis,1], [Ellipsis]) array([ 10, 35, 60, 85, 110])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Compute a matrix transpose, or reorder any number of axes:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.einsum(‘ji’, c) array(<a href="null">0, 3],
-       [1, 4],
-       [2, 5</a>) np.einsum(‘ij-&gt;ji’, c) array(<a href="null">0, 3],
-       [1, 4],
-       [2, 5</a>) np.einsum(c, [1,0]) array(<a href="null">0, 3],
-       [1, 4],
-       [2, 5</a>) np.transpose(c) array(<a href="null">0, 3],
-       [1, 4],
-       [2, 5</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Vector inner products:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.einsum(‘i,i’, b, b) 30 np.einsum(b, [0], b, [0]) 30 np.inner(b,b) 30</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Matrix vector multiplication:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.einsum(‘ij,j’, a, b) array([ 30, 80, 130, 180, 230]) np.einsum(a, [0,1], b, [1]) array([ 30, 80, 130, 180, 230]) np.dot(a, b) array([ 30, 80, 130, 180, 230]) np.einsum(‘…j,j’, a, b) array([ 30, 80, 130, 180, 230])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Broadcasting and scalar multiplication:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.einsum(‘…, …’, 3, c) array(<a href="null"> 0,  3,  6],
-       [ 9, 12, 15</a>) np.einsum(‘,ij’, 3, c) array(<a href="null"> 0,  3,  6],
-       [ 9, 12, 15</a>) np.einsum(3, [Ellipsis], c, [Ellipsis]) array(<a href="null"> 0,  3,  6],
-       [ 9, 12, 15</a>) np.multiply(3, c) array(<a href="null"> 0,  3,  6],
-       [ 9, 12, 15</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Vector outer product:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.einsum(‘i,j’, np.arange(2)+1, b) array(<a href="null">0, 1, 2, 3, 4],
-       [0, 2, 4, 6, 8</a>) np.einsum(np.arange(2)+1, [0], b, [1]) array(<a href="null">0, 1, 2, 3, 4],
-       [0, 2, 4, 6, 8</a>) np.outer(np.arange(2)+1, b) array(<a href="null">0, 1, 2, 3, 4],
-       [0, 2, 4, 6, 8</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Tensor contraction:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(60.).reshape(3,4,5) b = np.arange(24.).reshape(4,3,2) np.einsum(‘ijk,jil-&gt;kl’, a, b) array(<a href="null">4400., 4730.],
-       [4532., 4874.],
-       [4664., 5018.],
-       [4796., 5162.],
-       [4928., 5306.</a>) np.einsum(a, [0,1,2], b, [1,0,3], [2,3]) array(<a href="null">4400., 4730.],
-       [4532., 4874.],
-       [4664., 5018.],
-       [4796., 5162.],
-       [4928., 5306.</a>) np.tensordot(a,b, axes=([1,0],[0,1])) array(<a href="null">4400., 4730.],
-       [4532., 4874.],
-       [4664., 5018.],
-       [4796., 5162.],
-       [4928., 5306.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Writeable returned arrays (since version 1.10.0):</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.zeros((3, 3)) np.einsum(‘ii-&gt;i’, a)[:] = 1 a array(<a href="null">1., 0., 0.],
-       [0., 1., 0.],
-       [0., 0., 1.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Example of ellipsis use:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(6).reshape((3,2)) b = np.arange(12).reshape((4,3)) np.einsum(‘ki,jk-&gt;ij’, a, b) array(<a href="null">10, 28, 46, 64],
-       [13, 40, 67, 94</a>) np.einsum(‘ki,…k-&gt;i…’, a, b) array(<a href="null">10, 28, 46, 64],
-       [13, 40, 67, 94</a>) np.einsum(‘k…,jk’, a, b) array(<a href="null">10, 28, 46, 64],
-       [13, 40, 67, 94</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Chained array operations. For more complicated contractions, speed ups might be achieved by repeatedly computing a ‘greedy’ path or pre-computing the ‘optimal’ path and repeatedly applying it, using an <code>einsum_path</code> insertion (since version 1.12.0). Performance improvements can be particularly significant with larger arrays:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.ones(64).reshape(2,4,8)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Basic <code>einsum</code>: ~1520ms (benchmarked on 3.1GHz Intel i5.)</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>for iteration in range(500): … _ = np.einsum(‘ijk,ilm,njm,nlk,abc-&gt;’,a,a,a,a,a)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Sub-optimal <code>einsum</code> (due to repeated path calculation time): ~330ms</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>for iteration in range(500): … _ = np.einsum(‘ijk,ilm,njm,nlk,abc-&gt;’,a,a,a,a,a, optimize=‘optimal’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Greedy <code>einsum</code> (faster optimal path approximation): ~160ms</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>for iteration in range(500): … _ = np.einsum(‘ijk,ilm,njm,nlk,abc-&gt;’,a,a,a,a,a, optimize=‘greedy’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Optimal <code>einsum</code> (best usage pattern in some use cases): ~110ms</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>path = np.einsum_path(‘ijk,ilm,njm,nlk,abc-&gt;’,a,a,a,a,a, optimize=‘optimal’)[0] for iteration in range(500): … _ = np.einsum(‘ijk,ilm,njm,nlk,abc-&gt;’,a,a,a,a,a, optimize=path)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24673">view source</a></div></div><div class="public anchor" id="var-einsum_path"><h3>einsum_path</h3><div class="usage"><code>(einsum_path &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>einsum_path(subscripts, *operands, optimize=‘greedy’)</p>
-<p>Evaluates the lowest cost contraction order for an einsum expression by considering the creation of intermediate arrays.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>subscripts : str  Specifies the subscripts for summation. *operands : list of array_like  These are the arrays for the operation. optimize : {bool, list, tuple, ‘greedy’, ‘optimal’}  Choose the type of path. If a tuple is provided, the second argument is  assumed to be the maximum intermediate size created. If only a single  argument is provided the largest input or output array size is used  as a maximum intermediate size.</p>
-<pre><code>* if a list is given that starts with ``einsum_path``, uses this as the
-  contraction path
-* if False no optimization is taken
-* if True defaults to the 'greedy' algorithm
-* 'optimal' An algorithm that combinatorially explores all possible
-  ways of contracting the listed tensors and choosest the least costly
-  path. Scales exponentially with the number of terms in the
-  contraction.
-* 'greedy' An algorithm that chooses the best pair contraction
-  at each step. Effectively, this algorithm searches the largest inner,
-  Hadamard, and then outer products at each step. Scales cubically with
-  the number of terms in the contraction. Equivalent to the 'optimal'
-  path for most contractions.
-
-Default is 'greedy'.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>path : list of tuples  A list representation of the einsum path. string_repr : str  A printable representation of the einsum path.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The resulting path indicates which terms of the input contraction should be contracted first, the result of this contraction is then appended to the end of the contraction list. This list can then be iterated over until all intermediate contractions are complete.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>einsum, linalg.multi_dot</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>We can begin with a chain dot example. In this case, it is optimal to contract the <code>b</code> and <code>c</code> tensors first as represented by the first element of the path <code>(1, 2)</code>. The resulting tensor is added to the end of the contraction and the remaining contraction <code>(0, 1)</code> is then completed.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.random.seed(123) a = np.random.rand(2, 2) b = np.random.rand(2, 5) c = np.random.rand(5, 2) path_info = np.einsum_path(‘ij,jk,kl-&gt;il’, a, b, c, optimize=‘greedy’) print(path_info[0]) [‘einsum_path’, (1, 2), (0, 1)] print(path_info[1])  Complete contraction: ij,jk,kl-&gt;il # may vary  Naive scaling: 4  Optimized scaling: 3  Naive FLOP count: 1.600e+02  Optimized FLOP count: 5.600e+01  Theoretical speedup: 2.857</p>
-      <h2><a href="#largest-intermediate-4-000e-00-elements" name="largest-intermediate-4-000e-00-elements"></a> Largest intermediate: 4.000e+00 elements</h2>
-      <h2><a href="#scaling-current-remaining" name="scaling-current-remaining"></a>scaling current remaining</h2>
-      <p>3 kl,jk-&gt;jl ij,jl-&gt;il  3 jl,ij-&gt;il il-&gt;il</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>A more complex index transformation example.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>I = np.random.rand(10, 10, 10, 10) C = np.random.rand(10, 10) path_info = np.einsum_path(‘ea,fb,abcd,gc,hd-&gt;efgh’, C, C, I, C, C, … optimize=‘greedy’)</p>
-      <p>print(path_info[0]) [‘einsum_path’, (0, 2), (0, 3), (0, 2), (0, 1)] print(path_info[1])  Complete contraction: ea,fb,abcd,gc,hd-&gt;efgh # may vary  Naive scaling: 8  Optimized scaling: 5  Naive FLOP count: 8.000e+08  Optimized FLOP count: 8.000e+05  Theoretical speedup: 1000.000</p>
-      <h2><a href="#largest-intermediate-1-000e-04-elements" name="largest-intermediate-1-000e-04-elements"></a> Largest intermediate: 1.000e+04 elements</h2>
-      <h2><a href="#scaling-current-remaining" name="scaling-current-remaining"></a>scaling current remaining</h2>
-      <p>5 abcd,ea-&gt;bcde fb,gc,hd,bcde-&gt;efgh  5 bcde,fb-&gt;cdef gc,hd,cdef-&gt;efgh  5 cdef,gc-&gt;defg hd,defg-&gt;efgh  5 defg,hd-&gt;efgh efgh-&gt;efgh</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10008">view source</a></div></div><div class="public anchor" id="var-emath"><h3>emath</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Wrapper functions to more user-friendly calling of certain math functions whose output data-type is different than the input data-type in certain domains of the input.</p>
-<p>For example, for functions like <code>log</code> with branch cuts, the versions in this module provide the mathematically valid answers in the complex plane::</p>
-<p>&gt;&gt;&gt; import math  &gt;&gt;&gt; from numpy.lib import scimath  &gt;&gt;&gt; scimath.log(-math.exp(1)) == (1+1j*math.pi)  True</p>
-<p>Similarly, <code>sqrt</code>, other base logarithms, <code>power</code> and trig functions are correctly handled. See their respective docstrings for specific examples.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6791">view source</a></div></div><div class="public anchor" id="var-empty"><h3>empty</h3><div class="usage"><code>(empty self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>empty(shape, dtype=float, order=‘C’)</p>
-<p>Return a new array of given shape and type, without initializing entries.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>shape : int or tuple of int  Shape of the empty array, e.g., <code>(2, 3)</code> or <code>2</code>. dtype : data-type, optional  Desired output data-type for the array, e.g, <code>numpy.int8</code>. Default is  <code>numpy.float64</code>. order : {‘C’, ‘F’}, optional, default: ‘C’  Whether to store multi-dimensional data in row-major  (C-style) or column-major (Fortran-style) order in  memory.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Array of uninitialized (arbitrary) data of the given shape, dtype, and  order. Object arrays will be initialized to None.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>empty_like : Return an empty array with shape and type of input. ones : Return a new array setting values to one. zeros : Return a new array setting values to zero. full : Return a new array of given shape filled with value.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>empty</code>, unlike <code>zeros</code>, does not set the array values to zero, and may therefore be marginally faster. On the other hand, it requires the user to manually set all the values in the array, and should be used with caution.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.empty([2, 2]) array(<a href="null"> -9.74499359e+001,   6.69583040e-309],
-       [  2.13182611e-314,   3.06959433e-309</a>) #uninitialized</p>
-      <p>np.empty([2, 2], dtype=int) array(<a href="null">-1073741821, -1067949133],
-       [  496041986,    19249760</a>) #uninitialized</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18292">view source</a></div></div><div class="public anchor" id="var-empty_like"><h3>empty_like</h3><div class="usage"><code>(empty_like &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>empty_like(prototype, dtype=None, order=‘K’, subok=True, shape=None)</p>
-<p>Return a new array with the same shape and type as a given array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>prototype : array_like  The shape and data-type of <code>prototype</code> define these same attributes  of the returned array. dtype : data-type, optional  Overrides the data type of the result.</p>
-<pre><code>.. versionadded:: 1.6.0
-</code></pre>
-<p>order : {‘C’, ‘F’, ‘A’, or ‘K’}, optional  Overrides the memory layout of the result. ‘C’ means C-order,  ‘F’ means F-order, ‘A’ means ‘F’ if <code>prototype</code> is Fortran  contiguous, ‘C’ otherwise. ‘K’ means match the layout of <code>prototype</code>  as closely as possible.</p>
-<pre><code>.. versionadded:: 1.6.0
-</code></pre>
-<p>subok : bool, optional.  If True, then the newly created array will use the sub-class  type of ‘a’, otherwise it will be a base-class array. Defaults  to True. shape : int or sequence of ints, optional.  Overrides the shape of the result. If order=‘K’ and the number of  dimensions is unchanged, will try to keep order, otherwise,  order=‘C’ is implied.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Array of uninitialized (arbitrary) data with the same  shape and type as <code>prototype</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ones_like : Return an array of ones with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. full_like : Return a new array with shape of input filled with value. empty : Return a new uninitialized array.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This function does <em>not</em> initialize the returned array; to do that use <code>zeros_like</code> or <code>ones_like</code> instead. It may be marginally faster than the functions that do set the array values.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = ([1,2,3], [4,5,6]) # a is array-like np.empty_like(a) array(<a href="null">-1073741821, -1073741821,           3],    # uninitialized
-       [          0,           0, -1073741821</a>) a = np.array(<a href="null">1., 2., 3.],[4.,5.,6.</a>) np.empty_like(a) array(<a href="null"> -2.00000715e+000,   1.48219694e-323,  -2.00000572e+000], # uninitialized
-       [  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17329">view source</a></div></div><div class="public anchor" id="var-equal"><h3>equal</h3><div class="usage"><code>(equal self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>equal(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return (x1 == x2) element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>not_equal, greater_equal, less_equal, greater, less</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.equal([0, 1, 3], np.arange(3)) array([ True, True, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>What is compared are values, not types. So an int (1) and an array of length one can evaluate as True:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.equal(1, np.ones(1)) array([ True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24585">view source</a></div></div><div class="public anchor" id="var-ERR_CALL"><h3>ERR_CALL</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2424">view source</a></div></div><div class="public anchor" id="var-ERR_DEFAULT"><h3>ERR_DEFAULT</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13201">view source</a></div></div><div class="public anchor" id="var-ERR_IGNORE"><h3>ERR_IGNORE</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17197">view source</a></div></div><div class="public anchor" id="var-ERR_LOG"><h3>ERR_LOG</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20435">view source</a></div></div><div class="public anchor" id="var-ERR_PRINT"><h3>ERR_PRINT</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28800">view source</a></div></div><div class="public anchor" id="var-ERR_RAISE"><h3>ERR_RAISE</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8949">view source</a></div></div><div class="public anchor" id="var-ERR_WARN"><h3>ERR_WARN</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14367">view source</a></div></div><div class="public anchor" id="var-errstate"><h3>errstate</h3><div class="usage"><code>(errstate self &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>errstate(**kwargs)</p>
-<p>Context manager for floating-point error handling.</p>
-<p>Using an instance of <code>errstate</code> as a context manager allows statements in that context to execute with a known error handling behavior. Upon entering the context the error handling is set with <code>seterr</code> and <code>seterrcall</code>, and upon exiting it is reset to what it was before.</p>
-<p>.. versionchanged:: 1.17.0  <code>errstate</code> is also usable as a function decorator, saving  a level of indentation if an entire function is wrapped.  See :py:class:<code>contextlib.ContextDecorator</code> for more information.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>kwargs : {divide, over, under, invalid}  Keyword arguments. The valid keywords are the possible floating-point  exceptions. Each keyword should have a string value that defines the  treatment for the particular error. Possible values are  {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>seterr, geterr, seterrcall, geterrcall</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>For complete documentation of the types of floating-point exceptions and treatment options, see <code>seterr</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from collections import OrderedDict olderr = np.seterr(all=‘ignore’) # Set error handling to known state.</p>
-      <p>np.arange(3) / 0. array([nan, inf, inf]) with np.errstate(divide=‘warn’): … np.arange(3) / 0. array([nan, inf, inf])</p>
-      <p>np.sqrt(-1) nan with np.errstate(invalid=‘raise’): … np.sqrt(-1) Traceback (most recent call last):  File “<stdin>”, line 2, in <module> FloatingPointError: invalid value encountered in sqrt</module></stdin></p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Outside the context the error handling behavior has not changed:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>OrderedDict(sorted(np.geterr().items())) OrderedDict([(‘divide’, ‘ignore’), (‘invalid’, ‘ignore’), (‘over’, ‘ignore’), (‘under’, ‘ignore’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10858">view source</a></div></div><div class="public anchor" id="var-euler_gamma"><h3>euler_gamma</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25765">view source</a></div></div><div class="public anchor" id="var-exp"><h3>exp</h3><div class="usage"><code>(exp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>exp(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Calculate the exponential of all elements in the input array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Output array, element-wise exponential of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>expm1 : Calculate <code>exp(x) - 1</code> for all elements in the array. exp2 : Calculate <code>2**x</code> for all elements in the array.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The irrational number <code>e</code> is also known as Euler’s number. It is approximately 2.718281, and is the base of the natural logarithm, <code>ln</code> (this means that, if :math:<code>x = \ln y = \log_e y</code>, then :math:<code>e^x = y</code>. For real input, <code>exp(x)</code> is always positive.</p>
-<p>For complex arguments, <code>x = a + ib</code>, we can write :math:<code>e^x = e^a e^{ib}</code>. The first term, :math:<code>e^a</code>, is already known (it is the real argument, described above). The second term, :math:<code>e^{ib}</code>, is :math:<code>\cos b + i \sin b</code>, a function with magnitude 1 and a periodic phase.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Wikipedia, “Exponential function”,  <a href="https://en.wikipedia.org/wiki/Exponential_function">https://en.wikipedia.org/wiki/Exponential_function</a> .. [2] M. Abramovitz and I. A. Stegun, “Handbook of Mathematical Functions  with Formulas, Graphs, and Mathematical Tables,” Dover, 1964, p. 69,  <a href="http://www.math.sfu.ca/~cbm/aands/page_69.htm">http://www.math.sfu.ca/~cbm/aands/page_69.htm</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Plot the magnitude and phase of <code>exp(x)</code> in the complex plane:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt</p>
-      <p>x = np.linspace(-2*np.pi, 2*np.pi, 100) xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane out = np.exp(xx)</p>
-      <p>plt.subplot(121) plt.imshow(np.abs(out), … extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap=‘gray’) plt.title(‘Magnitude of exp(x)’)</p>
-      <p>plt.subplot(122) plt.imshow(np.angle(out), … extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap=‘hsv’) plt.title(‘Phase (angle) of exp(x)’) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16468">view source</a></div></div><div class="public anchor" id="var-exp2"><h3>exp2</h3><div class="usage"><code>(exp2 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>exp2(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Calculate <code>2**p</code> for all <code>p</code> in the input array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Element-wise 2 to the power <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>power</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.3.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.exp2([2, 3]) array([ 4., 8.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22166">view source</a></div></div><div class="public anchor" id="var-expand_dims"><h3>expand_dims</h3><div class="usage"><code>(expand_dims &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Expand the shape of an array.</p>
-<p>Insert a new axis that will appear at the <code>axis</code> position in the expanded array shape.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. axis : int or tuple of ints  Position in the expanded axes where the new axis (or axes) is placed.</p>
-<pre><code>.. deprecated:: 1.13.0
-    Passing an axis where ``axis &gt; a.ndim`` will be treated as
-    ``axis == a.ndim``, and passing ``axis &lt; -a.ndim - 1`` will
-    be treated as ``axis == 0``. This behavior is deprecated.
-
-.. versionchanged:: 1.18.0
-    A tuple of axes is now supported.  Out of range axes as
-    described above are now forbidden and raise an `AxisError`.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>result : ndarray  View of <code>a</code> with the number of dimensions increased.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>squeeze : The inverse operation, removing singleton dimensions reshape : Insert, remove, and combine dimensions, and resize existing ones doc.indexing, atleast_1d, atleast_2d, atleast_3d</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([1, 2]) x.shape (2,)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The following is equivalent to <code>x[np.newaxis, :]</code> or <code>x[np.newaxis]</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>y = np.expand_dims(x, axis=0) y array(<a href="null">1, 2</a>) y.shape (1, 2)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The following is equivalent to <code>x[:, np.newaxis]</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>y = np.expand_dims(x, axis=1) y array(<a href="null">1],
-       [2</a>) y.shape (2, 1)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p><code>axis</code> may also be a tuple:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>y = np.expand_dims(x, axis=(0, 1)) y array(<a href="null">[1, 2</a>])</p>
-      <p>y = np.expand_dims(x, axis=(2, 0)) y array(<a href="null">[1],
-        [2</a>])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that some examples may use <code>None</code> instead of <code>np.newaxis</code>. These are the same objects:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.newaxis is None True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26991">view source</a></div></div><div class="public anchor" id="var-expm1"><h3>expm1</h3><div class="usage"><code>(expm1 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>expm1(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Calculate <code>exp(x) - 1</code> for all elements in the array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Element-wise exponential minus one: <code>out = exp(x) - 1</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>log1p : <code>log(1 + x)</code>, the inverse of expm1.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This function provides greater precision than <code>exp(x) - 1</code> for small values of <code>x</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>The true value of <code>exp(1e-10) - 1</code> is <code>1.00000000005e-10</code> to about 32 significant digits. This example shows the superiority of expm1 in this case.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.expm1(1e-10) 1.00000000005e-10 np.exp(1e-10) - 1 1.000000082740371e-10</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21080">view source</a></div></div><div class="public anchor" id="var-extract"><h3>extract</h3><div class="usage"><code>(extract &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the elements of an array that satisfy some condition.</p>
-<p>This is equivalent to <code>np.compress(ravel(condition), ravel(arr))</code>. If <code>condition</code> is boolean <code>np.extract</code> is equivalent to <code>arr[condition]</code>.</p>
-<p>Note that <code>place</code> does the exact opposite of <code>extract</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>condition : array_like  An array whose nonzero or True entries indicate the elements of <code>arr</code>  to extract. arr : array_like  Input array of the same size as <code>condition</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>extract : ndarray  Rank 1 array of values from <code>arr</code> where <code>condition</code> is True.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>take, put, copyto, compress, place</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>arr = np.arange(12).reshape((3, 4)) arr array(<a href="null"> 0,  1,  2,  3],
-       [ 4,  5,  6,  7],
-       [ 8,  9, 10, 11</a>) condition = np.mod(arr, 3)==0 condition array(<a href="null"> True, False, False,  True],
-       [False, False,  True, False],
-       [False,  True, False, False</a>) np.extract(condition, arr) array([0, 3, 6, 9])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>If <code>condition</code> is boolean:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>arr[condition] array([0, 3, 6, 9])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15957">view source</a></div></div><div class="public anchor" id="var-eye"><h3>eye</h3><div class="usage"><code>(eye N &amp; [{M :M, k :k, dtype :dtype, order :order}])</code><code>(eye N &amp; [{M :M, k :k, dtype :dtype}])</code><code>(eye N &amp; [{M :M, k :k}])</code><code>(eye N &amp; [{M :M}])</code><code>(eye N)</code></div><div class="doc"><div class="markdown"><p>Return a 2-D array with ones on the diagonal and zeros elsewhere.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>N : int  Number of rows in the output. M : int, optional  Number of columns in the output. If None, defaults to <code>N</code>. k : int, optional  Index of the diagonal: 0 (the default) refers to the main diagonal,  a positive value refers to an upper diagonal, and a negative value  to a lower diagonal. dtype : data-type, optional  Data-type of the returned array. order : {‘C’, ‘F’}, optional  Whether the output should be stored in row-major (C-style) or  column-major (Fortran-style) order in memory.</p>
-<pre><code>.. versionadded:: 1.14.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>I : ndarray of shape (N,M)  An array where all elements are equal to zero, except for the <code>k</code>-th  diagonal, whose values are equal to one.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>identity : (almost) equivalent function diag : diagonal 2-D array from a 1-D array specified by the user.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.eye(2, dtype=int) array(<a href="null">1, 0],
-       [0, 1</a>) np.eye(3, k=1) array(<a href="null">0.,  1.,  0.],
-       [0.,  0.,  1.],
-       [0.,  0.,  0.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16964">view source</a></div></div><div class="public anchor" id="var-fabs"><h3>fabs</h3><div class="usage"><code>(fabs self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fabs(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute the absolute values element-wise.</p>
-<p>This function returns the absolute values (positive magnitude) of the data in <code>x</code>. Complex values are not handled, use <code>absolute</code> to find the absolute values of complex data.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  The array of numbers for which the absolute values are required. If  <code>x</code> is a scalar, the result <code>y</code> will also be a scalar. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  The absolute values of <code>x</code>, the returned values are always floats.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>absolute : Absolute values including <code>complex</code> types.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.fabs(-1) 1.0 np.fabs([-1.2, 1.2]) array([ 1.2, 1.2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14867">view source</a></div></div><div class="public anchor" id="var-fastCopyAndTranspose"><h3>fastCopyAndTranspose</h3><div class="usage"><code>(fastCopyAndTranspose self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>_fastCopyAndTranspose(a)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22354">view source</a></div></div><div class="public anchor" id="var-fft"><h3>fft</h3><div class="usage"></div><div class="doc"><div class="markdown"><h1><a href="#discrete-fourier-transform-mod-" name="discrete-fourier-transform-mod-"></a>Discrete Fourier Transform (:mod:<code>numpy.fft</code>)</h1>
-<p>.. currentmodule:: numpy.fft</p>
-<h2><a href="#standard-ffts" name="standard-ffts"></a>Standard FFTs</h2>
-<p>.. autosummary::  :toctree: generated/</p>
-<p>fft Discrete Fourier transform.  ifft Inverse discrete Fourier transform.  fft2 Discrete Fourier transform in two dimensions.  ifft2 Inverse discrete Fourier transform in two dimensions.  fftn Discrete Fourier transform in N-dimensions.  ifftn Inverse discrete Fourier transform in N dimensions.</p>
-<h2><a href="#real-ffts" name="real-ffts"></a>Real FFTs</h2>
-<p>.. autosummary::  :toctree: generated/</p>
-<p>rfft Real discrete Fourier transform.  irfft Inverse real discrete Fourier transform.  rfft2 Real discrete Fourier transform in two dimensions.  irfft2 Inverse real discrete Fourier transform in two dimensions.  rfftn Real discrete Fourier transform in N dimensions.  irfftn Inverse real discrete Fourier transform in N dimensions.</p>
-<h2><a href="#hermitian-ffts" name="hermitian-ffts"></a>Hermitian FFTs</h2>
-<p>.. autosummary::  :toctree: generated/</p>
-<p>hfft Hermitian discrete Fourier transform.  ihfft Inverse Hermitian discrete Fourier transform.</p>
-<h2><a href="#helper-routines" name="helper-routines"></a>Helper routines</h2>
-<p>.. autosummary::  :toctree: generated/</p>
-<p>fftfreq Discrete Fourier Transform sample frequencies.  rfftfreq DFT sample frequencies (for usage with rfft, irfft).  fftshift Shift zero-frequency component to center of spectrum.  ifftshift Inverse of fftshift.</p>
-<h2><a href="#background-information" name="background-information"></a>Background information</h2>
-<p>Fourier analysis is fundamentally a method for expressing a function as a sum of periodic components, and for recovering the function from those components. When both the function and its Fourier transform are replaced with discretized counterparts, it is called the discrete Fourier transform (DFT). The DFT has become a mainstay of numerical computing in part because of a very fast algorithm for computing it, called the Fast Fourier Transform (FFT), which was known to Gauss (1805) and was brought to light in its current form by Cooley and Tukey [CT]_. Press et al. [NR]_ provide an accessible introduction to Fourier analysis and its applications.</p>
-<p>Because the discrete Fourier transform separates its input into components that contribute at discrete frequencies, it has a great number of applications in digital signal processing, e.g., for filtering, and in this context the discretized input to the transform is customarily referred to as a <em>signal</em>, which exists in the <em>time domain</em>. The output is called a <em>spectrum</em> or <em>transform</em> and exists in the <em>frequency domain</em>.</p>
-<h2><a href="#implementation-details" name="implementation-details"></a>Implementation details</h2>
-<p>There are many ways to define the DFT, varying in the sign of the exponent, normalization, etc. In this implementation, the DFT is defined as</p>
-<p>.. math::  A_k = \sum_{m=0}^{n-1} a_m \exp\left{-2\pi i{mk \over n}\right}  \qquad k = 0,\ldots,n-1.</p>
-<p>The DFT is in general defined for complex inputs and outputs, and a single-frequency component at linear frequency :math:<code>f</code> is represented by a complex exponential :math:<code>a_m = \exp\{2\pi i\,f m\Delta t\}</code>, where :math:<code>\Delta t</code> is the sampling interval.</p>
-<p>The values in the result follow so-called “standard” order: If <code>A =
-fft(a, n)</code>, then <code>A[0]</code> contains the zero-frequency term (the sum of the signal), which is always purely real for real inputs. Then <code>A[1:n/2]</code> contains the positive-frequency terms, and <code>A[n/2+1:]</code> contains the negative-frequency terms, in order of decreasingly negative frequency. For an even number of input points, <code>A[n/2]</code> represents both positive and negative Nyquist frequency, and is also purely real for real input. For an odd number of input points, <code>A[(n-1)/2]</code> contains the largest positive frequency, while <code>A[(n+1)/2]</code> contains the largest negative frequency. The routine <code>np.fft.fftfreq(n)</code> returns an array giving the frequencies of corresponding elements in the output. The routine <code>np.fft.fftshift(A)</code> shifts transforms and their frequencies to put the zero-frequency components in the middle, and <code>np.fft.ifftshift(A)</code> undoes that shift.</p>
-<p>When the input <code>a</code> is a time-domain signal and <code>A = fft(a)</code>, <code>np.abs(A)</code> is its amplitude spectrum and <code>np.abs(A)**2</code> is its power spectrum. The phase spectrum is obtained by <code>np.angle(A)</code>.</p>
-<p>The inverse DFT is defined as</p>
-<p>.. math::  a_m = \frac{1}{n}\sum_{k=0}^{n-1}A_k\exp\left{2\pi i{mk\over n}\right}  \qquad m = 0,\ldots,n-1.</p>
-<p>It differs from the forward transform by the sign of the exponential argument and the default normalization by :math:<code>1/n</code>.</p>
-<h2><a href="#type-promotion" name="type-promotion"></a>Type Promotion</h2>
-<p><code>numpy.fft</code> promotes <code>float32</code> and <code>complex64</code> arrays to <code>float64</code> and <code>complex128</code> arrays respectively. For an FFT implementation that does not promote input arrays, see <code>scipy.fftpack</code>.</p>
-<h2><a href="#normalization" name="normalization"></a>Normalization</h2>
-<p>The default normalization has the direct transforms unscaled and the inverse transforms are scaled by :math:<code>1/n</code>. It is possible to obtain unitary transforms by setting the keyword argument <code>norm</code> to <code>"ortho"</code> (default is <code>None</code>) so that both direct and inverse transforms will be scaled by :math:<code>1/\sqrt{n}</code>.</p>
-<h2><a href="#real-and-hermitian-transforms" name="real-and-hermitian-transforms"></a>Real and Hermitian transforms</h2>
-<p>When the input is purely real, its transform is Hermitian, i.e., the component at frequency :math:<code>f_k</code> is the complex conjugate of the component at frequency :math:<code>-f_k</code>, which means that for real inputs there is no information in the negative frequency components that is not already available from the positive frequency components. The family of <code>rfft</code> functions is designed to operate on real inputs, and exploits this symmetry by computing only the positive frequency components, up to and including the Nyquist frequency. Thus, <code>n</code> input points produce <code>n/2+1</code> complex output points. The inverses of this family assumes the same symmetry of its input, and for an output of <code>n</code> points uses <code>n/2+1</code> input points.</p>
-<p>Correspondingly, when the spectrum is purely real, the signal is Hermitian. The <code>hfft</code> family of functions exploits this symmetry by using <code>n/2+1</code> complex points in the input (time) domain for <code>n</code> real points in the frequency domain.</p>
-<p>In higher dimensions, FFTs are used, e.g., for image analysis and filtering. The computational efficiency of the FFT means that it can also be a faster way to compute large convolutions, using the property that a convolution in the time domain is equivalent to a point-by-point multiplication in the frequency domain.</p>
-<h2><a href="#higher-dimensions" name="higher-dimensions"></a>Higher dimensions</h2>
-<p>In two dimensions, the DFT is defined as</p>
-<p>.. math::  A_{kl} = \sum_{m=0}^{M-1} \sum_{n=0}^{N-1}  a_{mn}\exp\left{-2\pi i \left({mk\over M}+{nl\over N}\right)\right}  \qquad k = 0, \ldots, M-1;\quad l = 0, \ldots, N-1,</p>
-<p>which extends in the obvious way to higher dimensions, and the inverses in higher dimensions also extend in the same way.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [CT] Cooley, James W., and John W. Tukey, 1965, “An algorithm for the  machine calculation of complex Fourier series,” <em>Math. Comput.</em>  19: 297-301.</p>
-<p>.. [NR] Press, W., Teukolsky, S., Vetterline, W.T., and Flannery, B.P.,  2007, <em>Numerical Recipes: The Art of Scientific Computing</em>, ch.  12-13. Cambridge Univ. Press, Cambridge, UK.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>For examples, see the various functions.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25971">view source</a></div></div><div class="public anchor" id="var-fill_diagonal"><h3>fill_diagonal</h3><div class="usage"><code>(fill_diagonal &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Fill the main diagonal of the given array of any dimensionality.</p>
-<p>For an array <code>a</code> with <code>a.ndim &gt;= 2</code>, the diagonal is the list of locations with indices <code>a[i, ..., i]</code> all identical. This function modifies the input array in-place, it does not return a value.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array, at least 2-D.  Array whose diagonal is to be filled, it gets modified in-place.</p>
-<p>val : scalar  Value to be written on the diagonal, its type must be compatible with  that of the array a.</p>
-<p>wrap : bool  For tall matrices in NumPy version up to 1.6.2, the  diagonal “wrapped” after N columns. You can have this behavior  with this option. This affects only tall matrices.</p>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>diag_indices, diag_indices_from</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.4.0</p>
-<p>This functionality can be obtained via <code>diag_indices</code>, but internally this version uses a much faster implementation that never constructs the indices and uses simple slicing.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.zeros((3, 3), int) np.fill_diagonal(a, 5) a array(<a href="null">5, 0, 0],
-       [0, 5, 0],
-       [0, 0, 5</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The same function can operate on a 4-D array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.zeros((3, 3, 3, 3), int) np.fill_diagonal(a, 4)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>We only show a few blocks for clarity:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a[0, 0] array(<a href="null">4, 0, 0],
-       [0, 0, 0],
-       [0, 0, 0</a>) a[1, 1] array(<a href="null">0, 0, 0],
-       [0, 4, 0],
-       [0, 0, 0</a>) a[2, 2] array(<a href="null">0, 0, 0],
-       [0, 0, 0],
-       [0, 0, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The wrap option affects only tall matrices:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <h1><a href="#tall-matrices-no-wrap" name="tall-matrices-no-wrap"></a>tall matrices no wrap</h1>
-      <p>a = np.zeros((5, 3), int) np.fill_diagonal(a, 4) a array(<a href="null">4, 0, 0],
-       [0, 4, 0],
-       [0, 0, 4],
-       [0, 0, 0],
-       [0, 0, 0</a>)</p>
-      <h1><a href="#tall-matrices-wrap" name="tall-matrices-wrap"></a>tall matrices wrap</h1>
-      <p>a = np.zeros((5, 3), int) np.fill_diagonal(a, 4, wrap=True) a array(<a href="null">4, 0, 0],
-       [0, 4, 0],
-       [0, 0, 4],
-       [0, 0, 0],
-       [4, 0, 0</a>)</p>
-      <h1><a href="#wide-matrices" name="wide-matrices"></a>wide matrices</h1>
-      <p>a = np.zeros((3, 5), int) np.fill_diagonal(a, 4, wrap=True) a array(<a href="null">4, 0, 0, 0, 0],
-       [0, 4, 0, 0, 0],
-       [0, 0, 4, 0, 0</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The anti-diagonal can be filled by reversing the order of elements using either <code>numpy.flipud</code> or <code>numpy.fliplr</code>.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.zeros((3, 3), int); np.fill_diagonal(np.fliplr(a), [1,2,3]) # Horizontal flip a array(<a href="null">0, 0, 1],
-       [0, 2, 0],
-       [3, 0, 0</a>) np.fill_diagonal(np.flipud(a), [1,2,3]) # Vertical flip a array(<a href="null">0, 0, 3],
-       [0, 2, 0],
-       [1, 0, 0</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that the order in which the diagonal is filled varies depending on the flip function.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19631">view source</a></div></div><div class="public anchor" id="var-find_common_type"><h3>find_common_type</h3><div class="usage"><code>(find_common_type array_types scalar_types)</code></div><div class="doc"><div class="markdown"><p>Determine common type following standard coercion rules.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>array_types : sequence  A list of dtypes or dtype convertible objects representing arrays. scalar_types : sequence  A list of dtypes or dtype convertible objects representing scalars.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>datatype : dtype  The common data type, which is the maximum of <code>array_types</code> ignoring  <code>scalar_types</code>, unless the maximum of <code>scalar_types</code> is of a  different kind (<code>dtype.kind</code>). If the kind is not understood, then  None is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>dtype, common_type, can_cast, mintypecode</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.find_common_type([], [np.int64, np.float32, complex]) dtype(‘complex128’) np.find_common_type([np.int64, np.float32], []) dtype(‘float64’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The standard casting rules ensure that a scalar cannot up-cast an array unless the scalar is of a fundamentally different kind of data (i.e. under a different hierarchy in the data type hierarchy) then the array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.find_common_type([np.float32], [np.int64, np.float64]) dtype(‘float32’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Complex is of a different type, so it up-casts the float in the <code>array_types</code> argument:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.find_common_type([np.float32], [complex]) dtype(‘complex128’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Type specifier strings are convertible to dtypes and can therefore be used instead of dtypes:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.find_common_type([‘f4’, ‘f4’, ‘i4’], [‘c8’]) dtype(‘complex128’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4018">view source</a></div></div><div class="public anchor" id="var-finfo"><h3>finfo</h3><div class="usage"><code>(finfo self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>finfo(dtype)</p>
-<p>Machine limits for floating point types.</p>
-<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
-<p>bits : int  The number of bits occupied by the type. eps : float  The smallest representable positive number such that  <code>1.0 + eps != 1.0</code>. Type of <code>eps</code> is an appropriate floating  point type. epsneg : floating point number of the appropriate type  The smallest representable positive number such that  <code>1.0 - epsneg != 1.0</code>. iexp : int  The number of bits in the exponent portion of the floating point  representation. machar : MachAr  The object which calculated these parameters and holds more  detailed information. machep : int  The exponent that yields <code>eps</code>. max : floating point number of the appropriate type  The largest representable number. maxexp : int  The smallest positive power of the base (2) that causes overflow. min : floating point number of the appropriate type  The smallest representable number, typically <code>-max</code>. minexp : int  The most negative power of the base (2) consistent with there  being no leading 0’s in the mantissa. negep : int  The exponent that yields <code>epsneg</code>. nexp : int  The number of bits in the exponent including its sign and bias. nmant : int  The number of bits in the mantissa. precision : int  The approximate number of decimal digits to which this kind of  float is precise. resolution : floating point number of the appropriate type  The approximate decimal resolution of this type, i.e.,  <code>10**-precision</code>. tiny : float  The smallest positive usable number. Type of <code>tiny</code> is an  appropriate floating point type.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>dtype : float, dtype, or instance  Kind of floating point data-type about which to get information.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>MachAr : The implementation of the tests that produce this information. iinfo : The equivalent for integer data types.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>For developers of NumPy: do not instantiate this at the module level. The initial calculation of these parameters is expensive and negatively impacts import times. These objects are cached, so calling <code>finfo()</code> repeatedly inside your functions is not a problem.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26164">view source</a></div></div><div class="public anchor" id="var-fix"><h3>fix</h3><div class="usage"><code>(fix &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Round to nearest integer towards zero.</p>
-<p>Round an array of floats element-wise to nearest integer towards zero. The rounded values are returned as floats.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  An array of floats to be rounded y : ndarray, optional  Output array</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray of floats  The array of rounded numbers</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>trunc, floor, ceil around : Round to given number of decimals</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.fix(3.14) 3.0 np.fix(3) 3.0 np.fix([2.1, 2.9, -2.1, -2.9]) array([ 2., 2., -2., -2.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3545">view source</a></div></div><div class="public anchor" id="var-flatiter"><h3>flatiter</h3><div class="usage"><code>(flatiter self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Flat iterator object to iterate over arrays.</p>
-<p>A <code>flatiter</code> iterator is returned by <code>x.flat</code> for any array <code>x</code>. It allows iterating over the array as if it were a 1-D array, either in a for-loop or by calling its <code>next</code> method.</p>
-<p>Iteration is done in row-major, C-style order (the last index varying the fastest). The iterator can also be indexed using basic slicing or advanced indexing.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.flat : Return a flat iterator over an array. ndarray.flatten : Returns a flattened copy of an array.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>A <code>flatiter</code> iterator can not be constructed directly from Python code by calling the <code>flatiter</code> constructor.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(6).reshape(2, 3) fl = x.flat type(fl) &lt;class ‘numpy.flatiter’&gt; for item in fl: … print(item) … 0 1 2 3 4 5</p>
-      <p>fl[2:4] array([2, 3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9493">view source</a></div></div><div class="public anchor" id="var-flatnonzero"><h3>flatnonzero</h3><div class="usage"><code>(flatnonzero &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return indices that are non-zero in the flattened version of a.</p>
-<p>This is equivalent to np.nonzero(np.ravel(a))[0].</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>res : ndarray  Output array, containing the indices of the elements of <code>a.ravel()</code>  that are non-zero.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>nonzero : Return the indices of the non-zero elements of the input array. ravel : Return a 1-D array containing the elements of the input array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(-2, 3) x array([-2, -1, 0, 1, 2]) np.flatnonzero(x) array([0, 1, 3, 4])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Use the indices of the non-zero elements as an index array to extract these elements:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x.ravel()[np.flatnonzero(x)] array([-2, -1, 1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L819">view source</a></div></div><div class="public anchor" id="var-flexible"><h3>flexible</h3><div class="usage"><code>(flexible self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all scalar types without predefined length. The actual size of these types depends on the specific <code>np.dtype</code> instantiation.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L353">view source</a></div></div><div class="public anchor" id="var-flip"><h3>flip</h3><div class="usage"><code>(flip &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Reverse the order of elements in an array along the given axis.</p>
-<p>The shape of the array is preserved, but the elements are reordered.</p>
-<p>.. versionadded:: 1.12.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>m : array_like  Input array. axis : None or int or tuple of ints, optional  Axis or axes along which to flip over. The default,  axis=None, will flip over all of the axes of the input array.  If axis is negative it counts from the last to the first axis.</p>
-<pre><code> If axis is a tuple of ints, flipping is performed on all of the axes
- specified in the tuple.
-
- .. versionchanged:: 1.15.0
-    None and tuples of axes are supported
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : array_like  A view of <code>m</code> with the entries of axis reversed. Since a view is  returned, this operation is done in constant time.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>flipud : Flip an array vertically (axis=0). fliplr : Flip an array horizontally (axis=1).</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>flip(m, 0) is equivalent to flipud(m).</p>
-<p>flip(m, 1) is equivalent to fliplr(m).</p>
-<p>flip(m, n) corresponds to <code>m[...,::-1,...]</code> with <code>::-1</code> at position n.</p>
-<p>flip(m) corresponds to <code>m[::-1,::-1,...,::-1]</code> with <code>::-1</code> at all positions.</p>
-<p>flip(m, (0, 1)) corresponds to <code>m[::-1,::-1,...]</code> with <code>::-1</code> at position 0 and position 1.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>A = np.arange(8).reshape((2,2,2)) A array(<a href="null">[0, 1],
-        [2, 3</a>,  <a href="null">4, 5],
-        [6, 7</a>]) np.flip(A, 0) array(<a href="null">[4, 5],
-        [6, 7</a>,  <a href="null">0, 1],
-        [2, 3</a>]) np.flip(A, 1) array(<a href="null">[2, 3],
-        [0, 1</a>,  <a href="null">6, 7],
-        [4, 5</a>]) np.flip(A) array(<a href="null">[7, 6],
-        [5, 4</a>,  <a href="null">3, 2],
-        [1, 0</a>]) np.flip(A, (0, 2)) array(<a href="null">[5, 4],
-        [7, 6</a>,  <a href="null">1, 0],
-        [3, 2</a>]) A = np.random.randn(3,4,5) np.all(np.flip(A,2) == A[:,:,::-1,…]) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11453">view source</a></div></div><div class="public anchor" id="var-fliplr"><h3>fliplr</h3><div class="usage"><code>(fliplr &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Flip array in the left/right direction.</p>
-<p>Flip the entries in each row in the left/right direction. Columns are preserved, but appear in a different order than before.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>m : array_like  Input array, must be at least 2-D.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>f : ndarray  A view of <code>m</code> with the columns reversed. Since a view  is returned, this operation is :math:<code>\mathcal O(1)</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>flipud : Flip array in the up/down direction. rot90 : Rotate array counterclockwise.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Equivalent to m[:,::-1]. Requires the array to be at least 2-D.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>A = np.diag([1.,2.,3.]) A array(<a href="null">1.,  0.,  0.],
-       [0.,  2.,  0.],
-       [0.,  0.,  3.</a>) np.fliplr(A) array(<a href="null">0.,  0.,  1.],
-       [0.,  2.,  0.],
-       [3.,  0.,  0.</a>)</p>
-      <p>A = np.random.randn(2,3,5) np.all(np.fliplr(A) == A[:,::-1,…]) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27067">view source</a></div></div><div class="public anchor" id="var-flipud"><h3>flipud</h3><div class="usage"><code>(flipud &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Flip array in the up/down direction.</p>
-<p>Flip the entries in each column in the up/down direction. Rows are preserved, but appear in a different order than before.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>m : array_like  Input array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : array_like  A view of <code>m</code> with the rows reversed. Since a view is  returned, this operation is :math:<code>\mathcal O(1)</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>fliplr : Flip array in the left/right direction. rot90 : Rotate array counterclockwise.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Equivalent to <code>m[::-1,...]</code>. Does not require the array to be two-dimensional.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>A = np.diag([1.0, 2, 3]) A array(<a href="null">1.,  0.,  0.],
-       [0.,  2.,  0.],
-       [0.,  0.,  3.</a>) np.flipud(A) array(<a href="null">0.,  0.,  3.],
-       [0.,  2.,  0.],
-       [1.,  0.,  0.</a>)</p>
-      <p>A = np.random.randn(2,3,5) np.all(np.flipud(A) == A[::-1,…]) True</p>
-      <p>np.flipud([1,2]) array([2, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14719">view source</a></div></div><div class="public anchor" id="var-float"><h3>float</h3><div class="usage"><code>(float self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Convert a string or number to a floating point number, if possible.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L79">view source</a></div></div><div class="public anchor" id="var-float128"><h3>float128</h3><div class="usage"><code>(float128 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Extended-precision floating-point number type, compatible with C <code>long double</code> but not necessarily with IEEE 754 quadruple-precision. Character code: <code>'g'</code>. Canonical name: <code>np.longdouble</code>. Alias: <code>np.longfloat</code>. Alias <em>on this platform</em>: <code>np.float128</code>: 128-bit extended-precision floating-point number type.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12586">view source</a></div></div><div class="public anchor" id="var-float16"><h3>float16</h3><div class="usage"><code>(float16 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Half-precision floating-point number type. Character code: <code>'e'</code>. Canonical name: <code>np.half</code>. Alias <em>on this platform</em>: <code>np.float16</code>: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15803">view source</a></div></div><div class="public anchor" id="var-float32"><h3>float32</h3><div class="usage"><code>(float32 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Single-precision floating-point number type, compatible with C <code>float</code>. Character code: <code>'f'</code>. Canonical name: <code>np.single</code>. Alias <em>on this platform</em>: <code>np.float32</code>: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3790">view source</a></div></div><div class="public anchor" id="var-float64"><h3>float64</h3><div class="usage"><code>(float64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Double-precision floating-point number type, compatible with Python <code>float</code> and C <code>double</code>. Character code: <code>'d'</code>. Canonical name: <code>np.double</code>. Alias: <code>np.float_</code>. Alias <em>on this platform</em>: <code>np.float64</code>: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5102">view source</a></div></div><div class="public anchor" id="var-float_"><h3>float_</h3><div class="usage"><code>(float_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Double-precision floating-point number type, compatible with Python <code>float</code> and C <code>double</code>. Character code: <code>'d'</code>. Canonical name: <code>np.double</code>. Alias: <code>np.float_</code>. Alias <em>on this platform</em>: <code>np.float64</code>: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2536">view source</a></div></div><div class="public anchor" id="var-float_power"><h3>float_power</h3><div class="usage"><code>(float_power self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>float_power(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>First array elements raised to powers from second array, element-wise.</p>
-<p>Raise each base in <code>x1</code> to the positionally-corresponding power in <code>x2</code>. <code>x1</code> and <code>x2</code> must be broadcastable to the same shape. This differs from the power function in that integers, float16, and float32 are promoted to floats with a minimum precision of float64 so that the result is always inexact. The intent is that the function will return a usable result for negative powers and seldom overflow for positive powers.</p>
-<p>.. versionadded:: 1.12.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  The bases. x2 : array_like  The exponents. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The bases in <code>x1</code> raised to the exponents in <code>x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>power : power function that preserves type</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Cube each element in a list.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x1 = range(6) x1 [0, 1, 2, 3, 4, 5] np.float_power(x1, 3) array([ 0., 1., 8., 27., 64., 125.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Raise the bases to different exponents.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] np.float_power(x1, x2) array([ 0., 1., 8., 27., 16., 5.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The effect of broadcasting.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x2 = np.array(<a href="null">1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1</a>) x2 array(<a href="null">1, 2, 3, 3, 2, 1],
-       [1, 2, 3, 3, 2, 1</a>) np.float_power(x1, x2) array(<a href="null">  0.,   1.,   8.,  27.,  16.,   5.],
-       [  0.,   1.,   8.,  27.,  16.,   5.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23815">view source</a></div></div><div class="public anchor" id="var-floating"><h3>floating</h3><div class="usage"><code>(floating self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all floating-point scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13587">view source</a></div></div><div class="public anchor" id="var-FLOATING_POINT_SUPPORT"><h3>FLOATING_POINT_SUPPORT</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6422">view source</a></div></div><div class="public anchor" id="var-floor"><h3>floor</h3><div class="usage"><code>(floor self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>floor(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the floor of the input, element-wise.</p>
-<p>The floor of the scalar <code>x</code> is the largest integer <code>i</code>, such that <code>i &lt;= x</code>. It is often denoted as :math:<code>\lfloor x \rfloor</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input data. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  The floor of each element in <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ceil, trunc, rint</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Some spreadsheet programs calculate the “floor-towards-zero”, in other words <code>floor(-2.5) == -2</code>. NumPy instead uses the definition of <code>floor</code> where <code>floor(-2.5) == -3</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.floor(a) array([-2., -2., -1., 0., 1., 1., 2.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L386">view source</a></div></div><div class="public anchor" id="var-floor_divide"><h3>floor_divide</h3><div class="usage"><code>(floor_divide self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>floor_divide(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the largest integer smaller or equal to the division of the inputs. It is equivalent to the Python <code>//</code> operator and pairs with the Python <code>%</code> (<code>remainder</code>), function so that <code>a = a % b + b * (a // b)</code> up to roundoff.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  Numerator. x2 : array_like  Denominator. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  y = floor(<code>x1</code>/<code>x2</code>)  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>remainder : Remainder complementary to floor_divide. divmod : Simultaneous floor division and remainder. divide : Standard division. floor : Round a number to the nearest integer toward minus infinity. ceil : Round a number to the nearest integer toward infinity.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.floor_divide(7,3) 2 np.floor_divide([1., 2., 3., 4.], 2.5) array([ 0., 0., 1., 1.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2226">view source</a></div></div><div class="public anchor" id="var-fmax"><h3>fmax</h3><div class="usage"><code>(fmax self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fmax(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Element-wise maximum of array elements.</p>
-<p>Compare two arrays and returns a new array containing the element-wise maxima. If one of the elements being compared is a NaN, then the non-nan element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are ignored when possible.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  The arrays holding the elements to be compared. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  The maximum of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>fmin :  Element-wise minimum of two arrays, ignores NaNs. maximum :  Element-wise maximum of two arrays, propagates NaNs. amax :  The maximum value of an array along a given axis, propagates NaNs. nanmax :  The maximum value of an array along a given axis, ignores NaNs.</p>
-<p>minimum, amin, nanmin</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.3.0</p>
-<p>The fmax is equivalent to <code>np.where(x1 &gt;= x2, x1, x2)</code> when neither x1 nor x2 are NaNs, but it is faster and does proper broadcasting.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.fmax([2, 3, 4], [1, 5, 2]) array([ 2., 5., 4.])</p>
-      <p>np.fmax(np.eye(2), [0.5, 2]) array(<a href="null"> 1. ,  2. ],
-       [ 0.5,  2. </a>)</p>
-      <p>np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan]) array([ 0., 0., nan])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17634">view source</a></div></div><div class="public anchor" id="var-fmin"><h3>fmin</h3><div class="usage"><code>(fmin self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fmin(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Element-wise minimum of array elements.</p>
-<p>Compare two arrays and returns a new array containing the element-wise minima. If one of the elements being compared is a NaN, then the non-nan element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are ignored when possible.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  The arrays holding the elements to be compared. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  The minimum of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>fmax :  Element-wise maximum of two arrays, ignores NaNs. minimum :  Element-wise minimum of two arrays, propagates NaNs. amin :  The minimum value of an array along a given axis, propagates NaNs. nanmin :  The minimum value of an array along a given axis, ignores NaNs.</p>
-<p>maximum, amax, nanmax</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.3.0</p>
-<p>The fmin is equivalent to <code>np.where(x1 &lt;= x2, x1, x2)</code> when neither x1 nor x2 are NaNs, but it is faster and does proper broadcasting.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.fmin([2, 3, 4], [1, 5, 2]) array([1, 3, 2])</p>
-      <p>np.fmin(np.eye(2), [0.5, 2]) array(<a href="null"> 0.5,  0. ],
-       [ 0. ,  1. </a>)</p>
-      <p>np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan]) array([ 0., 0., nan])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15282">view source</a></div></div><div class="public anchor" id="var-fmod"><h3>fmod</h3><div class="usage"><code>(fmod self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fmod(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the element-wise remainder of division.</p>
-<p>This is the NumPy implementation of the C library function fmod, the remainder has the same sign as the dividend <code>x1</code>. It is equivalent to the Matlab(TM) <code>rem</code> function and should not be confused with the Python modulus operator <code>x1 % x2</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  Dividend. x2 : array_like  Divisor. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : array_like  The remainder of the division of <code>x1</code> by <code>x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>remainder : Equivalent to the Python <code>%</code> operator. divide</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The result of the modulo operation for negative dividend and divisors is bound by conventions. For <code>fmod</code>, the sign of result is the sign of the dividend, while for <code>remainder</code> the sign of the result is the sign of the divisor. The <code>fmod</code> function is equivalent to the Matlab(TM) <code>rem</code> function.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.fmod([-3, -2, -1, 1, 2, 3], 2) array([-1, 0, -1, 1, 0, 1]) np.remainder([-3, -2, -1, 1, 2, 3], 2) array([1, 0, 1, 1, 0, 1])</p>
-      <p>np.fmod([5, 3], [2, 2.]) array([ 1., 1.]) a = np.arange(-3, 3).reshape(3, 2) a array(<a href="null">-3, -2],
-       [-1,  0],
-       [ 1,  2</a>) np.fmod(a, [2,2]) array(<a href="null">-1,  0],
-       [-1,  0],
-       [ 1,  0</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12072">view source</a></div></div><div class="public anchor" id="var-format_float_positional"><h3>format_float_positional</h3><div class="usage"><code>(format_float_positional x &amp; [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign, pad_left :pad_left, pad_right :pad_right}])</code><code>(format_float_positional x &amp; [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign, pad_left :pad_left}])</code><code>(format_float_positional x &amp; [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign}])</code><code>(format_float_positional x &amp; [{precision :precision, unique :unique, fractional :fractional, trim :trim}])</code><code>(format_float_positional x &amp; [{precision :precision, unique :unique, fractional :fractional}])</code><code>(format_float_positional x &amp; [{precision :precision, unique :unique}])</code><code>(format_float_positional x &amp; [{precision :precision}])</code><code>(format_float_positional x)</code></div><div class="doc"><div class="markdown"><p>Format a floating-point scalar as a decimal string in positional notation.</p>
-<p>Provides control over rounding, trimming and padding. Uses and assumes IEEE unbiased rounding. Uses the “Dragon4” algorithm.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : python float or numpy floating scalar  Value to format. precision : non-negative integer or None, optional  Maximum number of digits to print. May be None if <code>unique</code> is  <code>True</code>, but must be an integer if unique is <code>False</code>. unique : boolean, optional  If <code>True</code>, use a digit-generation strategy which gives the shortest  representation which uniquely identifies the floating-point number from  other values of the same type, by judicious rounding. If <code>precision</code>  was omitted, print out all necessary digits, otherwise digit generation  is cut off after <code>precision</code> digits and the remaining value is rounded.  If <code>False</code>, digits are generated as if printing an infinite-precision  value and stopping after <code>precision</code> digits, rounding the remaining  value. fractional : boolean, optional  If <code>True</code>, the cutoff of <code>precision</code> digits refers to the total number  of digits after the decimal point, including leading zeros.  If <code>False</code>, <code>precision</code> refers to the total number of significant  digits, before or after the decimal point, ignoring leading zeros. trim : one of ‘k’, ‘.’, ‘0’, ‘-’, optional  Controls post-processing trimming of trailing digits, as follows:</p>
-<pre><code>* 'k' : keep trailing zeros, keep decimal point (no trimming)
-* '.' : trim all trailing zeros, leave decimal point
-* '0' : trim all but the zero before the decimal point. Insert the
-  zero if it is missing.
-* '-' : trim trailing zeros and any trailing decimal point
-</code></pre>
-<p>sign : boolean, optional  Whether to show the sign for positive values. pad_left : non-negative integer, optional  Pad the left side of the string with whitespace until at least that  many characters are to the left of the decimal point. pad_right : non-negative integer, optional  Pad the right side of the string with whitespace until at least that  many characters are to the right of the decimal point.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>rep : string  The string representation of the floating point value</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>format_float_scientific</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.format_float_positional(np.float32(np.pi)) ‘3.1415927’ np.format_float_positional(np.float16(np.pi)) ‘3.14’ np.format_float_positional(np.float16(0.3)) ‘0.3’ np.format_float_positional(np.float16(0.3), unique=False, precision=10) ‘0.3000488281’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15352">view source</a></div></div><div class="public anchor" id="var-format_float_scientific"><h3>format_float_scientific</h3><div class="usage"><code>(format_float_scientific x &amp; [{precision :precision, unique :unique, trim :trim, sign :sign, pad_left :pad_left, exp_digits :exp_digits}])</code><code>(format_float_scientific x &amp; [{precision :precision, unique :unique, trim :trim, sign :sign, pad_left :pad_left}])</code><code>(format_float_scientific x &amp; [{precision :precision, unique :unique, trim :trim, sign :sign}])</code><code>(format_float_scientific x &amp; [{precision :precision, unique :unique, trim :trim}])</code><code>(format_float_scientific x &amp; [{precision :precision, unique :unique}])</code><code>(format_float_scientific x &amp; [{precision :precision}])</code><code>(format_float_scientific x)</code></div><div class="doc"><div class="markdown"><p>Format a floating-point scalar as a decimal string in scientific notation.</p>
-<p>Provides control over rounding, trimming and padding. Uses and assumes IEEE unbiased rounding. Uses the “Dragon4” algorithm.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : python float or numpy floating scalar  Value to format. precision : non-negative integer or None, optional  Maximum number of digits to print. May be None if <code>unique</code> is  <code>True</code>, but must be an integer if unique is <code>False</code>. unique : boolean, optional  If <code>True</code>, use a digit-generation strategy which gives the shortest  representation which uniquely identifies the floating-point number from  other values of the same type, by judicious rounding. If <code>precision</code>  was omitted, print all necessary digits, otherwise digit generation is  cut off after <code>precision</code> digits and the remaining value is rounded.  If <code>False</code>, digits are generated as if printing an infinite-precision  value and stopping after <code>precision</code> digits, rounding the remaining  value. trim : one of ‘k’, ‘.’, ‘0’, ‘-’, optional  Controls post-processing trimming of trailing digits, as follows:</p>
-<pre><code>* 'k' : keep trailing zeros, keep decimal point (no trimming)
-* '.' : trim all trailing zeros, leave decimal point
-* '0' : trim all but the zero before the decimal point. Insert the
-  zero if it is missing.
-* '-' : trim trailing zeros and any trailing decimal point
-</code></pre>
-<p>sign : boolean, optional  Whether to show the sign for positive values. pad_left : non-negative integer, optional  Pad the left side of the string with whitespace until at least that  many characters are to the left of the decimal point. exp_digits : non-negative integer, optional  Pad the exponent with zeros until it contains at least this many digits.  If omitted, the exponent will be at least 2 digits.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>rep : string  The string representation of the floating point value</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>format_float_positional</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.format_float_scientific(np.float32(np.pi)) ‘3.1415927e+00’ s = np.float32(1.23e24) np.format_float_scientific(s, unique=False, precision=15) ‘1.230000071797338e+24’ np.format_float_scientific(s, exp_digits=4) ‘1.23e+0024’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18943">view source</a></div></div><div class="public anchor" id="var-format_parser"><h3>format_parser</h3><div class="usage"><code>(format_parser self formats names titles &amp; [{aligned :aligned, byteorder :byteorder}])</code><code>(format_parser self formats names titles &amp; [{aligned :aligned}])</code><code>(format_parser self formats names titles)</code></div><div class="doc"><div class="markdown"><p>Class to convert formats, names, titles description to a dtype.</p>
-<p>After constructing the format_parser object, the dtype attribute is the converted data-type: <code>dtype = format_parser(formats, names, titles).dtype</code></p>
-<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
-<p>dtype : dtype  The converted data-type.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>formats : str or list of str  The format description, either specified as a string with  comma-separated format descriptions in the form <code>'f8, i4, a5'</code>, or  a list of format description strings in the form  <code>['f8', 'i4', 'a5']</code>. names : str or list/tuple of str  The field names, either specified as a comma-separated string in the  form <code>'col1, col2, col3'</code>, or as a list or tuple of strings in the  form <code>['col1', 'col2', 'col3']</code>.  An empty list can be used, in that case default field names  (‘f0’, ‘f1’, …) are used. titles : sequence  Sequence of title strings. An empty list can be used to leave titles  out. aligned : bool, optional  If True, align the fields by padding as the C-compiler would.  Default is False. byteorder : str, optional  If specified, all the fields will be changed to the  provided byte-order. Otherwise, the default byte-order is  used. For all available string specifiers, see <code>dtype.newbyteorder</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>dtype, typename, sctype2char</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.format_parser([‘&lt;f8’, ‘&lt;i4’, ‘&lt;a5’], [‘col1’, ‘col2’, ‘col3’], … [‘T1’, ‘T2’, ‘T3’]).dtype dtype([((‘T1’, ‘col1’), ‘&lt;f8’), ((‘T2’, ‘col2’), ‘&lt;i4’), ((‘T3’, ‘col3’), ‘S5’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p><code>names</code> and/or <code>titles</code> can be empty lists. If <code>titles</code> is an empty list, titles will simply not appear. If <code>names</code> is empty, default field names will be used.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.format_parser([‘f8’, ‘i4’, ‘a5’], [‘col1’, ‘col2’, ‘col3’], … []).dtype dtype([(‘col1’, ‘&lt;f8’), (‘col2’, ‘&lt;i4’), (‘col3’, ‘&lt;S5’)]) np.format_parser([‘&lt;f8’, ‘&lt;i4’, ‘&lt;a5’], [], []).dtype dtype([(‘f0’, ‘&lt;f8’), (‘f1’, ‘&lt;i4’), (‘f2’, ‘S5’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3678">view source</a></div></div><div class="public anchor" id="var-FPE_DIVIDEBYZERO"><h3>FPE_DIVIDEBYZERO</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10118">view source</a></div></div><div class="public anchor" id="var-FPE_INVALID"><h3>FPE_INVALID</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23619">view source</a></div></div><div class="public anchor" id="var-FPE_OVERFLOW"><h3>FPE_OVERFLOW</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16804">view source</a></div></div><div class="public anchor" id="var-FPE_UNDERFLOW"><h3>FPE_UNDERFLOW</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28964">view source</a></div></div><div class="public anchor" id="var-frexp"><h3>frexp</h3><div class="usage"><code>(frexp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Decompose the elements of x into mantissa and twos exponent.</p>
-<p>Returns (<code>mantissa</code>, <code>exponent</code>), where `x = mantissa * 2**exponent``. The mantissa is lies in the open interval(-1, 1), while the twos exponent is a signed integer.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Array of numbers to be decomposed. out1 : ndarray, optional  Output array for the mantissa. Must have the same shape as <code>x</code>. out2 : ndarray, optional  Output array for the exponent. Must have the same shape as <code>x</code>. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>mantissa : ndarray  Floating values between -1 and 1.  This is a scalar if <code>x</code> is a scalar. exponent : ndarray  Integer exponents of 2.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ldexp : Compute <code>y = x1 * 2**x2</code>, the inverse of <code>frexp</code>.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Complex dtypes are not supported, they will raise a TypeError.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(9) y1, y2 = np.frexp(x) y1 array([ 0. , 0.5 , 0.5 , 0.75 , 0.5 , 0.625, 0.75 , 0.875,  0.5 ]) y2 array([0, 1, 2, 2, 3, 3, 3, 3, 4]) y1 * 2**y2 array([ 0., 1., 2., 3., 4., 5., 6., 7., 8.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6573">view source</a></div></div><div class="public anchor" id="var-frombuffer"><h3>frombuffer</h3><div class="usage"><code>(frombuffer self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>frombuffer(buffer, dtype=float, count=-1, offset=0)</p>
-<p>Interpret a buffer as a 1-dimensional array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>buffer : buffer_like  An object that exposes the buffer interface. dtype : data-type, optional  Data-type of the returned array; default: float. count : int, optional  Number of items to read. <code>-1</code> means all data in the buffer. offset : int, optional  Start reading the buffer from this offset (in bytes); default: 0.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If the buffer has data that is not in machine byte-order, this should be specified as part of the data-type, e.g.::</p>
-<p>&gt;&gt;&gt; dt = np.dtype(int)  &gt;&gt;&gt; dt = dt.newbyteorder(‘&gt;’)  &gt;&gt;&gt; np.frombuffer(buf, dtype=dt) # doctest: +SKIP</p>
-<p>The data of the resulting array will not be byteswapped, but will be interpreted correctly.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>s = b’hello world’ np.frombuffer(s, dtype=‘S1’, count=5, offset=6) array([b’w’, b’o’, b’r’, b’l’, b’d’], dtype=‘|S1’)</p>
-      <p>np.frombuffer(b’\x01\x02‘, dtype=np.uint8) array([1, 2], dtype=uint8) np.frombuffer(b’\x01\x02\x03\x04\x05’, dtype=np.uint8, count=3) array([1, 2, 3], dtype=uint8)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9454">view source</a></div></div><div class="public anchor" id="var-fromfile"><h3>fromfile</h3><div class="usage"><code>(fromfile self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fromfile(file, dtype=float, count=-1, sep=’’, offset=0)</p>
-<p>Construct an array from data in a text or binary file.</p>
-<p>A highly efficient way of reading binary data with a known data-type, as well as parsing simply formatted text files. Data written using the <code>tofile</code> method can be read using this function.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>file : file or str or Path  Open file object or filename.</p>
-<pre><code>.. versionchanged:: 1.17.0
-    `pathlib.Path` objects are now accepted.
-</code></pre>
-<p>dtype : data-type  Data type of the returned array.  For binary files, it is used to determine the size and byte-order  of the items in the file.  Most builtin numeric types are supported and extension types may be supported.</p>
-<pre><code>.. versionadded:: 1.18.0
-    Complex dtypes.
-</code></pre>
-<p>count : int  Number of items to read. <code>-1</code> means all items (i.e., the complete  file). sep : str  Separator between items if file is a text file.  Empty ("“) separator means the file should be treated as binary.  Spaces (” ") in the separator match zero or more whitespace characters.  A separator consisting only of spaces must match at least one  whitespace. offset : int  The offset (in bytes) from the file’s current position. Defaults to 0.  Only permitted for binary files.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>load, save ndarray.tofile loadtxt : More flexible way of loading data from a text file.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Do not rely on the combination of <code>tofile</code> and <code>fromfile</code> for data storage, as the binary files generated are not platform independent. In particular, no byte-order or data-type information is saved. Data can be stored in the platform independent <code>.npy</code> format using <code>save</code> and <code>load</code> instead.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Construct an ndarray:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>dt = np.dtype([(‘time’, [(‘min’, np.int64), (‘sec’, np.int64)]), … (‘temp’, float)]) x = np.zeros((1,), dtype=dt) x[‘time’][‘min’] = 10; x[‘temp’] = 98.25 x array([((10, 0), 98.25)],  dtype=[(‘time’, [(‘min’, ‘&lt;i8’), (‘sec’, ‘&lt;i8’)]), (‘temp’, ‘&lt;f8’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Save the raw data to disk:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import tempfile fname = tempfile.mkstemp()[1] x.tofile(fname)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Read the raw data from disk:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.fromfile(fname, dtype=dt) array([((10, 0), 98.25)],  dtype=[(‘time’, [(‘min’, ‘&lt;i8’), (‘sec’, ‘&lt;i8’)]), (‘temp’, ‘&lt;f8’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The recommended way to store and load data:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.save(fname, x) np.load(fname + ‘.npy’) array([((10, 0), 98.25)],  dtype=[(‘time’, [(‘min’, ‘&lt;i8’), (‘sec’, ‘&lt;i8’)]), (‘temp’, ‘&lt;f8’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5925">view source</a></div></div><div class="public anchor" id="var-fromfunction"><h3>fromfunction</h3><div class="usage"><code>(fromfunction function shape &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Construct an array by executing a function over each coordinate.</p>
-<p>The resulting array therefore has a value <code>fn(x, y, z)</code> at coordinate <code>(x, y, z)</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>function : callable  The function is called with N parameters, where N is the rank of  <code>shape</code>. Each parameter represents the coordinates of the array  varying along a specific axis. For example, if <code>shape</code>  were <code>(2, 2)</code>, then the parameters would be  <code>array([[0, 0], [1, 1]])</code> and <code>array([[0, 1], [0, 1]])</code> shape : (N,) tuple of ints  Shape of the output array, which also determines the shape of  the coordinate arrays passed to <code>function</code>. dtype : data-type, optional  Data-type of the coordinate arrays passed to <code>function</code>.  By default, <code>dtype</code> is float.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>fromfunction : any  The result of the call to <code>function</code> is passed back directly.  Therefore the shape of <code>fromfunction</code> is completely determined by  <code>function</code>. If <code>function</code> returns a scalar value, the shape of  <code>fromfunction</code> would not match the <code>shape</code> parameter.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>indices, meshgrid</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Keywords other than <code>dtype</code> are passed to <code>function</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int) array(<a href="null"> True, False, False],
-       [False,  True, False],
-       [False, False,  True</a>)</p>
-      <p>np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int) array(<a href="null">0, 1, 2],
-       [1, 2, 3],
-       [2, 3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13036">view source</a></div></div><div class="public anchor" id="var-fromiter"><h3>fromiter</h3><div class="usage"><code>(fromiter self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fromiter(iterable, dtype, count=-1)</p>
-<p>Create a new 1-dimensional array from an iterable object.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>iterable : iterable object  An iterable object providing data for the array. dtype : data-type  The data-type of the returned array. count : int, optional  The number of items to read from <em>iterable</em>. The default is -1,  which means all data is read.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  The output array.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Specify <code>count</code> to improve performance. It allows <code>fromiter</code> to pre-allocate the output array, instead of resizing it on demand.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>iterable = (x*x for x in range(5)) np.fromiter(iterable, float) array([ 0., 1., 4., 9., 16.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15876">view source</a></div></div><div class="public anchor" id="var-frompyfunc"><h3>frompyfunc</h3><div class="usage"><code>(frompyfunc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>frompyfunc(func, nin, nout)</p>
-<p>Takes an arbitrary Python function and returns a NumPy ufunc.</p>
-<p>Can be used, for example, to add broadcasting to a built-in Python function (see Examples section).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>func : Python function object  An arbitrary Python function. nin : int  The number of input arguments. nout : int  The number of objects returned by <code>func</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ufunc  Returns a NumPy universal function (<code>ufunc</code>) object.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>vectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The returned ufunc always returns PyObject arrays.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Use frompyfunc to add broadcasting to the Python function <code>oct</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>oct_array = np.frompyfunc(oct, 1, 1) oct_array(np.array((10, 30, 100))) array([‘0o12’, ‘0o36’, ‘0o144’], dtype=object) np.array((oct(10), oct(30), oct(100))) # for comparison array([‘0o12’, ‘0o36’, ‘0o144’], dtype=‘&lt;U5’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26940">view source</a></div></div><div class="public anchor" id="var-fromregex"><h3>fromregex</h3><div class="usage"><code>(fromregex file regexp dtype &amp; [{encoding :encoding}])</code><code>(fromregex file regexp dtype)</code></div><div class="doc"><div class="markdown"><p>Construct an array from a text file, using regular expression parsing.</p>
-<p>The returned array is always a structured array, and is constructed from all matches of the regular expression in the file. Groups in the regular expression are converted to fields of the structured array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>file : str or file  Filename or file object to read. regexp : str or regexp  Regular expression used to parse the file.  Groups in the regular expression correspond to fields in the dtype. dtype : dtype or list of dtypes  Dtype for the structured array. encoding : str, optional  Encoding used to decode the inputfile. Does not apply to input streams.</p>
-<pre><code>.. versionadded:: 1.14.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>output : ndarray  The output array, containing the part of the content of <code>file</code> that  was matched by <code>regexp</code>. <code>output</code> is always a structured array.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>TypeError  When <code>dtype</code> is not a valid dtype for a structured array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>fromstring, loadtxt</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Dtypes for structured arrays can be specified in several forms, but all forms specify at least the data type and field name. For details see <code>doc.structured_arrays</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>f = open(‘test.dat’, ‘w’) _ = f.write(“1312 foo\n1534 bar\n444 qux”) f.close()</p>
-      <p>regexp = r“(\d+)\s+(…)” # match [digits, whitespace, anything] output = np.fromregex(‘test.dat’, regexp, … [(‘num’, np.int64), (‘key’, ‘S3’)]) output array([(1312, b’foo’), (1534, b’bar’), ( 444, b’qux’)],  dtype=[(‘num’, ‘&lt;i8’), (‘key’, ‘S3’)]) output[‘num’] array([1312, 1534, 444])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6362">view source</a></div></div><div class="public anchor" id="var-fromstring"><h3>fromstring</h3><div class="usage"><code>(fromstring self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>fromstring(string, dtype=float, count=-1, sep=’’)</p>
-<p>A new 1-D array initialized from text data in a string.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>string : str  A string containing the data. dtype : data-type, optional  The data type of the array; default: float. For binary input data,  the data must be in exactly this format. Most builtin numeric types are  supported and extension types may be supported.</p>
-<pre><code>.. versionadded:: 1.18.0
-    Complex dtypes.
-</code></pre>
-<p>count : int, optional  Read this number of <code>dtype</code> elements from the data. If this is  negative (the default), the count will be determined from the  length of the data. sep : str, optional  The string separating numbers in the data; extra whitespace between  elements is also ignored.</p>
-<pre><code>.. deprecated:: 1.14
-    Passing ``sep=''``, the default, is deprecated since it will
-    trigger the deprecated binary mode of this function. This mode
-    interprets `string` as binary bytes, rather than ASCII text with
-    decimal numbers, an operation which is better spelt
-    ``frombuffer(string, dtype, count)``. If `string` contains unicode
-    text, the binary mode of `fromstring` will first encode it into
-    bytes using either utf-8 (python 3) or the default encoding
-    (python 2), neither of which produce sane results.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>arr : ndarray  The constructed array.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If the string is not the correct size to satisfy the requested  <code>dtype</code> and <code>count</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>frombuffer, fromfile, fromiter</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.fromstring(‘1 2’, dtype=int, sep=‘ ’) array([1, 2]) np.fromstring(‘1, 2’, dtype=int, sep=‘,’) array([1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13669">view source</a></div></div><div class="public anchor" id="var-full"><h3>full</h3><div class="usage"><code>(full shape fill_value &amp; [{dtype :dtype, order :order}])</code><code>(full shape fill_value &amp; [{dtype :dtype}])</code><code>(full shape fill_value)</code></div><div class="doc"><div class="markdown"><p>Return a new array of given shape and type, filled with <code>fill_value</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>shape : int or sequence of ints  Shape of the new array, e.g., <code>(2, 3)</code> or <code>2</code>. fill_value : scalar  Fill value. dtype : data-type, optional  The desired data-type for the array The default, None, means  <code>np.array(fill_value).dtype</code>. order : {‘C’, ‘F’}, optional  Whether to store multidimensional data in C- or Fortran-contiguous  (row- or column-wise) order in memory.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Array of <code>fill_value</code> with the given shape, dtype, and order.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>full_like : Return a new array with shape of input filled with value. empty : Return a new uninitialized array. ones : Return a new array setting values to one. zeros : Return a new array setting values to zero.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.full((2, 2), np.inf) array(<a href="null">inf, inf],
-       [inf, inf</a>) np.full((2, 2), 10) array(<a href="null">10, 10],
-       [10, 10</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15917">view source</a></div></div><div class="public anchor" id="var-full_like"><h3>full_like</h3><div class="usage"><code>(full_like &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a full array with the same shape and type as a given array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  The shape and data-type of <code>a</code> define these same attributes of  the returned array. fill_value : scalar  Fill value. dtype : data-type, optional  Overrides the data type of the result. order : {‘C’, ‘F’, ‘A’, or ‘K’}, optional  Overrides the memory layout of the result. ‘C’ means C-order,  ‘F’ means F-order, ‘A’ means ‘F’ if <code>a</code> is Fortran contiguous,  ‘C’ otherwise. ‘K’ means match the layout of <code>a</code> as closely  as possible. subok : bool, optional.  If True, then the newly created array will use the sub-class  type of ‘a’, otherwise it will be a base-class array. Defaults  to True. shape : int or sequence of ints, optional.  Overrides the shape of the result. If order=‘K’ and the number of  dimensions is unchanged, will try to keep order, otherwise,  order=‘C’ is implied.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Array of <code>fill_value</code> with the same shape and type as <code>a</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>empty_like : Return an empty array with shape and type of input. ones_like : Return an array of ones with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. full : Return a new array of given shape filled with value.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(6, dtype=int) np.full_like(x, 1) array([1, 1, 1, 1, 1, 1]) np.full_like(x, 0.1) array([0, 0, 0, 0, 0, 0]) np.full_like(x, 0.1, dtype=np.double) array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1]) np.full_like(x, np.nan, dtype=np.double) array([nan, nan, nan, nan, nan, nan])</p>
-      <p>y = np.arange(6, dtype=np.double) np.full_like(y, 0.1) array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21516">view source</a></div></div><div class="public anchor" id="var-fv"><h3>fv</h3><div class="usage"><code>(fv &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the future value.</p>
-<p>.. deprecated:: 1.18</p>
-<p><code>fv</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
-<p>Given:  * a present value, <code>pv</code>  * an interest <code>rate</code> compounded once per period, of which  there are  * <code>nper</code> total  * a (fixed) payment, <code>pmt</code>, paid either  * at the beginning (<code>when</code> = {‘begin’, 1}) or the end  (<code>when</code> = {‘end’, 0}) of each period</p>
-<p>Return:  the value at the end of the <code>nper</code> periods</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>rate : scalar or array_like of shape(M, )  Rate of interest as decimal (not per cent) per period nper : scalar or array_like of shape(M, )  Number of compounding periods pmt : scalar or array_like of shape(M, )  Payment pv : scalar or array_like of shape(M, )  Present value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}, optional  When payments are due (‘begin’ (1) or ‘end’ (0)).  Defaults to {‘end’, 0}.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Future values. If all input is scalar, returns a scalar float. If  any input is array_like, returns future values for each input element.  If multiple inputs are array_like, they all must have the same shape.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The future value is computed by solving the equation::</p>
-<p>fv +  pv*(1+rate)**nper +  pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) == 0</p>
-<p>or, when <code>rate == 0</code>::</p>
-<p>fv + pv + pmt * nper == 0</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).  Open Document Format for Office Applications (OpenDocument)v1.2,  Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,  Pre-Draft 12. Organization for the Advancement of Structured Information  Standards (OASIS). Billerica, MA, USA. [ODT Document].  Available:  <a href="http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula">http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula</a>  OpenDocument-formula-20090508.odt</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>What is the future value after 10 years of saving $100 now, with an additional monthly savings of $100. Assume the interest rate is 5% (annually) compounded monthly?</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.fv(0.05/12, 10*12, -100, -100) 15692.928894335748</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>By convention, the negative sign represents cash flow out (i.e. money not available today). Thus, saving $100 a month at 5% annual interest leads to $15,692.93 available to spend in 10 years.</p>
-<p>If any input is array_like, returns an array of equal shape. Let’s compare different interest rates from the example above.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array((0.05, 0.06, 0.07))/12 np.fv(a, 10*12, -100, -100) array([ 15692.92889434, 16569.87435405, 17509.44688102]) # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7818">view source</a></div></div><div class="public anchor" id="var-gcd"><h3>gcd</h3><div class="usage"><code>(gcd self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>gcd(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Returns the greatest common divisor of <code>|x1|</code> and <code>|x2|</code></p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like, int  Arrays of values. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output).</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  The greatest common divisor of the absolute value of the inputs  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>lcm : The lowest common multiple</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.gcd(12, 20) 4 np.gcd.reduce([15, 25, 35]) 5 np.gcd(np.arange(6), 20) array([20, 1, 2, 1, 4, 5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14914">view source</a></div></div><div class="public anchor" id="var-generic"><h3>generic</h3><div class="usage"><code>(generic self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Base class for numpy scalar types.</p>
-<p>Class from which most (all?) numpy scalar types are derived. For consistency, exposes the same API as <code>ndarray</code>, despite many consequent attributes being either “get-only,” or completely irrelevant. This is the class from which it is strongly suggested users should derive custom scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1119">view source</a></div></div><div class="public anchor" id="var-genfromtxt"><h3>genfromtxt</h3><div class="usage"><code>(genfromtxt fname &amp; [{names :names, max_rows :max_rows, encoding :encoding, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, max_rows :max_rows, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, usemask :usemask, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, case_sensitive :case_sensitive, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, excludelist :excludelist, delimiter :delimiter, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{names :names, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, delimiter :delimiter, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, delimiter :delimiter, missing_values :missing_values, usecols :usecols}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters, missing_values :missing_values, filling_values :filling_values}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters, missing_values :missing_values}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter}])</code><code>(genfromtxt fname &amp; [{dtype :dtype, comments :comments}])</code><code>(genfromtxt fname &amp; [{dtype :dtype}])</code><code>(genfromtxt fname)</code></div><div class="doc"><div class="markdown"><p>Load data from a text file, with missing values handled as specified.</p>
-<p>Each line past the first <code>skip_header</code> lines is split at the <code>delimiter</code> character, and characters following the <code>comments</code> character are discarded.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>fname : file, str, pathlib.Path, list of str, generator  File, filename, list, or generator to read. If the filename  extension is <code>.gz</code> or <code>.bz2</code>, the file is first decompressed. Note  that generators must return byte strings. The strings  in a list or produced by a generator are treated as lines. dtype : dtype, optional  Data type of the resulting array.  If None, the dtypes will be determined by the contents of each  column, individually. comments : str, optional  The character used to indicate the start of a comment.  All the characters occurring on a line after a comment are discarded delimiter : str, int, or sequence, optional  The string used to separate values. By default, any consecutive  whitespaces act as delimiter. An integer or sequence of integers  can also be provided as width(s) of each field. skiprows : int, optional  <code>skiprows</code> was removed in numpy 1.10. Please use <code>skip_header</code> instead. skip_header : int, optional  The number of lines to skip at the beginning of the file. skip_footer : int, optional  The number of lines to skip at the end of the file. converters : variable, optional  The set of functions that convert the data of a column to a value.  The converters can also be used to provide a default value  for missing data: <code>converters = {3: lambda s: float(s or 0)}</code>. missing : variable, optional  <code>missing</code> was removed in numpy 1.10. Please use <code>missing_values</code>  instead. missing_values : variable, optional  The set of strings corresponding to missing data. filling_values : variable, optional  The set of values to be used as default when the data are missing. usecols : sequence, optional  Which columns to read, with 0 being the first. For example,  <code>usecols = (1, 4, 5)</code> will extract the 2nd, 5th and 6th columns. names : {None, True, str, sequence}, optional  If <code>names</code> is True, the field names are read from the first line after  the first <code>skip_header</code> lines. This line can optionally be proceeded  by a comment delimiter. If <code>names</code> is a sequence or a single-string of  comma-separated names, the names will be used to define the field names  in a structured dtype. If <code>names</code> is None, the names of the dtype  fields will be used, if any. excludelist : sequence, optional  A list of names to exclude. This list is appended to the default list  [‘return’,‘file’,‘print’]. Excluded names are appended an underscore:  for example, <code>file</code> would become <code>file_</code>. deletechars : str, optional  A string combining invalid characters that must be deleted from the  names. defaultfmt : str, optional  A format used to define default field names, such as “f%i” or “f_%02i”. autostrip : bool, optional  Whether to automatically strip white spaces from the variables. replace_space : char, optional  Character(s) used in replacement of white spaces in the variables  names. By default, use a ’_’. case_sensitive : {True, False, ‘upper’, ‘lower’}, optional  If True, field names are case sensitive.  If False or ‘upper’, field names are converted to upper case.  If ‘lower’, field names are converted to lower case. unpack : bool, optional  If True, the returned array is transposed, so that arguments may be  unpacked using <code>x, y, z = loadtxt(...)</code> usemask : bool, optional  If True, return a masked array.  If False, return a regular array. loose : bool, optional  If True, do not raise errors for invalid values. invalid_raise : bool, optional  If True, an exception is raised if an inconsistency is detected in the  number of columns.  If False, a warning is emitted and the offending lines are skipped. max_rows : int, optional  The maximum number of rows to read. Must not be used with skip_footer  at the same time. If given, the value must be at least 1. Default is  to read the entire file.</p>
-<pre><code>.. versionadded:: 1.10.0
-</code></pre>
-<p>encoding : str, optional  Encoding used to decode the inputfile. Does not apply when <code>fname</code> is  a file object. The special value ‘bytes’ enables backward compatibility  workarounds that ensure that you receive byte arrays when possible  and passes latin1 encoded strings to converters. Override this value to  receive unicode arrays and pass strings as input to converters. If set  to None the system default is used. The default value is ‘bytes’.</p>
-<pre><code>.. versionadded:: 1.14.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Data read from the text file. If <code>usemask</code> is True, this is a  masked array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.loadtxt : equivalent function when no data is missing.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<ul>
-  <li>When spaces are used as delimiters, or when no delimiter has been given  as input, there should not be any missing data between two fields.</li>
-  <li>When the variables are named (either by a flexible dtype or with <code>names</code>,  there must not be any header in the file (else a ValueError  exception is raised).</li>
-  <li>Individual values are not stripped of spaces by default.  When using a custom converter, make sure the function does remove spaces.</li>
-</ul>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy User Guide, section <code>I/O with NumPy
-       &lt;https://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html&gt;</code>_.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from io import StringIO import numpy as np</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Comma delimited file with mixed dtype</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>s = StringIO(u“1,1.3,abcde”) data = np.genfromtxt(s, dtype=[(‘myint’,‘i8’),(‘myfloat’,‘f8’), … (‘mystring’,‘S5’)], delimiter=“,”) data array((1, 1.3, b’abcde’),  dtype=[(‘myint’, ‘&lt;i8’), (‘myfloat’, ‘&lt;f8’), (‘mystring’, ‘S5’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using dtype = None</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>_ = s.seek(0) # needed for StringIO example only data = np.genfromtxt(s, dtype=None, … names = [‘myint’,‘myfloat’,‘mystring’], delimiter=“,”) data array((1, 1.3, b’abcde’),  dtype=[(‘myint’, ‘&lt;i8’), (‘myfloat’, ‘&lt;f8’), (‘mystring’, ‘S5’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Specifying dtype and names</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>_ = s.seek(0) data = np.genfromtxt(s, dtype=“i8,f8,S5”, … names=[‘myint’,‘myfloat’,‘mystring’], delimiter=“,”) data array((1, 1.3, b’abcde’),  dtype=[(‘myint’, ‘&lt;i8’), (‘myfloat’, ‘&lt;f8’), (‘mystring’, ‘S5’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>An example with fixed-width columns</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>s = StringIO(u“11.3abcde”) data = np.genfromtxt(s, dtype=None, names=[‘intvar’,‘fltvar’,‘strvar’], … delimiter=[1,3,5]) data array((1, 1.3, b’abcde’),  dtype=[(‘intvar’, ‘&lt;i8’), (‘fltvar’, ‘&lt;f8’), (‘strvar’, ‘S5’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>An example to show comments</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>f = StringIO(’’‘ … text,# of chars … hello world,11 … numpy,5’’‘) np.genfromtxt(f, dtype=‘S12,S12’, delimiter=’,’) array([(b’text’, b’‘), (b’hello world’, b’11‘), (b’numpy’, b’5’)],  dtype=[(‘f0’, ‘S12’), (‘f1’, ‘S12’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10682">view source</a></div></div><div class="public anchor" id="var-geomspace"><h3>geomspace</h3><div class="usage"><code>(geomspace &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return numbers spaced evenly on a log scale (a geometric progression).</p>
-<p>This is similar to <code>logspace</code>, but with endpoints specified directly. Each output sample is a constant multiple of the previous.</p>
-<p>.. versionchanged:: 1.16.0  Non-scalar <code>start</code> and <code>stop</code> are now supported.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>start : array_like  The starting value of the sequence. stop : array_like  The final value of the sequence, unless <code>endpoint</code> is False.  In that case, <code>num + 1</code> values are spaced over the  interval in log-space, of which all but the last (a sequence of  length <code>num</code>) are returned. num : integer, optional  Number of samples to generate. Default is 50. endpoint : boolean, optional  If true, <code>stop</code> is the last sample. Otherwise, it is not included.  Default is True. dtype : dtype  The type of the output array. If <code>dtype</code> is not given, infer the data  type from the other input arguments. axis : int, optional  The axis in the result to store the samples. Relevant only if start  or stop are array-like. By default (0), the samples will be along a  new axis inserted at the beginning. Use -1 to get an axis at the end.</p>
-<pre><code>.. versionadded:: 1.16.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>samples : ndarray  <code>num</code> samples, equally spaced on a log scale.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>logspace : Similar to geomspace, but with endpoints specified using log  and base. linspace : Similar to geomspace, but with arithmetic instead of geometric  progression. arange : Similar to linspace, with the step size specified instead of the  number of samples.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If the inputs or dtype are complex, the output will follow a logarithmic spiral in the complex plane. (There are an infinite number of spirals passing through two points; the output will follow the shortest such path.)</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.geomspace(1, 1000, num=4) array([ 1., 10., 100., 1000.]) np.geomspace(1, 1000, num=3, endpoint=False) array([ 1., 10., 100.]) np.geomspace(1, 1000, num=4, endpoint=False) array([ 1. , 5.62341325, 31.6227766 , 177.827941 ]) np.geomspace(1, 256, num=9) array([ 1., 2., 4., 8., 16., 32., 64., 128., 256.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that the above may not produce exact integers:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.geomspace(1, 256, num=9, dtype=int) array([ 1, 2, 4, 7, 16, 32, 63, 127, 256]) np.around(np.geomspace(1, 256, num=9)).astype(int) array([ 1, 2, 4, 8, 16, 32, 64, 128, 256])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Negative, decreasing, and complex inputs are allowed:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.geomspace(1000, 1, num=4) array([1000., 100., 10., 1.]) np.geomspace(-1000, -1, num=4) array([-1000., -100., -10., -1.]) np.geomspace(1j, 1000j, num=4) # Straight line array([0. +1.j, 0. +10.j, 0. +100.j, 0.+1000.j]) np.geomspace(-1+0j, 1+0j, num=5) # Circle array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,  6.12323400e-17+1.00000000e+00j, 7.07106781e-01+7.07106781e-01j,  1.00000000e+00+0.00000000e+00j])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Graphical illustration of <code>endpoint</code> parameter:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt N = 10 y = np.zeros(N) plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.axis([0.5, 2000, 0, 3]) [0.5, 2000, 0, 3] plt.grid(True, color=‘0.7’, linestyle=‘-’, which=‘both’, axis=‘both’) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25499">view source</a></div></div><div class="public anchor" id="var-get_array_wrap"><h3>get_array_wrap</h3><div class="usage"><code>(get_array_wrap &amp; [args])</code></div><div class="doc"><div class="markdown"><p>Find the wrapper for the array with the highest priority.</p>
-<p>In case of ties, leftmost wins. If no wrapper is found, return None</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6916">view source</a></div></div><div class="public anchor" id="var-get_include"><h3>get_include</h3><div class="usage"><code>(get_include)</code></div><div class="doc"><div class="markdown"><p>Return the directory that contains the NumPy *.h header files.</p>
-<p>Extension modules that need to compile against NumPy should use this function to locate the appropriate include directory.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>When using <code>distutils</code>, for example in <code>setup.py</code>. ::</p>
-<pre><code>import numpy as np
-...
-Extension('extension_name', ...
-        include_dirs=[np.get_include()])
-...
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1373">view source</a></div></div><div class="public anchor" id="var-get_printoptions"><h3>get_printoptions</h3><div class="usage"><code>(get_printoptions)</code></div><div class="doc"><div class="markdown"><p>Return the current print options.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>print_opts : dict  Dictionary of current print options with keys</p>
-<pre><code>  - precision : int
-  - threshold : int
-  - edgeitems : int
-  - linewidth : int
-  - suppress : bool
-  - nanstr : str
-  - infstr : str
-  - formatter : dict of callables
-  - sign : str
-
-For a full description of these options, see `set_printoptions`.
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>set_printoptions, printoptions, set_string_function</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24367">view source</a></div></div><div class="public anchor" id="var-getbufsize"><h3>getbufsize</h3><div class="usage"><code>(getbufsize)</code></div><div class="doc"><div class="markdown"><p>Return the size of the buffer used in ufuncs.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>getbufsize : int  Size of ufunc buffer in bytes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20766">view source</a></div></div><div class="public anchor" id="var-geterr"><h3>geterr</h3><div class="usage"><code>(geterr)</code></div><div class="doc"><div class="markdown"><p>Get the current way of handling floating-point errors.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>res : dict  A dictionary with keys “divide”, “over”, “under”, and “invalid”,  whose values are from the strings “ignore”, “print”, “log”, “warn”,  “raise”, and “call”. The keys represent possible floating-point  exceptions, and the values define how these exceptions are handled.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>geterrcall, seterr, seterrcall</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>For complete documentation of the types of floating-point exceptions and treatment options, see <code>seterr</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from collections import OrderedDict sorted(np.geterr().items()) [(‘divide’, ‘warn’), (‘invalid’, ‘warn’), (‘over’, ‘warn’), (‘under’, ‘ignore’)] np.arange(3.) / np.arange(3.) array([nan, 1., 1.])</p>
-      <p>oldsettings = np.seterr(all=‘warn’, over=‘raise’) OrderedDict(sorted(np.geterr().items())) OrderedDict([(‘divide’, ‘warn’), (‘invalid’, ‘warn’), (‘over’, ‘raise’), (‘under’, ‘warn’)]) np.arange(3.) / np.arange(3.) array([nan, 1., 1.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16927">view source</a></div></div><div class="public anchor" id="var-geterrcall"><h3>geterrcall</h3><div class="usage"><code>(geterrcall)</code></div><div class="doc"><div class="markdown"><p>Return the current callback function used on floating-point errors.</p>
-<p>When the error handling for a floating-point error (one of “divide”, “over”, “under”, or “invalid”) is set to ‘call’ or ‘log’, the function that is called or the log instance that is written to is returned by <code>geterrcall</code>. This function or log instance has been set with <code>seterrcall</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>errobj : callable, log instance or None  The current error handler. If no handler was set through <code>seterrcall</code>,  <code>None</code> is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>seterrcall, seterr, geterr</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>For complete documentation of the types of floating-point exceptions and treatment options, see <code>seterr</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.geterrcall() # we did not yet set a handler, returns None</p>
-      <p>oldsettings = np.seterr(all=‘call’) def err_handler(type, flag): … print(“Floating point error (%s), with flag %s” % (type, flag)) oldhandler = np.seterrcall(err_handler) np.array([1, 2, 3]) / 0.0 Floating point error (divide by zero), with flag 1 array([inf, inf, inf])</p>
-      <p>cur_handler = np.geterrcall() cur_handler is err_handler True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23215">view source</a></div></div><div class="public anchor" id="var-geterrobj"><h3>geterrobj</h3><div class="usage"><code>(geterrobj self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>geterrobj()</p>
-<p>Return the current object that defines floating-point error handling.</p>
-<p>The error object contains all information that defines the error handling behavior in NumPy. <code>geterrobj</code> is used internally by the other functions that get and set error handling behavior (<code>geterr</code>, <code>seterr</code>, <code>geterrcall</code>, <code>seterrcall</code>).</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>errobj : list  The error object, a list containing three elements:  [internal numpy buffer size, error mask, error callback function].</p>
-<pre><code>The error mask is a single integer that holds the treatment information
-on all four floating point errors. The information for each error type
-is contained in three bits of the integer. If we print it in base 8, we
-can see what treatment is set for "invalid", "under", "over", and
-"divide" (in that order). The printed string can be interpreted with
-
-* 0 : 'ignore'
-* 1 : 'warn'
-* 2 : 'raise'
-* 3 : 'call'
-* 4 : 'print'
-* 5 : 'log'
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>seterrobj, seterr, geterr, seterrcall, geterrcall getbufsize, setbufsize</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>For complete documentation of the types of floating-point exceptions and treatment options, see <code>seterr</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.geterrobj() # first get the defaults [8192, 521, None]</p>
-      <p>def err_handler(type, flag): … print(“Floating point error (%s), with flag %s” % (type, flag)) … old_bufsize = np.setbufsize(20000) old_err = np.seterr(divide=‘raise’) old_handler = np.seterrcall(err_handler) np.geterrobj() [8192, 521, <function err_handler="" at="" 0x91dcaac="">]</function></p>
-      <p>old_err = np.seterr(all=‘ignore’) np.base_repr(np.geterrobj()[1], 8) ‘0’ old_err = np.seterr(divide=‘warn’, over=‘log’, under=‘call’, … invalid=‘print’) np.base_repr(np.geterrobj()[1], 8) ‘4351’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20044">view source</a></div></div><div class="public anchor" id="var-gradient"><h3>gradient</h3><div class="usage"><code>(gradient &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the gradient of an N-dimensional array.</p>
-<p>The gradient is computed using second order accurate central differences in the interior points and either first or second order accurate one-sides (forward or backwards) differences at the boundaries. The returned gradient hence has the same shape as the input array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>f : array_like  An N-dimensional array containing samples of a scalar function. varargs : list of scalar or array, optional  Spacing between f values. Default unitary spacing for all dimensions.  Spacing can be specified using:</p>
-<pre><code>1. single scalar to specify a sample distance for all dimensions.
-2. N scalars to specify a constant sample distance for each dimension.
-   i.e. `dx`, `dy`, `dz`, ...
-3. N arrays to specify the coordinates of the values along each
-   dimension of F. The length of the array must match the size of
-   the corresponding dimension
-4. Any combination of N scalars/arrays with the meaning of 2. and 3.
-
-If `axis` is given, the number of varargs must equal the number of axes.
-Default: 1.
-</code></pre>
-<p>edge_order : {1, 2}, optional  Gradient is calculated using N-th order accurate differences  at the boundaries. Default: 1.</p>
-<pre><code>.. versionadded:: 1.9.1
-</code></pre>
-<p>axis : None or int or tuple of ints, optional  Gradient is calculated only along the given axis or axes  The default (axis = None) is to calculate the gradient for all the axes  of the input array. axis may be negative, in which case it counts from  the last to the first axis.</p>
-<pre><code>.. versionadded:: 1.11.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>gradient : ndarray or list of ndarray  A set of ndarrays (or a single ndarray if there is only one dimension)  corresponding to the derivatives of f with respect to each dimension.  Each derivative has the same shape as f.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>f = np.array([1, 2, 4, 7, 11, 16], dtype=float) np.gradient(f) array([1. , 1.5, 2.5, 3.5, 4.5, 5. ]) np.gradient(f, 2) array([0.5 , 0.75, 1.25, 1.75, 2.25, 2.5 ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Spacing can be also specified with an array that represents the coordinates of the values F along the dimensions. For instance a uniform spacing:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(f.size) np.gradient(f, x) array([1. , 1.5, 2.5, 3.5, 4.5, 5. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Or a non uniform one:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float) np.gradient(f, x) array([1. , 3. , 3.5, 6.7, 6.9, 2.5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>For two dimensional arrays, the return will be two arrays ordered by axis. In this example the first array stands for the gradient in rows and the second one in columns direction:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.gradient(np.array(<a href="null">1, 2, 6], [3, 4, 5</a>, dtype=float)) [array([[ 2., 2., -1.],  [ 2., 2., -1.]]), array([[1. , 2.5, 4. ],  [1. , 1. , 1. ]])]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>In this example the spacing is also specified: uniform for axis=0 and non uniform for axis=1</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>dx = 2. y = [1., 1.5, 3.5] np.gradient(np.array(<a href="null">1, 2, 6], [3, 4, 5</a>, dtype=float), dx, y) [array([[ 1. , 1. , -0.5],  [ 1. , 1. , -0.5]]), array([[2. , 2. , 2. ],  [2. , 1.7, 0.5]])]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>It is possible to specify how boundaries are treated using <code>edge_order</code></p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([0, 1, 2, 3, 4]) f = x**2 np.gradient(f, edge_order=1) array([1., 2., 4., 6., 7.]) np.gradient(f, edge_order=2) array([0., 2., 4., 6., 8.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The <code>axis</code> keyword can be used to specify a subset of axes of which the gradient is calculated</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.gradient(np.array(<a href="null">1, 2, 6], [3, 4, 5</a>, dtype=float), axis=0) array(<a href="null"> 2.,  2., -1.],
-       [ 2.,  2., -1.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Assuming that :math:<code>f\in C^{3}</code> (i.e., :math:<code>f</code> has at least 3 continuous derivatives) and let :math:<code>h_{*}</code> be a non-homogeneous stepsize, we minimize the “consistency error” :math:<code>\eta_{i}</code> between the true gradient and its estimate from a linear combination of the neighboring grid-points:</p>
-<p>.. math::</p>
-<pre><code>\eta_{i} = f_{i}^{\left(1\right)} -
-            \left[ \alpha f\left(x_{i}\right) +
-                    \beta f\left(x_{i} + h_{d}\right) +
-                    \gamma f\left(x_{i}-h_{s}\right)
-            \right]
-</code></pre>
-<p>By substituting :math:<code>f(x_{i} + h_{d})</code> and :math:<code>f(x_{i} - h_{s})</code> with their Taylor series expansion, this translates into solving the following the linear system:</p>
-<p>.. math::</p>
-<pre><code>\left\{
-    \begin{array}{r}
-        \alpha+\beta+\gamma=0 \\
-        \beta h_{d}-\gamma h_{s}=1 \\
-        \beta h_{d}^{2}+\gamma h_{s}^{2}=0
-    \end{array}
-\right.
-</code></pre>
-<p>The resulting approximation of :math:<code>f_{i}^{(1)}</code> is the following:</p>
-<p>.. math::</p>
-<pre><code>\hat f_{i}^{(1)} =
-    \frac{
-        h_{s}^{2}f\left(x_{i} + h_{d}\right)
-        + \left(h_{d}^{2} - h_{s}^{2}\right)f\left(x_{i}\right)
-        - h_{d}^{2}f\left(x_{i}-h_{s}\right)}
-        { h_{s}h_{d}\left(h_{d} + h_{s}\right)}
-    + \mathcal{O}\left(\frac{h_{d}h_{s}^{2}
-                        + h_{s}h_{d}^{2}}{h_{d}
-                        + h_{s}}\right)
-</code></pre>
-<p>It is worth noting that if :math:<code>h_{s}=h_{d}</code> (i.e., data are evenly spaced) we find the standard second order approximation:</p>
-<p>.. math::</p>
-<pre><code>\hat f_{i}^{(1)}=
-    \frac{f\left(x_{i+1}\right) - f\left(x_{i-1}\right)}{2h}
-    + \mathcal{O}\left(h^{2}\right)
-</code></pre>
-<p>With a similar procedure the forward/backward approximations used for boundaries can be derived.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics  (Texts in Applied Mathematics). New York: Springer. .. [2] Durran D. R. (1999) Numerical Methods for Wave Equations  in Geophysical Fluid Dynamics. New York: Springer. .. [3] Fornberg B. (1988) Generation of Finite Difference Formulas on  Arbitrarily Spaced Grids,  Mathematics of Computation 51, no. 184 : 699-706.  <code>PDF &lt;http://www.ams.org/journals/mcom/1988-51-184/
-        S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf&gt;</code>_.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3796">view source</a></div></div><div class="public anchor" id="var-greater"><h3>greater</h3><div class="usage"><code>(greater self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>greater(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the truth value of (x1 &gt; x2) element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>greater_equal, less, less_equal, equal, not_equal</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.greater([4,2],[2,2]) array([ True, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>If the inputs are ndarrays, then np.greater is equivalent to ‘&gt;’.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([4,2]) b = np.array([2,2]) a &gt; b array([ True, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12594">view source</a></div></div><div class="public anchor" id="var-greater_equal"><h3>greater_equal</h3><div class="usage"><code>(greater_equal self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>greater_equal(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the truth value of (x1 &gt;= x2) element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : bool or ndarray of bool  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>greater, less, less_equal, equal, not_equal</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.greater_equal([4, 2, 1], [2, 2, 2]) array([ True, True, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17156">view source</a></div></div><div class="public anchor" id="var-half"><h3>half</h3><div class="usage"><code>(half self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Half-precision floating-point number type. Character code: <code>'e'</code>. Canonical name: <code>np.half</code>. Alias <em>on this platform</em>: <code>np.float16</code>: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16281">view source</a></div></div><div class="public anchor" id="var-hamming"><h3>hamming</h3><div class="usage"><code>(hamming M)</code></div><div class="doc"><div class="markdown"><p>Return the Hamming window.</p>
-<p>The Hamming window is a taper formed by using a weighted cosine.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>M : int  Number of points in the output window. If zero or less, an  empty array is returned.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  The window, with the maximum value normalized to one (the value  one appears only if the number of samples is odd).</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>bartlett, blackman, hanning, kaiser</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The Hamming window is defined as</p>
-<p>.. math:: w(n) = 0.54 - 0.46cos\left(\frac{2\pi{n}}{M-1}\right)  \qquad 0 \leq n \leq M-1</p>
-<p>The Hamming was named for R. W. Hamming, an associate of J. W. Tukey and is described in Blackman and Tukey. It was recommended for smoothing the truncated autocovariance function in the time domain. Most references to the Hamming window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means “removing the foot”, i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power  spectra, Dover Publications, New York. .. [2] E.R. Kanasewich, “Time Sequence Analysis in Geophysics”, The  University of Alberta Press, 1975, pp. 109-110. .. [3] Wikipedia, “Window function”,  <a href="https://en.wikipedia.org/wiki/Window_function">https://en.wikipedia.org/wiki/Window_function</a> .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,  “Numerical Recipes”, Cambridge University Press, 1986, page 425.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.hamming(12) array([ 0.08 , 0.15302337, 0.34890909, 0.60546483, 0.84123594, # may vary  0.98136677, 0.98136677, 0.84123594, 0.60546483, 0.34890909,  0.15302337, 0.08 ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot the window and the frequency response:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt from numpy.fft import fft, fftshift window = np.hamming(51) plt.plot(window) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Hamming window”) Text(0.5, 1.0, ‘Hamming window’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“Sample”) Text(0.5, 0, ‘Sample’) plt.show()</p>
-      <p>plt.figure() </p><figure size="" 640x480="" with="" 0="" axes=""> A = fft(window, 2048) / 25.5 mag = np.abs(fftshift(A)) freq = np.linspace(-0.5, 0.5, len(A)) response = 20 * np.log10(mag) response = np.clip(response, -100, 100) plt.plot(freq, response) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Frequency response of Hamming window”) Text(0.5, 1.0, ‘Frequency response of Hamming window’) plt.ylabel(“Magnitude [dB]”) Text(0, 0.5, ‘Magnitude [dB]’) plt.xlabel(“Normalized frequency [cycles per sample]”) Text(0.5, 0, ‘Normalized frequency [cycles per sample]’) plt.axis(‘tight’) … plt.show()<p></p>
-    </figure></blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14035">view source</a></div></div><div class="public anchor" id="var-hanning"><h3>hanning</h3><div class="usage"><code>(hanning M)</code></div><div class="doc"><div class="markdown"><p>Return the Hanning window.</p>
-<p>The Hanning window is a taper formed by using a weighted cosine.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>M : int  Number of points in the output window. If zero or less, an  empty array is returned.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray, shape(M,)  The window, with the maximum value normalized to one (the value  one appears only if <code>M</code> is odd).</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>bartlett, blackman, hamming, kaiser</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The Hanning window is defined as</p>
-<p>.. math:: w(n) = 0.5 - 0.5cos\left(\frac{2\pi{n}}{M-1}\right)  \qquad 0 \leq n \leq M-1</p>
-<p>The Hanning was named for Julius von Hann, an Austrian meteorologist. It is also known as the Cosine Bell. Some authors prefer that it be called a Hann window, to help avoid confusion with the very similar Hamming window.</p>
-<p>Most references to the Hanning window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means “removing the foot”, i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power  spectra, Dover Publications, New York. .. [2] E.R. Kanasewich, “Time Sequence Analysis in Geophysics”,  The University of Alberta Press, 1975, pp. 106-108. .. [3] Wikipedia, “Window function”,  <a href="https://en.wikipedia.org/wiki/Window_function">https://en.wikipedia.org/wiki/Window_function</a> .. [4] W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,  “Numerical Recipes”, Cambridge University Press, 1986, page 425.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.hanning(12) array([0. , 0.07937323, 0.29229249, 0.57115742, 0.82743037,  0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249,  0.07937323, 0. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot the window and its frequency response:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt from numpy.fft import fft, fftshift window = np.hanning(51) plt.plot(window) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Hann window”) Text(0.5, 1.0, ‘Hann window’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“Sample”) Text(0.5, 0, ‘Sample’) plt.show()</p>
-      <p>plt.figure() </p><figure size="" 640x480="" with="" 0="" axes=""> A = fft(window, 2048) / 25.5 mag = np.abs(fftshift(A)) freq = np.linspace(-0.5, 0.5, len(A)) with np.errstate(divide=‘ignore’, invalid=‘ignore’): … response = 20 * np.log10(mag) … response = np.clip(response, -100, 100) plt.plot(freq, response) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Frequency response of the Hann window”) Text(0.5, 1.0, ‘Frequency response of the Hann window’) plt.ylabel(“Magnitude [dB]”) Text(0, 0.5, ‘Magnitude [dB]’) plt.xlabel(“Normalized frequency [cycles per sample]”) Text(0.5, 0, ‘Normalized frequency [cycles per sample]’) plt.axis(‘tight’) … plt.show()<p></p>
-    </figure></blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23621">view source</a></div></div><div class="public anchor" id="var-heaviside"><h3>heaviside</h3><div class="usage"><code>(heaviside self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>heaviside(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute the Heaviside step function.</p>
-<p>The Heaviside step function is defined as::</p>
-<pre><code>                      0   if x1 &lt; 0
-heaviside(x1, x2) =  x2   if x1 == 0
-                      1   if x1 &gt; 0
-</code></pre>
-<p>where <code>x2</code> is often taken to be 0.5, but 0 and 1 are also sometimes used.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  Input values. x2 : array_like  The value of the function when x1 is 0. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  The output array, element-wise Heaviside step function of <code>x1</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.13.0</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. Wikipedia, “Heaviside step function”,  <a href="https://en.wikipedia.org/wiki/Heaviside_step_function">https://en.wikipedia.org/wiki/Heaviside_step_function</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.heaviside([-1.5, 0, 2.0], 0.5) array([ 0. , 0.5, 1. ]) np.heaviside([-1.5, 0, 2.0], 1) array([ 0., 1., 1.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17009">view source</a></div></div><div class="public anchor" id="var-histogram"><h3>histogram</h3><div class="usage"><code>(histogram &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the histogram of a set of data.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. The histogram is computed over the flattened array. bins : int or sequence of scalars or str, optional  If <code>bins</code> is an int, it defines the number of equal-width  bins in the given range (10, by default). If <code>bins</code> is a  sequence, it defines a monotonically increasing array of bin edges,  including the rightmost edge, allowing for non-uniform bin widths.</p>
-<pre><code>.. versionadded:: 1.11.0
-
-If `bins` is a string, it defines the method used to calculate the
-optimal bin width, as defined by `histogram_bin_edges`.
-</code></pre>
-<p>range : (float, float), optional  The lower and upper range of the bins. If not provided, range  is simply <code>(a.min(), a.max())</code>. Values outside the range are  ignored. The first element of the range must be less than or  equal to the second. <code>range</code> affects the automatic bin  computation as well. While bin width is computed to be optimal  based on the actual data within <code>range</code>, the bin count will fill  the entire range including portions containing no data. normed : bool, optional</p>
-<pre><code>.. deprecated:: 1.6.0
-
-This is equivalent to the `density` argument, but produces incorrect
-results for unequal bin widths. It should not be used.
-
-.. versionchanged:: 1.15.0
-    DeprecationWarnings are actually emitted.
-</code></pre>
-<p>weights : array_like, optional  An array of weights, of the same shape as <code>a</code>. Each value in  <code>a</code> only contributes its associated weight towards the bin count  (instead of 1). If <code>density</code> is True, the weights are  normalized, so that the integral of the density over the range  remains 1. density : bool, optional  If <code>False</code>, the result will contain the number of samples in  each bin. If <code>True</code>, the result is the value of the  probability <em>density</em> function at the bin, normalized such that  the <em>integral</em> over the range is 1. Note that the sum of the  histogram values will not be equal to 1 unless bins of unity  width are chosen; it is not a probability <em>mass</em> function.</p>
-<pre><code>Overrides the ``normed`` keyword if given.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>hist : array  The values of the histogram. See <code>density</code> and <code>weights</code> for a  description of the possible semantics. bin_edges : array of dtype float  Return the bin edges <code>(length(hist)+1)</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>histogramdd, bincount, searchsorted, digitize, histogram_bin_edges</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>All but the last (righthand-most) bin is half-open. In other words, if <code>bins</code> is::</p>
-<p>[1, 2, 3, 4]</p>
-<p>then the first bin is <code>[1, 2)</code> (including 1, but excluding 2) and the second <code>[2, 3)</code>. The last bin, however, is <code>[3, 4]</code>, which <em>includes</em> 4.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.histogram([1, 2, 1], bins=[0, 1, 2, 3]) (array([0, 2, 1]), array([0, 1, 2, 3])) np.histogram(np.arange(4), bins=np.arange(5), density=True) (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4])) np.histogram(<a href="null">1, 2, 1], [1, 0, 1</a>, bins=[0,1,2,3]) (array([1, 4, 1]), array([0, 1, 2, 3]))</p>
-      <p>a = np.arange(5) hist, bin_edges = np.histogram(a, density=True) hist array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5]) hist.sum() 2.4999999999999996 np.sum(hist * np.diff(bin_edges)) 1.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>.. versionadded:: 1.11.0</p>
-<p>Automated Bin Selection Methods example, using 2 peak random data with 2000 points:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt rng = np.random.RandomState(10) # deterministic random data a = np.hstack((rng.normal(size=1000), … rng.normal(loc=5, scale=2, size=1000))) _ = plt.hist(a, bins=‘auto’) # arguments are passed to np.histogram plt.title(“Histogram with ‘auto’ bins”) Text(0.5, 1.0, “Histogram with ‘auto’ bins”) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15624">view source</a></div></div><div class="public anchor" id="var-histogram2d"><h3>histogram2d</h3><div class="usage"><code>(histogram2d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the bi-dimensional histogram of two data samples.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like, shape (N,)  An array containing the x coordinates of the points to be  histogrammed. y : array_like, shape (N,)  An array containing the y coordinates of the points to be  histogrammed. bins : int or array_like or [int, int] or [array, array], optional  The bin specification:</p>
-<pre><code>  * If int, the number of bins for the two dimensions (nx=ny=bins).
-  * If array_like, the bin edges for the two dimensions
-    (x_edges=y_edges=bins).
-  * If [int, int], the number of bins in each dimension
-    (nx, ny = bins).
-  * If [array, array], the bin edges in each dimension
-    (x_edges, y_edges = bins).
-  * A combination [int, array] or [array, int], where int
-    is the number of bins and array is the bin edges.
-</code></pre>
-<p>range : array_like, shape(2,2), optional  The leftmost and rightmost edges of the bins along each dimension  (if not specified explicitly in the <code>bins</code> parameters):  <code>[[xmin, xmax], [ymin, ymax]]</code>. All values outside of this range  will be considered outliers and not tallied in the histogram. density : bool, optional  If False, the default, returns the number of samples in each bin.  If True, returns the probability <em>density</em> function at the bin,  <code>bin_count / sample_count / bin_area</code>. normed : bool, optional  An alias for the density argument that behaves identically. To avoid  confusion with the broken normed argument to <code>histogram</code>, <code>density</code>  should be preferred. weights : array_like, shape(N,), optional  An array of values <code>w_i</code> weighing each sample <code>(x_i, y_i)</code>.  Weights are normalized to 1 if <code>normed</code> is True. If <code>normed</code> is  False, the values of the returned histogram are equal to the sum of  the weights belonging to the samples falling into each bin.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>H : ndarray, shape(nx, ny)  The bi-dimensional histogram of samples <code>x</code> and <code>y</code>. Values in <code>x</code>  are histogrammed along the first dimension and values in <code>y</code> are  histogrammed along the second dimension. xedges : ndarray, shape(nx+1,)  The bin edges along the first dimension. yedges : ndarray, shape(ny+1,)  The bin edges along the second dimension.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>histogram : 1D histogram histogramdd : Multidimensional histogram</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>When <code>normed</code> is True, then the returned histogram is the sample density, defined such that the sum over bins of the product <code>bin_value * bin_area</code> is 1.</p>
-<p>Please note that the histogram does not follow the Cartesian convention where <code>x</code> values are on the abscissa and <code>y</code> values on the ordinate axis. Rather, <code>x</code> is histogrammed along the first dimension of the array (vertical), and <code>y</code> along the second dimension of the array (horizontal). This ensures compatibility with <code>histogramdd</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from matplotlib.image import NonUniformImage import matplotlib.pyplot as plt</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Construct a 2-D histogram with variable bin width. First define the bin edges:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>xedges = [0, 1, 3, 5] yedges = [0, 2, 3, 4, 6]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Next we create a histogram H with random bin content:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.random.normal(2, 1, 100) y = np.random.normal(1, 1, 100) H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges)) H = H.T # Let each row list bins with common y range.</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>:func:<code>imshow &lt;matplotlib.pyplot.imshow&gt;</code> can only display square bins:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>fig = plt.figure(figsize=(7, 3)) ax = fig.add_subplot(131, title=‘imshow: square bins’) plt.imshow(H, interpolation=‘nearest’, origin=‘low’, … extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]]) &lt;matplotlib.image.AxesImage object at 0x…&gt;</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>:func:<code>pcolormesh &lt;matplotlib.pyplot.pcolormesh&gt;</code> can display actual edges:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>ax = fig.add_subplot(132, title=‘pcolormesh: actual edges’, … aspect=‘equal’) X, Y = np.meshgrid(xedges, yedges) ax.pcolormesh(X, Y, H) &lt;matplotlib.collections.QuadMesh object at 0x…&gt;</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>:class:<code>NonUniformImage &lt;matplotlib.image.NonUniformImage&gt;</code> can be used to display actual bin edges with interpolation:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>ax = fig.add_subplot(133, title=‘NonUniformImage: interpolated’, … aspect=‘equal’, xlim=xedges<a href="null">0, -1</a>, ylim=yedges<a href="null">0, -1</a>) im = NonUniformImage(ax, interpolation=‘bilinear’) xcenters = (xedges[:-1] + xedges[1:]) / 2 ycenters = (yedges[:-1] + yedges[1:]) / 2 im.set_data(xcenters, ycenters, H) ax.images.append(im) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1916">view source</a></div></div><div class="public anchor" id="var-histogram_bin_edges"><h3>histogram_bin_edges</h3><div class="usage"><code>(histogram_bin_edges &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Function to calculate only the edges of the bins used by the <code>histogram</code> function.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. The histogram is computed over the flattened array. bins : int or sequence of scalars or str, optional  If <code>bins</code> is an int, it defines the number of equal-width  bins in the given range (10, by default). If <code>bins</code> is a  sequence, it defines the bin edges, including the rightmost  edge, allowing for non-uniform bin widths.</p>
-<pre><code>If `bins` is a string from the list below, `histogram_bin_edges` will use
-the method chosen to calculate the optimal bin width and
-consequently the number of bins (see `Notes` for more detail on
-the estimators) from the data that falls within the requested
-range. While the bin width will be optimal for the actual data
-in the range, the number of bins will be computed to fill the
-entire range, including the empty portions. For visualisation,
-using the 'auto' option is suggested. Weighted data is not
-supported for automated bin size selection.
-
-'auto'
-    Maximum of the 'sturges' and 'fd' estimators. Provides good
-    all around performance.
-
-'fd' (Freedman Diaconis Estimator)
-    Robust (resilient to outliers) estimator that takes into
-    account data variability and data size.
-
-'doane'
-    An improved version of Sturges' estimator that works better
-    with non-normal datasets.
-
-'scott'
-    Less robust estimator that that takes into account data
-    variability and data size.
-
-'stone'
-    Estimator based on leave-one-out cross-validation estimate of
-    the integrated squared error. Can be regarded as a generalization
-    of Scott's rule.
-
-'rice'
-    Estimator does not take variability into account, only data
-    size. Commonly overestimates number of bins required.
-
-'sturges'
-    R's default method, only accounts for data size. Only
-    optimal for gaussian data and underestimates number of bins
-    for large non-gaussian datasets.
-
-'sqrt'
-    Square root (of data size) estimator, used by Excel and
-    other programs for its speed and simplicity.
-</code></pre>
-<p>range : (float, float), optional  The lower and upper range of the bins. If not provided, range  is simply <code>(a.min(), a.max())</code>. Values outside the range are  ignored. The first element of the range must be less than or  equal to the second. <code>range</code> affects the automatic bin  computation as well. While bin width is computed to be optimal  based on the actual data within <code>range</code>, the bin count will fill  the entire range including portions containing no data.</p>
-<p>weights : array_like, optional  An array of weights, of the same shape as <code>a</code>. Each value in  <code>a</code> only contributes its associated weight towards the bin count  (instead of 1). This is currently not used by any of the bin estimators,  but may be in the future.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>bin_edges : array of dtype float  The edges to pass into <code>histogram</code></p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>histogram</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The methods to estimate the optimal number of bins are well founded in literature, and are inspired by the choices R provides for histogram visualisation. Note that having the number of bins proportional to :math:<code>n^{1/3}</code> is asymptotically optimal, which is why it appears in most estimators. These are simply plug-in methods that give good starting points for number of bins. In the equations below, :math:<code>h</code> is the binwidth and :math:<code>n_h</code> is the number of bins. All estimators that compute bin counts are recast to bin width using the <code>ptp</code> of the data. The final bin count is obtained from <code>np.round(np.ceil(range / h))</code>.</p>
-<p>‘auto’ (maximum of the ‘sturges’ and ‘fd’ estimators)  A compromise to get a good value. For small datasets the Sturges  value will usually be chosen, while larger datasets will usually  default to FD. Avoids the overly conservative behaviour of FD  and Sturges for small and large datasets respectively.  Switchover point is usually :math:<code>a.size \approx 1000</code>.</p>
-<p>‘fd’ (Freedman Diaconis Estimator)  .. math:: h = 2 \frac{IQR}{n^{1/3}}</p>
-<pre><code>The binwidth is proportional to the interquartile range (IQR)
-and inversely proportional to cube root of a.size. Can be too
-conservative for small datasets, but is quite good for large
-datasets. The IQR is very robust to outliers.
-</code></pre>
-<p>‘scott’  .. math:: h = \sigma \sqrt[3]{\frac{24 * \sqrt{\pi}}{n}}</p>
-<pre><code>The binwidth is proportional to the standard deviation of the
-data and inversely proportional to cube root of ``x.size``. Can
-be too conservative for small datasets, but is quite good for
-large datasets. The standard deviation is not very robust to
-outliers. Values are very similar to the Freedman-Diaconis
-estimator in the absence of outliers.
-</code></pre>
-<p>‘rice’  .. math:: n_h = 2n^{1/3}</p>
-<pre><code>The number of bins is only proportional to cube root of
-``a.size``. It tends to overestimate the number of bins and it
-does not take into account data variability.
-</code></pre>
-<p>‘sturges’  .. math:: n_h = \log _{2}n+1</p>
-<pre><code>The number of bins is the base 2 log of ``a.size``.  This
-estimator assumes normality of data and is too conservative for
-larger, non-normal datasets. This is the default method in R's
-``hist`` method.
-</code></pre>
-<p>‘doane’  .. math:: n_h = 1 + \log_{2}(n) +  \log_{2}(1 + \frac{|g_1|}{\sigma_{g_1}})</p>
-<pre><code>    g_1 = mean[(\frac{x - \mu}{\sigma})^3]
-
-    \sigma_{g_1} = \sqrt{\frac{6(n - 2)}{(n + 1)(n + 3)}}
-
-An improved version of Sturges' formula that produces better
-estimates for non-normal datasets. This estimator attempts to
-account for the skew of the data.
-</code></pre>
-<p>‘sqrt’  .. math:: n_h = \sqrt n</p>
-<pre><code>The simplest and fastest estimator. Only takes into account the
-data size.
-</code></pre>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5]) np.histogram_bin_edges(arr, bins=‘auto’, range=(0, 1)) array([0. , 0.25, 0.5 , 0.75, 1. ]) np.histogram_bin_edges(arr, bins=2) array([0. , 2.5, 5. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>For consistency with histogram, an array of pre-computed bins is passed through unmodified:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.histogram_bin_edges(arr, [1, 2]) array([1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>This function allows one set of bins to be computed, and reused across multiple histograms:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>shared_bins = np.histogram_bin_edges(arr, bins=‘auto’) shared_bins array([0., 1., 2., 3., 4., 5.])</p>
-      <p>group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1]) hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins) hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins)</p>
-      <p>hist_0; hist_1 array([1, 1, 0, 1, 0]) array([2, 0, 1, 1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Which gives more easily comparable results than using separate bins for each histogram:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>hist_0, bins_0 = np.histogram(arr[group_id == 0], bins=‘auto’) hist_1, bins_1 = np.histogram(arr[group_id == 1], bins=‘auto’) hist_0; hist_1 array([1, 1, 1]) array([2, 1, 1, 2]) bins_0; bins_1 array([0., 1., 2., 3.]) array([0. , 1.25, 2.5 , 3.75, 5. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3186">view source</a></div></div><div class="public anchor" id="var-histogramdd"><h3>histogramdd</h3><div class="usage"><code>(histogramdd &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the multidimensional histogram of some data.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>sample : (N, D) array, or (D, N) array_like  The data to be histogrammed.</p>
-<pre><code>Note the unusual interpretation of sample when an array_like:
-
-* When an array, each row is a coordinate in a D-dimensional space -
-  such as ``histogramgramdd(np.array([p1, p2, p3]))``.
-* When an array_like, each element is the list of values for single
-  coordinate - such as ``histogramgramdd((X, Y, Z))``.
-
-The first form should be preferred.
-</code></pre>
-<p>bins : sequence or int, optional  The bin specification:</p>
-<pre><code>* A sequence of arrays describing the monotonically increasing bin
-  edges along each dimension.
-* The number of bins for each dimension (nx, ny, ... =bins)
-* The number of bins for all dimensions (nx=ny=...=bins).
-</code></pre>
-<p>range : sequence, optional  A sequence of length D, each an optional (lower, upper) tuple giving  the outer bin edges to be used if the edges are not given explicitly in  <code>bins</code>.  An entry of None in the sequence results in the minimum and maximum  values being used for the corresponding dimension.  The default, None, is equivalent to passing a tuple of D None values. density : bool, optional  If False, the default, returns the number of samples in each bin.  If True, returns the probability <em>density</em> function at the bin,  <code>bin_count / sample_count / bin_volume</code>. normed : bool, optional  An alias for the density argument that behaves identically. To avoid  confusion with the broken normed argument to <code>histogram</code>, <code>density</code>  should be preferred. weights : (N,) array_like, optional  An array of values <code>w_i</code> weighing each sample <code>(x_i, y_i, z_i, ...)</code>.  Weights are normalized to 1 if normed is True. If normed is False,  the values of the returned histogram are equal to the sum of the  weights belonging to the samples falling into each bin.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>H : ndarray  The multidimensional histogram of sample x. See normed and weights  for the different possible semantics. edges : list  A list of D arrays describing the bin edges for each dimension.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>histogram: 1-D histogram histogram2d: 2-D histogram</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>r = np.random.randn(100,3) H, edges = np.histogramdd(r, bins = (5, 8, 4)) H.shape, edges[0].size, edges[1].size, edges[2].size ((5, 8, 4), 6, 9, 5)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5110">view source</a></div></div><div class="public anchor" id="var-hsplit"><h3>hsplit</h3><div class="usage"><code>(hsplit &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Split an array into multiple sub-arrays horizontally (column-wise).</p>
-<p>Please refer to the <code>split</code> documentation. <code>hsplit</code> is equivalent to <code>split</code> with <code>axis=1</code>, the array is always split along the second axis regardless of the array dimension.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>split : Split an array into multiple sub-arrays of equal size.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(16.0).reshape(4, 4) x array(<a href="null"> 0.,   1.,   2.,   3.],
-       [ 4.,   5.,   6.,   7.],
-       [ 8.,   9.,  10.,  11.],
-       [12.,  13.,  14.,  15.</a>) np.hsplit(x, 2) [array([[ 0., 1.],  [ 4., 5.],  [ 8., 9.],  [12., 13.]]),  array([[ 2., 3.],  [ 6., 7.],  [10., 11.],  [14., 15.]])] np.hsplit(x, np.array([3, 6])) [array([[ 0., 1., 2.],  [ 4., 5., 6.],  [ 8., 9., 10.],  [12., 13., 14.]]),  array([[ 3.],  [ 7.],  [11.],  [15.]]),  array([], shape=(4, 0), dtype=float64)]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>With a higher dimensional array the split is still along the second axis.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(8.0).reshape(2, 2, 2) x array(<a href="null">[0.,  1.],
-        [2.,  3.</a>,  <a href="null">4.,  5.],
-        [6.,  7.</a>]) np.hsplit(x, 2) [array([[[0., 1.]],  [[4., 5.]]]),  array([[[2., 3.]],  [[6., 7.]]])]</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27302">view source</a></div></div><div class="public anchor" id="var-hstack"><h3>hstack</h3><div class="usage"><code>(hstack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Stack arrays in sequence horizontally (column wise).</p>
-<p>This is equivalent to concatenation along the second axis, except for 1-D arrays where it concatenates along the first axis. Rebuilds arrays divided by <code>hsplit</code>.</p>
-<p>This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions <code>concatenate</code>, <code>stack</code> and <code>block</code> provide more general stacking and concatenation operations.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>tup : sequence of ndarrays  The arrays must have the same shape along all but the second axis,  except 1-D arrays which can be any length.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>stacked : ndarray  The array formed by stacking the given arrays.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>stack : Join a sequence of arrays along a new axis. vstack : Stack arrays in sequence vertically (row wise). dstack : Stack arrays in sequence depth wise (along third axis). concatenate : Join a sequence of arrays along an existing axis. hsplit : Split array along second axis. block : Assemble arrays from blocks.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array((1,2,3)) b = np.array((2,3,4)) np.hstack((a,b)) array([1, 2, 3, 2, 3, 4]) a = np.array(<a href="null">1],[2],[3</a>) b = np.array(<a href="null">2],[3],[4</a>) np.hstack((a,b)) array(<a href="null">1, 2],
-       [2, 3],
-       [3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25776">view source</a></div></div><div class="public anchor" id="var-hypot"><h3>hypot</h3><div class="usage"><code>(hypot self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>hypot(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Given the “legs” of a right triangle, return its hypotenuse.</p>
-<p>Equivalent to <code>sqrt(x1**2 + x2**2)</code>, element-wise. If <code>x1</code> or <code>x2</code> is scalar_like (i.e., unambiguously cast-able to a scalar type), it is broadcast for use with each element of the other argument. (See Examples)</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Leg of the triangle(s). If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>z : ndarray  The hypotenuse of the triangle(s).  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3))) array(<a href="null"> 5.,  5.,  5.],
-       [ 5.,  5.,  5.],
-       [ 5.,  5.,  5.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Example showing broadcast of scalar_like argument:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.hypot(3*np.ones((3, 3)), [4]) array(<a href="null"> 5.,  5.,  5.],
-       [ 5.,  5.,  5.],
-       [ 5.,  5.,  5.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14943">view source</a></div></div><div class="public anchor" id="var-i0"><h3>i0</h3><div class="usage"><code>(i0 &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Modified Bessel function of the first kind, order 0.</p>
-<p>Usually denoted :math:<code>I_0</code>. This function does broadcast, but will <em>not</em> “up-cast” int dtype arguments unless accompanied by at least one float or complex dtype argument (see Raises below).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like, dtype float or complex  Argument of the Bessel function.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray, shape = x.shape, dtype = x.dtype  The modified Bessel function evaluated at each of the elements of <code>x</code>.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>TypeError: array cannot be safely cast to required type  If argument consists exclusively of int dtypes.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>scipy.special.i0, scipy.special.iv, scipy.special.ive</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The scipy implementation is recommended over this function: it is a proper ufunc written in C, and more than an order of magnitude faster.</p>
-<p>We use the algorithm published by Clenshaw [1]_ and referenced by Abramowitz and Stegun [2]_, for which the function domain is partitioned into the two intervals [0,8] and (8,inf), and Chebyshev polynomial expansions are employed in each interval. Relative error on the domain [0,30] using IEEE arithmetic is documented [3]_ as having a peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] C. W. Clenshaw, “Chebyshev series for mathematical functions”, in  <em>National Physical Laboratory Mathematical Tables</em>, vol. 5, London:  Her Majesty’s Stationery Office, 1962. .. [2] M. Abramowitz and I. A. Stegun, <em>Handbook of Mathematical  Functions</em>, 10th printing, New York: Dover, 1964, pp. 379.  <a href="http://www.math.sfu.ca/~cbm/aands/page_379.htm">http://www.math.sfu.ca/~cbm/aands/page_379.htm</a> .. [3] <a href="http://kobesearch.cpan.org/htdocs/Math-Cephes/Math/Cephes.html">http://kobesearch.cpan.org/htdocs/Math-Cephes/Math/Cephes.html</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.i0(0.) array(1.0) # may vary np.i0([0., 1. + 2j]) array([ 1.00000000+0.j , 0.18785373+0.64616944j]) # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13950">view source</a></div></div><div class="public anchor" id="var-identity"><h3>identity</h3><div class="usage"><code>(identity n &amp; [{dtype :dtype}])</code><code>(identity n)</code></div><div class="doc"><div class="markdown"><p>Return the identity array.</p>
-<p>The identity array is a square array with ones on the main diagonal.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>n : int  Number of rows (and columns) in <code>n</code> x <code>n</code> output. dtype : data-type, optional  Data-type of the output. Defaults to <code>float</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  <code>n</code> x <code>n</code> array with its main diagonal set to one,  and all other elements 0.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.identity(3) array(<a href="null">1.,  0.,  0.],
-       [0.,  1.,  0.],
-       [0.,  0.,  1.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16898">view source</a></div></div><div class="public anchor" id="var-iinfo"><h3>iinfo</h3><div class="usage"><code>(iinfo self int_type)</code></div><div class="doc"><div class="markdown"><p>iinfo(type)</p>
-<p>Machine limits for integer types.</p>
-<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
-<p>bits : int  The number of bits occupied by the type. min : int  The smallest integer expressible by the type. max : int  The largest integer expressible by the type.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>int_type : integer type, dtype, or instance  The kind of integer data type to get information about.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>finfo : The equivalent for floating point data types.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>With types:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>ii16 = np.iinfo(np.int16) ii16.min -32768 ii16.max 32767 ii32 = np.iinfo(np.int32) ii32.min -2147483648 ii32.max 2147483647</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>With instances:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>ii32 = np.iinfo(np.int32(10)) ii32.min -2147483648 ii32.max 2147483647</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21405">view source</a></div></div><div class="public anchor" id="var-imag"><h3>imag</h3><div class="usage"><code>(imag &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the imaginary part of the complex argument.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>val : array_like  Input array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  The imaginary component of the complex argument. If <code>val</code> is real,  the type of <code>val</code> is used for the output. If <code>val</code> has complex  elements, the returned type is float.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>real, angle, real_if_close</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1+2j, 3+4j, 5+6j]) a.imag array([2., 4., 6.]) a.imag = np.array([8, 10, 12]) a array([1. +8.j, 3.+10.j, 5.+12.j]) np.imag(1 + 1j) 1.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12504">view source</a></div></div><div class="public anchor" id="var-in1d"><h3>in1d</h3><div class="usage"><code>(in1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Test whether each element of a 1-D array is also present in a second array.</p>
-<p>Returns a boolean array the same length as <code>ar1</code> that is True where an element of <code>ar1</code> is in <code>ar2</code> and False otherwise.</p>
-<p>We recommend using :func:<code>isin</code> instead of <code>in1d</code> for new code.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>ar1 : (M,) array_like  Input array. ar2 : array_like  The values against which to test each value of <code>ar1</code>. assume_unique : bool, optional  If True, the input arrays are both assumed to be unique, which  can speed up the calculation. Default is False. invert : bool, optional  If True, the values in the returned array are inverted (that is,  False where an element of <code>ar1</code> is in <code>ar2</code> and True otherwise).  Default is False. <code>np.in1d(a, b, invert=True)</code> is equivalent  to (but is faster than) <code>np.invert(in1d(a, b))</code>.</p>
-<pre><code>.. versionadded:: 1.8.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>in1d : (M,) ndarray, bool  The values <code>ar1[in1d]</code> are in <code>ar2</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>isin : Version of this function that preserves the  shape of ar1. numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>in1d</code> can be considered as an element-wise function version of the python keyword <code>in</code>, for 1-D sequences. <code>in1d(a, b)</code> is roughly equivalent to <code>np.array([item in b for item in a])</code>. However, this idea fails if <code>ar2</code> is a set, or similar (non-sequence) container: As <code>ar2</code> is converted to an array, in those cases <code>asarray(ar2)</code> is an object array rather than the expected array of contained values.</p>
-<p>.. versionadded:: 1.4.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>test = np.array([0, 1, 2, 5, 0]) states = [0, 2] mask = np.in1d(test, states) mask array([ True, False, True, False, True]) test[mask] array([0, 2, 0]) mask = np.in1d(test, states, invert=True) mask array([False, True, False, True, False]) test[mask] array([1, 5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4898">view source</a></div></div><div class="public anchor" id="var-index_exp"><h3>index_exp</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A nicer way to build up index tuples for arrays.</p>
-<p>.. note::  Use one of the two predefined instances <code>index_exp</code> or <code>s_</code>  rather than directly using <code>IndexExpression</code>.</p>
-<p>For any index combination, including slicing and axis insertion, <code>a[indices]</code> is the same as <code>a[np.index_exp[indices]]</code> for any array <code>a</code>. However, <code>np.index_exp[indices]</code> can be used anywhere in Python code and returns a tuple of slice objects that can be used in the construction of complex index expressions.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>maketuple : bool  If True, always returns a tuple.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>index_exp : Predefined instance that always returns a tuple:  <code>index_exp = IndexExpression(maketuple=True)</code>. s_ : Predefined instance without tuple conversion:  <code>s_ = IndexExpression(maketuple=False)</code>.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>You can do all this with <code>slice()</code> plus a few special objects, but there’s a lot to remember and this version is simpler because it uses the standard array indexing syntax.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.s_[2::2] slice(2, None, 2) np.index_exp[2::2] (slice(2, None, 2),)</p>
-      <p>np.array([0, 1, 2, 3, 4])[np.s_[2::2]] array([2, 4])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18097">view source</a></div></div><div class="public anchor" id="var-indices"><h3>indices</h3><div class="usage"><code>(indices dimensions &amp; [{dtype :dtype, sparse :sparse}])</code><code>(indices dimensions &amp; [{dtype :dtype}])</code><code>(indices dimensions)</code></div><div class="doc"><div class="markdown"><p>Return an array representing the indices of a grid.</p>
-<p>Compute an array where the subarrays contain index values 0, 1, … varying only along the corresponding axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>dimensions : sequence of ints  The shape of the grid. dtype : dtype, optional  Data type of the result. sparse : boolean, optional  Return a sparse representation of the grid instead of a dense  representation. Default is False.</p>
-<pre><code>.. versionadded:: 1.17
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>grid : one ndarray or tuple of ndarrays  If sparse is False:  Returns one array of grid indices,  <code>grid.shape = (len(dimensions),) + tuple(dimensions)</code>.  If sparse is True:  Returns a tuple of arrays, with  <code>grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)</code> with  dimensions[i] in the ith place</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>mgrid, ogrid, meshgrid</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The output shape in the dense case is obtained by prepending the number of dimensions in front of the tuple of dimensions, i.e. if <code>dimensions</code> is a tuple <code>(r0, ..., rN-1)</code> of length <code>N</code>, the output shape is <code>(N, r0, ..., rN-1)</code>.</p>
-<p>The subarrays <code>grid[k]</code> contains the N-D array of indices along the <code>k-th</code> axis. Explicitly::</p>
-<pre><code>grid[k, i0, i1, ..., iN-1] = ik
-</code></pre>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>grid = np.indices((2, 3)) grid.shape (2, 2, 3) grid[0] # row indices array(<a href="null">0, 0, 0],
-       [1, 1, 1</a>) grid[1] # column indices array(<a href="null">0, 1, 2],
-       [0, 1, 2</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The indices can be used as an index into an array.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(20).reshape(5, 4) row, col = np.indices((2, 3)) x[row, col] array(<a href="null">0, 1, 2],
-       [4, 5, 6</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that it would be more straightforward in the above example to extract the required elements directly with <code>x[:2, :3]</code>.</p>
-<p>If sparse is set to true, the grid will be returned in a sparse representation.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>i, j = np.indices((2, 3), sparse=True) i.shape (2, 1) j.shape (1, 3) i # row indices array(<a href="null">0],
-       [1</a>) j # column indices array(<a href="null">0, 1, 2</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28529">view source</a></div></div><div class="public anchor" id="var-inexact"><h3>inexact</h3><div class="usage"><code>(inexact self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all numeric scalar types with a (potentially) inexact representation of the values in its range, such as floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L381">view source</a></div></div><div class="public anchor" id="var-Inf"><h3>Inf</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24060">view source</a></div></div><div class="public anchor" id="var-inf"><h3>inf</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4408">view source</a></div></div><div class="public anchor" id="var-Infinity"><h3>Infinity</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14129">view source</a></div></div><div class="public anchor" id="var-info"><h3>info</h3><div class="usage"><code>(info &amp; [{object :object, maxwidth :maxwidth, output :output, toplevel :toplevel}])</code><code>(info &amp; [{object :object, maxwidth :maxwidth, output :output}])</code><code>(info &amp; [{object :object, maxwidth :maxwidth}])</code><code>(info &amp; [{object :object}])</code><code>(info)</code></div><div class="doc"><div class="markdown"><p>Get help information for a function, class, or module.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>object : object or str, optional  Input object or name to get information about. If <code>object</code> is a  numpy object, its docstring is given. If it is a string, available  modules are searched for matching objects. If None, information  about <code>info</code> itself is returned. maxwidth : int, optional  Printing width. output : file like object, optional  File like object that the output is written to, default is  <code>stdout</code>. The object has to be opened in ‘w’ or ‘a’ mode. toplevel : str, optional  Start search at this level.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>source, lookfor</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>When used interactively with an object, <code>np.info(obj)</code> is equivalent to <code>help(obj)</code> on the Python prompt or <code>obj?</code> on the IPython prompt.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.info(np.polyval) # doctest: +SKIP  polyval(p, x)  Evaluate the polynomial p at x.  …</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>When using a string for <code>object</code> it is possible to get multiple results.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.info(‘fft’) # doctest: +SKIP  *** Found in numpy *** Core FFT routines …  *** Found in numpy.fft ***  fft(a, n=None, axis=-1) …  *** Repeat reference found in numpy.fft.fftpack ***  *** Total of 3 references found. ***</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9162">view source</a></div></div><div class="public anchor" id="var-infty"><h3>infty</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2739">view source</a></div></div><div class="public anchor" id="var-inner"><h3>inner</h3><div class="usage"><code>(inner &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>inner(a, b)</p>
-<p>Inner product of two arrays.</p>
-<p>Ordinary inner product of vectors for 1-D arrays (without complex conjugation), in higher dimensions a sum product over the last axes.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a, b : array_like  If <code>a</code> and <code>b</code> are nonscalar, their last dimensions must match.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  <code>out.shape = a.shape[:-1] + b.shape[:-1]</code></p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If the last dimension of <code>a</code> and <code>b</code> has different size.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>tensordot : Sum products over arbitrary axes. dot : Generalised matrix product, using second last dimension of <code>b</code>. einsum : Einstein summation convention.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>For vectors (1-D arrays) it computes the ordinary inner-product::</p>
-<pre><code>np.inner(a, b) = sum(a[:]*b[:])
-</code></pre>
-<p>More generally, if <code>ndim(a) = r &gt; 0</code> and <code>ndim(b) = s &gt; 0</code>::</p>
-<pre><code>np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))
-</code></pre>
-<p>or explicitly::</p>
-<pre><code>np.inner(a, b)[i0,...,ir-1,j0,...,js-1]
-     = sum(a[i0,...,ir-1,:]*b[j0,...,js-1,:])
-</code></pre>
-<p>In addition <code>a</code> or <code>b</code> may be scalars, in which case::</p>
-<p>np.inner(a,b) = a*b</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Ordinary inner product for vectors:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1,2,3]) b = np.array([0,1,0]) np.inner(a, b) 2</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>A multidimensional example:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(24).reshape((2,3,4)) b = np.arange(4) np.inner(a, b) array(<a href="null"> 14,  38,  62],
-       [ 86, 110, 134</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>An example where <code>b</code> is a scalar:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.inner(np.eye(2), 7) array(<a href="null">7., 0.],
-       [0., 7.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22990">view source</a></div></div><div class="public anchor" id="var-insert"><h3>insert</h3><div class="usage"><code>(insert &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Insert values along the given axis before the given indices.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr : array_like  Input array. obj : int, slice or sequence of ints  Object that defines the index or indices before which <code>values</code> is  inserted.</p>
-<pre><code>.. versionadded:: 1.8.0
-
-Support for multiple insertions when `obj` is a single scalar or a
-sequence with one element (similar to calling insert multiple
-times).
-</code></pre>
-<p>values : array_like  Values to insert into <code>arr</code>. If the type of <code>values</code> is different  from that of <code>arr</code>, <code>values</code> is converted to the type of <code>arr</code>.  <code>values</code> should be shaped so that <code>arr[...,obj,...] = values</code>  is legal. axis : int, optional  Axis along which to insert <code>values</code>. If <code>axis</code> is None then <code>arr</code>  is flattened first.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  A copy of <code>arr</code> with <code>values</code> inserted. Note that <code>insert</code>  does not occur in-place: a new array is returned. If  <code>axis</code> is None, <code>out</code> is a flattened array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>append : Append elements at the end of an array. concatenate : Join a sequence of arrays along an existing axis. delete : Delete elements from an array.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Note that for higher dimensional inserts <code>obj=0</code> behaves very different from <code>obj=[0]</code> just like <code>arr[:,0,:] = values</code> is different from <code>arr[:,[0],:] = values</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 1], [2, 2], [3, 3</a>) a array(<a href="null">1, 1],
-       [2, 2],
-       [3, 3</a>) np.insert(a, 1, 5) array([1, 5, 1, …, 2, 3, 3]) np.insert(a, 1, 5, axis=1) array(<a href="null">1, 5, 1],
-       [2, 5, 2],
-       [3, 5, 3</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Difference between sequence and scalars:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.insert(a, [1], <a href="null">1],[2],[3</a>, axis=1) array(<a href="null">1, 1, 1],
-       [2, 2, 2],
-       [3, 3, 3</a>) np.array_equal(np.insert(a, 1, [1, 2, 3], axis=1), … np.insert(a, [1], <a href="null">1],[2],[3</a>, axis=1)) True</p>
-      <p>b = a.flatten() b array([1, 1, 2, 2, 3, 3]) np.insert(b, [2, 2], [5, 6]) array([1, 1, 5, …, 2, 3, 3])</p>
-      <p>np.insert(b, slice(2, 4), [5, 6]) array([1, 1, 5, …, 2, 3, 3])</p>
-      <p>np.insert(b, [2, 2], [7.13, False]) # type casting array([1, 1, 7, …, 2, 3, 3])</p>
-      <p>x = np.arange(8).reshape(2, 4) idx = (1, 3) np.insert(x, idx, 999, axis=1) array(<a href="null">  0, 999,   1,   2, 999,   3],
-       [  4, 999,   5,   6, 999,   7</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21809">view source</a></div></div><div class="public anchor" id="var-int"><h3>int</h3><div class="usage"><code>(int self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>int([x]) -&gt; integer int(x, base=10) -&gt; integer</p>
-<p>Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.</p>
-<p>If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by ‘+’ or ‘-’ and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>int(‘0b100’, base=0) 4</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L710">view source</a></div></div><div class="public anchor" id="var-int0"><h3>int0</h3><div class="usage"><code>(int0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with Python <code>int</code> anc C <code>long</code>. Character code: <code>'l'</code>. Canonical name: <code>np.int_</code>. Alias <em>on this platform</em>: <code>np.int64</code>: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). Alias <em>on this platform</em>: <code>np.intp</code>: Signed integer large enough to fit pointer, compatible with C <code>intptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22529">view source</a></div></div><div class="public anchor" id="var-int16"><h3>int16</h3><div class="usage"><code>(int16 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>short</code>. Character code: <code>'h'</code>. Canonical name: <code>np.short</code>. Alias <em>on this platform</em>: <code>np.int16</code>: 16-bit signed integer (-32768 to 32767).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L195">view source</a></div></div><div class="public anchor" id="var-int32"><h3>int32</h3><div class="usage"><code>(int32 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>int</code>. Character code: <code>'i'</code>. Canonical name: <code>np.intc</code>. Alias <em>on this platform</em>: <code>np.int32</code>: 32-bit signed integer (-2147483648 to 2147483647).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5536">view source</a></div></div><div class="public anchor" id="var-int64"><h3>int64</h3><div class="usage"><code>(int64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with Python <code>int</code> anc C <code>long</code>. Character code: <code>'l'</code>. Canonical name: <code>np.int_</code>. Alias <em>on this platform</em>: <code>np.int64</code>: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). Alias <em>on this platform</em>: <code>np.intp</code>: Signed integer large enough to fit pointer, compatible with C <code>intptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7604">view source</a></div></div><div class="public anchor" id="var-int8"><h3>int8</h3><div class="usage"><code>(int8 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>char</code>. Character code: <code>'b'</code>. Canonical name: <code>np.byte</code>. Alias <em>on this platform</em>: <code>np.int8</code>: 8-bit signed integer (-128 to 127).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20131">view source</a></div></div><div class="public anchor" id="var-int_"><h3>int_</h3><div class="usage"><code>(int_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with Python <code>int</code> anc C <code>long</code>. Character code: <code>'l'</code>. Canonical name: <code>np.int_</code>. Alias <em>on this platform</em>: <code>np.int64</code>: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). Alias <em>on this platform</em>: <code>np.intp</code>: Signed integer large enough to fit pointer, compatible with C <code>intptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19065">view source</a></div></div><div class="public anchor" id="var-int_asbuffer"><h3>int_asbuffer</h3><div class="usage"><code>(int_asbuffer self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1593">view source</a></div></div><div class="public anchor" id="var-intc"><h3>intc</h3><div class="usage"><code>(intc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>int</code>. Character code: <code>'i'</code>. Canonical name: <code>np.intc</code>. Alias <em>on this platform</em>: <code>np.int32</code>: 32-bit signed integer (-2147483648 to 2147483647).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5530">view source</a></div></div><div class="public anchor" id="var-integer"><h3>integer</h3><div class="usage"><code>(integer self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all integer scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20041">view source</a></div></div><div class="public anchor" id="var-interp"><h3>interp</h3><div class="usage"><code>(interp &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>One-dimensional linear interpolation.</p>
-<p>Returns the one-dimensional piecewise linear interpolant to a function with given discrete data points (<code>xp</code>, <code>fp</code>), evaluated at <code>x</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  The x-coordinates at which to evaluate the interpolated values.</p>
-<p>xp : 1-D sequence of floats  The x-coordinates of the data points, must be increasing if argument  <code>period</code> is not specified. Otherwise, <code>xp</code> is internally sorted after  normalizing the periodic boundaries with <code>xp = xp % period</code>.</p>
-<p>fp : 1-D sequence of float or complex  The y-coordinates of the data points, same length as <code>xp</code>.</p>
-<p>left : optional float or complex corresponding to fp  Value to return for <code>x &lt; xp[0]</code>, default is <code>fp[0]</code>.</p>
-<p>right : optional float or complex corresponding to fp  Value to return for <code>x &gt; xp[-1]</code>, default is <code>fp[-1]</code>.</p>
-<p>period : None or float, optional  A period for the x-coordinates. This parameter allows the proper  interpolation of angular x-coordinates. Parameters <code>left</code> and <code>right</code>  are ignored if <code>period</code> is specified.</p>
-<pre><code>.. versionadded:: 1.10.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : float or complex (corresponding to fp) or ndarray  The interpolated values, same shape as <code>x</code>.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If <code>xp</code> and <code>fp</code> have different length  If <code>xp</code> or <code>fp</code> are not 1-D sequences  If <code>period == 0</code></p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The x-coordinate sequence is expected to be increasing, but this is not explicitly enforced. However, if the sequence <code>xp</code> is non-increasing, interpolation results are meaningless.</p>
-<p>Note that, since NaN is unsortable, <code>xp</code> also cannot contain NaNs.</p>
-<p>A simple check for <code>xp</code> being strictly increasing is::</p>
-<pre><code>np.all(np.diff(xp) &gt; 0)
-</code></pre>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>xp = [1, 2, 3] fp = [3, 2, 0] np.interp(2.5, xp, fp) 1.0 np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp) array([3. , 3. , 2.5 , 0.56, 0. ]) UNDEF = -99.0 np.interp(3.14, xp, fp, right=UNDEF) -99.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot an interpolant to the sine function:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.linspace(0, 2*np.pi, 10) y = np.sin(x) xvals = np.linspace(0, 2*np.pi, 50) yinterp = np.interp(xvals, x, y) import matplotlib.pyplot as plt plt.plot(x, y, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.plot(xvals, yinterp, ‘-x’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Interpolation with periodic x-coordinates:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = [-180, -170, -185, 185, -10, -5, 0, 365] xp = [190, -190, 350, -350] fp = [5, 10, 3, 4] np.interp(x, xp, fp, period=360) array([7.5 , 5. , 8.75, 6.25, 3. , 3.25, 3.5 , 3.75])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Complex interpolation:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = [1.5, 4.0] xp = [2,3,5] fp = [1.0j, 0, 2+3j] np.interp(x, xp, fp) array([0.+1.j , 1.+1.5j])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10582">view source</a></div></div><div class="public anchor" id="var-intersect1d"><h3>intersect1d</h3><div class="usage"><code>(intersect1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the intersection of two arrays.</p>
-<p>Return the sorted, unique values that are in both of the input arrays.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>ar1, ar2 : array_like  Input arrays. Will be flattened if not already 1D. assume_unique : bool  If True, the input arrays are both assumed to be unique, which  can speed up the calculation. Default is False. return_indices : bool  If True, the indices which correspond to the intersection of the two  arrays are returned. The first instance of a value is used if there are  multiple. Default is False.</p>
-<pre><code>.. versionadded:: 1.15.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>intersect1d : ndarray  Sorted 1D array of common and unique elements. comm1 : ndarray  The indices of the first occurrences of the common values in <code>ar1</code>.  Only provided if <code>return_indices</code> is True. comm2 : ndarray  The indices of the first occurrences of the common values in <code>ar2</code>.  Only provided if <code>return_indices</code> is True.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1]) array([1, 3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>To intersect more than two arrays, use functools.reduce:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from functools import reduce reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) array([3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>To return the indices of the values common to the input arrays along with the intersected values:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([1, 1, 2, 3, 4]) y = np.array([2, 1, 4, 6]) xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True) x_ind, y_ind (array([0, 2, 4]), array([1, 0, 2])) xy, x[x_ind], y[y_ind] (array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19570">view source</a></div></div><div class="public anchor" id="var-intp"><h3>intp</h3><div class="usage"><code>(intp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with Python <code>int</code> anc C <code>long</code>. Character code: <code>'l'</code>. Canonical name: <code>np.int_</code>. Alias <em>on this platform</em>: <code>np.int64</code>: 64-bit signed integer (-9223372036854775808 to 9223372036854775807). Alias <em>on this platform</em>: <code>np.intp</code>: Signed integer large enough to fit pointer, compatible with C <code>intptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4070">view source</a></div></div><div class="public anchor" id="var-invert"><h3>invert</h3><div class="usage"><code>(invert self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>invert(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute bit-wise inversion, or bit-wise NOT, element-wise.</p>
-<p>Computes the bit-wise NOT of the underlying binary representation of the integers in the input arrays. This ufunc implements the C/Python operator <code>~</code>.</p>
-<p>For signed integer inputs, the two’s complement is returned. In a two’s-complement system negative numbers are represented by the two’s complement of the absolute value. This is the most common method of representing signed integers on computers [1]_. A N-bit two’s-complement system can represent every integer in the range :math:<code>-2^{N-1}</code> to :math:<code>+2^{N-1}-1</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Only integer and boolean types are handled. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Result.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>bitwise_and, bitwise_or, bitwise_xor logical_not binary_repr :  Return the binary representation of the input number as a string.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>bitwise_not</code> is an alias for <code>invert</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.bitwise_not is np.invert True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Wikipedia, “Two’s complement”,  <a href="https://en.wikipedia.org/wiki/Two's_complement">https://en.wikipedia.org/wiki/Two's_complement</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>We’ve seen that 13 is represented by <code>00001101</code>. The invert or bit-wise NOT of 13 is then:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.invert(np.array(13, dtype=np.uint8)) x 242 np.binary_repr(x, width=8) ‘11110010’</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The result depends on the bit-width:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.invert(np.array(13, dtype=np.uint16)) x 65522 np.binary_repr(x, width=16) ‘1111111111110010’</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>When using signed integer types the result is the two’s complement of the result for the unsigned type:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.invert(np.array([13], dtype=np.int8)) array([-14], dtype=int8) np.binary_repr(-14, width=8) ‘11110010’</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Booleans are accepted as well:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.invert(np.array([True, False])) array([False, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2133">view source</a></div></div><div class="public anchor" id="var-ipmt"><h3>ipmt</h3><div class="usage"><code>(ipmt &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the interest portion of a payment.</p>
-<p>.. deprecated:: 1.18</p>
-<p><code>ipmt</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>rate : scalar or array_like of shape(M, )  Rate of interest as decimal (not per cent) per period per : scalar or array_like of shape(M, )  Interest paid against the loan changes during the life or the loan.  The <code>per</code> is the payment period to calculate the interest amount. nper : scalar or array_like of shape(M, )  Number of compounding periods pv : scalar or array_like of shape(M, )  Present value fv : scalar or array_like of shape(M, ), optional  Future value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}, optional  When payments are due (‘begin’ (1) or ‘end’ (0)).  Defaults to {‘end’, 0}.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Interest portion of payment. If all input is scalar, returns a scalar  float. If any input is array_like, returns interest payment for each  input element. If multiple inputs are array_like, they all must have  the same shape.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ppmt, pmt, pv</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The total payment is made up of payment against principal plus interest.</p>
-<p><code>pmt = ppmt + ipmt</code></p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>What is the amortization schedule for a 1 year loan of $2500 at 8.24% interest per year compounded monthly?</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>principal = 2500.00</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The ‘per’ variable represents the periods of the loan. Remember that financial equations start the period count at 1!</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>per = np.arange(1*12) + 1 ipmt = np.ipmt(0.0824/12, per, 1*12, principal) ppmt = np.ppmt(0.0824/12, per, 1*12, principal)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Each element of the sum of the ‘ipmt’ and ‘ppmt’ arrays should equal ‘pmt’.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>pmt = np.pmt(0.0824/12, 1*12, principal) np.allclose(ipmt + ppmt, pmt) True</p>
-      <p>fmt = ‘{0:2d} {1:8.2f} {2:8.2f} {3:8.2f}’ for payment in per: … index = payment - 1 … principal = principal + ppmt[index] … print(fmt.format(payment, ppmt[index], ipmt[index], principal))  1 -200.58 -17.17 2299.42  2 -201.96 -15.79 2097.46  3 -203.35 -14.40 1894.11  4 -204.74 -13.01 1689.37  5 -206.15 -11.60 1483.22  6 -207.56 -10.18 1275.66  7 -208.99 -8.76 1066.67  8 -210.42 -7.32 856.25  9 -211.87 -5.88 644.38 10 -213.32 -4.42 431.05 11 -214.79 -2.96 216.26 12 -216.26 -1.49 -0.00</p>
-      <p>interestpd = np.sum(ipmt) np.round(interestpd, 2) -112.98</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9913">view source</a></div></div><div class="public anchor" id="var-irr"><h3>irr</h3><div class="usage"><code>(irr &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the Internal Rate of Return (IRR).</p>
-<p>.. deprecated:: 1.18</p>
-<p><code>irr</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
-<p>This is the “average” periodically compounded rate of return that gives a net present value of 0.0; for a more complete explanation, see Notes below.</p>
-<p>:class:<code>decimal.Decimal</code> type is not supported.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>values : array_like, shape(N,)  Input cash flows per time period. By convention, net “deposits”  are negative and net “withdrawals” are positive. Thus, for  example, at least the first element of <code>values</code>, which represents  the initial investment, will typically be negative.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : float  Internal Rate of Return for periodic input values.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The IRR is perhaps best understood through an example (illustrated using np.irr in the Examples section below). Suppose one invests 100 units and then makes the following withdrawals at regular (fixed) intervals: 39, 59, 55, 20. Assuming the ending value is 0, one’s 100 unit investment yields 173 units; however, due to the combination of compounding and the periodic withdrawals, the “average” rate of return is neither simply 0.73/4 nor (1.73)^0.25-1. Rather, it is the solution (for :math:<code>r</code>) of the equation:</p>
-<p>.. math:: -100 + \frac{39}{1+r} + \frac{59}{(1+r)^2}  + \frac{55}{(1+r)^3} + \frac{20}{(1+r)^4} = 0</p>
-<p>In general, for <code>values</code> :math:<code>= [v_0, v_1, ... v_M]</code>, irr is the solution of the equation: [2]_</p>
-<p>.. math:: \sum_{t=0}^M{\frac{v_t}{(1+irr)^{t}}} = 0</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] L. J. Gitman, “Principles of Managerial Finance, Brief,” 3rd ed.,  Addison-Wesley, 2003, pg. 348.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>round(np.irr([-100, 39, 59, 55, 20]), 5) 0.28095 round(np.irr([-100, 0, 0, 74]), 5) -0.0955 round(np.irr([-100, 100, 0, -7]), 5) -0.0833 round(np.irr([-100, 100, 0, 7]), 5) 0.06206 round(np.irr([-5, 10.5, 1, -8, 1]), 5) 0.0886</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18661">view source</a></div></div><div class="public anchor" id="var-is_busday"><h3>is_busday</h3><div class="usage"><code>(is_busday &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>is_busday(dates, weekmask=‘1111100’, holidays=None, busdaycal=None, out=None)</p>
-<p>Calculates which of the given dates are valid days, and which are not.</p>
-<p>.. versionadded:: 1.7.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>dates : array_like of datetime64[D]  The array of dates to process. weekmask : str or array_like of bool, optional  A seven-element array indicating which of Monday through Sunday are  valid days. May be specified as a length-seven list or array, like  [1,1,1,1,1,0,0]; a length-seven string, like ‘1111100’; or a string  like “Mon Tue Wed Thu Fri”, made up of 3-character abbreviations for  weekdays, optionally separated by white space. Valid abbreviations  are: Mon Tue Wed Thu Fri Sat Sun holidays : array_like of datetime64[D], optional  An array of dates to consider as invalid dates. They may be  specified in any order, and NaT (not-a-time) dates are ignored.  This list is saved in a normalized form that is suited for  fast calculations of valid days. busdaycal : busdaycalendar, optional  A <code>busdaycalendar</code> object which specifies the valid days. If this  parameter is provided, neither weekmask nor holidays may be  provided. out : array of bool, optional  If provided, this array is filled with the result.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : array of bool  An array with the same shape as <code>dates</code>, containing True for  each valid day, and False for each invalid day.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>busdaycalendar: An object that specifies a custom set of valid days. busday_offset : Applies an offset counted in valid days. busday_count : Counts how many valid days are in a half-open date range.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <h1><a href="#the-weekdays-are-friday-saturday-and-monday" name="the-weekdays-are-friday-saturday-and-monday"></a>The weekdays are Friday, Saturday, and Monday</h1>
-      <p>… np.is_busday([‘2011-07-01’, ‘2011-07-02’, ‘2011-07-18’], … holidays=[‘2011-07-01’, ‘2011-07-04’, ‘2011-07-17’]) array([False, False, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5768">view source</a></div></div><div class="public anchor" id="var-isclose"><h3>isclose</h3><div class="usage"><code>(isclose &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns a boolean array where two arrays are element-wise equal within a tolerance.</p>
-<p>The tolerance values are positive, typically very small numbers. The relative difference (<code>rtol</code> * abs(<code>b</code>)) and the absolute difference <code>atol</code> are added together to compare against the absolute difference between <code>a</code> and <code>b</code>.</p>
-<p>.. warning:: The default <code>atol</code> is not appropriate for comparing numbers  that are much smaller than one (see Notes).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a, b : array_like  Input arrays to compare. rtol : float  The relative tolerance parameter (see Notes). atol : float  The absolute tolerance parameter (see Notes). equal_nan : bool  Whether to compare NaN’s as equal. If True, NaN’s in <code>a</code> will be  considered equal to NaN’s in <code>b</code> in the output array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : array_like  Returns a boolean array of where <code>a</code> and <code>b</code> are equal within the  given tolerance. If both <code>a</code> and <code>b</code> are scalars, returns a single  boolean value.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>allclose</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.7.0</p>
-<p>For finite values, isclose uses the following equation to test whether two floating point values are equivalent.</p>
-<p>absolute(<code>a</code> - <code>b</code>) &lt;= (<code>atol</code> + <code>rtol</code> * absolute(<code>b</code>))</p>
-<p>Unlike the built-in <code>math.isclose</code>, the above equation is not symmetric in <code>a</code> and <code>b</code> – it assumes <code>b</code> is the reference value – so that <code>isclose(a, b)</code> might be different from <code>isclose(b, a)</code>. Furthermore, the default value of atol is not zero, and is used to determine what small values should be considered close to zero. The default value is appropriate for expected values of order unity: if the expected values are significantly smaller than one, it can result in false positives. <code>atol</code> should be carefully selected for the use case at hand. A zero value for <code>atol</code> will result in <code>False</code> if either <code>a</code> or <code>b</code> is zero.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isclose([1e10,1e-7], [1.00001e10,1e-8]) array([ True, False]) np.isclose([1e10,1e-8], [1.00001e10,1e-9]) array([ True, True]) np.isclose([1e10,1e-8], [1.0001e10,1e-9]) array([False, True]) np.isclose([1.0, np.nan], [1.0, np.nan]) array([ True, False]) np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True) array([ True, True]) np.isclose([1e-8, 1e-7], [0.0, 0.0]) array([ True, False]) np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0) array([False, False]) np.isclose([1e-10, 1e-10], [1e-20, 0.0]) array([ True, True]) np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0) array([False, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22359">view source</a></div></div><div class="public anchor" id="var-iscomplex"><h3>iscomplex</h3><div class="usage"><code>(iscomplex &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns a bool array, where True if input element is complex.</p>
-<p>What is tested is whether the input has a non-zero imaginary part, not if the input type is complex.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray of bools  Output array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>isreal iscomplexobj : Return True if x is a complex type or an array of complex  numbers.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j]) array([ True, False, False, False, False, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12036">view source</a></div></div><div class="public anchor" id="var-iscomplexobj"><h3>iscomplexobj</h3><div class="usage"><code>(iscomplexobj &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Check for a complex type or an array of complex numbers.</p>
-<p>The type of the input is checked, not the value. Even if the input has an imaginary part equal to zero, <code>iscomplexobj</code> evaluates to True.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : any  The input can be of any type and shape.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>iscomplexobj : bool  The return value, True if <code>x</code> is of a complex type or has at least  one complex element.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>isrealobj, iscomplex</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.iscomplexobj(1) False np.iscomplexobj(1+0j) True np.iscomplexobj([3, 1+0j, True]) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5276">view source</a></div></div><div class="public anchor" id="var-isfinite"><h3>isfinite</h3><div class="usage"><code>(isfinite self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>isfinite(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Test element-wise for finiteness (not infinity or not Not a Number).</p>
-<p>The result is returned as a boolean array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray, bool  True where <code>x</code> is not positive infinity, negative infinity,  or NaN; false otherwise.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>isinf, isneginf, isposinf, isnan</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Not a Number, positive infinity and negative infinity are considered to be non-finite.</p>
-<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity. Also that positive infinity is not equivalent to negative infinity. But infinity is equivalent to positive infinity. Errors result if the second argument is also supplied when <code>x</code> is a scalar input, or if first and second arguments have different shapes.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isfinite(1) True np.isfinite(0) True np.isfinite(np.nan) False np.isfinite(np.inf) False np.isfinite(np.NINF) False np.isfinite([np.log(-1.),1.,np.log(0)]) array([False, True, False])</p>
-      <p>x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) np.isfinite(x, y) array([0, 1, 0]) y array([0, 1, 0])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12890">view source</a></div></div><div class="public anchor" id="var-isfortran"><h3>isfortran</h3><div class="usage"><code>(isfortran a)</code></div><div class="doc"><div class="markdown"><p>Check if the array is Fortran contiguous but <em>not</em> C contiguous.</p>
-<p>This function is obsolete and, because of changes due to relaxed stride checking, its return value for the same array may differ for versions of NumPy &gt;= 1.10.0 and previous versions. If you only want to check if an array is Fortran contiguous use <code>a.flags.f_contiguous</code> instead.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : ndarray  Input array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>isfortran : bool  Returns True if the array is Fortran contiguous but <em>not</em> C contiguous.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>np.array allows to specify whether the array is written in C-contiguous order (last index varies the fastest), or FORTRAN-contiguous order in memory (first index varies the fastest).</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 2, 3], [4, 5, 6</a>, order=‘C’) a array(<a href="null">1, 2, 3],
-       [4, 5, 6</a>) np.isfortran(a) False</p>
-      <p>b = np.array(<a href="null">1, 2, 3], [4, 5, 6</a>, order=‘F’) b array(<a href="null">1, 2, 3],
-       [4, 5, 6</a>) np.isfortran(b) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The transpose of a C-ordered array is a FORTRAN-ordered array.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 2, 3], [4, 5, 6</a>, order=‘C’) a array(<a href="null">1, 2, 3],
-       [4, 5, 6</a>) np.isfortran(a) False b = a.T b array(<a href="null">1, 4],
-       [2, 5],
-       [3, 6</a>) np.isfortran(b) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>C-ordered arrays evaluate as False even if they are also FORTRAN-ordered.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isfortran(np.array([1, 2], order=‘F’)) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15738">view source</a></div></div><div class="public anchor" id="var-isin"><h3>isin</h3><div class="usage"><code>(isin &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Calculates <code>element in test_elements</code>, broadcasting over <code>element</code> only. Returns a boolean array of the same shape as <code>element</code> that is True where an element of <code>element</code> is in <code>test_elements</code> and False otherwise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>element : array_like  Input array. test_elements : array_like  The values against which to test each value of <code>element</code>.  This argument is flattened if it is an array or array_like.  See notes for behavior with non-array-like parameters. assume_unique : bool, optional  If True, the input arrays are both assumed to be unique, which  can speed up the calculation. Default is False. invert : bool, optional  If True, the values in the returned array are inverted, as if  calculating <code>element not in test_elements</code>. Default is False.  <code>np.isin(a, b, invert=True)</code> is equivalent to (but faster  than) <code>np.invert(np.isin(a, b))</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>isin : ndarray, bool  Has the same shape as <code>element</code>. The values <code>element[isin]</code>  are in <code>test_elements</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>in1d : Flattened version of this function. numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>isin</code> is an element-wise function version of the python keyword <code>in</code>. <code>isin(a, b)</code> is roughly equivalent to <code>np.array([item in b for item in a])</code> if <code>a</code> and <code>b</code> are 1-D sequences.</p>
-<p><code>element</code> and <code>test_elements</code> are converted to arrays if they are not already. If <code>test_elements</code> is a set (or other non-sequence collection) it will be converted to an object array with one element, rather than an array of the values contained in <code>test_elements</code>. This is a consequence of the <code>array</code> constructor’s way of handling non-sequence collections. Converting the set to a list usually gives the desired behavior.</p>
-<p>.. versionadded:: 1.13.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>element = 2*np.arange(4).reshape((2, 2)) element array(<a href="null">0, 2],
-       [4, 6</a>) test_elements = [1, 2, 4, 8] mask = np.isin(element, test_elements) mask array(<a href="null">False,  True],
-       [ True, False</a>) element[mask] array([2, 4])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The indices of the matched values can be obtained with <code>nonzero</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.nonzero(mask) (array([0, 1]), array([1, 0]))</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The test can also be inverted:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>mask = np.isin(element, test_elements, invert=True) mask array(<a href="null"> True, False],
-       [False,  True</a>) element[mask] array([0, 6])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Because of how <code>array</code> handles sets, the following does not work as expected:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>test_set = {1, 2, 4, 8} np.isin(element, test_set) array(<a href="null">False, False],
-       [False, False</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Casting the set to a list gives the expected result:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isin(element, list(test_set)) array(<a href="null">False,  True],
-       [ True, False</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11101">view source</a></div></div><div class="public anchor" id="var-isinf"><h3>isinf</h3><div class="usage"><code>(isinf self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>isinf(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Test element-wise for positive or negative infinity.</p>
-<p>Returns a boolean array of the same shape as <code>x</code>, True where <code>x ==
-+/-inf</code>, otherwise False.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input values out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : bool (scalar) or boolean ndarray  True where <code>x</code> is positive or negative infinity, false otherwise.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>isneginf, isposinf, isnan, isfinite</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754).</p>
-<p>Errors result if the second argument is supplied when the first argument is a scalar, or if the first and second arguments have different shapes.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isinf(np.inf) True np.isinf(np.nan) False np.isinf(np.NINF) True np.isinf([np.inf, -np.inf, 1.0, np.nan]) array([ True, True, False, False])</p>
-      <p>x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) np.isinf(x, y) array([1, 0, 1]) y array([1, 0, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2426">view source</a></div></div><div class="public anchor" id="var-isnan"><h3>isnan</h3><div class="usage"><code>(isnan self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>isnan(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Test element-wise for NaN and return result as a boolean array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or bool  True where <code>x</code> is NaN, false otherwise.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>isinf, isneginf, isposinf, isfinite, isnat</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isnan(np.nan) True np.isnan(np.inf) False np.isnan([np.log(-1.),1.,np.log(0)]) array([ True, False, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10259">view source</a></div></div><div class="public anchor" id="var-isnat"><h3>isnat</h3><div class="usage"><code>(isnat self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>isnat(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Test element-wise for NaT (not a time) and return result as a boolean array.</p>
-<p>.. versionadded:: 1.13.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array with datetime or timedelta data type. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or bool  True where <code>x</code> is NaT, false otherwise.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>isnan, isinf, isneginf, isposinf, isfinite</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isnat(np.datetime64(“NaT”)) True np.isnat(np.datetime64(“2016-01-01”)) False np.isnat(np.array([“NaT”, “2016-01-01”], dtype=“datetime64[ns]”)) array([ True, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8951">view source</a></div></div><div class="public anchor" id="var-isneginf"><h3>isneginf</h3><div class="usage"><code>(isneginf &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Test element-wise for negative infinity, return result as bool array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  The input array. out : array_like, optional  A boolean array with the same shape and type as <code>x</code> to store the  result.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  A boolean array with the same dimensions as the input.  If second argument is not supplied then a numpy boolean array is  returned with values True where the corresponding element of the  input is negative infinity and values False where the element of  the input is not negative infinity.</p>
-<pre><code>If a second argument is supplied the result is stored there. If the
-type of that array is a numeric type the result is represented as
-zeros and ones, if the type is boolean then as False and True. The
-return value `out` is then a reference to that array.
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>isinf, isposinf, isnan, isfinite</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754).</p>
-<p>Errors result if the second argument is also supplied when x is a scalar input, if first and second arguments have different shapes, or if the first argument has complex values.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isneginf(np.NINF) True np.isneginf(np.inf) False np.isneginf(np.PINF) False np.isneginf([-np.inf, 0., np.inf]) array([ True, False, False])</p>
-      <p>x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) np.isneginf(x, y) array([1, 0, 0]) y array([1, 0, 0])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3486">view source</a></div></div><div class="public anchor" id="var-isposinf"><h3>isposinf</h3><div class="usage"><code>(isposinf &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Test element-wise for positive infinity, return result as bool array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  The input array. y : array_like, optional  A boolean array with the same shape as <code>x</code> to store the result.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  A boolean array with the same dimensions as the input.  If second argument is not supplied then a boolean array is returned  with values True where the corresponding element of the input is  positive infinity and values False where the element of the input is  not positive infinity.</p>
-<pre><code>If a second argument is supplied the result is stored there. If the
-type of that array is a numeric type the result is represented as zeros
-and ones, if the type is boolean then as False and True.
-The return value `out` is then a reference to that array.
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>isinf, isneginf, isfinite, isnan</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754).</p>
-<p>Errors result if the second argument is also supplied when x is a scalar input, if first and second arguments have different shapes, or if the first argument has complex values</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isposinf(np.PINF) True np.isposinf(np.inf) True np.isposinf(np.NINF) False np.isposinf([-np.inf, 0., np.inf]) array([False, False, True])</p>
-      <p>x = np.array([-np.inf, 0., np.inf]) y = np.array([2, 2, 2]) np.isposinf(x, y) array([0, 0, 1]) y array([0, 0, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22108">view source</a></div></div><div class="public anchor" id="var-isreal"><h3>isreal</h3><div class="usage"><code>(isreal &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns a bool array, where True if input element is real.</p>
-<p>If element has complex type with zero complex part, the return value for that element is True.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray, bool  Boolean array of same shape as <code>x</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>iscomplex isrealobj : Return True if x is not a complex type.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isreal([1+1j, 1+0j, 4.5, 3, 2, 2j]) array([False, True, True, True, True, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16806">view source</a></div></div><div class="public anchor" id="var-isrealobj"><h3>isrealobj</h3><div class="usage"><code>(isrealobj &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return True if x is a not complex type or an array of complex numbers.</p>
-<p>The type of the input is checked, not the value. So even if the input has an imaginary part equal to zero, <code>isrealobj</code> evaluates to False if the data type is complex.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : any  The input can be of any type and shape.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : bool  The return value, False if <code>x</code> is of a complex type.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>iscomplexobj, isreal</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isrealobj(1) True np.isrealobj(1+0j) False np.isrealobj([3, 1+0j, True]) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25694">view source</a></div></div><div class="public anchor" id="var-isscalar"><h3>isscalar</h3><div class="usage"><code>(isscalar element)</code></div><div class="doc"><div class="markdown"><p>Returns True if the type of <code>element</code> is a scalar type.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>element : any  Input argument, can be of any type and shape.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>val : bool  True if <code>element</code> is a scalar type, False if it is not.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndim : Get the number of dimensions of an array</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If you need a stricter way to identify a <em>numerical</em> scalar, use <code>isinstance(x, numbers.Number)</code>, as that returns <code>False</code> for most non-numerical elements such as strings.</p>
-<p>In most cases <code>np.ndim(x) == 0</code> should be used instead of this function, as that will also return true for 0d arrays. This is how numpy overloads functions in the style of the <code>dx</code> arguments to <code>gradient</code> and the <code>bins</code> argument to <code>histogram</code>. Some key differences:</p>
-<p>+————————————–+—————+——————-+ | x |<code>isscalar(x)</code>|<code>np.ndim(x) == 0</code>| +======================================+===============+===================+ | PEP 3141 numeric objects (including | <code>True</code> | <code>True</code> | | builtins) | | | +————————————–+—————+——————-+ | builtin string and buffer objects | <code>True</code> | <code>True</code> | +————————————–+—————+——————-+ | other builtin objects, like | <code>False</code> | <code>True</code> | | <code>pathlib.Path</code>, <code>Exception</code>, | | | | the result of <code>re.compile</code> | | | +————————————–+—————+——————-+ | third-party objects like | <code>False</code> | <code>True</code> | | <code>matplotlib.figure.Figure</code> | | | +————————————–+—————+——————-+ | zero-dimensional numpy arrays | <code>False</code> | <code>True</code> | +————————————–+—————+——————-+ | other numpy arrays | <code>False</code> | <code>False</code> | +————————————–+—————+——————-+ | <code>list</code>, <code>tuple</code>, and other sequence | <code>False</code> | <code>False</code> | | objects | | | +————————————–+—————+——————-+</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.isscalar(3.1) True np.isscalar(np.array(3.1)) False np.isscalar([3.1]) False np.isscalar(False) True np.isscalar(‘numpy’) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>NumPy supports PEP 3141 numbers:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from fractions import Fraction np.isscalar(Fraction(5, 17)) True from numbers import Number np.isscalar(Number()) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L857">view source</a></div></div><div class="public anchor" id="var-issctype"><h3>issctype</h3><div class="usage"><code>(issctype rep)</code></div><div class="doc"><div class="markdown"><p>Determines whether the given object represents a scalar data-type.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>rep : any  If <code>rep</code> is an instance of a scalar dtype, True is returned. If not,  False is returned.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : bool  Boolean result of check whether <code>rep</code> is a scalar dtype.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>issubsctype, issubdtype, obj2sctype, sctype2char</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.issctype(np.int32) True np.issctype(list) False np.issctype(1.1) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Strings are also a scalar type:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.issctype(np.dtype(‘str’)) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18149">view source</a></div></div><div class="public anchor" id="var-issubclass_"><h3>issubclass_</h3><div class="usage"><code>(issubclass_ arg1 arg2)</code></div><div class="doc"><div class="markdown"><p>Determine if a class is a subclass of a second class.</p>
-<p><code>issubclass_</code> is equivalent to the Python built-in <code>issubclass</code>, except that it returns False instead of raising a TypeError if one of the arguments is not a class.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arg1 : class  Input class. True is returned if <code>arg1</code> is a subclass of <code>arg2</code>. arg2 : class or tuple of classes.  Input class. If a tuple of classes, True is returned if <code>arg1</code> is a  subclass of any of the tuple elements.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : bool  Whether <code>arg1</code> is a subclass of <code>arg2</code> or not.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>issubsctype, issubdtype, issctype</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.issubclass_(np.int32, int) False # True on Python 2.7 np.issubclass_(np.int32, float) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7674">view source</a></div></div><div class="public anchor" id="var-issubdtype"><h3>issubdtype</h3><div class="usage"><code>(issubdtype arg1 arg2)</code></div><div class="doc"><div class="markdown"><p>Returns True if first argument is a typecode lower/equal in type hierarchy.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arg1, arg2 : dtype_like  dtype or string representing a typecode.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : bool</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>issubsctype, issubclass_ numpy.core.numerictypes : Overview of numpy type hierarchy.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.issubdtype(‘S1’, np.string_) True np.issubdtype(np.float64, np.float32) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26233">view source</a></div></div><div class="public anchor" id="var-issubsctype"><h3>issubsctype</h3><div class="usage"><code>(issubsctype arg1 arg2)</code></div><div class="doc"><div class="markdown"><p>Determine if the first argument is a subclass of the second argument.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arg1, arg2 : dtype or dtype specifier  Data-types.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : bool  The result.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>issctype, issubdtype, obj2sctype</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.issubsctype(‘S8’, str) False np.issubsctype(np.array([1]), int) True np.issubsctype(np.array([1]), float) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21981">view source</a></div></div><div class="public anchor" id="var-iterable"><h3>iterable</h3><div class="usage"><code>(iterable y)</code></div><div class="doc"><div class="markdown"><p>Check whether or not an object can be iterated over.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>y : object  Input object.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>b : bool  Return <code>True</code> if the object has an iterator method or is a  sequence and <code>False</code> otherwise.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.iterable([1, 2, 3]) True np.iterable(2) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21309">view source</a></div></div><div class="public anchor" id="var-ix_"><h3>ix_</h3><div class="usage"><code>(ix_ &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Construct an open mesh from multiple sequences.</p>
-<p>This function takes N 1-D sequences and returns N outputs with N dimensions each, such that the shape is 1 in all but one dimension and the dimension with the non-unit shape value cycles through all N dimensions.</p>
-<p>Using <code>ix_</code> one can quickly construct index arrays that will index the cross product. <code>a[np.ix_([1,3],[2,5])]</code> returns the array <code>[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>args : 1-D sequences  Each sequence should be of integer or boolean type.  Boolean sequences will be interpreted as boolean masks for the  corresponding dimension (equivalent to passing in  <code>np.nonzero(boolean_sequence)</code>).</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : tuple of ndarrays  N arrays with N dimensions each, with N the number of input  sequences. Together these arrays form an open mesh.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ogrid, mgrid, meshgrid</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(10).reshape(2, 5) a array(<a href="null">0, 1, 2, 3, 4],
-       [5, 6, 7, 8, 9</a>) ixgrid = np.ix_([0, 1], [2, 4]) ixgrid (array(<a href="null">0],
-       [1</a>), array(<a href="null">2, 4</a>)) ixgrid[0].shape, ixgrid[1].shape ((2, 1), (1, 2)) a[ixgrid] array(<a href="null">2, 4],
-       [7, 9</a>)</p>
-      <p>ixgrid = np.ix_([True, True], [2, 4]) a[ixgrid] array(<a href="null">2, 4],
-       [7, 9</a>) ixgrid = np.ix_([True, True], [False, False, True, False, True]) a[ixgrid] array(<a href="null">2, 4],
-       [7, 9</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1533">view source</a></div></div><div class="public anchor" id="var-kaiser"><h3>kaiser</h3><div class="usage"><code>(kaiser M beta)</code></div><div class="doc"><div class="markdown"><p>Return the Kaiser window.</p>
-<p>The Kaiser window is a taper formed by using a Bessel function.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>M : int  Number of points in the output window. If zero or less, an  empty array is returned. beta : float  Shape parameter for window.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : array  The window, with the maximum value normalized to one (the value  one appears only if the number of samples is odd).</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>bartlett, blackman, hamming, hanning</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The Kaiser window is defined as</p>
-<p>.. math:: w(n) = I_0\left( \beta \sqrt{1-\frac{4n^2}{(M-1)^2}}  \right)/I_0(\beta)</p>
-<p>with</p>
-<p>.. math:: \quad -\frac{M-1}{2} \leq n \leq \frac{M-1}{2},</p>
-<p>where :math:<code>I_0</code> is the modified zeroth-order Bessel function.</p>
-<p>The Kaiser was named for Jim Kaiser, who discovered a simple approximation to the DPSS window based on Bessel functions. The Kaiser window is a very good approximation to the Digital Prolate Spheroidal Sequence, or Slepian window, which is the transform which maximizes the energy in the main lobe of the window relative to total energy.</p>
-<p>The Kaiser can approximate many other windows by varying the beta parameter.</p>
-<p>==== ======================= beta Window shape ==== ======================= 0 Rectangular 5 Similar to a Hamming 6 Similar to a Hanning 8.6 Similar to a Blackman ==== =======================</p>
-<p>A beta value of 14 is probably a good starting point. Note that as beta gets large, the window narrows, and so the number of samples needs to be large enough to sample the increasingly narrow spike, otherwise NaNs will get returned.</p>
-<p>Most references to the Kaiser window come from the signal processing literature, where it is used as one of many windowing functions for smoothing values. It is also known as an apodization (which means “removing the foot”, i.e. smoothing discontinuities at the beginning and end of the sampled signal) or tapering function.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] J. F. Kaiser, “Digital Filters” - Ch 7 in “Systems analysis by  digital computer”, Editors: F.F. Kuo and J.F. Kaiser, p 218-285.  John Wiley and Sons, New York, (1966). .. [2] E.R. Kanasewich, “Time Sequence Analysis in Geophysics”, The  University of Alberta Press, 1975, pp. 177-178. .. [3] Wikipedia, “Window function”,  <a href="https://en.wikipedia.org/wiki/Window_function">https://en.wikipedia.org/wiki/Window_function</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt np.kaiser(12, 14)  array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary  2.29737120e-01, 5.99885316e-01, 9.45674898e-01,  9.45674898e-01, 5.99885316e-01, 2.29737120e-01,  4.65200189e-02, 3.46009194e-03, 7.72686684e-06])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot the window and the frequency response:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from numpy.fft import fft, fftshift window = np.kaiser(51, 14) plt.plot(window) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Kaiser window”) Text(0.5, 1.0, ‘Kaiser window’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“Sample”) Text(0.5, 0, ‘Sample’) plt.show()</p>
-      <p>plt.figure() </p><figure size="" 640x480="" with="" 0="" axes=""> A = fft(window, 2048) / 25.5 mag = np.abs(fftshift(A)) freq = np.linspace(-0.5, 0.5, len(A)) response = 20 * np.log10(mag) response = np.clip(response, -100, 100) plt.plot(freq, response) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Frequency response of Kaiser window”) Text(0.5, 1.0, ‘Frequency response of Kaiser window’) plt.ylabel(“Magnitude [dB]”) Text(0, 0.5, ‘Magnitude [dB]’) plt.xlabel(“Normalized frequency [cycles per sample]”) Text(0.5, 0, ‘Normalized frequency [cycles per sample]’) plt.axis(‘tight’) (-0.5, 0.5, -100.0, …) # may vary plt.show()<p></p>
-    </figure></blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8447">view source</a></div></div><div class="public anchor" id="var-kron"><h3>kron</h3><div class="usage"><code>(kron &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Kronecker product of two arrays.</p>
-<p>Computes the Kronecker product, a composite array made of blocks of the second array scaled by the first.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a, b : array_like</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>outer : The outer product</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The function assumes that the number of dimensions of <code>a</code> and <code>b</code> are the same, if necessary prepending the smallest with ones. If <code>a.shape = (r0,r1,..,rN)</code> and <code>b.shape = (s0,s1,...,sN)</code>, the Kronecker product has shape <code>(r0*s0, r1*s1, ..., rN*SN)</code>. The elements are products of elements from <code>a</code> and <code>b</code>, organized explicitly by::</p>
-<pre><code>kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]
-</code></pre>
-<p>where::</p>
-<pre><code>kt = it * st + jt,  t = 0,...,N
-</code></pre>
-<p>In the common 2-D case (N=1), the block structure can be visualized::</p>
-<pre><code>[[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
- [  ...                              ...   ],
- [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]]
-</code></pre>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.kron([1,10,100], [5,6,7]) array([ 5, 6, 7, …, 500, 600, 700]) np.kron([5,6,7], [1,10,100]) array([ 5, 50, 500, …, 7, 70, 700])</p>
-      <p>np.kron(np.eye(2), np.ones((2,2))) array(<a href="null">1.,  1.,  0.,  0.],
-       [1.,  1.,  0.,  0.],
-       [0.,  0.,  1.,  1.],
-       [0.,  0.,  1.,  1.</a>)</p>
-      <p>a = np.arange(100).reshape((2,5,2,5)) b = np.arange(24).reshape((2,3,4)) c = np.kron(a,b) c.shape (2, 10, 6, 20) I = (1,3,0,2) J = (0,2,1) J1 = (0,) + J # extend to ndim=4 S1 = (1,) + b.shape K = tuple(np.array(I) * np.array(S1) + np.array(J1)) c[K] == a[I]*b[J] True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L284">view source</a></div></div><div class="public anchor" id="var-lcm"><h3>lcm</h3><div class="usage"><code>(lcm self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>lcm(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Returns the lowest common multiple of <code>|x1|</code> and <code>|x2|</code></p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like, int  Arrays of values. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output).</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  The lowest common multiple of the absolute value of the inputs  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>gcd : The greatest common divisor</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.lcm(12, 20) 60 np.lcm.reduce([3, 12, 20]) 60 np.lcm.reduce([40, 12, 20]) 120 np.lcm(np.arange(6), 20) array([ 0, 20, 20, 60, 20, 20])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5622">view source</a></div></div><div class="public anchor" id="var-ldexp"><h3>ldexp</h3><div class="usage"><code>(ldexp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>ldexp(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Returns x1 * 2**x2, element-wise.</p>
-<p>The mantissas <code>x1</code> and twos exponents <code>x2</code> are used to construct floating point numbers <code>x1 * 2**x2</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  Array of multipliers. x2 : array_like, int  Array of twos exponents. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  The result of <code>x1 * 2**x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>frexp : Return (y1, y2) from <code>x = y1 * 2**y2</code>, inverse to <code>ldexp</code>.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Complex dtypes are not supported, they will raise a TypeError.</p>
-<p><code>ldexp</code> is useful as the inverse of <code>frexp</code>, if used by itself it is more clear to simply use the expression <code>x1 * 2**x2</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.ldexp(5, np.arange(4)) array([ 5., 10., 20., 40.], dtype=float16)</p>
-      <p>x = np.arange(6) np.ldexp(*np.frexp(x)) array([ 0., 1., 2., 3., 4., 5.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22536">view source</a></div></div><div class="public anchor" id="var-left_shift"><h3>left_shift</h3><div class="usage"><code>(left_shift self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>left_shift(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Shift the bits of an integer to the left.</p>
-<p>Bits are shifted to the left by appending <code>x2</code> 0s at the right of <code>x1</code>. Since the internal representation of numbers is in binary format, this operation is equivalent to multiplying <code>x1</code> by <code>2**x2</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like of integer type  Input values. x2 : array_like of integer type  Number of zeros to append to <code>x1</code>. Has to be non-negative.  If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : array of integer type  Return <code>x1</code> with bits shifted <code>x2</code> times to the left.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>right_shift : Shift the bits of an integer to the right. binary_repr : Return the binary representation of the input number  as a string.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.binary_repr(5) ‘101’ np.left_shift(5, 2) 20 np.binary_repr(20) ‘10100’</p>
-      <p>np.left_shift(5, [1,2,3]) array([10, 20, 40])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27574">view source</a></div></div><div class="public anchor" id="var-less"><h3>less</h3><div class="usage"><code>(less self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>less(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the truth value of (x1 &lt; x2) element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>greater, less_equal, greater_equal, equal, not_equal</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.less([1, 2], [2, 2]) array([ True, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20461">view source</a></div></div><div class="public anchor" id="var-less_equal"><h3>less_equal</h3><div class="usage"><code>(less_equal self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>less_equal(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the truth value of (x1 =&lt; x2) element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>greater, less, greater_equal, equal, not_equal</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.less_equal([4, 2, 1], [2, 2, 2]) array([False, True, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8406">view source</a></div></div><div class="public anchor" id="var-lexsort"><h3>lexsort</h3><div class="usage"><code>(lexsort &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>lexsort(keys, axis=-1)</p>
-<p>Perform an indirect stable sort using a sequence of keys.</p>
-<p>Given multiple sorting keys, which can be interpreted as columns in a spreadsheet, lexsort returns an array of integer indices that describes the sort order by multiple columns. The last key in the sequence is used for the primary sort order, the second-to-last key for the secondary sort order, and so on. The keys argument must be a sequence of objects that can be converted to arrays of the same shape. If a 2D array is provided for the keys argument, it’s rows are interpreted as the sorting keys and sorting is according to the last row, second last row etc.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>keys : (k, N) array or tuple containing k (N,)-shaped sequences  The <code>k</code> different “columns” to be sorted. The last column (or row if  <code>keys</code> is a 2D array) is the primary sort key. axis : int, optional  Axis to be indirectly sorted. By default, sort over the last axis.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>indices : (N,) ndarray of ints  Array of indices that sort the keys along the specified axis.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>argsort : Indirect sort. ndarray.sort : In-place sort. sort : Return a sorted copy of an array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Sort names: first by surname, then by name.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>surnames = (‘Hertz’, ‘Galilei’, ‘Hertz’) first_names = (‘Heinrich’, ‘Galileo’, ‘Gustav’) ind = np.lexsort((first_names, surnames)) ind array([1, 2, 0])</p>
-      <p>[surnames[i] + “, ” + first_names[i] for i in ind]
-[‘Galilei, Galileo’, ‘Hertz, Gustav’, ‘Hertz, Heinrich’]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Sort two columns of numbers:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = [1,5,1,4,3,4,4] # First column b = [9,4,0,4,0,2,1] # Second column ind = np.lexsort((b,a)) # Sort by a, then by b ind array([2, 0, 4, 6, 5, 3, 1])</p>
-      <p>[(a[i],b[i]) for i in ind]
-[(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that sorting is first according to the elements of <code>a</code>. Secondary sorting is according to the elements of <code>b</code>.</p>
-<p>A normal <code>argsort</code> would have yielded:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>[(a[i],b[i]) for i in np.argsort(a)]
-[(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Structured arrays are sorted lexically by <code>argsort</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)], … dtype=np.dtype([(‘x’, int), (‘y’, int)]))</p>
-      <p>np.argsort(x) # or np.argsort(x, order=(‘x’, ‘y’)) array([2, 0, 4, 6, 5, 3, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16672">view source</a></div></div><div class="public anchor" id="var-lib"><h3>lib</h3><div class="usage"></div><div class="doc"><div class="markdown"><p><strong>Note:</strong> almost all functions in the <code>numpy.lib</code> namespace are also present in the main <code>numpy</code> namespace. Please use the functions as <code>np.&lt;funcname&gt;</code> where possible.</p>
-<p><code>numpy.lib</code> is mostly a space for implementing functions that don’t belong in core or in another NumPy submodule with a clear purpose (e.g. <code>random</code>, <code>fft</code>, <code>linalg</code>, <code>ma</code>).</p>
-<p>Most contains basic functions that are used by several submodules and are useful to have in the main name-space.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20181">view source</a></div></div><div class="public anchor" id="var-linalg"><h3>linalg</h3><div class="usage"></div><div class="doc"><div class="markdown"><h1><code>numpy.linalg</code></h1>
-<p>The NumPy linear algebra functions rely on BLAS and LAPACK to provide efficient low level implementations of standard linear algebra algorithms. Those libraries may be provided by NumPy itself using C versions of a subset of their reference implementations but, when possible, highly optimized libraries that take advantage of specialized processor functionality are preferred. Examples of such libraries are OpenBLAS, MKL (TM), and ATLAS. Because those libraries are multithreaded and processor dependent, environmental variables and external packages such as threadpoolctl may be needed to control the number of threads or specify the processor architecture.</p>
-<ul>
-  <li>OpenBLAS: <a href="https://www.openblas.net/">https://www.openblas.net/</a></li>
-  <li>threadpoolctl: <a href="https://github.com/joblib/threadpoolctl">https://github.com/joblib/threadpoolctl</a></li>
-</ul>
-<p>Please note that the most-used linear algebra functions in NumPy are present in the main <code>numpy</code> namespace rather than in <code>numpy.linalg</code>. There are: <code>dot</code>, <code>vdot</code>, <code>inner</code>, <code>outer</code>, <code>matmul</code>, <code>tensordot</code>, <code>einsum</code>, <code>einsum_path</code> and <code>kron</code>.</p>
-<p>Functions present in numpy.linalg are listed below.</p>
-<h2><a href="#matrix-and-vector-products" name="matrix-and-vector-products"></a>Matrix and vector products</h2>
-<p>multi_dot  matrix_power</p>
-<h2><a href="#decompositions" name="decompositions"></a>Decompositions</h2>
-<p>cholesky  qr  svd</p>
-<h2><a href="#matrix-eigenvalues" name="matrix-eigenvalues"></a>Matrix eigenvalues</h2>
-<p>eig  eigh  eigvals  eigvalsh</p>
-<h2><a href="#norms-and-other-numbers" name="norms-and-other-numbers"></a>Norms and other numbers</h2>
-<p>norm  cond  det  matrix_rank  slogdet</p>
-<h2><a href="#solving-equations-and-inverting-matrices" name="solving-equations-and-inverting-matrices"></a>Solving equations and inverting matrices</h2>
-<p>solve  tensorsolve  lstsq  inv  pinv  tensorinv</p>
-<h2><a href="#exceptions" name="exceptions"></a>Exceptions</h2>
-<p>LinAlgError</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19742">view source</a></div></div><div class="public anchor" id="var-linspace"><h3>linspace</h3><div class="usage"><code>(linspace &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return evenly spaced numbers over a specified interval.</p>
-<p>Returns <code>num</code> evenly spaced samples, calculated over the interval [<code>start</code>, <code>stop</code>].</p>
-<p>The endpoint of the interval can optionally be excluded.</p>
-<p>.. versionchanged:: 1.16.0  Non-scalar <code>start</code> and <code>stop</code> are now supported.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>start : array_like  The starting value of the sequence. stop : array_like  The end value of the sequence, unless <code>endpoint</code> is set to False.  In that case, the sequence consists of all but the last of <code>num + 1</code>  evenly spaced samples, so that <code>stop</code> is excluded. Note that the step  size changes when <code>endpoint</code> is False. num : int, optional  Number of samples to generate. Default is 50. Must be non-negative. endpoint : bool, optional  If True, <code>stop</code> is the last sample. Otherwise, it is not included.  Default is True. retstep : bool, optional  If True, return (<code>samples</code>, <code>step</code>), where <code>step</code> is the spacing  between samples. dtype : dtype, optional  The type of the output array. If <code>dtype</code> is not given, infer the data  type from the other input arguments.</p>
-<pre><code>.. versionadded:: 1.9.0
-</code></pre>
-<p>axis : int, optional  The axis in the result to store the samples. Relevant only if start  or stop are array-like. By default (0), the samples will be along a  new axis inserted at the beginning. Use -1 to get an axis at the end.</p>
-<pre><code>.. versionadded:: 1.16.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>samples : ndarray  There are <code>num</code> equally spaced samples in the closed interval  <code>[start, stop]</code> or the half-open interval <code>[start, stop)</code>  (depending on whether <code>endpoint</code> is True or False). step : float, optional  Only returned if <code>retstep</code> is True</p>
-<pre><code>Size of spacing between samples.
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>arange : Similar to <code>linspace</code>, but uses a step size (instead of the  number of samples). geomspace : Similar to <code>linspace</code>, but with numbers spaced evenly on a log  scale (a geometric progression). logspace : Similar to <code>geomspace</code>, but with the end points specified as  logarithms.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.linspace(2.0, 3.0, num=5) array([2. , 2.25, 2.5 , 2.75, 3. ]) np.linspace(2.0, 3.0, num=5, endpoint=False) array([2. , 2.2, 2.4, 2.6, 2.8]) np.linspace(2.0, 3.0, num=5, retstep=True) (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Graphical illustration:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt N = 8 y = np.zeros(N) x1 = np.linspace(0, 10, N, endpoint=True) x2 = np.linspace(0, 10, N, endpoint=False) plt.plot(x1, y, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.plot(x2, y + 0.5, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.ylim([-0.5, 1]) (-0.5, 1) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9332">view source</a></div></div><div class="public anchor" id="var-little_endian"><h3>little_endian</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25024">view source</a></div></div><div class="public anchor" id="var-load"><h3>load</h3><div class="usage"><code>(load file &amp; [{mmap_mode :mmap_mode, allow_pickle :allow_pickle, fix_imports :fix_imports, encoding :encoding}])</code><code>(load file &amp; [{mmap_mode :mmap_mode, allow_pickle :allow_pickle, fix_imports :fix_imports}])</code><code>(load file &amp; [{mmap_mode :mmap_mode, allow_pickle :allow_pickle}])</code><code>(load file &amp; [{mmap_mode :mmap_mode}])</code><code>(load file)</code></div><div class="doc"><div class="markdown"><p>Load arrays or pickled objects from <code>.npy</code>, <code>.npz</code> or pickled files.</p>
-<p>.. warning:: Loading files that contain object arrays uses the <code>pickle</code>  module, which is not secure against erroneous or maliciously  constructed data. Consider passing <code>allow_pickle=False</code> to  load data that is known not to contain object arrays for the  safer handling of untrusted sources.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>file : file-like object, string, or pathlib.Path  The file to read. File-like objects must support the  <code>seek()</code> and <code>read()</code> methods. Pickled files require that the  file-like object support the <code>readline()</code> method as well. mmap_mode : {None, ‘r+’, ‘r’, ‘w+’, ‘c’}, optional  If not None, then memory-map the file, using the given mode (see  <code>numpy.memmap</code> for a detailed description of the modes). A  memory-mapped array is kept on disk. However, it can be accessed  and sliced like any ndarray. Memory mapping is especially useful  for accessing small fragments of large files without reading the  entire file into memory. allow_pickle : bool, optional  Allow loading pickled object arrays stored in npy files. Reasons for  disallowing pickles include security, as loading pickled data can  execute arbitrary code. If pickles are disallowed, loading object  arrays will fail. Default: False</p>
-<pre><code>.. versionchanged:: 1.16.3
-    Made default False in response to CVE-2019-6446.
-</code></pre>
-<p>fix_imports : bool, optional  Only useful when loading Python 2 generated pickled files on Python 3,  which includes npy/npz files containing object arrays. If <code>fix_imports</code>  is True, pickle will try to map the old Python 2 names to the new names  used in Python 3. encoding : str, optional  What encoding to use when reading Python 2 strings. Only useful when  loading Python 2 generated pickled files in Python 3, which includes  npy/npz files containing object arrays. Values other than ‘latin1’,  ‘ASCII’, and ‘bytes’ are not allowed, as they can corrupt numerical  data. Default: ‘ASCII’</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>result : array, tuple, dict, etc.  Data stored in the file. For <code>.npz</code> files, the returned instance  of NpzFile class must be closed to avoid leaking file descriptors.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>IOError  If the input file does not exist or cannot be read. ValueError  The file contains an object array, but allow_pickle=False given.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>save, savez, savez_compressed, loadtxt memmap : Create a memory-map to an array stored in a file on disk. lib.format.open_memmap : Create or load a memory-mapped <code>.npy</code> file.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<ul>
-  <li>If the file contains pickle data, then whatever object is stored  in the pickle is returned.</li>
-  <li>If the file is a <code>.npy</code> file, then a single array is returned.</li>
-  <li>If the file is a <code>.npz</code> file, then a dictionary-like object is  returned, containing <code>{filename: array}</code> key-value pairs, one for  each file in the archive.</li>
-  <li>If the file is a <code>.npz</code> file, the returned value supports the  context manager protocol in a similar fashion to the open function::
-    <p>with load(‘foo.npz’) as data:  a = data[‘a’]</p>
-  </li>
-</ul>
-<p>The underlying file descriptor is closed when exiting the ‘with’  block.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Store data to disk, and load it again:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.save(‘/tmp/123’, np.array(<a href="null">1, 2, 3], [4, 5, 6</a>)) np.load(‘/tmp/123.npy’) array(<a href="null">1, 2, 3],
-       [4, 5, 6</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Store compressed data to disk, and load it again:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a=np.array(<a href="null">1, 2, 3], [4, 5, 6</a>) b=np.array([1, 2]) np.savez(‘/tmp/123.npz’, a=a, b=b) data = np.load(‘/tmp/123.npz’) data[‘a’] array(<a href="null">1, 2, 3],
-       [4, 5, 6</a>) data[‘b’] array([1, 2]) data.close()</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Mem-map the stored array, and then access the second row directly from disk:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>X = np.load(‘/tmp/123.npy’, mmap_mode=‘r’) X[1, :] memmap([4, 5, 6])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7359">view source</a></div></div><div class="public anchor" id="var-loads"><h3>loads</h3><div class="usage"><code>(loads &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18867">view source</a></div></div><div class="public anchor" id="var-loadtxt"><h3>loadtxt</h3><div class="usage"><code>(loadtxt fname &amp; [{max_rows :max_rows, encoding :encoding, ndmin :ndmin, dtype :dtype, comments :comments, unpack :unpack, converters :converters, delimiter :delimiter, skiprows :skiprows, usecols :usecols}])</code><code>(loadtxt fname &amp; [{encoding :encoding, ndmin :ndmin, dtype :dtype, comments :comments, unpack :unpack, converters :converters, delimiter :delimiter, skiprows :skiprows, usecols :usecols}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols, unpack :unpack, ndmin :ndmin}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols, unpack :unpack}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments, delimiter :delimiter}])</code><code>(loadtxt fname &amp; [{dtype :dtype, comments :comments}])</code><code>(loadtxt fname &amp; [{dtype :dtype}])</code><code>(loadtxt fname)</code></div><div class="doc"><div class="markdown"><p>Load data from a text file.</p>
-<p>Each row in the text file must have the same number of values.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>fname : file, str, or pathlib.Path  File, filename, or generator to read. If the filename extension is  <code>.gz</code> or <code>.bz2</code>, the file is first decompressed. Note that  generators should return byte strings. dtype : data-type, optional  Data-type of the resulting array; default: float. If this is a  structured data-type, the resulting array will be 1-dimensional, and  each row will be interpreted as an element of the array. In this  case, the number of columns used must match the number of fields in  the data-type. comments : str or sequence of str, optional  The characters or list of characters used to indicate the start of a  comment. None implies no comments. For backwards compatibility, byte  strings will be decoded as ‘latin1’. The default is ‘#’. delimiter : str, optional  The string used to separate values. For backwards compatibility, byte  strings will be decoded as ‘latin1’. The default is whitespace. converters : dict, optional  A dictionary mapping column number to a function that will parse the  column string into the desired value. E.g., if column 0 is a date  string: <code>converters = {0: datestr2num}</code>. Converters can also be  used to provide a default value for missing data (but see also  <code>genfromtxt</code>): <code>converters = {3: lambda s: float(s.strip() or 0)}</code>.  Default: None. skiprows : int, optional  Skip the first <code>skiprows</code> lines, including comments; default: 0. usecols : int or sequence, optional  Which columns to read, with 0 being the first. For example,  <code>usecols = (1,4,5)</code> will extract the 2nd, 5th and 6th columns.  The default, None, results in all columns being read.</p>
-<pre><code>.. versionchanged:: 1.11.0
-    When a single column has to be read it is possible to use
-    an integer instead of a tuple. E.g ``usecols = 3`` reads the
-    fourth column the same way as ``usecols = (3,)`` would.
-</code></pre>
-<p>unpack : bool, optional  If True, the returned array is transposed, so that arguments may be  unpacked using <code>x, y, z = loadtxt(...)</code>. When used with a structured  data-type, arrays are returned for each field. Default is False. ndmin : int, optional  The returned array will have at least <code>ndmin</code> dimensions.  Otherwise mono-dimensional axes will be squeezed.  Legal values: 0 (default), 1 or 2.</p>
-<pre><code>.. versionadded:: 1.6.0
-</code></pre>
-<p>encoding : str, optional  Encoding used to decode the inputfile. Does not apply to input streams.  The special value ‘bytes’ enables backward compatibility workarounds  that ensures you receive byte arrays as results if possible and passes  ‘latin1’ encoded strings to converters. Override this value to receive  unicode arrays and pass strings as input to converters. If set to None  the system default is used. The default value is ‘bytes’.</p>
-<pre><code>.. versionadded:: 1.14.0
-</code></pre>
-<p>max_rows : int, optional  Read <code>max_rows</code> lines of content after <code>skiprows</code> lines. The default  is to read all the lines.</p>
-<pre><code>.. versionadded:: 1.16.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Data read from the text file.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>load, fromstring, fromregex genfromtxt : Load data with missing values handled as specified. scipy.io.loadmat : reads MATLAB data files</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This function aims to be a fast reader for simply formatted files. The <code>genfromtxt</code> function provides more sophisticated handling of, e.g., lines with missing values.</p>
-<p>.. versionadded:: 1.10.0</p>
-<p>The strings produced by the Python float.hex method can be used as input for floats.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from io import StringIO # StringIO behaves like a file object c = StringIO(u“0 1\n2 3”) np.loadtxt(c) array(<a href="null">0., 1.],
-       [2., 3.</a>)</p>
-      <p>d = StringIO(u“M 21 72\nF 35 58”) np.loadtxt(d, dtype={‘names’: (‘gender’, ‘age’, ‘weight’), … ‘formats’: (‘S1’, ‘i4’, ‘f4’)}) array([(b’M’, 21, 72.), (b’F’, 35, 58.)],  dtype=[(‘gender’, ‘S1’), (‘age’, ‘&lt;i4’), (‘weight’, ‘&lt;f4’)])</p>
-      <p>c = StringIO(u“1,0,2\n3,0,4”) x, y = np.loadtxt(c, delimiter=‘,’, usecols=(0, 2), unpack=True) x array([1., 3.]) y array([2., 4.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6922">view source</a></div></div><div class="public anchor" id="var-log"><h3>log</h3><div class="usage"><code>(log self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>log(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Natural logarithm, element-wise.</p>
-<p>The natural logarithm <code>log</code> is the inverse of the exponential function, so that <code>log(exp(x)) = x</code>. The natural logarithm is logarithm in base <code>e</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input value. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The natural logarithm of <code>x</code>, element-wise.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>log10, log2, log1p, emath.log</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Logarithm is a multivalued function: for each <code>x</code> there is an infinite number of <code>z</code> such that <code>exp(z) = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi, pi]</code>.</p>
-<p>For real-valued input data types, <code>log</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
-<p>For complex-valued input, <code>log</code> is a complex analytical function that has a branch cut <code>[-inf, 0]</code> and is continuous from above on it. <code>log</code> handles the floating-point negative zero as an infinitesimal negative number, conforming to the C99 standard.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 67. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Logarithm”. <a href="https://en.wikipedia.org/wiki/Logarithm">https://en.wikipedia.org/wiki/Logarithm</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.log([1, np.e, np.e**2, 0]) array([ 0., 1., 2., -Inf])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12962">view source</a></div></div><div class="public anchor" id="var-log10"><h3>log10</h3><div class="usage"><code>(log10 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>log10(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the base 10 logarithm of the input array, element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The logarithm to the base 10 of <code>x</code>, element-wise. NaNs are  returned where x is negative.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>emath.log10</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Logarithm is a multivalued function: for each <code>x</code> there is an infinite number of <code>z</code> such that <code>10**z = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi, pi]</code>.</p>
-<p>For real-valued input data types, <code>log10</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
-<p>For complex-valued input, <code>log10</code> is a complex analytical function that has a branch cut <code>[-inf, 0]</code> and is continuous from above on it. <code>log10</code> handles the floating-point negative zero as an infinitesimal negative number, conforming to the C99 standard.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 67. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Logarithm”. <a href="https://en.wikipedia.org/wiki/Logarithm">https://en.wikipedia.org/wiki/Logarithm</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.log10([1e-15, -3.]) array([-15., nan])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17394">view source</a></div></div><div class="public anchor" id="var-log1p"><h3>log1p</h3><div class="usage"><code>(log1p self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>log1p(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the natural logarithm of one plus the input array, element-wise.</p>
-<p>Calculates <code>log(1 + x)</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  Natural logarithm of <code>1 + x</code>, element-wise.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>expm1 : <code>exp(x) - 1</code>, the inverse of <code>log1p</code>.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>For real-valued input, <code>log1p</code> is accurate also for <code>x</code> so small that <code>1 + x == 1</code> in floating-point accuracy.</p>
-<p>Logarithm is a multivalued function: for each <code>x</code> there is an infinite number of <code>z</code> such that <code>exp(z) = 1 + x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi, pi]</code>.</p>
-<p>For real-valued input data types, <code>log1p</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
-<p>For complex-valued input, <code>log1p</code> is a complex analytical function that has a branch cut <code>[-inf, -1]</code> and is continuous from above on it. <code>log1p</code> handles the floating-point negative zero as an infinitesimal negative number, conforming to the C99 standard.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] M. Abramowitz and I.A. Stegun, “Handbook of Mathematical Functions”,  10th printing, 1964, pp. 67. <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a> .. [2] Wikipedia, “Logarithm”. <a href="https://en.wikipedia.org/wiki/Logarithm">https://en.wikipedia.org/wiki/Logarithm</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.log1p(1e-99) 1e-99 np.log(1 + 1e-99) 0.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L507">view source</a></div></div><div class="public anchor" id="var-log2"><h3>log2</h3><div class="usage"><code>(log2 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>log2(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Base-2 logarithm of <code>x</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  Base-2 logarithm of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>log, log10, log1p, emath.log2</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.3.0</p>
-<p>Logarithm is a multivalued function: for each <code>x</code> there is an infinite number of <code>z</code> such that <code>2**z = x</code>. The convention is to return the <code>z</code> whose imaginary part lies in <code>[-pi, pi]</code>.</p>
-<p>For real-valued input data types, <code>log2</code> always returns real output. For each value that cannot be expressed as a real number or infinity, it yields <code>nan</code> and sets the <code>invalid</code> floating point error flag.</p>
-<p>For complex-valued input, <code>log2</code> is a complex analytical function that has a branch cut <code>[-inf, 0]</code> and is continuous from above on it. <code>log2</code> handles the floating-point negative zero as an infinitesimal negative number, conforming to the C99 standard.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([0, 1, 2, 2**4]) np.log2(x) array([-Inf, 0., 1., 4.])</p>
-      <p>xi = np.array([0+1.j, 1, 2+0.j, 4.j]) np.log2(xi) array([ 0.+2.26618007j, 0.+0.j , 1.+0.j , 2.+2.26618007j])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27512">view source</a></div></div><div class="public anchor" id="var-logaddexp"><h3>logaddexp</h3><div class="usage"><code>(logaddexp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logaddexp(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Logarithm of the sum of exponentiations of the inputs.</p>
-<p>Calculates <code>log(exp(x1) + exp(x2))</code>. This function is useful in statistics where the calculated probabilities of events may be so small as to exceed the range of normal floating point numbers. In such cases the logarithm of the calculated probability is stored. This function allows adding probabilities stored in such a fashion.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Input values. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>result : ndarray  Logarithm of <code>exp(x1) + exp(x2)</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.3.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>prob1 = np.log(1e-50) prob2 = np.log(2.5e-50) prob12 = np.logaddexp(prob1, prob2) prob12 -113.87649168120691 np.exp(prob12) 3.5000000000000057e-50</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5309">view source</a></div></div><div class="public anchor" id="var-logaddexp2"><h3>logaddexp2</h3><div class="usage"><code>(logaddexp2 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logaddexp2(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Logarithm of the sum of exponentiations of the inputs in base-2.</p>
-<p>Calculates <code>log2(2**x1 + 2**x2)</code>. This function is useful in machine learning when the calculated probabilities of events may be so small as to exceed the range of normal floating point numbers. In such cases the base-2 logarithm of the calculated probability can be used instead. This function allows adding probabilities stored in such a fashion.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Input values. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>result : ndarray  Base-2 logarithm of <code>2**x1 + 2**x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>logaddexp: Logarithm of the sum of exponentiations of the inputs.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.3.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>prob1 = np.log2(1e-50) prob2 = np.log2(2.5e-50) prob12 = np.logaddexp2(prob1, prob2) prob1, prob2, prob12 (-166.09640474436813, -164.77447664948076, -164.28904982231052) 2**prob12 3.4999999999999914e-50</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26370">view source</a></div></div><div class="public anchor" id="var-logical_and"><h3>logical_and</h3><div class="usage"><code>(logical_and self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logical_and(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute the truth value of x1 AND x2 element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or bool  Boolean result of the logical AND operation applied to the elements  of <code>x1</code> and <code>x2</code>; the shape is determined by broadcasting.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>logical_or, logical_not, logical_xor bitwise_and</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.logical_and(True, False) False np.logical_and([True, False], [False, False]) array([False, False])</p>
-      <p>x = np.arange(5) np.logical_and(x&gt;1, x&lt;4) array([False, False, True, True, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L764">view source</a></div></div><div class="public anchor" id="var-logical_not"><h3>logical_not</h3><div class="usage"><code>(logical_not self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logical_not(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute the truth value of NOT x element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Logical NOT is applied to the elements of <code>x</code>. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : bool or ndarray of bool  Boolean result with the same shape as <code>x</code> of the NOT operation  on elements of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>logical_and, logical_or, logical_xor</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.logical_not(3) False np.logical_not([True, False, 0, 1]) array([False, True, True, False])</p>
-      <p>x = np.arange(5) np.logical_not(x&lt;3) array([False, False, False, True, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18820">view source</a></div></div><div class="public anchor" id="var-logical_or"><h3>logical_or</h3><div class="usage"><code>(logical_or self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logical_or(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute the truth value of x1 OR x2 element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Logical OR is applied to the elements of <code>x1</code> and <code>x2</code>.  If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or bool  Boolean result of the logical OR operation applied to the elements  of <code>x1</code> and <code>x2</code>; the shape is determined by broadcasting.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>logical_and, logical_not, logical_xor bitwise_or</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.logical_or(True, False) True np.logical_or([True, False], [False, False]) array([ True, False])</p>
-      <p>x = np.arange(5) np.logical_or(x &lt; 1, x &gt; 3) array([ True, False, False, False, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4331">view source</a></div></div><div class="public anchor" id="var-logical_xor"><h3>logical_xor</h3><div class="usage"><code>(logical_xor self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>logical_xor(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute the truth value of x1 XOR x2, element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Logical XOR is applied to the elements of <code>x1</code> and <code>x2</code>. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : bool or ndarray of bool  Boolean result of the logical XOR operation applied to the elements  of <code>x1</code> and <code>x2</code>; the shape is determined by broadcasting.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>logical_and, logical_or, logical_not, bitwise_xor</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.logical_xor(True, False) True np.logical_xor([True, True, False, False], [True, False, True, False]) array([False, True, True, False])</p>
-      <p>x = np.arange(5) np.logical_xor(x &lt; 1, x &gt; 3) array([ True, False, False, False, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Simple example showing support of broadcasting</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.logical_xor(0, np.eye(2)) array(<a href="null"> True, False],
-       [False,  True</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23887">view source</a></div></div><div class="public anchor" id="var-logspace"><h3>logspace</h3><div class="usage"><code>(logspace &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return numbers spaced evenly on a log scale.</p>
-<p>In linear space, the sequence starts at <code>base ** start</code> (<code>base</code> to the power of <code>start</code>) and ends with <code>base ** stop</code> (see <code>endpoint</code> below).</p>
-<p>.. versionchanged:: 1.16.0  Non-scalar <code>start</code> and <code>stop</code> are now supported.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>start : array_like  <code>base ** start</code> is the starting value of the sequence. stop : array_like  <code>base ** stop</code> is the final value of the sequence, unless <code>endpoint</code>  is False. In that case, <code>num + 1</code> values are spaced over the  interval in log-space, of which all but the last (a sequence of  length <code>num</code>) are returned. num : integer, optional  Number of samples to generate. Default is 50. endpoint : boolean, optional  If true, <code>stop</code> is the last sample. Otherwise, it is not included.  Default is True. base : float, optional  The base of the log space. The step size between the elements in  <code>ln(samples) / ln(base)</code> (or <code>log_base(samples)</code>) is uniform.  Default is 10.0. dtype : dtype  The type of the output array. If <code>dtype</code> is not given, infer the data  type from the other input arguments. axis : int, optional  The axis in the result to store the samples. Relevant only if start  or stop are array-like. By default (0), the samples will be along a  new axis inserted at the beginning. Use -1 to get an axis at the end.</p>
-<pre><code>.. versionadded:: 1.16.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>samples : ndarray  <code>num</code> samples, equally spaced on a log scale.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>arange : Similar to linspace, with the step size specified instead of the  number of samples. Note that, when used with a float endpoint, the  endpoint may or may not be included. linspace : Similar to logspace, but with the samples uniformly distributed  in linear space, instead of log space. geomspace : Similar to logspace, but with endpoints specified directly.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Logspace is equivalent to the code</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>y = np.linspace(start, stop, num=num, endpoint=endpoint) … # doctest: +SKIP power(base, y).astype(dtype) … # doctest: +SKIP</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.logspace(2.0, 3.0, num=4) array([ 100. , 215.443469 , 464.15888336, 1000. ]) np.logspace(2.0, 3.0, num=4, endpoint=False) array([100. , 177.827941 , 316.22776602, 562.34132519]) np.logspace(2.0, 3.0, num=4, base=2.0) array([4. , 5.0396842 , 6.34960421, 8. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Graphical illustration:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt N = 10 x1 = np.logspace(0.1, 1, N, endpoint=True) x2 = np.logspace(0.1, 1, N, endpoint=False) y = np.zeros(N) plt.plot(x1, y, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.plot(x2, y + 0.5, ‘o’) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.ylim([-0.5, 1]) (-0.5, 1) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18731">view source</a></div></div><div class="public anchor" id="var-long"><h3>long</h3><div class="usage"><code>(long self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>int([x]) -&gt; integer int(x, base=10) -&gt; integer</p>
-<p>Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.</p>
-<p>If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by ‘+’ or ‘-’ and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>int(‘0b100’, base=0) 4</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7708">view source</a></div></div><div class="public anchor" id="var-longcomplex"><h3>longcomplex</h3><div class="usage"><code>(longcomplex self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two extended-precision floating-point numbers. Character code: <code>'G'</code>. Canonical name: <code>np.clongdouble</code>. Alias: <code>np.clongfloat</code>. Alias: <code>np.longcomplex</code>. Alias <em>on this platform</em>: <code>np.complex256</code>: Complex number type composed of 2 128-bit extended-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7724">view source</a></div></div><div class="public anchor" id="var-longdouble"><h3>longdouble</h3><div class="usage"><code>(longdouble self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Extended-precision floating-point number type, compatible with C <code>long double</code> but not necessarily with IEEE 754 quadruple-precision. Character code: <code>'g'</code>. Canonical name: <code>np.longdouble</code>. Alias: <code>np.longfloat</code>. Alias <em>on this platform</em>: <code>np.float128</code>: 128-bit extended-precision floating-point number type.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6487">view source</a></div></div><div class="public anchor" id="var-longfloat"><h3>longfloat</h3><div class="usage"><code>(longfloat self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Extended-precision floating-point number type, compatible with C <code>long double</code> but not necessarily with IEEE 754 quadruple-precision. Character code: <code>'g'</code>. Canonical name: <code>np.longdouble</code>. Alias: <code>np.longfloat</code>. Alias <em>on this platform</em>: <code>np.float128</code>: 128-bit extended-precision floating-point number type.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L499">view source</a></div></div><div class="public anchor" id="var-longlong"><h3>longlong</h3><div class="usage"><code>(longlong self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>long long</code>. Character code: <code>'q'</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28966">view source</a></div></div><div class="public anchor" id="var-lookfor"><h3>lookfor</h3><div class="usage"><code>(lookfor what &amp; [{module :module, import_modules :import_modules, regenerate :regenerate, output :output}])</code><code>(lookfor what &amp; [{module :module, import_modules :import_modules, regenerate :regenerate}])</code><code>(lookfor what &amp; [{module :module, import_modules :import_modules}])</code><code>(lookfor what &amp; [{module :module}])</code><code>(lookfor what)</code></div><div class="doc"><div class="markdown"><p>Do a keyword search on docstrings.</p>
-<p>A list of objects that matched the search is displayed, sorted by relevance. All given keywords need to be found in the docstring for it to be returned as a result, but the order does not matter.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>what : str  String containing words to look for. module : str or list, optional  Name of module(s) whose docstrings to go through. import_modules : bool, optional  Whether to import sub-modules in packages. Default is True. regenerate : bool, optional  Whether to re-generate the docstring cache. Default is False. output : file-like, optional  File-like object to write the output to. If omitted, use a pager.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>source, info</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Relevance is determined only roughly, by checking if the keywords occur in the function name, at the start of a docstring, etc.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.lookfor(‘binary representation’) # doctest: +SKIP</p>
-      <h2><a href="#search-results-for-binary-representation" name="search-results-for-binary-representation"></a>Search results for ‘binary representation’</h2>
-      <p>numpy.binary_repr  Return the binary representation of the input number as a string. numpy.core.setup_common.long_double_representation  Given a binary dump as given by GNU od -b, look for long double numpy.base_repr  Return a string representation of a number in the given base system. …</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21667">view source</a></div></div><div class="public anchor" id="var-ma"><h3>ma</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>=============</p>
-<h1><a href="#masked-arrays" name="masked-arrays"></a>Masked Arrays</h1>
-<p>Arrays sometimes contain invalid or missing data. When doing operations on such arrays, we wish to suppress invalid values, which is the purpose masked arrays fulfill (an example of typical use is given below).</p>
-<p>For example, examine the following array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([2, 1, 3, np.nan, 5, 2, 3, np.nan])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>When we try to calculate the mean of the data, the result is undetermined:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.mean(x) nan</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The mean is calculated using roughly <code>np.sum(x)/len(x)</code>, but since any number added to <code>NaN</code> [1]_ produces <code>NaN</code>, this doesn’t work. Enter masked arrays:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>m = np.ma.masked_array(x, np.isnan(x)) m masked_array(data = [2.0 1.0 3.0 – 5.0 2.0 3.0 –],  mask = [False False False True False False False True],  fill_value=1e+20)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Here, we construct a masked array that suppress all <code>NaN</code> values. We may now proceed to calculate the mean of the other values:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.mean(m) 2.6666666666666665</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>.. [1] Not-a-Number, a floating point value that is the result of an  invalid operation.</p>
-<p>.. moduleauthor:: Pierre Gerard-Marchant .. moduleauthor:: Jarrod Millman</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15056">view source</a></div></div><div class="public anchor" id="var-MachAr"><h3>MachAr</h3><div class="usage"><code>(MachAr self &amp; [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float, float_to_str :float_to_str, title :title}])</code><code>(MachAr self &amp; [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float, float_to_str :float_to_str}])</code><code>(MachAr self &amp; [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float}])</code><code>(MachAr self &amp; [{float_conv :float_conv, int_conv :int_conv}])</code><code>(MachAr self &amp; [{float_conv :float_conv}])</code><code>(MachAr self)</code></div><div class="doc"><div class="markdown"><p>Diagnosing machine parameters.</p>
-<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
-<p>ibeta : int  Radix in which numbers are represented. it : int  Number of base-<code>ibeta</code> digits in the floating point mantissa M. machep : int  Exponent of the smallest (most negative) power of <code>ibeta</code> that,  added to 1.0, gives something different from 1.0 eps : float  Floating-point number <code>beta**machep</code> (floating point precision) negep : int  Exponent of the smallest power of <code>ibeta</code> that, subtracted  from 1.0, gives something different from 1.0. epsneg : float  Floating-point number <code>beta**negep</code>. iexp : int  Number of bits in the exponent (including its sign and bias). minexp : int  Smallest (most negative) power of <code>ibeta</code> consistent with there  being no leading zeros in the mantissa. xmin : float  Floating point number <code>beta**minexp</code> (the smallest [in  magnitude] usable floating value). maxexp : int  Smallest (positive) power of <code>ibeta</code> that causes overflow. xmax : float  <code>(1-epsneg) * beta**maxexp</code> (the largest [in magnitude]  usable floating value). irnd : int  In <code>range(6)</code>, information on what kind of rounding is done  in addition, and on how underflow is handled. ngrd : int  Number of ‘guard digits’ used when truncating the product  of two mantissas to fit the representation. epsilon : float  Same as <code>eps</code>. tiny : float  Same as <code>xmin</code>. huge : float  Same as <code>xmax</code>. precision : float  <code>- int(-log10(eps))</code> resolution : float  <code>- 10**(-precision)</code></p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>float_conv : function, optional  Function that converts an integer or integer array to a float  or float array. Default is <code>float</code>. int_conv : function, optional  Function that converts a float or float array to an integer or  integer array. Default is <code>int</code>. float_to_float : function, optional  Function that converts a float array to float. Default is <code>float</code>.  Note that this does not seem to do anything useful in the current  implementation. float_to_str : function, optional  Function that converts a single float to a string. Default is  <code>lambda v:'%24.16e' %v</code>. title : str, optional  Title that is printed in the string representation of <code>MachAr</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>finfo : Machine limits for floating point types. iinfo : Machine limits for integer types.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Press, Teukolsky, Vetterling and Flannery,  “Numerical Recipes in C++,” 2nd ed,  Cambridge University Press, 2002, p. 31.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L203">view source</a></div></div><div class="public anchor" id="var-mafromtxt"><h3>mafromtxt</h3><div class="usage"><code>(mafromtxt fname &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Load ASCII data stored in a text file and return a masked array.</p>
-<p>.. deprecated:: 1.17  np.mafromtxt is a deprecated alias of <code>genfromtxt</code> which  overwrites the <code>usemask</code> argument with <code>True</code> even when  explicitly called as <code>mafromtxt(..., usemask=False)</code>.  Use <code>genfromtxt</code> instead.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>fname, kwargs : For a description of input parameters, see <code>genfromtxt</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.genfromtxt : generic function to load ASCII data.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22869">view source</a></div></div><div class="public anchor" id="var-mask_indices"><h3>mask_indices</h3><div class="usage"><code>(mask_indices n mask_func &amp; [{k :k}])</code><code>(mask_indices n mask_func)</code></div><div class="doc"><div class="markdown"><p>Return the indices to access (n, n) arrays, given a masking function.</p>
-<p>Assume <code>mask_func</code> is a function that, for a square array a of size <code>(n, n)</code> with a possible offset argument <code>k</code>, when called as <code>mask_func(a, k)</code> returns a new array with zeros in certain locations (functions like <code>triu</code> or <code>tril</code> do precisely this). Then this function returns the indices where the non-zero values would be located.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>n : int  The returned indices will be valid to access arrays of shape (n, n). mask_func : callable  A function whose call signature is similar to that of <code>triu</code>, <code>tril</code>.  That is, <code>mask_func(x, k)</code> returns a boolean array, shaped like <code>x</code>.  <code>k</code> is an optional argument to the function. k : scalar  An optional argument which is passed through to <code>mask_func</code>. Functions  like <code>triu</code>, <code>tril</code> take a second argument that is interpreted as an  offset.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>indices : tuple of arrays.  The <code>n</code> arrays of indices corresponding to the locations where  <code>mask_func(np.ones((n, n)), k)</code> is True.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>triu, tril, triu_indices, tril_indices</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.4.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>These are the indices that would allow you to access the upper triangular part of any 3x3 array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>iu = np.mask_indices(3, np.triu)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>For example, if <code>a</code> is a 3x3 array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(9).reshape(3, 3) a array(<a href="null">0, 1, 2],
-       [3, 4, 5],
-       [6, 7, 8</a>) a[iu] array([0, 1, 2, 4, 5, 8])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>An offset can be passed also to the masking function. This gets us the indices starting on the first diagonal right of the main one:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>iu1 = np.mask_indices(3, np.triu, 1)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>with which we now extract only three elements:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a[iu1] array([1, 2, 5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17456">view source</a></div></div><div class="public anchor" id="var-mat"><h3>mat</h3><div class="usage"><code>(mat data &amp; [{dtype :dtype}])</code><code>(mat data)</code></div><div class="doc"><div class="markdown"><p>Interpret the input as a matrix.</p>
-<p>Unlike <code>matrix</code>, <code>asmatrix</code> does not make a copy if the input is already a matrix or an ndarray. Equivalent to <code>matrix(data, copy=False)</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>data : array_like  Input data. dtype : data-type  Data-type of the output matrix.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>mat : matrix  <code>data</code> interpreted as a matrix.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">1, 2], [3, 4</a>)</p>
-      <p>m = np.asmatrix(x)</p>
-      <p>x[0,0] = 5</p>
-      <p>m matrix(<a href="null">5, 2],
-        [3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9421">view source</a></div></div><div class="public anchor" id="var-math"><h3>math</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>This module provides access to the mathematical functions defined by the C standard.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15053">view source</a></div></div><div class="public anchor" id="var-matmul"><h3>matmul</h3><div class="usage"><code>(matmul self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>matmul(x1, x2, /, out=None, *, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Matrix product of two arrays.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Input arrays, scalars not allowed. out : ndarray, optional  A location into which the result is stored. If provided, it must have  a shape that matches the signature <code>(n,k),(k,m)-&gt;(n,m)</code>. If not  provided or None, a freshly-allocated array is returned. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<pre><code>.. versionadded:: 1.16
-   Now handles ufunc kwargs
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The matrix product of the inputs.  This is a scalar only when both x1, x2 are 1-d vectors.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If the last dimension of <code>a</code> is not the same size as  the second-to-last dimension of <code>b</code>.</p>
-<pre><code>If a scalar value is passed in.
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>vdot : Complex-conjugating dot product. tensordot : Sum products over arbitrary axes. einsum : Einstein summation convention. dot : alternative matrix product with different broadcasting rules.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The behavior depends on the arguments in the following way.</p>
-<ul>
-  <li>If both arguments are 2-D they are multiplied like conventional  matrices.</li>
-  <li>If either argument is N-D, N &gt; 2, it is treated as a stack of  matrices residing in the last two indexes and broadcast accordingly.</li>
-  <li>If the first argument is 1-D, it is promoted to a matrix by  prepending a 1 to its dimensions. After matrix multiplication  the prepended 1 is removed.</li>
-  <li>If the second argument is 1-D, it is promoted to a matrix by  appending a 1 to its dimensions. After matrix multiplication  the appended 1 is removed.</li>
-</ul>
-<p><code>matmul</code> differs from <code>dot</code> in two important ways:</p>
-<ul>
-  <li>Multiplication by scalars is not allowed, use <code>*</code> instead.</li>
-  <li>Stacks of matrices are broadcast together as if the matrices  were elements, respecting the signature <code>(n,k),(k,m)-&gt;(n,m)</code>:</li>
-</ul>
-<p>&gt;&gt;&gt; a = np.ones([9, 5, 7, 4])  &gt;&gt;&gt; c = np.ones([9, 5, 4, 3])  &gt;&gt;&gt; np.dot(a, c).shape  (9, 5, 7, 9, 5, 3)  &gt;&gt;&gt; np.matmul(a, c).shape  (9, 5, 7, 3)  &gt;&gt;&gt; # n is 7, k is 4, m is 3</p>
-<p>The matmul function implements the semantics of the <code>@</code> operator introduced in Python 3.5 following PEP465.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>For 2-D arrays it is the matrix product:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 0],
-...               [0, 1</a>) b = np.array(<a href="null">4, 1],
-...               [2, 2</a>) np.matmul(a, b) array(<a href="null">4, 1],
-       [2, 2</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>For 2-D mixed with 1-D, the result is the usual.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 0],
-...               [0, 1</a>) b = np.array([1, 2]) np.matmul(a, b) array([1, 2]) np.matmul(b, a) array([1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Broadcasting is conventional for stacks of arrays</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(2 * 2 * 4).reshape((2, 2, 4)) b = np.arange(2 * 2 * 4).reshape((2, 4, 2)) np.matmul(a,b).shape (2, 2, 2) np.matmul(a, b)[0, 1, 1] 98 sum(a[0, 1, :] * b[0 , :, 1]) 98</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Vector, vector returns the scalar inner product, but neither argument is complex-conjugated:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.matmul([2j, 3j], [2j, 3j]) (-13+0j)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Scalar multiplication raises an error.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.matmul([1,2], 3) Traceback (most recent call last): … ValueError: matmul: Input operand 1 does not have enough dimensions …</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>.. versionadded:: 1.10.0</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6668">view source</a></div></div><div class="public anchor" id="var-matrix"><h3>matrix</h3><div class="usage"><code>(matrix self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>matrix(data, dtype=None, copy=True)</p>
-<p>.. note:: It is no longer recommended to use this class, even for linear  algebra. Instead use regular arrays. The class may be removed  in the future.</p>
-<p>Returns a matrix from an array-like object, or from a string of data. A matrix is a specialized 2-D array that retains its 2-D nature through operations. It has certain special operators, such as <code>*</code> (matrix multiplication) and <code>**</code> (matrix power).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>data : array_like or string  If <code>data</code> is a string, it is interpreted as a matrix with commas  or spaces separating columns, and semicolons separating rows. dtype : data-type  Data-type of the output matrix. copy : bool  If <code>data</code> is already an <code>ndarray</code>, then this flag determines  whether the data is copied (the default), or whether a view is  constructed.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>array</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.matrix(‘1 2; 3 4’) a matrix(<a href="null">1, 2],
-        [3, 4</a>)</p>
-      <p>np.matrix(<a href="null">1, 2], [3, 4</a>) matrix(<a href="null">1, 2],
-        [3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8364">view source</a></div></div><div class="public anchor" id="var-matrixlib"><h3>matrixlib</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Sub-package containing the matrix class and related functions.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5618">view source</a></div></div><div class="public anchor" id="var-max"><h3>max</h3><div class="usage"><code>(max &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the maximum of an array or maximum along an axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  Axis or axes along which to operate. By default, flattened input is  used.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If this is a tuple of ints, the maximum is selected over multiple axes,
-instead of a single axis or all the axes as before.
-</code></pre>
-<p>out : ndarray, optional  Alternative output array in which to place the result. Must  be of the same shape and buffer length as the expected output.  See <code>ufuncs-output-type</code> for more details.</p>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `amax` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<p>initial : scalar, optional  The minimum value of an output element. Must be present to allow  computation on empty slice. See <code>~numpy.ufunc.reduce</code> for details.</p>
-<pre><code>.. versionadded:: 1.15.0
-</code></pre>
-<p>where : array_like of bool, optional  Elements to compare for the maximum. See <code>~numpy.ufunc.reduce</code>  for details.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>amax : ndarray or scalar  Maximum of <code>a</code>. If <code>axis</code> is None, the result is a scalar value.  If <code>axis</code> is given, the result is an array of dimension  <code>a.ndim - 1</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>amin :  The minimum value of an array along a given axis, propagating any NaNs. nanmax :  The maximum value of an array along a given axis, ignoring any NaNs. maximum :  Element-wise maximum of two arrays, propagating any NaNs. fmax :  Element-wise maximum of two arrays, ignoring any NaNs. argmax :  Return the indices of the maximum values.</p>
-<p>nanmin, minimum, fmin</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>NaN values are propagated, that is if at least one item is NaN, the corresponding max value will be NaN as well. To ignore NaN values (MATLAB behavior), please use nanmax.</p>
-<p>Don’t use <code>amax</code> for element-wise comparison of 2 arrays; when <code>a.shape[0]</code> is 2, <code>maximum(a[0], a[1])</code> is faster than <code>amax(a, axis=0)</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(4).reshape((2,2)) a array(<a href="null">0, 1],
-       [2, 3</a>) np.amax(a) # Maximum of the flattened array 3 np.amax(a, axis=0) # Maxima along the first axis array([2, 3]) np.amax(a, axis=1) # Maxima along the second axis array([1, 3]) np.amax(a, where=[False, True], initial=-1, axis=0) array([-1, 3]) b = np.arange(5, dtype=float) b[2] = np.NaN np.amax(b) nan np.amax(b, where=~np.isnan(b), initial=-1) 4.0 np.nanmax(b) 4.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>You can use an initial value to compute the maximum of an empty slice, or to initialize it to a different value:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.max(<a href="null">-50], [10</a>, axis=-1, initial=0) array([ 0, 10])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Notice that the initial value is used as one of the elements for which the maximum is determined, unlike for the default argument Python’s max function, which is only used for empty iterables.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.max([5], initial=6) 6 max([5], default=6) 5</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9047">view source</a></div></div><div class="public anchor" id="var-MAXDIMS"><h3>MAXDIMS</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26989">view source</a></div></div><div class="public anchor" id="var-maximum"><h3>maximum</h3><div class="usage"><code>(maximum self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>maximum(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Element-wise maximum of array elements.</p>
-<p>Compare two arrays and returns a new array containing the element-wise maxima. If one of the elements being compared is a NaN, then that element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are propagated.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  The arrays holding the elements to be compared. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  The maximum of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>minimum :  Element-wise minimum of two arrays, propagates NaNs. fmax :  Element-wise maximum of two arrays, ignores NaNs. amax :  The maximum value of an array along a given axis, propagates NaNs. nanmax :  The maximum value of an array along a given axis, ignores NaNs.</p>
-<p>fmin, amin, nanmin</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The maximum is equivalent to <code>np.where(x1 &gt;= x2, x1, x2)</code> when neither x1 nor x2 are nans, but it is faster and does proper broadcasting.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.maximum([2, 3, 4], [1, 5, 2]) array([2, 5, 4])</p>
-      <p>np.maximum(np.eye(2), [0.5, 2]) # broadcasting array(<a href="null"> 1. ,  2. ],
-       [ 0.5,  2. </a>)</p>
-      <p>np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan]) array([nan, nan, nan]) np.maximum(np.Inf, 1) inf</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9683">view source</a></div></div><div class="public anchor" id="var-maximum_sctype"><h3>maximum_sctype</h3><div class="usage"><code>(maximum_sctype t)</code></div><div class="doc"><div class="markdown"><p>Return the scalar type of highest precision of the same kind as the input.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>t : dtype or dtype specifier  The input data type. This can be a <code>dtype</code> object or an object that  is convertible to a <code>dtype</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : dtype  The highest precision data type of the same kind (<code>dtype.kind</code>) as <code>t</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>obj2sctype, mintypecode, sctype2char dtype</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.maximum_sctype(int) &lt;class ‘numpy.int64’&gt; np.maximum_sctype(np.uint8) &lt;class ‘numpy.uint64’&gt; np.maximum_sctype(complex) &lt;class ‘numpy.complex256’&gt; # may vary</p>
-      <p>np.maximum_sctype(str) &lt;class ‘numpy.str_’&gt;</p>
-      <p>np.maximum_sctype(‘i2’) &lt;class ‘numpy.int64’&gt; np.maximum_sctype(‘f4’) &lt;class ‘numpy.float128’&gt; # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4165">view source</a></div></div><div class="public anchor" id="var-MAY_SHARE_BOUNDS"><h3>MAY_SHARE_BOUNDS</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1393">view source</a></div></div><div class="public anchor" id="var-MAY_SHARE_EXACT"><h3>MAY_SHARE_EXACT</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14131">view source</a></div></div><div class="public anchor" id="var-may_share_memory"><h3>may_share_memory</h3><div class="usage"><code>(may_share_memory &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>may_share_memory(a, b, max_work=None)</p>
-<p>Determine if two arrays might share memory</p>
-<p>A return of True does not necessarily mean that the two arrays share any element. It just means that they <em>might</em>.</p>
-<p>Only the memory bounds of a and b are checked by default.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a, b : ndarray  Input arrays max_work : int, optional  Effort to spend on solving the overlap problem. See  <code>shares_memory</code> for details. Default for <code>may_share_memory</code>  is to do a bounds check.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : bool</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>shares_memory</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.may_share_memory(np.array([1,2]), np.array([5,8,9])) False x = np.zeros([3, 4]) np.may_share_memory(x[:,0], x[:,1]) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20304">view source</a></div></div><div class="public anchor" id="var-mean"><h3>mean</h3><div class="usage"><code>(mean &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the arithmetic mean along the specified axis.</p>
-<p>Returns the average of the array elements. The average is taken over the flattened array by default, otherwise over the specified axis. <code>float64</code> intermediate and return values are used for integer inputs.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array containing numbers whose mean is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : None or int or tuple of ints, optional  Axis or axes along which the means are computed. The default is to  compute the mean of the flattened array.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If this is a tuple of ints, a mean is performed over multiple axes,
-instead of a single axis or all the axes as before.
-</code></pre>
-<p>dtype : data-type, optional  Type to use in computing the mean. For integer inputs, the default  is <code>float64</code>; for floating point inputs, it is the same as the  input dtype. out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>; if provided, it must have the same shape as the  expected output, but the type will be cast if necessary.  See <code>ufuncs-output-type</code> for more details.</p>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `mean` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>m : ndarray, see dtype parameter above  If <code>out=None</code>, returns a new array containing the mean values,  otherwise a reference to the output array is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>average : Weighted average std, var, nanmean, nanstd, nanvar</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The arithmetic mean is the sum of the elements along the axis divided by the number of elements.</p>
-<p>Note that for floating-point input, the mean is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for <code>float32</code> (see example below). Specifying a higher-precision accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
-<p>By default, <code>float16</code> results are computed using <code>float32</code> intermediates for extra precision.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 2], [3, 4</a>) np.mean(a) 2.5 np.mean(a, axis=0) array([2., 3.]) np.mean(a, axis=1) array([1.5, 3.5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>In single precision, <code>mean</code> can be inaccurate:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.zeros((2, 512*512), dtype=np.float32) a[0, :] = 1.0 a[1, :] = 0.1 np.mean(a) 0.54999924</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Computing the mean in float64 is more accurate:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.mean(a, dtype=np.float64) 0.55000000074505806 # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6809">view source</a></div></div><div class="public anchor" id="var-median"><h3>median</h3><div class="usage"><code>(median &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the median along the specified axis.</p>
-<p>Returns the median of the array elements.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array or object that can be converted to an array. axis : {int, sequence of int, None}, optional  Axis or axes along which the medians are computed. The default  is to compute the median along a flattened version of the array.  A sequence of axes is supported since version 1.9.0. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow use of memory of input array <code>a</code> for  calculations. The input array will be modified by the call to  <code>median</code>. This will save memory when you do not need to preserve  the contents of the input array. Treat the input as undefined,  but it will probably be fully or partially sorted. Default is  False. If <code>overwrite_input</code> is <code>True</code> and <code>a</code> is not already an  <code>ndarray</code>, an error will be raised. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>arr</code>.</p>
-<pre><code>.. versionadded:: 1.9.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>median : ndarray  A new array holding the result. If the input contains integers  or floats smaller than <code>float64</code>, then the output data-type is  <code>np.float64</code>. Otherwise, the data-type of the output is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>mean, percentile</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Given a vector <code>V</code> of length <code>N</code>, the median of <code>V</code> is the middle value of a sorted copy of <code>V</code>, <code>V_sorted</code> - i e., <code>V_sorted[(N-1)/2]</code>, when <code>N</code> is odd, and the average of the two middle values of <code>V_sorted</code> when <code>N</code> is even.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">10, 7, 4], [3, 2, 1</a>) a array(<a href="null">10,  7,  4],
-       [ 3,  2,  1</a>) np.median(a) 3.5 np.median(a, axis=0) array([6.5, 4.5, 2.5]) np.median(a, axis=1) array([7., 2.]) m = np.median(a, axis=0) out = np.zeros_like(m) np.median(a, axis=0, out=m) array([6.5, 4.5, 2.5]) m array([6.5, 4.5, 2.5]) b = a.copy() np.median(b, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a==b) b = a.copy() np.median(b, axis=None, overwrite_input=True) 3.5 assert not np.all(a==b)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28989">view source</a></div></div><div class="public anchor" id="var-memmap"><h3>memmap</h3><div class="usage"><code>(memmap self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create a memory-map to an array stored in a <em>binary</em> file on disk.</p>
-<p>Memory-mapped files are used for accessing small segments of large files on disk, without reading the entire file into memory. NumPy’s memmap’s are array-like objects. This differs from Python’s <code>mmap</code> module, which uses file-like objects.</p>
-<p>This subclass of ndarray has some unpleasant interactions with some operations, because it doesn’t quite fit properly as a subclass. An alternative to using this subclass is to create the <code>mmap</code> object yourself, then create an ndarray with ndarray.__new__ directly, passing the object created in its ‘buffer=’ parameter.</p>
-<p>This class may at some point be turned into a factory function which returns a view into an mmap buffer.</p>
-<p>Delete the memmap instance to close the memmap file.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>filename : str, file-like object, or pathlib.Path instance  The file name or file object to be used as the array data buffer. dtype : data-type, optional  The data-type used to interpret the file contents.  Default is <code>uint8</code>. mode : {‘r+’, ‘r’, ‘w+’, ‘c’}, optional  The file is opened in this mode:</p>
-<pre><code>+------+-------------------------------------------------------------+
-| 'r'  | Open existing file for reading only.                        |
-+------+-------------------------------------------------------------+
-| 'r+' | Open existing file for reading and writing.                 |
-+------+-------------------------------------------------------------+
-| 'w+' | Create or overwrite existing file for reading and writing.  |
-+------+-------------------------------------------------------------+
-| 'c'  | Copy-on-write: assignments affect data in memory, but       |
-|      | changes are not saved to disk.  The file on disk is         |
-|      | read-only.                                                  |
-+------+-------------------------------------------------------------+
-
-Default is 'r+'.
-</code></pre>
-<p>offset : int, optional  In the file, array data starts at this offset. Since <code>offset</code> is  measured in bytes, it should normally be a multiple of the byte-size  of <code>dtype</code>. When <code>mode != 'r'</code>, even positive offsets beyond end of  file are valid; The file will be extended to accommodate the  additional data. By default, <code>memmap</code> will start at the beginning of  the file, even if <code>filename</code> is a file pointer <code>fp</code> and  <code>fp.tell() != 0</code>. shape : tuple, optional  The desired shape of the array. If <code>mode == 'r'</code> and the number  of remaining bytes after <code>offset</code> is not a multiple of the byte-size  of <code>dtype</code>, you must specify <code>shape</code>. By default, the returned array  will be 1-D with the number of elements determined by file size  and data-type. order : {‘C’, ‘F’}, optional  Specify the order of the ndarray memory layout:  :term:<code>row-major</code>, C-style or :term:<code>column-major</code>,  Fortran-style. This only has an effect if the shape is  greater than 1-D. The default order is ‘C’.</p>
-<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
-<p>filename : str or pathlib.Path instance  Path to the mapped file. offset : int  Offset position in the file. mode : str  File mode.</p>
-<h2><a href="#methods" name="methods"></a>Methods</h2>
-<p>flush  Flush any changes in memory to file on disk.  When you delete a memmap object, flush is called first to write  changes to disk before removing the object.</p>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>lib.format.open_memmap : Create or load a memory-mapped <code>.npy</code> file.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The memmap object can be used anywhere an ndarray is accepted. Given a memmap <code>fp</code>, <code>isinstance(fp, numpy.ndarray)</code> returns <code>True</code>.</p>
-<p>Memory-mapped files cannot be larger than 2GB on 32-bit systems.</p>
-<p>When a memmap causes a file to be created or extended beyond its current size in the filesystem, the contents of the new part are unspecified. On systems with POSIX filesystem semantics, the extended part will be filled with zero bytes.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>data = np.arange(12, dtype=‘float32’) data.resize((3,4))</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>This example uses a temporary file so that doctest doesn’t write files to your directory. You would use a ‘normal’ filename.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from tempfile import mkdtemp import os.path as path filename = path.join(mkdtemp(), ‘newfile.dat’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Create a memmap with dtype and shape that matches our data:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>fp = np.memmap(filename, dtype=‘float32’, mode=‘w+’, shape=(3,4)) fp memmap(<a href="null">0., 0., 0., 0.],
-        [0., 0., 0., 0.],
-        [0., 0., 0., 0.</a>, dtype=float32)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Write data to memmap array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>fp[:] = data[:] fp memmap(<a href="null">  0.,   1.,   2.,   3.],
-        [  4.,   5.,   6.,   7.],
-        [  8.,   9.,  10.,  11.</a>, dtype=float32)</p>
-      <p>fp.filename == path.abspath(filename) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Deletion flushes memory changes to disk before removing the object:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>del fp</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Load the memmap and verify data was stored:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>newfp = np.memmap(filename, dtype=‘float32’, mode=‘r’, shape=(3,4)) newfp memmap(<a href="null">  0.,   1.,   2.,   3.],
-        [  4.,   5.,   6.,   7.],
-        [  8.,   9.,  10.,  11.</a>, dtype=float32)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Read-only memmap:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>fpr = np.memmap(filename, dtype=‘float32’, mode=‘r’, shape=(3,4)) fpr.flags.writeable False</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Copy-on-write memmap:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>fpc = np.memmap(filename, dtype=‘float32’, mode=‘c’, shape=(3,4)) fpc.flags.writeable True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>It’s possible to assign to copy-on-write array, but values are only written into the memory copy of the array, and not written to disk:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>fpc memmap(<a href="null">  0.,   1.,   2.,   3.],
-        [  4.,   5.,   6.,   7.],
-        [  8.,   9.,  10.,  11.</a>, dtype=float32) fpc[0,:] = 0 fpc memmap(<a href="null">  0.,   0.,   0.,   0.],
-        [  4.,   5.,   6.,   7.],
-        [  8.,   9.,  10.,  11.</a>, dtype=float32)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>File on disk is unchanged:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>fpr memmap(<a href="null">  0.,   1.,   2.,   3.],
-        [  4.,   5.,   6.,   7.],
-        [  8.,   9.,  10.,  11.</a>, dtype=float32)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Offset into a memmap:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>fpo = np.memmap(filename, dtype=‘float32’, mode=‘r’, offset=16) fpo memmap([ 4., 5., 6., 7., 8., 9., 10., 11.], dtype=float32)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8592">view source</a></div></div><div class="public anchor" id="var-meshgrid"><h3>meshgrid</h3><div class="usage"><code>(meshgrid &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return coordinate matrices from coordinate vectors.</p>
-<p>Make N-D coordinate arrays for vectorized evaluations of N-D scalar/vector fields over N-D grids, given one-dimensional coordinate arrays x1, x2,…, xn.</p>
-<p>.. versionchanged:: 1.9  1-D and 0-D cases are allowed.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2,…, xn : array_like  1-D arrays representing the coordinates of a grid. indexing : {‘xy’, ‘ij’}, optional  Cartesian (‘xy’, default) or matrix (‘ij’) indexing of output.  See Notes for more details.</p>
-<pre><code>.. versionadded:: 1.7.0
-</code></pre>
-<p>sparse : bool, optional  If True a sparse grid is returned in order to conserve memory.  Default is False.</p>
-<pre><code>.. versionadded:: 1.7.0
-</code></pre>
-<p>copy : bool, optional  If False, a view into the original arrays are returned in order to  conserve memory. Default is True. Please note that  <code>sparse=False, copy=False</code> will likely return non-contiguous  arrays. Furthermore, more than one element of a broadcast array  may refer to a single memory location. If you need to write to the  arrays, make copies first.</p>
-<pre><code>.. versionadded:: 1.7.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>X1, X2,…, XN : ndarray  For vectors <code>x1</code>, <code>x2</code>,…, ‘xn’ with lengths <code>Ni=len(xi)</code> ,  return <code>(N1, N2, N3,...Nn)</code> shaped arrays if indexing=‘ij’  or <code>(N2, N1, N3,...Nn)</code> shaped arrays if indexing=‘xy’  with the elements of <code>xi</code> repeated to fill the matrix along  the first dimension for <code>x1</code>, the second for <code>x2</code> and so on.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This function supports both indexing conventions through the indexing keyword argument. Giving the string ‘ij’ returns a meshgrid with matrix indexing, while ‘xy’ returns a meshgrid with Cartesian indexing. In the 2-D case with inputs of length M and N, the outputs are of shape (N, M) for ‘xy’ indexing and (M, N) for ‘ij’ indexing. In the 3-D case with inputs of length M, N and P, outputs are of shape (N, M, P) for ‘xy’ indexing and (M, N, P) for ‘ij’ indexing. The difference is illustrated by the following code snippet::</p>
-<pre><code>xv, yv = np.meshgrid(x, y, sparse=False, indexing='ij')
-for i in range(nx):
-    for j in range(ny):
-        # treat xv[i,j], yv[i,j]
-
-xv, yv = np.meshgrid(x, y, sparse=False, indexing='xy')
-for i in range(nx):
-    for j in range(ny):
-        # treat xv[j,i], yv[j,i]
-</code></pre>
-<p>In the 1-D and 0-D case, the indexing and sparse keywords have no effect.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>index_tricks.mgrid : Construct a multi-dimensional “meshgrid”  using indexing notation. index_tricks.ogrid : Construct an open multi-dimensional “meshgrid”  using indexing notation.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>nx, ny = (3, 2) x = np.linspace(0, 1, nx) y = np.linspace(0, 1, ny) xv, yv = np.meshgrid(x, y) xv array(<a href="null">0. , 0.5, 1. ],
-       [0. , 0.5, 1. </a>) yv array(<a href="null">0.,  0.,  0.],
-       [1.,  1.,  1.</a>) xv, yv = np.meshgrid(x, y, sparse=True) # make sparse output arrays xv array(<a href="null">0. ,  0.5,  1. </a>) yv array(<a href="null">0.],
-       [1.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p><code>meshgrid</code> is very useful to evaluate functions on a grid.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt x = np.arange(-5, 5, 0.1) y = np.arange(-5, 5, 0.1) xx, yy = np.meshgrid(x, y, sparse=True) z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2) h = plt.contourf(x,y,z) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28614">view source</a></div></div><div class="public anchor" id="var-mgrid"><h3>mgrid</h3><div class="usage"></div><div class="doc"><div class="markdown"><p><code>nd_grid</code> instance which returns a dense multi-dimensional “meshgrid”.</p>
-<p>An instance of <code>numpy.lib.index_tricks.nd_grid</code> which returns an dense (or fleshed out) mesh-grid when indexed, so that each returned argument has the same shape. The dimensions and number of the output arrays are equal to the number of indexing dimensions. If the step length is not a complex number, then the stop is not inclusive.</p>
-<p>However, if the step length is a <strong>complex number</strong> (e.g. 5j), then the integer part of its magnitude is interpreted as specifying the number of points to create between the start and stop values, where the stop value <strong>is inclusive</strong>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>mesh-grid <code>ndarrays</code> all of the same dimensions</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.lib.index_tricks.nd_grid : class of <code>ogrid</code> and <code>mgrid</code> objects ogrid : like mgrid but returns open (not fleshed out) mesh grids r_ : array concatenator</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.mgrid[0:5,0:5] array(<a href="null">[0, 0, 0, 0, 0],
-        [1, 1, 1, 1, 1],
-        [2, 2, 2, 2, 2],
-        [3, 3, 3, 3, 3],
-        [4, 4, 4, 4, 4</a>,  <a href="null">0, 1, 2, 3, 4],
-        [0, 1, 2, 3, 4],
-        [0, 1, 2, 3, 4],
-        [0, 1, 2, 3, 4],
-        [0, 1, 2, 3, 4</a>]) np.mgrid[-1:1:5j] array([-1. , -0.5, 0. , 0.5, 1. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4997">view source</a></div></div><div class="public anchor" id="var-min"><h3>min</h3><div class="usage"><code>(min &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the minimum of an array or minimum along an axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  Axis or axes along which to operate. By default, flattened input is  used.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If this is a tuple of ints, the minimum is selected over multiple axes,
-instead of a single axis or all the axes as before.
-</code></pre>
-<p>out : ndarray, optional  Alternative output array in which to place the result. Must  be of the same shape and buffer length as the expected output.  See <code>ufuncs-output-type</code> for more details.</p>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `amin` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<p>initial : scalar, optional  The maximum value of an output element. Must be present to allow  computation on empty slice. See <code>~numpy.ufunc.reduce</code> for details.</p>
-<pre><code>.. versionadded:: 1.15.0
-</code></pre>
-<p>where : array_like of bool, optional  Elements to compare for the minimum. See <code>~numpy.ufunc.reduce</code>  for details.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>amin : ndarray or scalar  Minimum of <code>a</code>. If <code>axis</code> is None, the result is a scalar value.  If <code>axis</code> is given, the result is an array of dimension  <code>a.ndim - 1</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>amax :  The maximum value of an array along a given axis, propagating any NaNs. nanmin :  The minimum value of an array along a given axis, ignoring any NaNs. minimum :  Element-wise minimum of two arrays, propagating any NaNs. fmin :  Element-wise minimum of two arrays, ignoring any NaNs. argmin :  Return the indices of the minimum values.</p>
-<p>nanmax, maximum, fmax</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>NaN values are propagated, that is if at least one item is NaN, the corresponding min value will be NaN as well. To ignore NaN values (MATLAB behavior), please use nanmin.</p>
-<p>Don’t use <code>amin</code> for element-wise comparison of 2 arrays; when <code>a.shape[0]</code> is 2, <code>minimum(a[0], a[1])</code> is faster than <code>amin(a, axis=0)</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(4).reshape((2,2)) a array(<a href="null">0, 1],
-       [2, 3</a>) np.amin(a) # Minimum of the flattened array 0 np.amin(a, axis=0) # Minima along the first axis array([0, 1]) np.amin(a, axis=1) # Minima along the second axis array([0, 2]) np.amin(a, where=[False, True], initial=10, axis=0) array([10, 1])</p>
-      <p>b = np.arange(5, dtype=float) b[2] = np.NaN np.amin(b) nan np.amin(b, where=~np.isnan(b), initial=10) 0.0 np.nanmin(b) 0.0</p>
-      <p>np.min(<a href="null">-50], [10</a>, axis=-1, initial=0) array([-50, 0])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Notice that the initial value is used as one of the elements for which the minimum is determined, unlike for the default argument Python’s max function, which is only used for empty iterables.</p>
-<p>Notice that this isn’t the same as Python’s <code>default</code> argument.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.min([6], initial=5) 5 min([6], default=5) 6</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1801">view source</a></div></div><div class="public anchor" id="var-min_scalar_type"><h3>min_scalar_type</h3><div class="usage"><code>(min_scalar_type &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>min_scalar_type(a)</p>
-<p>For scalar <code>a</code>, returns the data type with the smallest size and smallest scalar kind which can hold its value. For non-scalar array <code>a</code>, returns the vector’s dtype unmodified.</p>
-<p>Floating point values are not demoted to integers, and complex values are not demoted to floats.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : scalar or array_like  The value whose minimal data type is to be found.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : dtype  The minimal data type.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.6.0</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>result_type, promote_types, dtype, can_cast</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.min_scalar_type(10) dtype(‘uint8’)</p>
-      <p>np.min_scalar_type(-260) dtype(‘int16’)</p>
-      <p>np.min_scalar_type(3.1) dtype(‘float16’)</p>
-      <p>np.min_scalar_type(1e50) dtype(‘float64’)</p>
-      <p>np.min_scalar_type(np.arange(4,dtype=‘f8’)) dtype(‘float64’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8045">view source</a></div></div><div class="public anchor" id="var-minimum"><h3>minimum</h3><div class="usage"><code>(minimum self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>minimum(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Element-wise minimum of array elements.</p>
-<p>Compare two arrays and returns a new array containing the element-wise minima. If one of the elements being compared is a NaN, then that element is returned. If both elements are NaNs then the first is returned. The latter distinction is important for complex NaNs, which are defined as at least one of the real or imaginary parts being a NaN. The net effect is that NaNs are propagated.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  The arrays holding the elements to be compared. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  The minimum of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>maximum :  Element-wise maximum of two arrays, propagates NaNs. fmin :  Element-wise minimum of two arrays, ignores NaNs. amin :  The minimum value of an array along a given axis, propagates NaNs. nanmin :  The minimum value of an array along a given axis, ignores NaNs.</p>
-<p>fmax, amax, nanmax</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The minimum is equivalent to <code>np.where(x1 &lt;= x2, x1, x2)</code> when neither x1 nor x2 are NaNs, but it is faster and does proper broadcasting.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.minimum([2, 3, 4], [1, 5, 2]) array([1, 3, 2])</p>
-      <p>np.minimum(np.eye(2), [0.5, 2]) # broadcasting array(<a href="null"> 0.5,  0. ],
-       [ 0. ,  1. </a>)</p>
-      <p>np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan]) array([nan, nan, nan]) np.minimum(-np.Inf, 1) -inf</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10511">view source</a></div></div><div class="public anchor" id="var-mintypecode"><h3>mintypecode</h3><div class="usage"><code>(mintypecode typechars &amp; [{typeset :typeset, default :default}])</code><code>(mintypecode typechars &amp; [{typeset :typeset}])</code><code>(mintypecode typechars)</code></div><div class="doc"><div class="markdown"><p>Return the character for the minimum-size type to which given types can be safely cast.</p>
-<p>The returned type character must represent the smallest size dtype such that an array of the returned type can handle the data from an array of all types in <code>typechars</code> (or if <code>typechars</code> is an array, then its dtype.char).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>typechars : list of str or array_like  If a list of strings, each string should represent a dtype.  If array_like, the character representation of the array dtype is used. typeset : str or list of str, optional  The set of characters that the returned character is chosen from.  The default set is ‘GDFgdf’. default : str, optional  The default character, this is returned if none of the characters in  <code>typechars</code> matches a character in <code>typeset</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>typechar : str  The character representing the minimum-size type that was found.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>dtype, sctype2char, maximum_sctype</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.mintypecode([‘d’, ‘f’, ‘S’]) ‘d’ x = np.array([1.1, 2-3.j]) np.mintypecode(x) ‘D’</p>
-      <p>np.mintypecode(‘abceh’, default=‘G’) ‘G’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8217">view source</a></div></div><div class="public anchor" id="var-mirr"><h3>mirr</h3><div class="usage"><code>(mirr &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Modified internal rate of return.</p>
-<p>.. deprecated:: 1.18</p>
-<p><code>mirr</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>values : array_like  Cash flows (must contain at least one positive and one negative  value) or nan is returned. The first value is considered a sunk  cost at time zero. finance_rate : scalar  Interest rate paid on the cash flows reinvest_rate : scalar  Interest rate received on the cash flows upon reinvestment</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : float  Modified internal rate of return</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19962">view source</a></div></div><div class="public anchor" id="var-mod"><h3>mod</h3><div class="usage"><code>(mod self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>remainder(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return element-wise remainder of division.</p>
-<p>Computes the remainder complementary to the <code>floor_divide</code> function. It is equivalent to the Python modulus operator<code>x1 % x2</code> and has the same sign as the divisor <code>x2</code>. The MATLAB function equivalent to <code>np.remainder</code> is <code>mod</code>.</p>
-<p>.. warning::</p>
-<pre><code>This should not be confused with:
-
-* Python 3.7's `math.remainder` and C's ``remainder``, which
-  computes the IEEE remainder, which are the complement to
-  ``round(x1 / x2)``.
-* The MATLAB ``rem`` function and or the C ``%`` operator which is the
-  complement to ``int(x1 / x2)``.
-</code></pre>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  Dividend array. x2 : array_like  Divisor array. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The element-wise remainder of the quotient <code>floor_divide(x1, x2)</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>floor_divide : Equivalent of Python <code>//</code> operator. divmod : Simultaneous floor division and remainder. fmod : Equivalent of the MATLAB <code>rem</code> function. divide, floor</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Returns 0 when <code>x2</code> is 0 and both <code>x1</code> and <code>x2</code> are (arrays of) integers. <code>mod</code> is an alias of <code>remainder</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.remainder([4, 7], [2, 3]) array([0, 1]) np.remainder(np.arange(7), 5) array([0, 1, 2, 3, 4, 0, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19894">view source</a></div></div><div class="public anchor" id="var-modf"><h3>modf</h3><div class="usage"><code>(modf self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the fractional and integral parts of an array, element-wise.</p>
-<p>The fractional and integral parts are negative if the given number is negative.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y1 : ndarray  Fractional part of <code>x</code>.  This is a scalar if <code>x</code> is a scalar. y2 : ndarray  Integral part of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>For integer input the return values are floats.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>divmod : <code>divmod(x, 1)</code> is equivalent to <code>modf</code> with the return values  switched, except it always has a positive remainder.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.modf([0, 3.5]) (array([ 0. , 0.5]), array([ 0., 3.])) np.modf(-0.5) (-0.5, -0)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28802">view source</a></div></div><div class="public anchor" id="var-ModuleDeprecationWarning"><h3>ModuleDeprecationWarning</h3><div class="usage"><code>(ModuleDeprecationWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Module deprecation warning.</p>
-<p>The nose tester turns ordinary Deprecation warnings into test failures. That makes it hard to deprecate whole modules, because they get imported by default. So this is a special Deprecation warning that the nose tester will let pass without making tests fail.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20294">view source</a></div></div><div class="public anchor" id="var-moveaxis"><h3>moveaxis</h3><div class="usage"><code>(moveaxis &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Move axes of an array to new positions.</p>
-<p>Other axes remain in their original order.</p>
-<p>.. versionadded:: 1.11.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : np.ndarray  The array whose axes should be reordered. source : int or sequence of int  Original positions of the axes to move. These must be unique. destination : int or sequence of int  Destination positions for each of the original axes. These must also be  unique.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>result : np.ndarray  Array with moved axes. This array is a view of the input array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>transpose: Permute the dimensions of an array. swapaxes: Interchange two axes of an array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.zeros((3, 4, 5)) np.moveaxis(x, 0, -1).shape (4, 5, 3) np.moveaxis(x, -1, 0).shape (5, 3, 4)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>These all achieve the same result:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.transpose(x).shape (5, 4, 3) np.swapaxes(x, 0, -1).shape (5, 4, 3) np.moveaxis(x, [0, 1], [-1, -2]).shape (5, 4, 3) np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape (5, 4, 3)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28193">view source</a></div></div><div class="public anchor" id="var-msort"><h3>msort</h3><div class="usage"><code>(msort &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a copy of an array sorted along the first axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array to be sorted.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>sorted_array : ndarray  Array of the same type and shape as <code>a</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>sort</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>np.msort(a)</code> is equivalent to <code>np.sort(a, axis=0)</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6165">view source</a></div></div><div class="public anchor" id="var-multiply"><h3>multiply</h3><div class="usage"><code>(multiply self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>multiply(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Multiply arguments element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Input arrays to be multiplied. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The product of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Equivalent to <code>x1</code> * <code>x2</code> in terms of array broadcasting.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.multiply(2.0, 4.0) 8.0</p>
-      <p>x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.multiply(x1, x2) array(<a href="null">  0.,   1.,   4.],
-       [  0.,   4.,  10.],
-       [  0.,   7.,  16.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5364">view source</a></div></div><div class="public anchor" id="var-NAN"><h3>NAN</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14127">view source</a></div></div><div class="public anchor" id="var-NaN"><h3>NaN</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L201">view source</a></div></div><div class="public anchor" id="var-nan"><h3>nan</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12502">view source</a></div></div><div class="public anchor" id="var-nan_to_num"><h3>nan_to_num</h3><div class="usage"><code>(nan_to_num &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Replace NaN with zero and infinity with large finite numbers (default behaviour) or with the numbers defined by the user using the <code>nan</code>, <code>posinf</code> and/or <code>neginf</code> keywords.</p>
-<p>If <code>x</code> is inexact, NaN is replaced by zero or by the user defined value in <code>nan</code> keyword, infinity is replaced by the largest finite floating point values representable by <code>x.dtype</code> or by the user defined value in <code>posinf</code> keyword and -infinity is replaced by the most negative finite floating point values representable by <code>x.dtype</code> or by the user defined value in <code>neginf</code> keyword.</p>
-<p>For complex dtypes, the above is applied to each of the real and imaginary components of <code>x</code> separately.</p>
-<p>If <code>x</code> is not inexact, then no replacements are made.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : scalar or array_like  Input data. copy : bool, optional  Whether to create a copy of <code>x</code> (True) or to replace values  in-place (False). The in-place operation only occurs if  casting to an array does not require a copy.  Default is True.</p>
-<pre><code>.. versionadded:: 1.13
-</code></pre>
-<p>nan : int, float, optional  Value to be used to fill NaN values. If no value is passed  then NaN values will be replaced with 0.0.</p>
-<pre><code>.. versionadded:: 1.17
-</code></pre>
-<p>posinf : int, float, optional  Value to be used to fill positive infinity values. If no value is  passed then positive infinity values will be replaced with a very  large number.</p>
-<pre><code>.. versionadded:: 1.17
-</code></pre>
-<p>neginf : int, float, optional  Value to be used to fill negative infinity values. If no value is  passed then negative infinity values will be replaced with a very  small (or negative) number.</p>
-<pre><code>.. versionadded:: 1.17
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  <code>x</code>, with the non-finite values replaced. If <code>copy</code> is False, this may  be <code>x</code> itself.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>isinf : Shows which elements are positive or negative infinity. isneginf : Shows which elements are negative infinity. isposinf : Shows which elements are positive infinity. isnan : Shows which elements are Not a Number (NaN). isfinite : Shows which elements are finite (not NaN, not infinity)</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.nan_to_num(np.inf) 1.7976931348623157e+308 np.nan_to_num(-np.inf) -1.7976931348623157e+308 np.nan_to_num(np.nan) 0.0 x = np.array([np.inf, -np.inf, np.nan, -128, 128]) np.nan_to_num(x) array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary  -1.28000000e+002, 1.28000000e+002]) np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333) array([ 3.3333333e+07, 3.3333333e+07, -9.9990000e+03,  -1.2800000e+02, 1.2800000e+02]) y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)]) array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000, # may vary  -1.28000000e+002, 1.28000000e+002]) np.nan_to_num(y) array([ 1.79769313e+308 +0.00000000e+000j, # may vary  0.00000000e+000 +0.00000000e+000j,  0.00000000e+000 +1.79769313e+308j]) np.nan_to_num(y, nan=111111, posinf=222222) array([222222.+111111.j, 111111. +0.j, 111111.+222222.j])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24186">view source</a></div></div><div class="public anchor" id="var-nanargmax"><h3>nanargmax</h3><div class="usage"><code>(nanargmax &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices of the maximum values in the specified axis ignoring NaNs. For all-NaN slices <code>ValueError</code> is raised. Warning: the results cannot be trusted if a slice contains only NaNs and -Infs.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. axis : int, optional  Axis along which to operate. By default flattened input is used.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>index_array : ndarray  An array of indices or a single index value.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>argmax, nanargmin</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">np.nan, 4], [2, 3</a>) np.argmax(a) 0 np.nanargmax(a) 1 np.nanargmax(a, axis=0) array([1, 0]) np.nanargmax(a, axis=1) array([1, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17528">view source</a></div></div><div class="public anchor" id="var-nanargmin"><h3>nanargmin</h3><div class="usage"><code>(nanargmin &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices of the minimum values in the specified axis ignoring NaNs. For all-NaN slices <code>ValueError</code> is raised. Warning: the results cannot be trusted if a slice contains only NaNs and Infs.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. axis : int, optional  Axis along which to operate. By default flattened input is used.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>index_array : ndarray  An array of indices or a single index value.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>argmin, nanargmax</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">np.nan, 4], [2, 3</a>) np.argmin(a) 0 np.nanargmin(a) 2 np.nanargmin(a, axis=0) array([1, 1]) np.nanargmin(a, axis=1) array([1, 0])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7968">view source</a></div></div><div class="public anchor" id="var-nancumprod"><h3>nancumprod</h3><div class="usage"><code>(nancumprod &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cumulative product of array elements over a given axis treating Not a Numbers (NaNs) as one. The cumulative product does not change when NaNs are encountered and leading NaNs are replaced by ones.</p>
-<p>Ones are returned for slices that are all-NaN or empty.</p>
-<p>.. versionadded:: 1.12.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. axis : int, optional  Axis along which the cumulative product is computed. By default  the input is flattened. dtype : dtype, optional  Type of the returned array, as well as of the accumulator in which  the elements are multiplied. If <em>dtype</em> is not specified, it  defaults to the dtype of <code>a</code>, unless <code>a</code> has an integer dtype with  a precision less than that of the default platform integer. In  that case, the default platform integer is used instead. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output  but the type of the resulting values will be cast if necessary.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>nancumprod : ndarray  A new array holding the result is returned unless <code>out</code> is  specified, in which case it is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.cumprod : Cumulative product across array propagating NaNs. isnan : Show which elements are NaN.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.nancumprod(1) array([1]) np.nancumprod([1]) array([1]) np.nancumprod([1, np.nan]) array([1., 1.]) a = np.array(<a href="null">1, 2], [3, np.nan</a>) np.nancumprod(a) array([1., 2., 6., 6.]) np.nancumprod(a, axis=0) array(<a href="null">1.,  2.],
-       [3.,  2.</a>) np.nancumprod(a, axis=1) array(<a href="null">1.,  2.],
-       [3.,  3.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13088">view source</a></div></div><div class="public anchor" id="var-nancumsum"><h3>nancumsum</h3><div class="usage"><code>(nancumsum &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the cumulative sum of array elements over a given axis treating Not a Numbers (NaNs) as zero. The cumulative sum does not change when NaNs are encountered and leading NaNs are replaced by zeros.</p>
-<p>Zeros are returned for slices that are all-NaN or empty.</p>
-<p>.. versionadded:: 1.12.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. axis : int, optional  Axis along which the cumulative sum is computed. The default  (None) is to compute the cumsum over the flattened array. dtype : dtype, optional  Type of the returned array and of the accumulator in which the  elements are summed. If <code>dtype</code> is not specified, it defaults  to the dtype of <code>a</code>, unless <code>a</code> has an integer dtype with a  precision less than that of the default platform integer. In  that case, the default platform integer is used. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output  but the type will be cast if necessary. See <code>ufuncs-output-type</code> for  more details.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>nancumsum : ndarray.  A new array holding the result is returned unless <code>out</code> is  specified, in which it is returned. The result has the same  size as <code>a</code>, and the same shape as <code>a</code> if <code>axis</code> is not None  or <code>a</code> is a 1-d array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.cumsum : Cumulative sum across array propagating NaNs. isnan : Show which elements are NaN.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.nancumsum(1) array([1]) np.nancumsum([1]) array([1]) np.nancumsum([1, np.nan]) array([1., 1.]) a = np.array(<a href="null">1, 2], [3, np.nan</a>) np.nancumsum(a) array([1., 3., 6., 6.]) np.nancumsum(a, axis=0) array(<a href="null">1.,  2.],
-       [4.,  2.</a>) np.nancumsum(a, axis=1) array(<a href="null">1.,  3.],
-       [3.,  3.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10188">view source</a></div></div><div class="public anchor" id="var-nanmax"><h3>nanmax</h3><div class="usage"><code>(nanmax &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the maximum of an array or maximum along an axis, ignoring any NaNs. When all-NaN slices are encountered a <code>RuntimeWarning</code> is raised and NaN is returned for that slice.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array containing numbers whose maximum is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the maximum is computed. The default is to compute  the maximum of the flattened array. out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>; if provided, it must have the same shape as the  expected output, but the type will be cast if necessary. See  <code>ufuncs-output-type</code> for more details.</p>
-<pre><code>.. versionadded:: 1.8.0
-</code></pre>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
-<pre><code>If the value is anything but the default, then
-`keepdims` will be passed through to the `max` method
-of sub-classes of `ndarray`.  If the sub-classes methods
-does not implement `keepdims` any exceptions will be raised.
-
-.. versionadded:: 1.8.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>nanmax : ndarray  An array with the same shape as <code>a</code>, with the specified axis removed.  If <code>a</code> is a 0-d array, or if axis is None, an ndarray scalar is  returned. The same dtype as <code>a</code> is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>nanmin :  The minimum value of an array along a given axis, ignoring any NaNs. amax :  The maximum value of an array along a given axis, propagating any NaNs. fmax :  Element-wise maximum of two arrays, ignoring any NaNs. maximum :  Element-wise maximum of two arrays, propagating any NaNs. isnan :  Shows which elements are Not a Number (NaN). isfinite:  Shows which elements are neither NaN nor infinity.</p>
-<p>amin, fmin, minimum</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity. Positive infinity is treated as a very large number and negative infinity is treated as a very small (i.e. negative) number.</p>
-<p>If the input has a integer type the function is equivalent to np.max.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 2], [3, np.nan</a>) np.nanmax(a) 3.0 np.nanmax(a, axis=0) array([3., 2.]) np.nanmax(a, axis=1) array([2., 3.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>When positive infinity and negative infinity are present:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.nanmax([1, 2, np.nan, np.NINF]) 2.0 np.nanmax([1, 2, np.nan, np.inf]) inf</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1034">view source</a></div></div><div class="public anchor" id="var-nanmean"><h3>nanmean</h3><div class="usage"><code>(nanmean &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the arithmetic mean along the specified axis, ignoring NaNs.</p>
-<p>Returns the average of the array elements. The average is taken over the flattened array by default, otherwise over the specified axis. <code>float64</code> intermediate and return values are used for integer inputs.</p>
-<p>For all-NaN slices, NaN is returned and a <code>RuntimeWarning</code> is raised.</p>
-<p>.. versionadded:: 1.8.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array containing numbers whose mean is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the means are computed. The default is to compute  the mean of the flattened array. dtype : data-type, optional  Type to use in computing the mean. For integer inputs, the default  is <code>float64</code>; for inexact inputs, it is the same as the input  dtype. out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>; if provided, it must have the same shape as the  expected output, but the type will be cast if necessary. See  <code>ufuncs-output-type</code> for more details. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
-<pre><code>If the value is anything but the default, then
-`keepdims` will be passed through to the `mean` or `sum` methods
-of sub-classes of `ndarray`.  If the sub-classes methods
-does not implement `keepdims` any exceptions will be raised.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>m : ndarray, see dtype parameter above  If <code>out=None</code>, returns a new array containing the mean values,  otherwise a reference to the output array is returned. Nan is  returned for slices that contain only NaNs.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>average : Weighted average mean : Arithmetic mean taken while not ignoring NaNs var, nanvar</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The arithmetic mean is the sum of the non-NaN elements along the axis divided by the number of non-NaN elements.</p>
-<p>Note that for floating-point input, the mean is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for <code>float32</code>. Specifying a higher-precision accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, np.nan], [3, 4</a>) np.nanmean(a) 2.6666666666666665 np.nanmean(a, axis=0) array([2., 4.]) np.nanmean(a, axis=1) array([1., 3.5]) # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25342">view source</a></div></div><div class="public anchor" id="var-nanmedian"><h3>nanmedian</h3><div class="usage"><code>(nanmedian &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the median along the specified axis, while ignoring NaNs.</p>
-<p>Returns the median of the array elements.</p>
-<p>.. versionadded:: 1.9.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array or object that can be converted to an array. axis : {int, sequence of int, None}, optional  Axis or axes along which the medians are computed. The default  is to compute the median along a flattened version of the array.  A sequence of axes is supported since version 1.9.0. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow use of memory of input array <code>a</code> for  calculations. The input array will be modified by the call to  <code>median</code>. This will save memory when you do not need to preserve  the contents of the input array. Treat the input as undefined,  but it will probably be fully or partially sorted. Default is  False. If <code>overwrite_input</code> is <code>True</code> and <code>a</code> is not already an  <code>ndarray</code>, an error will be raised. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
-<pre><code>If this is anything but the default value it will be passed
-through (in the special case of an empty array) to the
-`mean` function of the underlying array.  If the array is
-a sub-class and `mean` does not have the kwarg `keepdims` this
-will raise a RuntimeError.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>median : ndarray  A new array holding the result. If the input contains integers  or floats smaller than <code>float64</code>, then the output data-type is  <code>np.float64</code>. Otherwise, the data-type of the output is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>mean, median, percentile</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Given a vector <code>V</code> of length <code>N</code>, the median of <code>V</code> is the middle value of a sorted copy of <code>V</code>, <code>V_sorted</code> - i.e., <code>V_sorted[(N-1)/2]</code>, when <code>N</code> is odd and the average of the two middle values of <code>V_sorted</code> when <code>N</code> is even.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">10.0, 7, 4], [3, 2, 1</a>) a[0, 1] = np.nan a array(<a href="null">10., nan,  4.],
-       [ 3.,  2.,  1.</a>) np.median(a) nan np.nanmedian(a) 3.0 np.nanmedian(a, axis=0) array([6.5, 2. , 2.5]) np.median(a, axis=1) array([nan, 2.]) b = a.copy() np.nanmedian(b, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a==b) b = a.copy() np.nanmedian(b, axis=None, overwrite_input=True) 3.0 assert not np.all(a==b)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25832">view source</a></div></div><div class="public anchor" id="var-nanmin"><h3>nanmin</h3><div class="usage"><code>(nanmin &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return minimum of an array or minimum along an axis, ignoring any NaNs. When all-NaN slices are encountered a <code>RuntimeWarning</code> is raised and Nan is returned for that slice.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array containing numbers whose minimum is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the minimum is computed. The default is to compute  the minimum of the flattened array. out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>; if provided, it must have the same shape as the  expected output, but the type will be cast if necessary. See  <code>ufuncs-output-type</code> for more details.</p>
-<pre><code>.. versionadded:: 1.8.0
-</code></pre>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
-<pre><code>If the value is anything but the default, then
-`keepdims` will be passed through to the `min` method
-of sub-classes of `ndarray`.  If the sub-classes methods
-does not implement `keepdims` any exceptions will be raised.
-
-.. versionadded:: 1.8.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>nanmin : ndarray  An array with the same shape as <code>a</code>, with the specified axis  removed. If <code>a</code> is a 0-d array, or if axis is None, an ndarray  scalar is returned. The same dtype as <code>a</code> is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>nanmax :  The maximum value of an array along a given axis, ignoring any NaNs. amin :  The minimum value of an array along a given axis, propagating any NaNs. fmin :  Element-wise minimum of two arrays, ignoring any NaNs. minimum :  Element-wise minimum of two arrays, propagating any NaNs. isnan :  Shows which elements are Not a Number (NaN). isfinite:  Shows which elements are neither NaN nor infinity.</p>
-<p>amax, fmax, maximum</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic (IEEE 754). This means that Not a Number is not equivalent to infinity. Positive infinity is treated as a very large number and negative infinity is treated as a very small (i.e. negative) number.</p>
-<p>If the input has a integer type the function is equivalent to np.min.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 2], [3, np.nan</a>) np.nanmin(a) 1.0 np.nanmin(a, axis=0) array([1., 2.]) np.nanmin(a, axis=1) array([1., 3.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>When positive infinity and negative infinity are present:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.nanmin([1, 2, np.nan, np.inf]) 1.0 np.nanmin([1, 2, np.nan, np.NINF]) -inf</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17870">view source</a></div></div><div class="public anchor" id="var-nanpercentile"><h3>nanpercentile</h3><div class="usage"><code>(nanpercentile &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the qth percentile of the data along the specified axis, while ignoring nan values.</p>
-<p>Returns the qth percentile(s) of the array elements.</p>
-<p>.. versionadded:: 1.9.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array or object that can be converted to an array, containing  nan values to be ignored. q : array_like of float  Percentile or sequence of percentiles to compute, which must be between  0 and 100 inclusive. axis : {int, tuple of int, None}, optional  Axis or axes along which the percentiles are computed. The  default is to compute the percentile(s) along a flattened  version of the array. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow the input array <code>a</code> to be modified by intermediate  calculations, to save memory. In this case, the contents of the input  <code>a</code> after this function completes is undefined. interpolation : {‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}  This optional parameter specifies the interpolation method to  use when the desired percentile lies between two data points  <code>i &lt; j</code>:</p>
-<pre><code>* 'linear': ``i + (j - i) * fraction``, where ``fraction``
-  is the fractional part of the index surrounded by ``i``
-  and ``j``.
-* 'lower': ``i``.
-* 'higher': ``j``.
-* 'nearest': ``i`` or ``j``, whichever is nearest.
-* 'midpoint': ``(i + j) / 2``.
-</code></pre>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left in  the result as dimensions with size one. With this option, the  result will broadcast correctly against the original array <code>a</code>.</p>
-<pre><code>If this is anything but the default value it will be passed
-through (in the special case of an empty array) to the
-`mean` function of the underlying array.  If the array is
-a sub-class and `mean` does not have the kwarg `keepdims` this
-will raise a RuntimeError.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>percentile : scalar or ndarray  If <code>q</code> is a single percentile and <code>axis=None</code>, then the result  is a scalar. If multiple percentiles are given, first axis of  the result corresponds to the percentiles. The other axes are  the axes that remain after the reduction of <code>a</code>. If the input  contains integers or floats smaller than <code>float64</code>, the output  data-type is <code>float64</code>. Otherwise, the output data-type is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>nanmean nanmedian : equivalent to <code>nanpercentile(..., 50)</code> percentile, median, mean nanquantile : equivalent to nanpercentile, but with q in the range [0, 1].</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Given a vector <code>V</code> of length <code>N</code>, the <code>q</code>-th percentile of <code>V</code> is the value <code>q/100</code> of the way from the minimum to the maximum in a sorted copy of <code>V</code>. The values and distances of the two nearest neighbors as well as the <code>interpolation</code> parameter will determine the percentile if the normalized ranking does not match the location of <code>q</code> exactly. This function is the same as the median if <code>q=50</code>, the same as the minimum if <code>q=0</code> and the same as the maximum if <code>q=100</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">10., 7., 4.], [3., 2., 1.</a>) a[0][1] = np.nan a array(<a href="null">10.,  nan,   4.],
-      [ 3.,   2.,   1.</a>) np.percentile(a, 50) nan np.nanpercentile(a, 50) 3.0 np.nanpercentile(a, 50, axis=0) array([6.5, 2. , 2.5]) np.nanpercentile(a, 50, axis=1, keepdims=True) array(<a href="null">7.],
-       [2.</a>) m = np.nanpercentile(a, 50, axis=0) out = np.zeros_like(m) np.nanpercentile(a, 50, axis=0, out=out) array([6.5, 2. , 2.5]) m array([6.5, 2. , 2.5])</p>
-      <p>b = a.copy() np.nanpercentile(b, 50, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a==b)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5418">view source</a></div></div><div class="public anchor" id="var-nanprod"><h3>nanprod</h3><div class="usage"><code>(nanprod &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the product of array elements over a given axis treating Not a Numbers (NaNs) as ones.</p>
-<p>One is returned for slices that are all-NaN or empty.</p>
-<p>.. versionadded:: 1.10.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array containing numbers whose product is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the product is computed. The default is to compute  the product of the flattened array. dtype : data-type, optional  The type of the returned array and of the accumulator in which the  elements are summed. By default, the dtype of <code>a</code> is used. An  exception is when <code>a</code> has an integer type with less precision than  the platform (u)intp. In that case, the default will be either  (u)int32 or (u)int64 depending on whether the platform is 32 or 64  bits. For inexact inputs, dtype must be inexact. out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>. If provided, it must have the same shape as the  expected output, but the type will be cast if necessary. See  <code>ufuncs-output-type</code> for more details. The casting of NaN to integer  can yield unexpected results. keepdims : bool, optional  If True, the axes which are reduced are left in the result as  dimensions with size one. With this option, the result will  broadcast correctly against the original <code>arr</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>nanprod : ndarray  A new array holding the result is returned unless <code>out</code> is  specified, in which case it is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.prod : Product across array propagating NaNs. isnan : Show which elements are NaN.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.nanprod(1) 1 np.nanprod([1]) 1 np.nanprod([1, np.nan]) 1.0 a = np.array(<a href="null">1, 2], [3, np.nan</a>) np.nanprod(a) 6.0 np.nanprod(a, axis=0) array([3., 2.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4761">view source</a></div></div><div class="public anchor" id="var-nanquantile"><h3>nanquantile</h3><div class="usage"><code>(nanquantile &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the qth quantile of the data along the specified axis, while ignoring nan values. Returns the qth quantile(s) of the array elements.</p>
-<p>.. versionadded:: 1.15.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array or object that can be converted to an array, containing  nan values to be ignored q : array_like of float  Quantile or sequence of quantiles to compute, which must be between  0 and 1 inclusive. axis : {int, tuple of int, None}, optional  Axis or axes along which the quantiles are computed. The  default is to compute the quantile(s) along a flattened  version of the array. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow the input array <code>a</code> to be modified by intermediate  calculations, to save memory. In this case, the contents of the input  <code>a</code> after this function completes is undefined. interpolation : {‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}  This optional parameter specifies the interpolation method to  use when the desired quantile lies between two data points  <code>i &lt; j</code>:</p>
-<pre><code>* linear: ``i + (j - i) * fraction``, where ``fraction``
-  is the fractional part of the index surrounded by ``i``
-  and ``j``.
-* lower: ``i``.
-* higher: ``j``.
-* nearest: ``i`` or ``j``, whichever is nearest.
-* midpoint: ``(i + j) / 2``.
-</code></pre>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left in  the result as dimensions with size one. With this option, the  result will broadcast correctly against the original array <code>a</code>.</p>
-<pre><code>If this is anything but the default value it will be passed
-through (in the special case of an empty array) to the
-`mean` function of the underlying array.  If the array is
-a sub-class and `mean` does not have the kwarg `keepdims` this
-will raise a RuntimeError.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>quantile : scalar or ndarray  If <code>q</code> is a single percentile and <code>axis=None</code>, then the result  is a scalar. If multiple quantiles are given, first axis of  the result corresponds to the quantiles. The other axes are  the axes that remain after the reduction of <code>a</code>. If the input  contains integers or floats smaller than <code>float64</code>, the output  data-type is <code>float64</code>. Otherwise, the output data-type is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>quantile nanmean, nanmedian nanmedian : equivalent to <code>nanquantile(..., 0.5)</code> nanpercentile : same as nanquantile, but with q in the range [0, 100].</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">10., 7., 4.], [3., 2., 1.</a>) a[0][1] = np.nan a array(<a href="null">10.,  nan,   4.],
-      [ 3.,   2.,   1.</a>) np.quantile(a, 0.5) nan np.nanquantile(a, 0.5) 3.0 np.nanquantile(a, 0.5, axis=0) array([6.5, 2. , 2.5]) np.nanquantile(a, 0.5, axis=1, keepdims=True) array(<a href="null">7.],
-       [2.</a>) m = np.nanquantile(a, 0.5, axis=0) out = np.zeros_like(m) np.nanquantile(a, 0.5, axis=0, out=out) array([6.5, 2. , 2.5]) m array([6.5, 2. , 2.5]) b = a.copy() np.nanquantile(b, 0.5, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a==b)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14507">view source</a></div></div><div class="public anchor" id="var-nanstd"><h3>nanstd</h3><div class="usage"><code>(nanstd &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the standard deviation along the specified axis, while ignoring NaNs.</p>
-<p>Returns the standard deviation, a measure of the spread of a distribution, of the non-NaN array elements. The standard deviation is computed for the flattened array by default, otherwise over the specified axis.</p>
-<p>For all-NaN slices or slices with zero degrees of freedom, NaN is returned and a <code>RuntimeWarning</code> is raised.</p>
-<p>.. versionadded:: 1.8.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Calculate the standard deviation of the non-NaN values. axis : {int, tuple of int, None}, optional  Axis or axes along which the standard deviation is computed. The default is  to compute the standard deviation of the flattened array. dtype : dtype, optional  Type to use in computing the standard deviation. For arrays of  integer type the default is float64, for arrays of float types it  is the same as the array type. out : ndarray, optional  Alternative output array in which to place the result. It must have  the same shape as the expected output but the type (of the  calculated values) will be cast if necessary. ddof : int, optional  Means Delta Degrees of Freedom. The divisor used in calculations  is <code>N - ddof</code>, where <code>N</code> represents the number of non-NaN  elements. By default <code>ddof</code> is zero.</p>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
-<pre><code>If this value is anything but the default it is passed through
-as-is to the relevant functions of the sub-classes.  If these
-functions do not have a `keepdims` kwarg, a RuntimeError will
-be raised.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>standard_deviation : ndarray, see dtype parameter above.  If <code>out</code> is None, return a new array containing the standard  deviation, otherwise return a reference to the output array. If  ddof is &gt;= the number of non-NaN elements in a slice or the slice  contains only NaNs, then the result for that slice is NaN.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>var, mean, std nanvar, nanmean ufuncs-output-type</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The standard deviation is the square root of the average of the squared deviations from the mean: <code>std = sqrt(mean(abs(x - x.mean())**2))</code>.</p>
-<p>The average squared deviation is normally calculated as <code>x.sum() / N</code>, where <code>N = len(x)</code>. If, however, <code>ddof</code> is specified, the divisor <code>N - ddof</code> is used instead. In standard statistical practice, <code>ddof=1</code> provides an unbiased estimator of the variance of the infinite population. <code>ddof=0</code> provides a maximum likelihood estimate of the variance for normally distributed variables. The standard deviation computed in this function is the square root of the estimated variance, so even with <code>ddof=1</code>, it will not be an unbiased estimate of the standard deviation per se.</p>
-<p>Note that, for complex numbers, <code>std</code> takes the absolute value before squaring, so that the result is always real and nonnegative.</p>
-<p>For floating-point input, the <em>std</em> is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for float32 (see example below). Specifying a higher-accuracy accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, np.nan], [3, 4</a>) np.nanstd(a) 1.247219128924647 np.nanstd(a, axis=0) array([1., 0.]) np.nanstd(a, axis=1) array([0., 0.5]) # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22889">view source</a></div></div><div class="public anchor" id="var-nansum"><h3>nansum</h3><div class="usage"><code>(nansum &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the sum of array elements over a given axis treating Not a Numbers (NaNs) as zero.</p>
-<p>In NumPy versions &lt;= 1.9.0 Nan is returned for slices that are all-NaN or empty. In later versions zero is returned.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array containing numbers whose sum is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the sum is computed. The default is to compute the  sum of the flattened array. dtype : data-type, optional  The type of the returned array and of the accumulator in which the  elements are summed. By default, the dtype of <code>a</code> is used. An  exception is when <code>a</code> has an integer type with less precision than  the platform (u)intp. In that case, the default will be either  (u)int32 or (u)int64 depending on whether the platform is 32 or 64  bits. For inexact inputs, dtype must be inexact.</p>
-<pre><code>.. versionadded:: 1.8.0
-</code></pre>
-<p>out : ndarray, optional  Alternate output array in which to place the result. The default  is <code>None</code>. If provided, it must have the same shape as the  expected output, but the type will be cast if necessary. See  <code>ufuncs-output-type</code> for more details. The casting of NaN to integer  can yield unexpected results.</p>
-<pre><code>.. versionadded:: 1.8.0
-</code></pre>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
-<pre><code>If the value is anything but the default, then
-`keepdims` will be passed through to the `mean` or `sum` methods
-of sub-classes of `ndarray`.  If the sub-classes methods
-does not implement `keepdims` any exceptions will be raised.
-
-.. versionadded:: 1.8.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>nansum : ndarray.  A new array holding the result is returned unless <code>out</code> is  specified, in which it is returned. The result has the same  size as <code>a</code>, and the same shape as <code>a</code> if <code>axis</code> is not None  or <code>a</code> is a 1-d array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.sum : Sum across array propagating NaNs. isnan : Show which elements are NaN. isfinite: Show which elements are not NaN or +/-inf.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If both positive and negative infinity are present, the sum will be Not A Number (NaN).</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.nansum(1) 1 np.nansum([1]) 1 np.nansum([1, np.nan]) 1.0 a = np.array(<a href="null">1, 1], [1, np.nan</a>) np.nansum(a) 3.0 np.nansum(a, axis=0) array([2., 1.]) np.nansum([1, np.nan, np.inf]) inf np.nansum([1, np.nan, np.NINF]) -inf from numpy.testing import suppress_warnings with suppress_warnings() as sup: … sup.filter(RuntimeWarning) … np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present nan</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4671">view source</a></div></div><div class="public anchor" id="var-nanvar"><h3>nanvar</h3><div class="usage"><code>(nanvar &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the variance along the specified axis, while ignoring NaNs.</p>
-<p>Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis.</p>
-<p>For all-NaN slices or slices with zero degrees of freedom, NaN is returned and a <code>RuntimeWarning</code> is raised.</p>
-<p>.. versionadded:: 1.8.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array containing numbers whose variance is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : {int, tuple of int, None}, optional  Axis or axes along which the variance is computed. The default is to compute  the variance of the flattened array. dtype : data-type, optional  Type to use in computing the variance. For arrays of integer type  the default is <code>float64</code>; for arrays of float types it is the same as  the array type. out : ndarray, optional  Alternate output array in which to place the result. It must have  the same shape as the expected output, but the type is cast if  necessary. ddof : int, optional  “Delta Degrees of Freedom”: the divisor used in the calculation is  <code>N - ddof</code>, where <code>N</code> represents the number of non-NaN  elements. By default <code>ddof</code> is zero. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the original <code>a</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>variance : ndarray, see dtype parameter above  If <code>out</code> is None, return a new array containing the variance,  otherwise return a reference to the output array. If ddof is &gt;= the  number of non-NaN elements in a slice or the slice contains only  NaNs, then the result for that slice is NaN.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>std : Standard deviation mean : Average var : Variance while not ignoring NaNs nanstd, nanmean ufuncs-output-type</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The variance is the average of the squared deviations from the mean, i.e., <code>var = mean(abs(x - x.mean())**2)</code>.</p>
-<p>The mean is normally calculated as <code>x.sum() / N</code>, where <code>N = len(x)</code>. If, however, <code>ddof</code> is specified, the divisor <code>N - ddof</code> is used instead. In standard statistical practice, <code>ddof=1</code> provides an unbiased estimator of the variance of a hypothetical infinite population. <code>ddof=0</code> provides a maximum likelihood estimate of the variance for normally distributed variables.</p>
-<p>Note that for complex numbers, the absolute value is taken before squaring, so that the result is always real and nonnegative.</p>
-<p>For floating-point input, the variance is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for <code>float32</code> (see example below). Specifying a higher-accuracy accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
-<p>For this function to work on sub-classes of ndarray, they must define <code>sum</code> with the kwarg <code>keepdims</code></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, np.nan], [3, 4</a>) np.nanvar(a) 1.5555555555555554 np.nanvar(a, axis=0) array([1., 0.]) np.nanvar(a, axis=1) array([0., 0.25]) # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28033">view source</a></div></div><div class="public anchor" id="var-nbytes"><h3>nbytes</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Base object for a dictionary for look-up with any alias for an array dtype.</p>
-<p>Instances of <code>_typedict</code> can not be used as dictionaries directly, first they have to be populated.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25824">view source</a></div></div><div class="public anchor" id="var-ndarray"><h3>ndarray</h3><div class="usage"><code>(ndarray self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>ndarray(shape, dtype=float, buffer=None, offset=0,  strides=None, order=None)</p>
-<p>An array object represents a multidimensional, homogeneous array of fixed-size items. An associated data-type object describes the format of each element in the array (its byte-order, how many bytes it occupies in memory, whether it is an integer, a floating point number, or something else, etc.)</p>
-<p>Arrays should be constructed using <code>array</code>, <code>zeros</code> or <code>empty</code> (refer to the See Also section below). The parameters given here refer to a low-level method (<code>ndarray(...)</code>) for instantiating an array.</p>
-<p>For more information, refer to the <code>numpy</code> module and examine the methods and attributes of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>(for the <strong>new</strong> method; see Notes below)</p>
-<p>shape : tuple of ints  Shape of created array. dtype : data-type, optional  Any object that can be interpreted as a numpy data type. buffer : object exposing buffer interface, optional  Used to fill the array with data. offset : int, optional  Offset of array data in buffer. strides : tuple of ints, optional  Strides of data in memory. order : {‘C’, ‘F’}, optional  Row-major (C-style) or column-major (Fortran-style) order.</p>
-<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
-<p>T : ndarray  Transpose of the array. data : buffer  The array’s elements, in memory. dtype : dtype object  Describes the format of the elements in the array. flags : dict  Dictionary containing information related to memory use, e.g.,  ‘C_CONTIGUOUS’, ‘OWNDATA’, ‘WRITEABLE’, etc. flat : numpy.flatiter object  Flattened version of the array as an iterator. The iterator  allows assignments, e.g., <code>x.flat = 3</code> (See <code>ndarray.flat</code> for  assignment examples; TODO). imag : ndarray  Imaginary part of the array. real : ndarray  Real part of the array. size : int  Number of elements in the array. itemsize : int  The memory use of each array element in bytes. nbytes : int  The total number of bytes required to store the array data,  i.e., <code>itemsize * size</code>. ndim : int  The array’s number of dimensions. shape : tuple of ints  Shape of the array. strides : tuple of ints  The step-size required to move from one element to the next in  memory. For example, a contiguous <code>(3, 4)</code> array of type  <code>int16</code> in C-order has strides <code>(8, 2)</code>. This implies that  to move from element to element in memory requires jumps of 2 bytes.  To move from row-to-row, one needs to jump 8 bytes at a time  (<code>2 * 4</code>). ctypes : ctypes object  Class containing properties of the array needed for interaction  with ctypes. base : ndarray  If the array is a view into another array, that array is its <code>base</code>  (unless that array is also a view). The <code>base</code> array is where the  array data is actually stored.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>array : Construct an array. zeros : Create an array, each element of which is zero. empty : Create an array, but leave its allocated memory unchanged (i.e.,  it contains “garbage”). dtype : Create a data-type.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>There are two modes of creating an array using <code>__new__</code>:</p>
-<ol>
-  <li>If <code>buffer</code> is None, then only <code>shape</code>, <code>dtype</code>, and <code>order</code>  are used.</li>
-  <li>If <code>buffer</code> is an object exposing the buffer interface, then  all keywords are interpreted.</li>
-</ol>
-<p>No <code>__init__</code> method is needed because the array is fully initialized after the <code>__new__</code> method.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>These examples illustrate the low-level <code>ndarray</code> constructor. Refer to the <code>See Also</code> section above for easier ways of constructing an ndarray.</p>
-<p>First mode, <code>buffer</code> is None:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.ndarray(shape=(2,2), dtype=float, order=‘F’) array(<a href="null">0.0e+000, 0.0e+000], # random
-       [     nan, 2.5e-323</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Second mode:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.ndarray((2,), buffer=np.array([1,2,3]), … offset=np.int_().itemsize, … dtype=int) # offset = 1*itemsize, i.e. skip first element array([2, 3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13399">view source</a></div></div><div class="public anchor" id="var-ndenumerate"><h3>ndenumerate</h3><div class="usage"><code>(ndenumerate self arr)</code></div><div class="doc"><div class="markdown"><p>Multidimensional index iterator.</p>
-<p>Return an iterator yielding pairs of array coordinates and values.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr : ndarray  Input array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndindex, flatiter</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 2], [3, 4</a>) for index, x in np.ndenumerate(a): … print(index, x) (0, 0) 1 (0, 1) 2 (1, 0) 3 (1, 1) 4</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14008">view source</a></div></div><div class="public anchor" id="var-ndfromtxt"><h3>ndfromtxt</h3><div class="usage"><code>(ndfromtxt fname &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Load ASCII data stored in a file and return it as a single array.</p>
-<p>.. deprecated:: 1.17  ndfromtxt<code>is a deprecated alias of</code>genfromtxt<code>which
-    overwrites the ``usemask`` argument with</code>False<code>even when
-    explicitly called as ``ndfromtxt(..., usemask=True)``.
-    Use</code>genfromtxt` instead.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>fname, kwargs : For a description of input parameters, see <code>genfromtxt</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.genfromtxt : generic function.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15151">view source</a></div></div><div class="public anchor" id="var-ndim"><h3>ndim</h3><div class="usage"><code>(ndim &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the number of dimensions of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. If it is not already an ndarray, a conversion is  attempted.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>number_of_dimensions : int  The number of dimensions in <code>a</code>. Scalars are zero-dimensional.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.ndim : equivalent method shape : dimensions of array ndarray.shape : dimensions of array</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.ndim(<a href="null">1,2,3],[4,5,6</a>) 2 np.ndim(np.array(<a href="null">1,2,3],[4,5,6</a>)) 2 np.ndim(1) 0</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18344">view source</a></div></div><div class="public anchor" id="var-ndindex"><h3>ndindex</h3><div class="usage"><code>(ndindex self &amp; [shape])</code></div><div class="doc"><div class="markdown"><p>An N-dimensional iterator object to index arrays.</p>
-<p>Given the shape of an array, an <code>ndindex</code> instance iterates over the N-dimensional index of the array. At each iteration a tuple of indices is returned, the last dimension is iterated over first.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p><code>*args</code> : ints  The size of each dimension of the array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndenumerate, flatiter</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>for index in np.ndindex(3, 2, 1): … print(index) (0, 0, 0) (0, 1, 0) (1, 0, 0) (1, 1, 0) (2, 0, 0) (2, 1, 0)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2709">view source</a></div></div><div class="public anchor" id="var-nditer"><h3>nditer</h3><div class="usage"><code>(nditer self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Efficient multi-dimensional iterator object to iterate over arrays. To get started using this object, see the :ref:<code>introductory guide to array iteration &lt;arrays.nditer&gt;</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>op : ndarray or sequence of array_like  The array(s) to iterate over.</p>
-<p>flags : sequence of str, optional  Flags to control the behavior of the iterator.</p>
-<pre><code>  * ``buffered`` enables buffering when required.
-  * ``c_index`` causes a C-order index to be tracked.
-  * ``f_index`` causes a Fortran-order index to be tracked.
-  * ``multi_index`` causes a multi-index, or a tuple of indices
-    with one per iteration dimension, to be tracked.
-  * ``common_dtype`` causes all the operands to be converted to
-    a common data type, with copying or buffering as necessary.
-  * ``copy_if_overlap`` causes the iterator to determine if read
-    operands have overlap with write operands, and make temporary
-    copies as necessary to avoid overlap. False positives (needless
-    copying) are possible in some cases.
-  * ``delay_bufalloc`` delays allocation of the buffers until
-    a reset() call is made. Allows ``allocate`` operands to
-    be initialized before their values are copied into the buffers.
-  * ``external_loop`` causes the ``values`` given to be
-    one-dimensional arrays with multiple values instead of
-    zero-dimensional arrays.
-  * ``grow_inner`` allows the ``value`` array sizes to be made
-    larger than the buffer size when both ``buffered`` and
-    ``external_loop`` is used.
-  * ``ranged`` allows the iterator to be restricted to a sub-range
-    of the iterindex values.
-  * ``refs_ok`` enables iteration of reference types, such as
-    object arrays.
-  * ``reduce_ok`` enables iteration of ``readwrite`` operands
-    which are broadcasted, also known as reduction operands.
-  * ``zerosize_ok`` allows `itersize` to be zero.
-</code></pre>
-<p>op_flags : list of list of str, optional  This is a list of flags for each operand. At minimum, one of  <code>readonly</code>, <code>readwrite</code>, or <code>writeonly</code> must be specified.</p>
-<pre><code>  * ``readonly`` indicates the operand will only be read from.
-  * ``readwrite`` indicates the operand will be read from and written to.
-  * ``writeonly`` indicates the operand will only be written to.
-  * ``no_broadcast`` prevents the operand from being broadcasted.
-  * ``contig`` forces the operand data to be contiguous.
-  * ``aligned`` forces the operand data to be aligned.
-  * ``nbo`` forces the operand data to be in native byte order.
-  * ``copy`` allows a temporary read-only copy if required.
-  * ``updateifcopy`` allows a temporary read-write copy if required.
-  * ``allocate`` causes the array to be allocated if it is None
-    in the ``op`` parameter.
-  * ``no_subtype`` prevents an ``allocate`` operand from using a subtype.
-  * ``arraymask`` indicates that this operand is the mask to use
-    for selecting elements when writing to operands with the
-    'writemasked' flag set. The iterator does not enforce this,
-    but when writing from a buffer back to the array, it only
-    copies those elements indicated by this mask.
-  * ``writemasked`` indicates that only elements where the chosen
-    ``arraymask`` operand is True will be written to.
-  * ``overlap_assume_elementwise`` can be used to mark operands that are
-    accessed only in the iterator order, to allow less conservative
-    copying when ``copy_if_overlap`` is present.
-</code></pre>
-<p>op_dtypes : dtype or tuple of dtype(s), optional  The required data type(s) of the operands. If copying or buffering  is enabled, the data will be converted to/from their original types. order : {‘C’, ‘F’, ‘A’, ‘K’}, optional  Controls the iteration order. ‘C’ means C order, ‘F’ means  Fortran order, ‘A’ means ‘F’ order if all the arrays are Fortran  contiguous, ‘C’ order otherwise, and ‘K’ means as close to the  order the array elements appear in memory as possible. This also  affects the element memory order of <code>allocate</code> operands, as they  are allocated to be compatible with iteration order.  Default is ‘K’. casting : {‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}, optional  Controls what kind of data casting may occur when making a copy  or buffering. Setting this to ‘unsafe’ is not recommended,  as it can adversely affect accumulations.</p>
-<pre><code>* 'no' means the data types should not be cast at all.
-* 'equiv' means only byte-order changes are allowed.
-* 'safe' means only casts which can preserve values are allowed.
-* 'same_kind' means only safe casts or casts within a kind,
-  like float64 to float32, are allowed.
-* 'unsafe' means any data conversions may be done.
-</code></pre>
-<p>op_axes : list of list of ints, optional  If provided, is a list of ints or None for each operands.  The list of axes for an operand is a mapping from the dimensions  of the iterator to the dimensions of the operand. A value of  -1 can be placed for entries, causing that dimension to be  treated as <code>newaxis</code>. itershape : tuple of ints, optional  The desired shape of the iterator. This allows <code>allocate</code> operands  with a dimension mapped by op_axes not corresponding to a dimension  of a different operand to get a value not equal to 1 for that  dimension. buffersize : int, optional  When buffering is enabled, controls the size of the temporary  buffers. Set to 0 for the default value.</p>
-<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
-<p>dtypes : tuple of dtype(s)  The data types of the values provided in <code>value</code>. This may be  different from the operand data types if buffering is enabled.  Valid only before the iterator is closed. finished : bool  Whether the iteration over the operands is finished or not. has_delayed_bufalloc : bool  If True, the iterator was created with the <code>delay_bufalloc</code> flag,  and no reset() function was called on it yet. has_index : bool  If True, the iterator was created with either the <code>c_index</code> or  the <code>f_index</code> flag, and the property <code>index</code> can be used to  retrieve it. has_multi_index : bool  If True, the iterator was created with the <code>multi_index</code> flag,  and the property <code>multi_index</code> can be used to retrieve it. index  When the <code>c_index</code> or <code>f_index</code> flag was used, this property  provides access to the index. Raises a ValueError if accessed  and <code>has_index</code> is False. iterationneedsapi : bool  Whether iteration requires access to the Python API, for example  if one of the operands is an object array. iterindex : int  An index which matches the order of iteration. itersize : int  Size of the iterator. itviews  Structured view(s) of <code>operands</code> in memory, matching the reordered  and optimized iterator access pattern. Valid only before the iterator  is closed. multi_index  When the <code>multi_index</code> flag was used, this property  provides access to the index. Raises a ValueError if accessed  accessed and <code>has_multi_index</code> is False. ndim : int  The dimensions of the iterator. nop : int  The number of iterator operands. operands : tuple of operand(s)  The array(s) to be iterated over. Valid only before the iterator is  closed. shape : tuple of ints  Shape tuple, the shape of the iterator. value  Value of <code>operands</code> at current iteration. Normally, this is a  tuple of array scalars, but if the flag <code>external_loop</code> is used,  it is a tuple of one dimensional arrays.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>nditer</code> supersedes <code>flatiter</code>. The iterator implementation behind <code>nditer</code> is also exposed by the NumPy C API.</p>
-<p>The Python exposure supplies two iteration interfaces, one which follows the Python iterator protocol, and another which mirrors the C-style do-while pattern. The native Python approach is better in most cases, but if you need the coordinates or index of an iterator, use the C-style pattern.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Here is how we might write an <code>iter_add</code> function, using the Python iterator protocol:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>def iter_add_py(x, y, out=None): … addop = np.add … it = np.nditer([x, y, out], [], … <a href="null">'readonly'], ['readonly'], ['writeonly','allocate'</a>) … with it: … for (a, b, c) in it: … addop(a, b, out=c) … return it.operands[2]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Here is the same function, but following the C-style pattern:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>def iter_add(x, y, out=None): … addop = np.add … it = np.nditer([x, y, out], [], … <a href="null">'readonly'], ['readonly'], ['writeonly','allocate'</a>) … with it: … while not it.finished: … addop(it[0], it[1], out=it[2]) … it.iternext() … return it.operands[2]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Here is an example outer product function:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>def outer_it(x, y, out=None): … mulop = np.multiply … it = np.nditer([x, y, out], [‘external_loop’], … <a href="null">'readonly'], ['readonly'], ['writeonly', 'allocate'</a>, … op_axes=[list(range(x.ndim)) + [-1] * y.ndim, … [-1] * x.ndim + list(range(y.ndim)), … None]) … with it: … for (a, b, c) in it: … mulop(a, b, out=c) … return it.operands[2]</p>
-      <p>a = np.arange(2)+1 b = np.arange(3)+1 outer_it(a,b) array(<a href="null">1, 2, 3],
-       [2, 4, 6</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Here is an example function which operates like a “lambda” ufunc:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>def luf(lamdaexpr, *args, **kwargs): … ’‘‘luf(lambdaexpr, op1, …, opn, out=None, order=‘K’, casting=‘safe’, buffersize=0)’’’ … nargs = len(args) … op = (kwargs.get(‘out’,None),) + args … it = np.nditer(op, [‘buffered’,‘external_loop’], … <a href="null">'writeonly','allocate','no_broadcast'</a> + … <a href="null">'readonly','nbo','aligned'</a>*nargs, … order=kwargs.get(‘order’,‘K’), … casting=kwargs.get(‘casting’,‘safe’), … buffersize=kwargs.get(‘buffersize’,0)) … while not it.finished: … it[0] = lamdaexpr(*it[1:]) … it.iternext() … return it.operands[0]</p>
-      <p>a = np.arange(5) b = np.ones(5) luf(lambda i,j:i*i + j/2, a, b) array([ 0.5, 1.5, 4.5, 9.5, 16.5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>If operand flags <code>"writeonly"</code> or <code>"readwrite"</code> are used the operands may be views into the original data with the <code>WRITEBACKIFCOPY</code> flag. In this case <code>nditer</code> must be used as a context manager or the <code>nditer.close</code> method must be called before using the result. The temporary data will be written back to the original data when the <code>__exit__</code> function is called but not before:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(6, dtype=‘i4’)[::-2] with np.nditer(a, [], … <a href="null">'writeonly', 'updateifcopy'</a>, … casting=‘unsafe’, … op_dtypes=[np.dtype(‘f4’)]) as i: … x = i.operands[0] … x[:] = [-1, -2, -3] … # a still unchanged here a, x (array([-1, -2, -3], dtype=int32), array([-1., -2., -3.], dtype=float32))</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>It is important to note that once the iterator is exited, dangling references (like <code>x</code> in the example) may or may not share data with the original data <code>a</code>. If writeback semantics were active, i.e. if <code>x.base.flags.writebackifcopy</code> is <code>True</code>, then exiting the iterator will sever the connection between <code>x</code> and <code>a</code>, writing to <code>x</code> will no longer write to <code>a</code>. If writeback semantics are not active, then <code>x.data</code> will still point at some part of <code>a.data</code>, and writing to one will affect the other.</p>
-<p>Context management and the <code>close</code> method appeared in version 1.15.0.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4410">view source</a></div></div><div class="public anchor" id="var-negative"><h3>negative</h3><div class="usage"><code>(negative self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>negative(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Numerical negative, element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like or scalar  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  Returned array or scalar: <code>y = -x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.negative([1.,-1.]) array([-1., 1.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9754">view source</a></div></div><div class="public anchor" id="var-nested_iters"><h3>nested_iters</h3><div class="usage"><code>(nested_iters self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Create nditers for use in nested loops</p>
-<p>Create a tuple of <code>nditer</code> objects which iterate in nested loops over different axes of the op argument. The first iterator is used in the outermost loop, the last in the innermost loop. Advancing one will change the subsequent iterators to point at its new element.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>op : ndarray or sequence of array_like  The array(s) to iterate over.</p>
-<p>axes : list of list of int  Each item is used as an “op_axes” argument to an nditer</p>
-<p>flags, op_flags, op_dtypes, order, casting, buffersize (optional)  See <code>nditer</code> parameters of the same name</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>iters : tuple of nditer  An nditer for each item in <code>axes</code>, outermost first</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>nditer</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Basic usage. Note how y is the “flattened” version of [a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified the first iter’s axes as [1]</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(12).reshape(2, 3, 2) i, j = np.nested_iters(a, <a href="null">1], [0, 2</a>, flags=[“multi_index”]) for x in i: … print(i.multi_index) … for y in j: … print(’’, j.multi_index, y) (0,)  (0, 0) 0  (0, 1) 1  (1, 0) 6  (1, 1) 7 (1,)  (0, 0) 2  (0, 1) 3  (1, 0) 8  (1, 1) 9 (2,)  (0, 0) 4  (0, 1) 5  (1, 0) 10  (1, 1) 11</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14996">view source</a></div></div><div class="public anchor" id="var-nextafter"><h3>nextafter</h3><div class="usage"><code>(nextafter self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>nextafter(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the next floating-point value after x1 towards x2, element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  Values to find the next representable value of. x2 : array_like  The direction where to look for the next representable value of <code>x1</code>.  If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  The next representable values of <code>x1</code> in the direction of <code>x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>eps = np.finfo(np.float64).eps np.nextafter(1, 2) == eps + 1 True np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps] array([ True, True])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25129">view source</a></div></div><div class="public anchor" id="var-NINF"><h3>NINF</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1591">view source</a></div></div><div class="public anchor" id="var-nonzero"><h3>nonzero</h3><div class="usage"><code>(nonzero &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices of the elements that are non-zero.</p>
-<p>Returns a tuple of arrays, one for each dimension of <code>a</code>, containing the indices of the non-zero elements in that dimension. The values in <code>a</code> are always tested and returned in row-major, C-style order.</p>
-<p>To group the indices by element, rather than dimension, use <code>argwhere</code>, which returns a row for each non-zero element.</p>
-<p>.. note::</p>
-<p>When called on a zero-d array or scalar, <code>nonzero(a)</code> is treated  as <code>nonzero(atleast1d(a))</code>.</p>
-<p>.. deprecated:: 1.17.0</p>
-<pre><code>  Use `atleast1d` explicitly if this behavior is deliberate.
-</code></pre>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>tuple_of_arrays : tuple  Indices of elements that are non-zero.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>flatnonzero :  Return indices that are non-zero in the flattened version of the input  array. ndarray.nonzero :  Equivalent ndarray method. count_nonzero :  Counts the number of non-zero elements in the input array.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>While the nonzero values can be obtained with <code>a[nonzero(a)]</code>, it is recommended to use <code>x[x.astype(bool)]</code> or <code>x[x != 0]</code> instead, which will correctly handle 0-d arrays.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">3, 0, 0], [0, 4, 0], [5, 6, 0</a>) x array(<a href="null">3, 0, 0],
-       [0, 4, 0],
-       [5, 6, 0</a>) np.nonzero(x) (array([0, 1, 2, 2]), array([0, 1, 0, 1]))</p>
-      <p>x[np.nonzero(x)] array([3, 4, 5, 6]) np.transpose(np.nonzero(x)) array(<a href="null">0, 0],
-       [1, 1],
-       [2, 0],
-       [2, 1</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>A common use for <code>nonzero</code> is to find the indices of an array, where a condition is True. Given an array <code>a</code>, the condition <code>a</code> &gt; 3 is a boolean array and since False is interpreted as 0, np.nonzero(a &gt; 3) yields the indices of the <code>a</code> where the condition is true.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 2, 3], [4, 5, 6], [7, 8, 9</a>) a &gt; 3 array(<a href="null">False, False, False],
-       [ True,  True,  True],
-       [ True,  True,  True</a>) np.nonzero(a &gt; 3) (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using this result to index <code>a</code> is equivalent to using the mask directly:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a[np.nonzero(a &gt; 3)] array([4, 5, 6, 7, 8, 9]) a[a &gt; 3] # prefer this spelling array([4, 5, 6, 7, 8, 9])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p><code>nonzero</code> can also be called as a method of the array.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>(a &gt; 3).nonzero() (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8774">view source</a></div></div><div class="public anchor" id="var-not_equal"><h3>not_equal</h3><div class="usage"><code>(not_equal self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>not_equal(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return (x1 != x2) element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  Input arrays. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Output array, element-wise comparison of <code>x1</code> and <code>x2</code>.  Typically of type bool, unless <code>dtype=object</code> is passed.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>equal, greater, greater_equal, less, less_equal</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.not_equal([1.,2.], [1., 3.]) array([False, True]) np.not_equal([1, 2], <a href="null">1, 3],[1, 4</a>) array(<a href="null">False,  True],
-       [False,  True</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6062">view source</a></div></div><div class="public anchor" id="var-nper"><h3>nper</h3><div class="usage"><code>(nper &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the number of periodic payments.</p>
-<p>.. deprecated:: 1.18</p>
-<p><code>nper</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
-<p>:class:<code>decimal.Decimal</code> type is not supported.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>rate : array_like  Rate of interest (per period) pmt : array_like  Payment pv : array_like  Present value fv : array_like, optional  Future value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}, optional  When payments are due (‘begin’ (1) or ‘end’ (0))</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The number of periods <code>nper</code> is computed by solving the equation::</p>
-<p>fv + pv*(1+rate)**nper + pmt*(1+rate*when)/rate*((1+rate)**nper-1) = 0</p>
-<p>but if <code>rate = 0</code> then::</p>
-<p>fv + pv + pmt*nper = 0</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>If you only had $150/month to pay towards the loan, how long would it take to pay-off a loan of $8,000 at 7% annual interest?</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>print(np.round(np.nper(0.07/12, -150, 8000), 5)) 64.07335</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>So, over 64 months would be required to pay off the loan.</p>
-<p>The same analysis could be done with several different interest rates and/or payments and/or total amounts to produce an entire table.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.nper(*(np.ogrid[0.07/12: 0.08/12: 0.01/12, … -150 : -99 : 50 , … 8000 : 9001 : 1000])) array(<a href="null">[ 64.07334877,  74.06368256],
-        [108.07548412, 127.99022654</a>,  <a href="null"> 66.12443902,  76.87897353],
-        [114.70165583, 137.90124779</a>])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7611">view source</a></div></div><div class="public anchor" id="var-npv"><h3>npv</h3><div class="usage"><code>(npv &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the NPV (Net Present Value) of a cash flow series.</p>
-<p>.. deprecated:: 1.18</p>
-<p><code>npv</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>rate : scalar  The discount rate. values : array_like, shape(M, )  The values of the time series of cash flows. The (fixed) time  interval between cash flow “events” must be the same as that for  which <code>rate</code> is given (i.e., if <code>rate</code> is per year, then precisely  a year is understood to elapse between each cash flow event). By  convention, investments or “deposits” are negative, income or  “withdrawals” are positive; <code>values</code> must begin with the initial  investment, thus <code>values[0]</code> will typically be negative.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : float  The NPV of the input cash flow series <code>values</code> at the discount  <code>rate</code>.</p>
-<h2><a href="#warnings" name="warnings"></a>Warnings</h2>
-<p><code>npv</code> considers a series of cashflows starting in the present (t = 0). NPV can also be defined with a series of future cashflows, paid at the end, rather than the start, of each period. If future cashflows are used, the first cashflow <code>values[0]</code> must be zeroed and added to the net present value of the future cashflows. This is demonstrated in the examples.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Returns the result of: [2]_</p>
-<p>.. math :: \sum_{t=0}^{M-1}{\frac{values_t}{(1+rate)^{t}}}</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] L. J. Gitman, “Principles of Managerial Finance, Brief,” 3rd ed.,  Addison-Wesley, 2003, pg. 346.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Consider a potential project with an initial investment of $40 000 and projected cashflows of $5 000, $8 000, $12 000 and $30 000 at the end of each period discounted at a rate of 8% per period. To find the project’s net present value:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>rate, cashflows = 0.08, [-40_000, 5_000, 8_000, 12_000, 30_000] np.npv(rate, cashflows).round(5) 3065.22267</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>It may be preferable to split the projected cashflow into an initial investment and expected future cashflows. In this case, the value of the initial cashflow is zero and the initial investment is later added to the future cashflows net present value:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>initial_cashflow = cashflows[0] cashflows[0] = 0 np.round(np.npv(rate, cashflows) + initial_cashflow, 5) 3065.22267</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16324">view source</a></div></div><div class="public anchor" id="var-numarray"><h3>numarray</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25019">view source</a></div></div><div class="public anchor" id="var-number"><h3>number</h3><div class="usage"><code>(number self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all numeric scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17525">view source</a></div></div><div class="public anchor" id="var-NZERO"><h3>NZERO</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23617">view source</a></div></div><div class="public anchor" id="var-obj2sctype"><h3>obj2sctype</h3><div class="usage"><code>(obj2sctype rep &amp; [{default :default}])</code><code>(obj2sctype rep)</code></div><div class="doc"><div class="markdown"><p>Return the scalar dtype or NumPy equivalent of Python type of an object.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>rep : any  The object of which the type is returned. default : any, optional  If given, this is returned for objects whose types can not be  determined. If not given, None is returned for those objects.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>dtype : dtype or Python type  The data type of <code>rep</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>sctype2char, issctype, issubsctype, issubdtype, maximum_sctype</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.obj2sctype(np.int32) &lt;class ‘numpy.int32’&gt; np.obj2sctype(np.array([1., 2.])) &lt;class ‘numpy.float64’&gt; np.obj2sctype(np.array([1.j])) &lt;class ‘numpy.complex128’&gt;</p>
-      <p>np.obj2sctype(dict) &lt;class ‘numpy.object_’&gt; np.obj2sctype(‘string’)</p>
-      <p>np.obj2sctype(1, default=list) &lt;class ‘list’&gt;</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3971">view source</a></div></div><div class="public anchor" id="var-object"><h3>object</h3><div class="usage"><code>(object self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>The base class of the class hierarchy.</p>
-<p>When called, it accepts no arguments and returns a new featureless instance that has no instance attributes and cannot be given any.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L812">view source</a></div></div><div class="public anchor" id="var-object0"><h3>object0</h3><div class="usage"><code>(object0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Any Python object. Character code: <code>'O'</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18340">view source</a></div></div><div class="public anchor" id="var-object_"><h3>object_</h3><div class="usage"><code>(object_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Any Python object. Character code: <code>'O'</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25690">view source</a></div></div><div class="public anchor" id="var-ogrid"><h3>ogrid</h3><div class="usage"></div><div class="doc"><div class="markdown"><p><code>nd_grid</code> instance which returns an open multi-dimensional “meshgrid”.</p>
-<p>An instance of <code>numpy.lib.index_tricks.nd_grid</code> which returns an open (i.e. not fleshed out) mesh-grid when indexed, so that only one dimension of each returned array is greater than 1. The dimension and number of the output arrays are equal to the number of indexing dimensions. If the step length is not a complex number, then the stop is not inclusive.</p>
-<p>However, if the step length is a <strong>complex number</strong> (e.g. 5j), then the integer part of its magnitude is interpreted as specifying the number of points to create between the start and stop values, where the stop value <strong>is inclusive</strong>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>mesh-grid  <code>ndarrays</code> with only one dimension not equal to 1</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>np.lib.index_tricks.nd_grid : class of <code>ogrid</code> and <code>mgrid</code> objects mgrid : like <code>ogrid</code> but returns dense (or fleshed out) mesh grids r_ : array concatenator</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from numpy import ogrid ogrid[-1:1:5j] array([-1. , -0.5, 0. , 0.5, 1. ]) ogrid[0:5,0:5]
-[array([[0],  [1],  [2],  [3],  [4]]), array([[0, 1, 2, 3, 4]])]</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22069">view source</a></div></div><div class="public anchor" id="var-oldnumeric"><h3>oldnumeric</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22357">view source</a></div></div><div class="public anchor" id="var-ones"><h3>ones</h3><div class="usage"><code>(ones shape &amp; [{dtype :dtype, order :order}])</code><code>(ones shape &amp; [{dtype :dtype}])</code><code>(ones shape)</code></div><div class="doc"><div class="markdown"><p>Return a new array of given shape and type, filled with ones.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>shape : int or sequence of ints  Shape of the new array, e.g., <code>(2, 3)</code> or <code>2</code>. dtype : data-type, optional  The desired data-type for the array, e.g., <code>numpy.int8</code>. Default is  <code>numpy.float64</code>. order : {‘C’, ‘F’}, optional, default: C  Whether to store multi-dimensional data in row-major  (C-style) or column-major (Fortran-style) order in  memory.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Array of ones with the given shape, dtype, and order.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ones_like : Return an array of ones with shape and type of input. empty : Return a new uninitialized array. zeros : Return a new array setting values to zero. full : Return a new array of given shape filled with value.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.ones(5) array([1., 1., 1., 1., 1.])</p>
-      <p>np.ones((5,), dtype=int) array([1, 1, 1, 1, 1])</p>
-      <p>np.ones((2, 1)) array(<a href="null">1.],
-       [1.</a>)</p>
-      <p>s = (2,2) np.ones(s) array(<a href="null">1.,  1.],
-       [1.,  1.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3580">view source</a></div></div><div class="public anchor" id="var-ones_like"><h3>ones_like</h3><div class="usage"><code>(ones_like &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an array of ones with the same shape and type as a given array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  The shape and data-type of <code>a</code> define these same attributes of  the returned array. dtype : data-type, optional  Overrides the data type of the result.</p>
-<pre><code>.. versionadded:: 1.6.0
-</code></pre>
-<p>order : {‘C’, ‘F’, ‘A’, or ‘K’}, optional  Overrides the memory layout of the result. ‘C’ means C-order,  ‘F’ means F-order, ‘A’ means ‘F’ if <code>a</code> is Fortran contiguous,  ‘C’ otherwise. ‘K’ means match the layout of <code>a</code> as closely  as possible.</p>
-<pre><code>.. versionadded:: 1.6.0
-</code></pre>
-<p>subok : bool, optional.  If True, then the newly created array will use the sub-class  type of ‘a’, otherwise it will be a base-class array. Defaults  to True. shape : int or sequence of ints, optional.  Overrides the shape of the result. If order=‘K’ and the number of  dimensions is unchanged, will try to keep order, otherwise,  order=‘C’ is implied.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Array of ones with the same shape and type as <code>a</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>empty_like : Return an empty array with shape and type of input. zeros_like : Return an array of zeros with shape and type of input. full_like : Return a new array with shape of input filled with value. ones : Return a new array setting values to one.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(6) x = x.reshape((2, 3)) x array(<a href="null">0, 1, 2],
-       [3, 4, 5</a>) np.ones_like(x) array(<a href="null">1, 1, 1],
-       [1, 1, 1</a>)</p>
-      <p>y = np.arange(3, dtype=float) y array([0., 1., 2.]) np.ones_like(y) array([1., 1., 1.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21454">view source</a></div></div><div class="public anchor" id="var-outer"><h3>outer</h3><div class="usage"><code>(outer &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the outer product of two vectors.</p>
-<p>Given two vectors, <code>a = [a0, a1, ..., aM]</code> and <code>b = [b0, b1, ..., bN]</code>, the outer product [1]_ is::</p>
-<p><a href="null">a0*b0  a0*b1 ... a0*bN ]
-   [a1*b0    .
-   [ ...          .
-   [aM*b0            aM*bN </a></p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : (M,) array_like  First input vector. Input is flattened if  not already 1-dimensional. b : (N,) array_like  Second input vector. Input is flattened if  not already 1-dimensional. out : (M, N) ndarray, optional  A location where the result is stored</p>
-<pre><code>.. versionadded:: 1.9.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : (M, N) ndarray  <code>out[i, j] = a[i] * b[j]</code></p>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>inner einsum : <code>einsum('i,j-&gt;ij', a.ravel(), b.ravel())</code> is the equivalent. ufunc.outer : A generalization to N dimensions and other operations.  <code>np.multiply.outer(a.ravel(), b.ravel())</code> is the equivalent.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] : G. H. Golub and C. F. Van Loan, <em>Matrix Computations</em>, 3rd  ed., Baltimore, MD, Johns Hopkins University Press, 1996,  pg. 8.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Make a (*very* coarse) grid for computing a Mandelbrot set:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5)) rl array(<a href="null">-2., -1.,  0.,  1.,  2.],
-       [-2., -1.,  0.,  1.,  2.],
-       [-2., -1.,  0.,  1.,  2.],
-       [-2., -1.,  0.,  1.,  2.],
-       [-2., -1.,  0.,  1.,  2.</a>) im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,))) im array(<a href="null">0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
-       [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
-       [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
-       [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
-       [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j</a>) grid = rl + im grid array(<a href="null">-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
-       [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
-       [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
-       [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
-       [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>An example using a “vector” of letters:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([‘a’, ‘b’, ‘c’], dtype=object) np.outer(x, [1, 2, 3]) array(<a href="null">'a', 'aa', 'aaa'],
-       ['b', 'bb', 'bbb'],
-       ['c', 'cc', 'ccc'</a>, dtype=object)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16546">view source</a></div></div><div class="public anchor" id="var-packbits"><h3>packbits</h3><div class="usage"><code>(packbits &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>packbits(a, axis=None, bitorder=‘big’)</p>
-<p>Packs the elements of a binary-valued array into bits in a uint8 array.</p>
-<p>The result is padded to full bytes by inserting zero bits at the end.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  An array of integers or booleans whose elements should be packed to  bits. axis : int, optional  The dimension over which bit-packing is done.  <code>None</code> implies packing the flattened array. bitorder : {‘big’, ‘little’}, optional  The order of the input bits. ‘big’ will mimic bin(val),  <code>[0, 0, 0, 0, 0, 0, 1, 1] =&gt; 3 = 0b00000011 =&gt;</code>, ‘little’ will  reverse the order so <code>[1, 1, 0, 0, 0, 0, 0, 0] =&gt; 3</code>.  Defaults to ‘big’.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>packed : ndarray  Array of type uint8 whose elements represent bits corresponding to the  logical (0 or nonzero) value of the input elements. The shape of  <code>packed</code> has the same number of dimensions as the input (unless <code>axis</code>  is None, in which case the output is 1-D).</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>unpackbits: Unpacks elements of a uint8 array into a binary-valued output  array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">[1,0,1],
-...                [0,1,0</a>, … <a href="null">1,1,0],
-...                [0,0,1</a>]) b = np.packbits(a, axis=-1) b array(<a href="null">[160],
-        [ 64</a>,  <a href="null">192],
-        [ 32</a>], dtype=uint8)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000, and 32 = 0010 0000.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14312">view source</a></div></div><div class="public anchor" id="var-pad"><h3>pad</h3><div class="usage"><code>(pad &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Pad an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>array : array_like of rank N  The array to pad. pad_width : {sequence, array_like, int}  Number of values padded to the edges of each axis.  ((before_1, after_1), … (before_N, after_N)) unique pad widths  for each axis.  ((before, after),) yields same before and after pad for each axis.  (pad,) or int is a shortcut for before = after = pad width for all  axes. mode : str or function, optional  One of the following string values or a user supplied function.</p>
-<pre><code>'constant' (default)
-    Pads with a constant value.
-'edge'
-    Pads with the edge values of array.
-'linear_ramp'
-    Pads with the linear ramp between end_value and the
-    array edge value.
-'maximum'
-    Pads with the maximum value of all or part of the
-    vector along each axis.
-'mean'
-    Pads with the mean value of all or part of the
-    vector along each axis.
-'median'
-    Pads with the median value of all or part of the
-    vector along each axis.
-'minimum'
-    Pads with the minimum value of all or part of the
-    vector along each axis.
-'reflect'
-    Pads with the reflection of the vector mirrored on
-    the first and last values of the vector along each
-    axis.
-'symmetric'
-    Pads with the reflection of the vector mirrored
-    along the edge of the array.
-'wrap'
-    Pads with the wrap of the vector along the axis.
-    The first values are used to pad the end and the
-    end values are used to pad the beginning.
-'empty'
-    Pads with undefined values.
-
-    .. versionadded:: 1.17
-
-&lt;function&gt;
-    Padding function, see Notes.
-</code></pre>
-<p>stat_length : sequence or int, optional  Used in ‘maximum’, ‘mean’, ‘median’, and ‘minimum’. Number of  values at edge of each axis used to calculate the statistic value.</p>
-<pre><code>((before_1, after_1), ... (before_N, after_N)) unique statistic
-lengths for each axis.
-
-((before, after),) yields same before and after statistic lengths
-for each axis.
-
-(stat_length,) or int is a shortcut for before = after = statistic
-length for all axes.
-
-Default is ``None``, to use the entire axis.
-</code></pre>
-<p>constant_values : sequence or scalar, optional  Used in ‘constant’. The values to set the padded values for each  axis.</p>
-<pre><code>``((before_1, after_1), ... (before_N, after_N))`` unique pad constants
-for each axis.
-
-``((before, after),)`` yields same before and after constants for each
-axis.
-
-``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
-all axes.
-
-Default is 0.
-</code></pre>
-<p>end_values : sequence or scalar, optional  Used in ‘linear_ramp’. The values used for the ending value of the  linear_ramp and that will form the edge of the padded array.</p>
-<pre><code>``((before_1, after_1), ... (before_N, after_N))`` unique end values
-for each axis.
-
-``((before, after),)`` yields same before and after end values for each
-axis.
-
-``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
-all axes.
-
-Default is 0.
-</code></pre>
-<p>reflect_type : {‘even’, ‘odd’}, optional  Used in ‘reflect’, and ‘symmetric’. The ‘even’ style is the  default with an unaltered reflection around the edge value. For  the ‘odd’ style, the extended part of the array is created by  subtracting the reflected values from two times the edge value.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>pad : ndarray  Padded array of rank equal to <code>array</code> with shape increased  according to <code>pad_width</code>.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.7.0</p>
-<p>For an array with rank greater than 1, some of the padding of later axes is calculated from padding of previous axes. This is easiest to think about with a rank 2 array where the corners of the padded array are calculated by using padded values from the first axis.</p>
-<p>The padding function, if used, should modify a rank 1 array in-place. It has the following signature::</p>
-<pre><code>padding_func(vector, iaxis_pad_width, iaxis, kwargs)
-</code></pre>
-<p>where</p>
-<pre><code>vector : ndarray
-    A rank 1 array already padded with zeros.  Padded values are
-    vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:].
-iaxis_pad_width : tuple
-    A 2-tuple of ints, iaxis_pad_width[0] represents the number of
-    values padded at the beginning of vector where
-    iaxis_pad_width[1] represents the number of values padded at
-    the end of vector.
-iaxis : int
-    The axis currently being calculated.
-kwargs : dict
-    Any keyword arguments the function requires.
-</code></pre>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = [1, 2, 3, 4, 5] np.pad(a, (2, 3), ‘constant’, constant_values=(4, 6)) array([4, 4, 1, …, 6, 6, 6])</p>
-      <p>np.pad(a, (2, 3), ‘edge’) array([1, 1, 1, …, 5, 5, 5])</p>
-      <p>np.pad(a, (2, 3), ‘linear_ramp’, end_values=(5, -4)) array([ 5, 3, 1, 2, 3, 4, 5, 2, -1, -4])</p>
-      <p>np.pad(a, (2,), ‘maximum’) array([5, 5, 1, 2, 3, 4, 5, 5, 5])</p>
-      <p>np.pad(a, (2,), ‘mean’) array([3, 3, 1, 2, 3, 4, 5, 3, 3])</p>
-      <p>np.pad(a, (2,), ‘median’) array([3, 3, 1, 2, 3, 4, 5, 3, 3])</p>
-      <p>a = <a href="null">1, 2], [3, 4</a> np.pad(a, ((3, 2), (2, 3)), ‘minimum’) array(<a href="null">1, 1, 1, 2, 1, 1, 1],
-       [1, 1, 1, 2, 1, 1, 1],
-       [1, 1, 1, 2, 1, 1, 1],
-       [1, 1, 1, 2, 1, 1, 1],
-       [3, 3, 3, 4, 3, 3, 3],
-       [1, 1, 1, 2, 1, 1, 1],
-       [1, 1, 1, 2, 1, 1, 1</a>)</p>
-      <p>a = [1, 2, 3, 4, 5] np.pad(a, (2, 3), ‘reflect’) array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])</p>
-      <p>np.pad(a, (2, 3), ‘reflect’, reflect_type=‘odd’) array([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8])</p>
-      <p>np.pad(a, (2, 3), ‘symmetric’) array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])</p>
-      <p>np.pad(a, (2, 3), ‘symmetric’, reflect_type=‘odd’) array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])</p>
-      <p>np.pad(a, (2, 3), ‘wrap’) array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])</p>
-      <p>def pad_with(vector, pad_width, iaxis, kwargs): … pad_value = kwargs.get(‘padder’, 10) … vector[:pad_width[0]] = pad_value … vector[-pad_width[1]:] = pad_value a = np.arange(6) a = a.reshape((2, 3)) np.pad(a, 2, pad_with) array(<a href="null">10, 10, 10, 10, 10, 10, 10],
-       [10, 10, 10, 10, 10, 10, 10],
-       [10, 10,  0,  1,  2, 10, 10],
-       [10, 10,  3,  4,  5, 10, 10],
-       [10, 10, 10, 10, 10, 10, 10],
-       [10, 10, 10, 10, 10, 10, 10</a>) np.pad(a, 2, pad_with, padder=100) array(<a href="null">100, 100, 100, 100, 100, 100, 100],
-       [100, 100, 100, 100, 100, 100, 100],
-       [100, 100,   0,   1,   2, 100, 100],
-       [100, 100,   3,   4,   5, 100, 100],
-       [100, 100, 100, 100, 100, 100, 100],
-       [100, 100, 100, 100, 100, 100, 100</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2932">view source</a></div></div><div class="public anchor" id="var-partition"><h3>partition</h3><div class="usage"><code>(partition &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a partitioned copy of an array.</p>
-<p>Creates a copy of the array with its elements rearranged in such a way that the value of the element in k-th position is in the position it would be in a sorted array. All elements smaller than the k-th element are moved before this element and all equal or greater are moved behind it. The ordering of the elements in the two partitions is undefined.</p>
-<p>.. versionadded:: 1.8.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array to be sorted. kth : int or sequence of ints  Element index to partition by. The k-th value of the element  will be in its final sorted position and all smaller elements  will be moved before it and all equal or greater elements behind  it. The order of all elements in the partitions is undefined. If  provided with a sequence of k-th it will partition all elements  indexed by k-th of them into their sorted position at once. axis : int or None, optional  Axis along which to sort. If None, the array is flattened before  sorting. The default is -1, which sorts along the last axis. kind : {‘introselect’}, optional  Selection algorithm. Default is ‘introselect’. order : str or list of str, optional  When <code>a</code> is an array with fields defined, this argument  specifies which fields to compare first, second, etc. A single  field can be specified as a string. Not all fields need be  specified, but unspecified fields will still be used, in the  order in which they come up in the dtype, to break ties.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>partitioned_array : ndarray  Array of the same type and shape as <code>a</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.partition : Method to sort an array in-place. argpartition : Indirect partition. sort : Full sorting</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The various selection algorithms are characterized by their average speed, worst case performance, work space size, and whether they are stable. A stable sort keeps items with the same key in the same relative order. The available algorithms have the following properties:</p>
-<p>================= ======= ============= ============ =======  kind speed worst case work space stable ================= ======= ============= ============ ======= ‘introselect’ 1 O(n) 0 no ================= ======= ============= ============ =======</p>
-<p>All the partition algorithms make temporary copies of the data when partitioning along any but the last axis. Consequently, partitioning along the last axis is faster and uses less space than partitioning along any other axis.</p>
-<p>The sort order for complex numbers is lexicographic. If both the real and imaginary parts are non-nan then the order is determined by the real parts except when they are equal, in which case the order is determined by the imaginary parts.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([3, 4, 2, 1]) np.partition(a, 3) array([2, 1, 3, 4])</p>
-      <p>np.partition(a, (1, 3)) array([1, 2, 3, 4])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10357">view source</a></div></div><div class="public anchor" id="var-percentile"><h3>percentile</h3><div class="usage"><code>(percentile &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the q-th percentile of the data along the specified axis.</p>
-<p>Returns the q-th percentile(s) of the array elements.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array or object that can be converted to an array. q : array_like of float  Percentile or sequence of percentiles to compute, which must be between  0 and 100 inclusive. axis : {int, tuple of int, None}, optional  Axis or axes along which the percentiles are computed. The  default is to compute the percentile(s) along a flattened  version of the array.</p>
-<pre><code>.. versionchanged:: 1.9.0
-    A tuple of axes is supported
-</code></pre>
-<p>out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow the input array <code>a</code> to be modified by intermediate  calculations, to save memory. In this case, the contents of the input  <code>a</code> after this function completes is undefined.</p>
-<p>interpolation : {‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}  This optional parameter specifies the interpolation method to  use when the desired percentile lies between two data points  <code>i &lt; j</code>:</p>
-<pre><code>* 'linear': ``i + (j - i) * fraction``, where ``fraction``
-  is the fractional part of the index surrounded by ``i``
-  and ``j``.
-* 'lower': ``i``.
-* 'higher': ``j``.
-* 'nearest': ``i`` or ``j``, whichever is nearest.
-* 'midpoint': ``(i + j) / 2``.
-
-.. versionadded:: 1.9.0
-</code></pre>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left in  the result as dimensions with size one. With this option, the  result will broadcast correctly against the original array <code>a</code>.</p>
-<pre><code>.. versionadded:: 1.9.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>percentile : scalar or ndarray  If <code>q</code> is a single percentile and <code>axis=None</code>, then the result  is a scalar. If multiple percentiles are given, first axis of  the result corresponds to the percentiles. The other axes are  the axes that remain after the reduction of <code>a</code>. If the input  contains integers or floats smaller than <code>float64</code>, the output  data-type is <code>float64</code>. Otherwise, the output data-type is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>mean median : equivalent to <code>percentile(..., 50)</code> nanpercentile quantile : equivalent to percentile, except with q in the range [0, 1].</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Given a vector <code>V</code> of length <code>N</code>, the q-th percentile of <code>V</code> is the value <code>q/100</code> of the way from the minimum to the maximum in a sorted copy of <code>V</code>. The values and distances of the two nearest neighbors as well as the <code>interpolation</code> parameter will determine the percentile if the normalized ranking does not match the location of <code>q</code> exactly. This function is the same as the median if <code>q=50</code>, the same as the minimum if <code>q=0</code> and the same as the maximum if <code>q=100</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">10, 7, 4], [3, 2, 1</a>) a array(<a href="null">10,  7,  4],
-       [ 3,  2,  1</a>) np.percentile(a, 50) 3.5 np.percentile(a, 50, axis=0) array([6.5, 4.5, 2.5]) np.percentile(a, 50, axis=1) array([7., 2.]) np.percentile(a, 50, axis=1, keepdims=True) array(<a href="null">7.],
-       [2.</a>)</p>
-      <p>m = np.percentile(a, 50, axis=0) out = np.zeros_like(m) np.percentile(a, 50, axis=0, out=out) array([6.5, 4.5, 2.5]) m array([6.5, 4.5, 2.5])</p>
-      <p>b = a.copy() np.percentile(b, 50, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a == b)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The different types of interpolation can be visualized graphically:</p>
-<p>.. plot::</p>
-<pre><code>import matplotlib.pyplot as plt
-
-a = np.arange(4)
-p = np.linspace(0, 100, 6001)
-ax = plt.gca()
-lines = [
-    ('linear', None),
-    ('higher', '--'),
-    ('lower', '--'),
-    ('nearest', '-.'),
-    ('midpoint', '-.'),
-]
-for interpolation, style in lines:
-    ax.plot(
-        p, np.percentile(a, p, interpolation=interpolation),
-        label=interpolation, linestyle=style)
-ax.set(
-    title='Interpolation methods for list: ' + str(a),
-    xlabel='Percentile',
-    ylabel='List item returned',
-    yticks=a)
-ax.legend()
-plt.show()
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14369">view source</a></div></div><div class="public anchor" id="var-pi"><h3>pi</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14835">view source</a></div></div><div class="public anchor" id="var-piecewise"><h3>piecewise</h3><div class="usage"><code>(piecewise &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Evaluate a piecewise-defined function.</p>
-<p>Given a set of conditions and corresponding functions, evaluate each function on the input data wherever its condition is true.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : ndarray or scalar  The input domain. condlist : list of bool arrays or bool scalars  Each boolean array corresponds to a function in <code>funclist</code>. Wherever  <code>condlist[i]</code> is True, <code>funclist[i](x)</code> is used as the output value.</p>
-<pre><code>Each boolean array in `condlist` selects a piece of `x`,
-and should therefore be of the same shape as `x`.
-
-The length of `condlist` must correspond to that of `funclist`.
-If one extra function is given, i.e. if
-``len(funclist) == len(condlist) + 1``, then that extra function
-is the default value, used wherever all conditions are false.
-</code></pre>
-<p>funclist : list of callables, f(x,*args,**kw), or scalars  Each function is evaluated over <code>x</code> wherever its corresponding  condition is True. It should take a 1d array as input and give an 1d  array or a scalar value as output. If, instead of a callable,  a scalar is provided then a constant function (<code>lambda x: scalar</code>) is  assumed. args : tuple, optional  Any further arguments given to <code>piecewise</code> are passed to the functions  upon execution, i.e., if called <code>piecewise(..., ..., 1, 'a')</code>, then  each function is called as <code>f(x, 1, 'a')</code>. kw : dict, optional  Keyword arguments used in calling <code>piecewise</code> are passed to the  functions upon execution, i.e., if called  <code>piecewise(..., ..., alpha=1)</code>, then each function is called as  <code>f(x, alpha=1)</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  The output is the same shape and type as x and is found by  calling the functions in <code>funclist</code> on the appropriate portions of <code>x</code>,  as defined by the boolean arrays in <code>condlist</code>. Portions not covered  by any condition have a default value of 0.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>choose, select, where</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This is similar to choose or select, except that functions are evaluated on elements of <code>x</code> that satisfy the corresponding condition from <code>condlist</code>.</p>
-<p>The result is::</p>
-<pre><code>    |--
-    |funclist[0](x[condlist[0]])
-</code></pre>
-<p>out = |funclist<a href="x[condlist[1]]">1</a>  |…  |funclist<a href="x[condlist[n2]]">n2</a>  |–</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Define the sigma function, which is -1 for <code>x &lt; 0</code> and +1 for <code>x &gt;= 0</code>.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.linspace(-2.5, 2.5, 6) np.piecewise(x, [x &lt; 0, x &gt;= 0], [-1, 1]) array([-1., -1., -1., 1., 1., 1.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Define the absolute value, which is <code>-x</code> for <code>x &lt;0</code> and <code>x</code> for <code>x &gt;= 0</code>.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.piecewise(x, [x &lt; 0, x &gt;= 0], [lambda x: -x, lambda x: x]) array([2.5, 1.5, 0.5, 0.5, 1.5, 2.5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Apply the same function to a scalar value.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>y = -2 np.piecewise(y, [y &lt; 0, y &gt;= 0], [lambda x: -x, lambda x: x]) array(2)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20621">view source</a></div></div><div class="public anchor" id="var-PINF"><h3>PINF</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22010">view source</a></div></div><div class="public anchor" id="var-place"><h3>place</h3><div class="usage"><code>(place &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Change elements of an array based on conditional and input values.</p>
-<p>Similar to <code>np.copyto(arr, vals, where=mask)</code>, the difference is that <code>place</code> uses the first N elements of <code>vals</code>, where N is the number of True values in <code>mask</code>, while <code>copyto</code> uses the elements where <code>mask</code> is True.</p>
-<p>Note that <code>extract</code> does the exact opposite of <code>place</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr : ndarray  Array to put data into. mask : array_like  Boolean mask array. Must have the same size as <code>a</code>. vals : 1-D sequence  Values to put into <code>a</code>. Only the first N elements are used, where  N is the number of True values in <code>mask</code>. If <code>vals</code> is smaller  than N, it will be repeated, and if elements of <code>a</code> are to be masked,  this sequence must be non-empty.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>copyto, put, take, extract</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>arr = np.arange(6).reshape(2, 3) np.place(arr, arr&gt;2, [44, 55]) arr array(<a href="null"> 0,  1,  2],
-       [44, 55, 44</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5542">view source</a></div></div><div class="public anchor" id="var-pmt"><h3>pmt</h3><div class="usage"><code>(pmt &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the payment against loan principal plus interest.</p>
-<p>.. deprecated:: 1.18</p>
-<p><code>pmt</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
-<p>Given:  * a present value, <code>pv</code> (e.g., an amount borrowed)  * a future value, <code>fv</code> (e.g., 0)  * an interest <code>rate</code> compounded once per period, of which  there are  * <code>nper</code> total  * and (optional) specification of whether payment is made  at the beginning (<code>when</code> = {‘begin’, 1}) or the end  (<code>when</code> = {‘end’, 0}) of each period</p>
-<p>Return:  the (fixed) periodic payment.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>rate : array_like  Rate of interest (per period) nper : array_like  Number of compounding periods pv : array_like  Present value fv : array_like, optional  Future value (default = 0) when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}  When payments are due (‘begin’ (1) or ‘end’ (0))</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Payment against loan plus interest. If all input is scalar, returns a  scalar float. If any input is array_like, returns payment for each  input element. If multiple inputs are array_like, they all must have  the same shape.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The payment is computed by solving the equation::</p>
-<p>fv +  pv*(1 + rate)**nper +  pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) == 0</p>
-<p>or, when <code>rate == 0</code>::</p>
-<p>fv + pv + pmt * nper == 0</p>
-<p>for <code>pmt</code>.</p>
-<p>Note that computing a monthly mortgage payment is only one use for this function. For example, pmt returns the periodic deposit one must make to achieve a specified future balance given an initial deposit, a fixed, periodically compounded interest rate, and the total number of periods.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).  Open Document Format for Office Applications (OpenDocument)v1.2,  Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,  Pre-Draft 12. Organization for the Advancement of Structured Information  Standards (OASIS). Billerica, MA, USA. [ODT Document].  Available:  <a href="http://www.oasis-open.org/committees/documents.php">http://www.oasis-open.org/committees/documents.php</a>  ?wg_abbrev=office-formulaOpenDocument-formula-20090508.odt</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>What is the monthly payment needed to pay off a $200,000 loan in 15 years at an annual interest rate of 7.5%?</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.pmt(0.075/12, 12*15, 200000) -1854.0247200054619</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>In order to pay-off (i.e., have a future-value of 0) the $200,000 obtained today, a monthly payment of $1,854.02 would be required. Note that this example illustrates usage of <code>fv</code> having a default value of 0.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27358">view source</a></div></div><div class="public anchor" id="var-poly"><h3>poly</h3><div class="usage"><code>(poly &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the coefficients of a polynomial with the given sequence of roots.</p>
-<p>Returns the coefficients of the polynomial whose leading coefficient is one for the given sequence of zeros (multiple roots must be included in the sequence as many times as their multiplicity; see Examples). A square matrix (or array, which will be treated as a matrix) can also be given, in which case the coefficients of the characteristic polynomial of the matrix are returned.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>seq_of_zeros : array_like, shape (N,) or (N, N)  A sequence of polynomial roots, or a square array or matrix object.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>c : ndarray  1D array of polynomial coefficients from highest to lowest degree:</p>
-<pre><code>``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]``
-where c[0] always equals 1.
-</code></pre>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If input is the wrong shape (the input must be a 1-D or square  2-D array).</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>polyval : Compute polynomial values. roots : Return the roots of a polynomial. polyfit : Least squares polynomial fit. poly1d : A one-dimensional polynomial class.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Specifying the roots of a polynomial still leaves one degree of freedom, typically represented by an undetermined leading coefficient. [1]_ In the case of this function, that coefficient - the first one in the returned array - is always taken as one. (If for some reason you have one other point, the only automatic way presently to leverage that information is to use <code>polyfit</code>.)</p>
-<p>The characteristic polynomial, :math:<code>p_a(t)</code>, of an <code>n</code>-by-<code>n</code> matrix <strong>A</strong> is given by</p>
-<pre><code>:math:`p_a(t) = \mathrm{det}(t\, \mathbf{I} - \mathbf{A})`,
-</code></pre>
-<p>where <strong>I</strong> is the <code>n</code>-by-<code>n</code> identity matrix. [2]_</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] M. Sullivan and M. Sullivan, III, “Algebra and Trignometry,  Enhanced With Graphing Utilities,” Prentice-Hall, pg. 318, 1996.</p>
-<p>.. [2] G. Strang, “Linear Algebra and Its Applications, 2nd Edition,”  Academic Press, pg. 182, 1980.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Given a sequence of a polynomial’s zeros:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.poly((0, 0, 0)) # Multiple root example array([1., 0., 0., 0.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The line above represents z**3 + 0*z**2 + 0*z + 0.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.poly((-1./2, 0, 1./2)) array([ 1. , 0. , -0.25, 0. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The line above represents z**3 - z/4</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.poly((np.random.random(1)[0], 0, np.random.random(1)[0])) array([ 1. , -0.77086955, 0.08618131, 0. ]) # random</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Given a square array object:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>P = np.array(<a href="null">0, 1./3], [-1./2, 0</a>) np.poly(P) array([1. , 0. , 0.16666667])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note how in all cases the leading coefficient is always 1.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4077">view source</a></div></div><div class="public anchor" id="var-poly1d"><h3>poly1d</h3><div class="usage"><code>(poly1d self c_or_r &amp; [{r :r, variable :variable}])</code><code>(poly1d self c_or_r &amp; [{r :r}])</code><code>(poly1d self c_or_r)</code></div><div class="doc"><div class="markdown"><p>A one-dimensional polynomial class.</p>
-<p>A convenience class, used to encapsulate “natural” operations on polynomials so that said operations may take on their customary form in code (see Examples).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>c_or_r : array_like  The polynomial’s coefficients, in decreasing powers, or if  the value of the second parameter is True, the polynomial’s  roots (values where the polynomial evaluates to 0). For example,  <code>poly1d([1, 2, 3])</code> returns an object that represents  :math:<code>x^2 + 2x + 3</code>, whereas <code>poly1d([1, 2, 3], True)</code> returns  one that represents :math:<code>(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6</code>. r : bool, optional  If True, <code>c_or_r</code> specifies the polynomial’s roots; the default  is False. variable : str, optional  Changes the variable used when printing <code>p</code> from <code>x</code> to <code>variable</code>  (see Examples).</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Construct the polynomial :math:<code>x^2 + 2x + 3</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p = np.poly1d([1, 2, 3]) print(np.poly1d(p))  2 1 x + 2 x + 3</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Evaluate the polynomial at :math:<code>x = 0.5</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p(0.5) 4.25</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Find the roots:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p.r array([-1.+1.41421356j, -1.-1.41421356j]) p(p.r) array([ -4.44089210e-16+0.j, -4.44089210e-16+0.j]) # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>These numbers in the previous line represent (0, 0) to machine precision</p>
-<p>Show the coefficients:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p.c array([1, 2, 3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Display the order (the leading zero-coefficients are removed):</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p.order 2</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Show the coefficient of the k-th power in the polynomial (which is equivalent to <code>p.c[-(i+1)]</code>):</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p[1] 2</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Polynomials can be added, subtracted, multiplied, and divided (returns quotient and remainder):</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p * p poly1d([ 1, 4, 10, 12, 9])</p>
-      <p>(p**3 + 4) / p (poly1d([ 1., 4., 10., 12., 9.]), poly1d([4.]))</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p><code>asarray(p)</code> gives the coefficient array, so polynomials can be used in all functions that accept arrays:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p**2 # square of polynomial poly1d([ 1, 4, 10, 12, 9])</p>
-      <p>np.square(p) # square of individual coefficients array([1, 4, 9])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The variable used in the string representation of <code>p</code> can be modified, using the <code>variable</code> parameter:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p = np.poly1d([1,2,3], variable=‘z’) print(p)  2 1 z + 2 z + 3</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Construct a polynomial from its roots:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.poly1d([1, 2], True) poly1d([ 1., -3., 2.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>This is the same polynomial as obtained by:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.poly1d([1, -1]) * np.poly1d([1, -2]) poly1d([ 1, -3, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12789">view source</a></div></div><div class="public anchor" id="var-polyadd"><h3>polyadd</h3><div class="usage"><code>(polyadd &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the sum of two polynomials.</p>
-<p>Returns the polynomial resulting from the sum of two input polynomials. Each input must be either a poly1d object or a 1D sequence of polynomial coefficients, from highest to lowest degree.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a1, a2 : array_like or poly1d object  Input polynomials.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or poly1d object  The sum of the inputs. If either input is a poly1d object, then the  output is also a poly1d object. Otherwise, it is a 1D array of  polynomial coefficients from highest to lowest degree.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>poly1d : A one-dimensional polynomial class. poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.polyadd([1, 2], [9, 5, 4]) array([9, 6, 6])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using poly1d objects:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p1 = np.poly1d([1, 2]) p2 = np.poly1d([9, 5, 4]) print(p1) 1 x + 2 print(p2)  2 9 x + 5 x + 4 print(np.polyadd(p1, p2))  2 9 x + 6 x + 6</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17955">view source</a></div></div><div class="public anchor" id="var-polyder"><h3>polyder</h3><div class="usage"><code>(polyder &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the derivative of the specified order of a polynomial.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>p : poly1d or sequence  Polynomial to differentiate.  A sequence is interpreted as polynomial coefficients, see <code>poly1d</code>. m : int, optional  Order of differentiation (default: 1)</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>der : poly1d  A new polynomial representing the derivative.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>polyint : Anti-derivative of a polynomial. poly1d : Class for one-dimensional polynomials.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>The derivative of the polynomial :math:<code>x^3 + x^2 + x^1 + 1</code> is:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p = np.poly1d([1,1,1,1]) p2 = np.polyder(p) p2 poly1d([3, 2, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>which evaluates to:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p2(2.) 17.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>We can verify this, approximating the derivative with <code>(f(x + h) - f(x))/h</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>(p(2. + 0.001) - p(2.)) / 0.001 17.007000999997857</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The fourth-order derivative of a 3rd-order polynomial is zero:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.polyder(p, 2) poly1d([6, 2]) np.polyder(p, 3) poly1d([6]) np.polyder(p, 4) poly1d([0.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28140">view source</a></div></div><div class="public anchor" id="var-polydiv"><h3>polydiv</h3><div class="usage"><code>(polydiv &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Returns the quotient and remainder of polynomial division.</p>
-<p>The input arrays are the coefficients (including any coefficients equal to zero) of the “numerator” (dividend) and “denominator” (divisor) polynomials, respectively.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>u : array_like or poly1d  Dividend polynomial’s coefficients.</p>
-<p>v : array_like or poly1d  Divisor polynomial’s coefficients.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>q : ndarray  Coefficients, including those equal to zero, of the quotient. r : ndarray  Coefficients, including those equal to zero, of the remainder.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub polyval</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Both <code>u</code> and <code>v</code> must be 0-d or 1-d (ndim = 0 or 1), but <code>u.ndim</code> need not equal <code>v.ndim</code>. In other words, all four possible combinations - <code>u.ndim = v.ndim = 0</code>, <code>u.ndim = v.ndim = 1</code>, <code>u.ndim = 1, v.ndim = 0</code>, and <code>u.ndim = 0, v.ndim = 1</code> - work.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>.. math:: \frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([3.0, 5.0, 2.0]) y = np.array([2.0, 1.0]) np.polydiv(x, y) (array([1.5 , 1.75]), array([0.25]))</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28754">view source</a></div></div><div class="public anchor" id="var-polyfit"><h3>polyfit</h3><div class="usage"><code>(polyfit &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Least squares polynomial fit.</p>
-<p>Fit a polynomial <code>p(x) = p[0] * x**deg + ... + p[deg]</code> of degree <code>deg</code> to points <code>(x, y)</code>. Returns a vector of coefficients <code>p</code> that minimises the squared error in the order <code>deg</code>, <code>deg-1</code>, … <code>0</code>.</p>
-<p>The <code>Polynomial.fit &lt;numpy.polynomial.polynomial.Polynomial.fit&gt;</code> class method is recommended for new code as it is more stable numerically. See the documentation of the method for more information.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like, shape (M,)  x-coordinates of the M sample points <code>(x[i], y[i])</code>. y : array_like, shape (M,) or (M, K)  y-coordinates of the sample points. Several data sets of sample  points sharing the same x-coordinates can be fitted at once by  passing in a 2D-array that contains one dataset per column. deg : int  Degree of the fitting polynomial rcond : float, optional  Relative condition number of the fit. Singular values smaller than  this relative to the largest singular value will be ignored. The  default value is len(x)*eps, where eps is the relative precision of  the float type, about 2e-16 in most cases. full : bool, optional  Switch determining nature of return value. When it is False (the  default) just the coefficients are returned, when True diagnostic  information from the singular value decomposition is also returned. w : array_like, shape (M,), optional  Weights to apply to the y-coordinates of the sample points. For  gaussian uncertainties, use 1/sigma (not 1/sigma**2). cov : bool or str, optional  If given and not <code>False</code>, return not just the estimate but also its  covariance matrix. By default, the covariance are scaled by  chi2/sqrt(N-dof), i.e., the weights are presumed to be unreliable  except in a relative sense and everything is scaled such that the  reduced chi2 is unity. This scaling is omitted if <code>cov='unscaled'</code>,  as is relevant for the case that the weights are 1/sigma**2, with  sigma known to be a reliable estimate of the uncertainty.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>p : ndarray, shape (deg + 1,) or (deg + 1, K)  Polynomial coefficients, highest power first. If <code>y</code> was 2-D, the  coefficients for <code>k</code>-th data set are in <code>p[:,k]</code>.</p>
-<p>residuals, rank, singular_values, rcond  Present only if <code>full</code> = True. Residuals is sum of squared residuals  of the least-squares fit, the effective rank of the scaled Vandermonde  coefficient matrix, its singular values, and the specified value of  <code>rcond</code>. For more details, see <code>linalg.lstsq</code>.</p>
-<p>V : ndarray, shape (M,M) or (M,M,K)  Present only if <code>full</code> = False and <code>cov</code>=True. The covariance  matrix of the polynomial coefficient estimates. The diagonal of  this matrix are the variance estimates for each coefficient. If y  is a 2-D array, then the covariance matrix for the <code>k</code>-th data set  are in <code>V[:,:,k]</code></p>
-<h2><a href="#warns" name="warns"></a>Warns</h2>
-<p>RankWarning  The rank of the coefficient matrix in the least-squares fit is  deficient. The warning is only raised if <code>full</code> = False.</p>
-<pre><code>The warnings can be turned off by
-
-&gt;&gt;&gt; import warnings
-&gt;&gt;&gt; warnings.simplefilter('ignore', np.RankWarning)
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>polyval : Compute polynomial values. linalg.lstsq : Computes a least-squares fit. scipy.interpolate.UnivariateSpline : Computes spline fits.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The solution minimizes the squared error</p>
-<p>.. math ::  E = \sum_{j=0}^k |p(x_j) - y_j|^2</p>
-<p>in the equations::</p>
-<pre><code>x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]
-x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]
-...
-x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]
-</code></pre>
-<p>The coefficient matrix of the coefficients <code>p</code> is a Vandermonde matrix.</p>
-<p><code>polyfit</code> issues a <code>RankWarning</code> when the least-squares fit is badly conditioned. This implies that the best fit is not well-defined due to numerical error. The results may be improved by lowering the polynomial degree or by replacing <code>x</code> by <code>x</code> - <code>x</code>.mean(). The <code>rcond</code> parameter can also be set to a value smaller than its default, but the resulting fit may be spurious: including contributions from the small singular values can add numerical noise to the result.</p>
-<p>Note that fitting polynomial coefficients is inherently badly conditioned when the degree of the polynomial is large or the interval of sample points is badly centered. The quality of the fit should always be checked in these cases. When polynomial fits are not satisfactory, splines may be a good alternative.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Wikipedia, “Curve fitting”,  <a href="https://en.wikipedia.org/wiki/Curve_fitting">https://en.wikipedia.org/wiki/Curve_fitting</a> .. [2] Wikipedia, “Polynomial interpolation”,  <a href="https://en.wikipedia.org/wiki/Polynomial_interpolation">https://en.wikipedia.org/wiki/Polynomial_interpolation</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import warnings x = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0]) y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0]) z = np.polyfit(x, y, 3) z array([ 0.08703704, -0.81349206, 1.69312169, -0.03968254]) # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>It is convenient to use <code>poly1d</code> objects for dealing with polynomials:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p = np.poly1d(z) p(0.5) 0.6143849206349179 # may vary p(3.5) -0.34732142857143039 # may vary p(10) 22.579365079365115 # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>High-order polynomials may oscillate wildly:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>with warnings.catch_warnings(): … warnings.simplefilter(‘ignore’, np.RankWarning) … p30 = np.poly1d(np.polyfit(x, y, 30)) … p30(4) -0.80000000000000204 # may vary p30(5) -0.99999999999999445 # may vary p30(4.5) -0.10547061179440398 # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Illustration:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt xp = np.linspace(-2, 6, 100) _ = plt.plot(x, y, ‘.’, xp, p(xp), ‘-’, xp, p30(xp), ‘–’) plt.ylim(-2,2) (-2, 2) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18376">view source</a></div></div><div class="public anchor" id="var-polyint"><h3>polyint</h3><div class="usage"><code>(polyint &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an antiderivative (indefinite integral) of a polynomial.</p>
-<p>The returned order <code>m</code> antiderivative <code>P</code> of polynomial <code>p</code> satisfies :math:<code>\frac{d^m}{dx^m}P(x) = p(x)</code> and is defined up to <code>m - 1</code> integration constants <code>k</code>. The constants determine the low-order polynomial part</p>
-<p>.. math:: \frac{k_{m-1}}{0!} x^0 + \ldots + \frac{k_0}{(m-1)!}x^{m-1}</p>
-<p>of <code>P</code> so that :math:<code>P^{(j)}(0) = k_{m-j-1}</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>p : array_like or poly1d  Polynomial to integrate.  A sequence is interpreted as polynomial coefficients, see <code>poly1d</code>. m : int, optional  Order of the antiderivative. (Default: 1) k : list of <code>m</code> scalars or scalar, optional  Integration constants. They are given in the order of integration:  those corresponding to highest-order terms come first.</p>
-<pre><code>If ``None`` (default), all constants are assumed to be zero.
-If `m = 1`, a single scalar can be given instead of a list.
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>polyder : derivative of a polynomial poly1d.integ : equivalent method</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>The defining property of the antiderivative:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p = np.poly1d([1,1,1]) P = np.polyint(p) P  poly1d([ 0.33333333, 0.5 , 1. , 0. ]) # may vary np.polyder(P) == p True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The integration constants default to zero, but can be specified:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>P = np.polyint(p, 3) P(0) 0.0 np.polyder(P)(0) 0.0 np.polyder(P, 2)(0) 0.0 P = np.polyint(p, 3, k=[6,5,3]) P poly1d([ 0.01666667, 0.04166667, 0.16666667, 3. , 5. , 3. ]) # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that 3 = 6 / 2!, and that the constants are given in the order of integrations. Constant of the highest-order polynomial term comes first:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.polyder(P, 2)(0) 6.0 np.polyder(P, 1)(0) 5.0 P(0) 3.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9615">view source</a></div></div><div class="public anchor" id="var-polymul"><h3>polymul</h3><div class="usage"><code>(polymul &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the product of two polynomials.</p>
-<p>Finds the polynomial resulting from the multiplication of the two input polynomials. Each input must be either a poly1d object or a 1D sequence of polynomial coefficients, from highest to lowest degree.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a1, a2 : array_like or poly1d object  Input polynomials.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or poly1d object  The polynomial resulting from the multiplication of the inputs. If  either inputs is a poly1d object, then the output is also a poly1d  object. Otherwise, it is a 1D array of polynomial coefficients from  highest to lowest degree.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>poly1d : A one-dimensional polynomial class. poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval convolve : Array convolution. Same output as polymul, but has parameter  for overlap mode.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.polymul([1, 2, 3], [9, 5, 1]) array([ 9, 23, 38, 17, 3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using poly1d objects:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p1 = np.poly1d([1, 2, 3]) p2 = np.poly1d([9, 5, 1]) print(p1)  2 1 x + 2 x + 3 print(p2)  2 9 x + 5 x + 1 print(np.polymul(p1, p2))  4 3 2 9 x + 23 x + 38 x + 17 x + 3</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18243">view source</a></div></div><div class="public anchor" id="var-polynomial"><h3>polynomial</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A sub-package for efficiently dealing with polynomials.</p>
-<p>Within the documentation for this sub-package, a “finite power series,” i.e., a polynomial (also referred to simply as a “series”) is represented by a 1-D numpy array of the polynomial’s coefficients, ordered from lowest order term to highest. For example, array([1,2,3]) represents <code>P_0 + 2*P_1 + 3*P_2</code>, where P_n is the n-th order basis polynomial applicable to the specific module in question, e.g., <code>polynomial</code> (which “wraps” the “standard” basis) or <code>chebyshev</code>. For optimal performance, all operations on polynomials, including evaluation at an argument, are implemented as operations on the coefficients. Additional (module-specific) information can be found in the docstring for the module of interest.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28124">view source</a></div></div><div class="public anchor" id="var-polysub"><h3>polysub</h3><div class="usage"><code>(polysub &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Difference (subtraction) of two polynomials.</p>
-<p>Given two polynomials <code>a1</code> and <code>a2</code>, returns <code>a1 - a2</code>. <code>a1</code> and <code>a2</code> can be either array_like sequences of the polynomials’ coefficients (including coefficients equal to zero), or <code>poly1d</code> objects.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a1, a2 : array_like or poly1d  Minuend and subtrahend polynomials, respectively.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or poly1d  Array or <code>poly1d</code> object of the difference polynomial’s coefficients.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>polyval, polydiv, polymul, polyadd</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>.. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2)</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.polysub([2, 10, -2], [3, 10, -4]) array([-1, 0, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9267">view source</a></div></div><div class="public anchor" id="var-polyval"><h3>polyval</h3><div class="usage"><code>(polyval &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Evaluate a polynomial at specific values.</p>
-<p>If <code>p</code> is of length N, this function returns the value:</p>
-<pre><code>``p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]``
-</code></pre>
-<p>If <code>x</code> is a sequence, then <code>p(x)</code> is returned for each element of <code>x</code>. If <code>x</code> is another polynomial then the composite polynomial <code>p(x(t))</code> is returned.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>p : array_like or poly1d object  1D array of polynomial coefficients (including coefficients equal  to zero) from highest degree to the constant term, or an  instance of poly1d. x : array_like or poly1d object  A number, an array of numbers, or an instance of poly1d, at  which to evaluate <code>p</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>values : ndarray or poly1d  If <code>x</code> is a poly1d instance, the result is the composition of the two  polynomials, i.e., <code>x</code> is “substituted” in <code>p</code> and the simplified  result is returned. In addition, the type of <code>x</code> - array_like or  poly1d - governs the type of the output: <code>x</code> array_like =&gt; <code>values</code>  array_like, <code>x</code> a poly1d object =&gt; <code>values</code> is also.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>poly1d: A polynomial class.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Horner’s scheme [1]_ is used to evaluate the polynomial. Even so, for polynomials of high degree the values may be inaccurate due to rounding errors. Use carefully.</p>
-<p>If <code>x</code> is a subtype of <code>ndarray</code> the return value will be of the same type.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng.  trans. Ed.), <em>Handbook of Mathematics</em>, New York, Van Nostrand  Reinhold Co., 1985, pg. 720.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.polyval([3,0,1], 5) # 3 * 5**2 + 0 * 5**1 + 1 76 np.polyval([3,0,1], np.poly1d(5)) poly1d([76.]) np.polyval(np.poly1d([3,0,1]), 5) 76 np.polyval(np.poly1d([3,0,1]), np.poly1d(5)) poly1d([76.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2553">view source</a></div></div><div class="public anchor" id="var-positive"><h3>positive</h3><div class="usage"><code>(positive self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>positive(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Numerical positive, element-wise.</p>
-<p>.. versionadded:: 1.13.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like or scalar  Input array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  Returned array or scalar: <code>y = +x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Equivalent to <code>x.copy()</code>, but only defined for types that support arithmetic.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4385">view source</a></div></div><div class="public anchor" id="var-power"><h3>power</h3><div class="usage"><code>(power self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>power(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>First array elements raised to powers from second array, element-wise.</p>
-<p>Raise each base in <code>x1</code> to the positionally-corresponding power in <code>x2</code>. <code>x1</code> and <code>x2</code> must be broadcastable to the same shape. Note that an integer type raised to a negative integer power will raise a ValueError.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  The bases. x2 : array_like  The exponents. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The bases in <code>x1</code> raised to the exponents in <code>x2</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>float_power : power function that promotes integers to float</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Cube each element in a list.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x1 = range(6) x1 [0, 1, 2, 3, 4, 5] np.power(x1, 3) array([ 0, 1, 8, 27, 64, 125])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Raise the bases to different exponents.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0] np.power(x1, x2) array([ 0., 1., 8., 27., 16., 5.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The effect of broadcasting.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x2 = np.array(<a href="null">1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1</a>) x2 array(<a href="null">1, 2, 3, 3, 2, 1],
-       [1, 2, 3, 3, 2, 1</a>) np.power(x1, x2) array(<a href="null"> 0,  1,  8, 27, 16,  5],
-       [ 0,  1,  8, 27, 16,  5</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14768">view source</a></div></div><div class="public anchor" id="var-ppmt"><h3>ppmt</h3><div class="usage"><code>(ppmt &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the payment against loan principal.</p>
-<p>.. deprecated:: 1.18</p>
-<p><code>ppmt</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>rate : array_like  Rate of interest (per period) per : array_like, int  Amount paid against the loan changes. The <code>per</code> is the period of  interest. nper : array_like  Number of compounding periods pv : array_like  Present value fv : array_like, optional  Future value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}  When payments are due (‘begin’ (1) or ‘end’ (0))</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>pmt, pv, ipmt</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8912">view source</a></div></div><div class="public anchor" id="var-print_function"><h3>print_function</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18036">view source</a></div></div><div class="public anchor" id="var-printoptions"><h3>printoptions</h3><div class="usage"><code>(printoptions &amp; [args {:as kwds}])</code></div><div class="doc"><div class="markdown"><p>Context manager for setting print options.</p>
-<p>Set print options for the scope of the <code>with</code> block, and restore the old options at the end. See <code>set_printoptions</code> for the full description of available options.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from numpy.testing import assert_equal with np.printoptions(precision=2): … np.array([2.0]) / 3 array([0.67])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The <code>as</code>-clause of the <code>with</code>-statement gives the current print options:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>with np.printoptions(precision=2) as opts: … assert_equal(opts, np.get_printoptions())</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>set_printoptions, get_printoptions</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20105">view source</a></div></div><div class="public anchor" id="var-prod"><h3>prod</h3><div class="usage"><code>(prod &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the product of array elements over a given axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  Axis or axes along which a product is performed. The default,  axis=None, will calculate the product of all the elements in the  input array. If axis is negative it counts from the last to the  first axis.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If axis is a tuple of ints, a product is performed on all of the
-axes specified in the tuple instead of a single axis or all the
-axes as before.
-</code></pre>
-<p>dtype : dtype, optional  The type of the returned array, as well as of the accumulator in  which the elements are multiplied. The dtype of <code>a</code> is used by  default unless <code>a</code> has an integer dtype of less precision than the  default platform integer. In that case, if <code>a</code> is signed then the  platform integer is used while if <code>a</code> is unsigned then an unsigned  integer of the same precision as the platform integer is used. out : ndarray, optional  Alternative output array in which to place the result. It must have  the same shape as the expected output, but the type of the output  values will be cast if necessary. keepdims : bool, optional  If this is set to True, the axes which are reduced are left in the  result as dimensions with size one. With this option, the result  will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `prod` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<p>initial : scalar, optional  The starting value for this product. See <code>~numpy.ufunc.reduce</code> for details.</p>
-<pre><code>.. versionadded:: 1.15.0
-</code></pre>
-<p>where : array_like of bool, optional  Elements to include in the product. See <code>~numpy.ufunc.reduce</code> for details.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>product_along_axis : ndarray, see <code>dtype</code> parameter above.  An array shaped as <code>a</code> but with the specified axis removed.  Returns a reference to <code>out</code> if specified.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.prod : equivalent method ufuncs-output-type</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Arithmetic is modular when using integer types, and no error is raised on overflow. That means that, on a 32-bit platform:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([536870910, 536870910, 536870910, 536870910]) np.prod(x) 16 # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The product of an empty array is the neutral element 1:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.prod([]) 1.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>By default, calculate the product of all elements:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.prod([1.,2.]) 2.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Even when the input array is two-dimensional:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.prod(<a href="null">1.,2.],[3.,4.</a>) 24.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>But we can also specify the axis over which to multiply:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.prod(<a href="null">1.,2.],[3.,4.</a>, axis=1) array([ 2., 12.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Or select specific elements to include:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.prod([1., np.nan, 3.], where=[True, False, True]) 3.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>If the type of <code>x</code> is unsigned, then the output type is the unsigned platform integer:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([1, 2, 3], dtype=np.uint8) np.prod(x).dtype == np.uint True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>If <code>x</code> is of a signed integer type, then the output type is the default platform integer:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([1, 2, 3], dtype=np.int8) np.prod(x).dtype == int True</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>You can also start the product with a value other than one:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.prod([1, 2], initial=5) 10</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7242">view source</a></div></div><div class="public anchor" id="var-product"><h3>product</h3><div class="usage"><code>(product &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the product of array elements over a given axis.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>prod : equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13517">view source</a></div></div><div class="public anchor" id="var-promote_types"><h3>promote_types</h3><div class="usage"><code>(promote_types self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>promote_types(type1, type2)</p>
-<p>Returns the data type with the smallest size and smallest scalar kind to which both <code>type1</code> and <code>type2</code> may be safely cast. The returned data type is always in native byte order.</p>
-<p>This function is symmetric, but rarely associative.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>type1 : dtype or dtype specifier  First data type. type2 : dtype or dtype specifier  Second data type.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : dtype  The promoted data type.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.6.0</p>
-<p>Starting in NumPy 1.9, promote_types function now returns a valid string length when given an integer or float dtype as one argument and a string dtype as another argument. Previously it always returned the input string dtype, even if it wasn’t long enough to store the max integer/float value converted to a string.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>result_type, dtype, can_cast</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.promote_types(‘f4’, ‘f8’) dtype(‘float64’)</p>
-      <p>np.promote_types(‘i8’, ‘f4’) dtype(‘float64’)</p>
-      <p>np.promote_types(‘&gt;i8’, ‘&lt;c8’) dtype(‘complex128’)</p>
-      <p>np.promote_types(‘i4’, ‘S8’) dtype(‘S11’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>An example of a non-associative case:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>p = np.promote_types p(‘S’, p(‘i1’, ‘u1’)) dtype(‘S6’) p(p(‘S’, ‘i1’), ‘u1’) dtype(‘S4’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20195">view source</a></div></div><div class="public anchor" id="var-ptp"><h3>ptp</h3><div class="usage"><code>(ptp &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Range of values (maximum - minimum) along an axis.</p>
-<p>The name of the function comes from the acronym for ‘peak to peak’.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input values. axis : None or int or tuple of ints, optional  Axis along which to find the peaks. By default, flatten the  array. <code>axis</code> may be negative, in  which case it counts from the last to the first axis.</p>
-<pre><code>.. versionadded:: 1.15.0
-
-If this is a tuple of ints, a reduction is performed on multiple
-axes, instead of a single axis or all the axes as before.
-</code></pre>
-<p>out : array_like  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type of the output values will be cast if necessary.</p>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `ptp` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>ptp : ndarray  A new array holding the result, unless <code>out</code> was  specified, in which case a reference to <code>out</code> is returned.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(4).reshape((2,2)) x array(<a href="null">0, 1],
-       [2, 3</a>)</p>
-      <p>np.ptp(x, axis=0) array([2, 2])</p>
-      <p>np.ptp(x, axis=1) array([1, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13531">view source</a></div></div><div class="public anchor" id="var-put"><h3>put</h3><div class="usage"><code>(put &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Replaces specified elements of an array with given values.</p>
-<p>The indexing works on the flattened target array. <code>put</code> is roughly equivalent to:</p>
-<p>::</p>
-<pre><code>a.flat[ind] = v
-</code></pre>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : ndarray  Target array. ind : array_like  Target indices, interpreted as integers. v : array_like  Values to place in <code>a</code> at target indices. If <code>v</code> is shorter than  <code>ind</code> it will be repeated as necessary. mode : {‘raise’, ‘wrap’, ‘clip’}, optional  Specifies how out-of-bounds indices will behave.</p>
-<pre><code>* 'raise' -- raise an error (default)
-* 'wrap' -- wrap around
-* 'clip' -- clip to the range
-
-'clip' mode means that all indices that are too large are replaced
-by the index that addresses the last element along that axis. Note
-that this disables indexing with negative numbers. In 'raise' mode,
-if an exception occurs the target array may still be modified.
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>putmask, place put_along_axis : Put elements by matching the array and the index arrays</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(5) np.put(a, [0, 2], [-44, -55]) a array([-44, 1, -55, 3, 4])</p>
-      <p>a = np.arange(5) np.put(a, 22, -5, mode=‘clip’) a array([ 0, 1, 2, 3, -5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6011">view source</a></div></div><div class="public anchor" id="var-put_along_axis"><h3>put_along_axis</h3><div class="usage"><code>(put_along_axis &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Put values into the destination array by matching 1d index and data slices.</p>
-<p>This iterates over matching 1d slices oriented along the specified axis in the index and data arrays, and uses the former to place values into the latter. These slices can be different lengths.</p>
-<p>Functions returning an index along an axis, like <code>argsort</code> and <code>argpartition</code>, produce suitable indices for this function.</p>
-<p>.. versionadded:: 1.15.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr: ndarray (Ni…, M, Nk…)  Destination array. indices: ndarray (Ni…, J, Nk…)  Indices to change along each 1d slice of <code>arr</code>. This must match the  dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast  against <code>arr</code>. values: array_like (Ni…, J, Nk…)  values to insert at those indices. Its shape and dimension are  broadcast to match that of <code>indices</code>. axis: int  The axis to take 1d slices along. If axis is None, the destination  array is treated as if a flattened 1d view had been created of it.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This is equivalent to (but faster than) the following use of <code>ndindex</code> and <code>s_</code>, which sets each of <code>ii</code> and <code>kk</code> to a tuple of indices::</p>
-<pre><code>Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
-J = indices.shape[axis]  # Need not equal M
-
-for ii in ndindex(Ni):
-    for kk in ndindex(Nk):
-        a_1d       = a      [ii + s_[:,] + kk]
-        indices_1d = indices[ii + s_[:,] + kk]
-        values_1d  = values [ii + s_[:,] + kk]
-        for j in range(J):
-            a_1d[indices_1d[j]] = values_1d[j]
-</code></pre>
-<p>Equivalently, eliminating the inner loop, the last two lines would be::</p>
-<pre><code>        a_1d[indices_1d] = values_1d
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>take_along_axis :  Take values from the input array by matching 1d index and data slices</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>For this sample array</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">10, 30, 20], [60, 40, 50</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>We can replace the maximum values with:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>ai = np.expand_dims(np.argmax(a, axis=1), axis=1) ai array(<a href="null">1],
-       [0</a>) np.put_along_axis(a, ai, 99, axis=1) a array(<a href="null">10, 99, 20],
-       [99, 40, 50</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4258">view source</a></div></div><div class="public anchor" id="var-putmask"><h3>putmask</h3><div class="usage"><code>(putmask &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>putmask(a, mask, values)</p>
-<p>Changes elements of an array based on conditional and input values.</p>
-<p>Sets <code>a.flat[n] = values[n]</code> for each n where <code>mask.flat[n]==True</code>.</p>
-<p>If <code>values</code> is not the same size as <code>a</code> and <code>mask</code> then it will repeat. This gives behavior different from <code>a[mask] = values</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Target array. mask : array_like  Boolean mask array. It has to be the same shape as <code>a</code>. values : array_like  Values to put into <code>a</code> where <code>mask</code> is True. If <code>values</code> is smaller  than <code>a</code> it will be repeated.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>place, put, take, copyto</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(6).reshape(2, 3) np.putmask(x, x&gt;2, x**2) x array(<a href="null"> 0,  1,  2],
-       [ 9, 16, 25</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>If <code>values</code> is smaller than <code>a</code> it is repeated:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(5) np.putmask(x, x&gt;1, [-33, -44]) x array([ 0, 1, -33, -44, -33])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11683">view source</a></div></div><div class="public anchor" id="var-pv"><h3>pv</h3><div class="usage"><code>(pv &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the present value.</p>
-<p>.. deprecated:: 1.18</p>
-<p><code>pv</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
-<p>Given:  * a future value, <code>fv</code>  * an interest <code>rate</code> compounded once per period, of which  there are  * <code>nper</code> total  * a (fixed) payment, <code>pmt</code>, paid either  * at the beginning (<code>when</code> = {‘begin’, 1}) or the end  (<code>when</code> = {‘end’, 0}) of each period</p>
-<p>Return:  the value now</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>rate : array_like  Rate of interest (per period) nper : array_like  Number of compounding periods pmt : array_like  Payment fv : array_like, optional  Future value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}, optional  When payments are due (‘begin’ (1) or ‘end’ (0))</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray, float  Present value of a series of payments or investments.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The present value is computed by solving the equation::</p>
-<p>fv +  pv*(1 + rate)**nper +  pmt*(1 + rate*when)/rate*((1 + rate)**nper - 1) = 0</p>
-<p>or, when <code>rate = 0</code>::</p>
-<p>fv + pv + pmt * nper = 0</p>
-<p>for <code>pv</code>, which is then returned.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).  Open Document Format for Office Applications (OpenDocument)v1.2,  Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,  Pre-Draft 12. Organization for the Advancement of Structured Information  Standards (OASIS). Billerica, MA, USA. [ODT Document].  Available:  <a href="http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula">http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula</a>  OpenDocument-formula-20090508.odt</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>What is the present value (e.g., the initial investment) of an investment that needs to total $15692.93 after 10 years of saving $100 every month? Assume the interest rate is 5% (annually) compounded monthly.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.pv(0.05/12, 10*12, -100, 15692.93) -100.00067131625819</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>By convention, the negative sign represents cash flow out (i.e., money not available today). Thus, to end up with $15,692.93 in 10 years saving $100 a month at 5% annual interest, one’s initial deposit should also be $100.</p>
-<p>If any input is array_like, <code>pv</code> returns an array of equal shape. Let’s compare different interest rates in the example above:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array((0.05, 0.04, 0.03))/12 np.pv(a, 10*12, -100, 15692.93) array([ -100.00067132, -649.26771385, -1273.78633713]) # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>So, to end up with the same $15692.93 under the same $100 per month “savings plan,” for annual interest rates of 4% and 3%, one would need initial investments of $649.27 and $1273.79, respectively.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27207">view source</a></div></div><div class="public anchor" id="var-PZERO"><h3>PZERO</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9544">view source</a></div></div><div class="public anchor" id="var-quantile"><h3>quantile</h3><div class="usage"><code>(quantile &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the q-th quantile of the data along the specified axis.</p>
-<p>.. versionadded:: 1.15.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array or object that can be converted to an array. q : array_like of float  Quantile or sequence of quantiles to compute, which must be between  0 and 1 inclusive. axis : {int, tuple of int, None}, optional  Axis or axes along which the quantiles are computed. The  default is to compute the quantile(s) along a flattened  version of the array. out : ndarray, optional  Alternative output array in which to place the result. It must  have the same shape and buffer length as the expected output,  but the type (of the output) will be cast if necessary. overwrite_input : bool, optional  If True, then allow the input array <code>a</code> to be modified by intermediate  calculations, to save memory. In this case, the contents of the input  <code>a</code> after this function completes is undefined. interpolation : {‘linear’, ‘lower’, ‘higher’, ‘midpoint’, ‘nearest’}  This optional parameter specifies the interpolation method to  use when the desired quantile lies between two data points  <code>i &lt; j</code>:</p>
-<pre><code>    * linear: ``i + (j - i) * fraction``, where ``fraction``
-      is the fractional part of the index surrounded by ``i``
-      and ``j``.
-    * lower: ``i``.
-    * higher: ``j``.
-    * nearest: ``i`` or ``j``, whichever is nearest.
-    * midpoint: ``(i + j) / 2``.
-</code></pre>
-<p>keepdims : bool, optional  If this is set to True, the axes which are reduced are left in  the result as dimensions with size one. With this option, the  result will broadcast correctly against the original array <code>a</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>quantile : scalar or ndarray  If <code>q</code> is a single quantile and <code>axis=None</code>, then the result  is a scalar. If multiple quantiles are given, first axis of  the result corresponds to the quantiles. The other axes are  the axes that remain after the reduction of <code>a</code>. If the input  contains integers or floats smaller than <code>float64</code>, the output  data-type is <code>float64</code>. Otherwise, the output data-type is the  same as that of the input. If <code>out</code> is specified, that array is  returned instead.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>mean percentile : equivalent to quantile, but with q in the range [0, 100]. median : equivalent to <code>quantile(..., 0.5)</code> nanquantile</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Given a vector <code>V</code> of length <code>N</code>, the q-th quantile of <code>V</code> is the value <code>q</code> of the way from the minimum to the maximum in a sorted copy of <code>V</code>. The values and distances of the two nearest neighbors as well as the <code>interpolation</code> parameter will determine the quantile if the normalized ranking does not match the location of <code>q</code> exactly. This function is the same as the median if <code>q=0.5</code>, the same as the minimum if <code>q=0.0</code> and the same as the maximum if <code>q=1.0</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">10, 7, 4], [3, 2, 1</a>) a array(<a href="null">10,  7,  4],
-       [ 3,  2,  1</a>) np.quantile(a, 0.5) 3.5 np.quantile(a, 0.5, axis=0) array([6.5, 4.5, 2.5]) np.quantile(a, 0.5, axis=1) array([7., 2.]) np.quantile(a, 0.5, axis=1, keepdims=True) array(<a href="null">7.],
-       [2.</a>) m = np.quantile(a, 0.5, axis=0) out = np.zeros_like(m) np.quantile(a, 0.5, axis=0, out=out) array([6.5, 4.5, 2.5]) m array([6.5, 4.5, 2.5]) b = a.copy() np.quantile(b, 0.5, axis=1, overwrite_input=True) array([7., 2.]) assert not np.all(a == b)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12254">view source</a></div></div><div class="public anchor" id="var-r_"><h3>r_</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Translates slice objects to concatenation along the first axis.</p>
-<p>This is a simple way to build up arrays quickly. There are two use cases.</p>
-<ol>
-  <li>If the index expression contains comma separated arrays, then stack  them along their first axis.</li>
-  <li>If the index expression contains slice notation or scalars then create  a 1-D array with a range indicated by the slice notation.</li>
-</ol>
-<p>If slice notation is used, the syntax <code>start:stop:step</code> is equivalent to <code>np.arange(start, stop, step)</code> inside of the brackets. However, if <code>step</code> is an imaginary number (i.e. 100j) then its integer portion is interpreted as a number-of-points desired and the start and stop are inclusive. In other words <code>start:stop:stepj</code> is interpreted as <code>np.linspace(start, stop, step, endpoint=1)</code> inside of the brackets. After expansion of slice notation, all comma separated sequences are concatenated together.</p>
-<p>Optional character strings placed as the first element of the index expression can be used to change the output. The strings ‘r’ or ‘c’ result in matrix output. If the result is 1-D and ‘r’ is specified a 1 x N (row) matrix is produced. If the result is 1-D and ‘c’ is specified, then a N x 1 (column) matrix is produced. If the result is 2-D then both provide the same matrix result.</p>
-<p>A string integer specifies which axis to stack multiple comma separated arrays along. A string of two comma-separated integers allows indication of the minimum number of dimensions to force each entry into as the second integer (the axis to concatenate along is still the first integer).</p>
-<p>A string with three comma-separated integers allows specification of the axis to concatenate along, the minimum number of dimensions to force the entries to, and which axis should contain the start of the arrays which are less than the specified number of dimensions. In other words the third integer allows you to specify where the 1‘s should be placed in the shape of the arrays that have their shapes upgraded. By default, they are placed in the front of the shape tuple. The third argument allows you to specify where the start of the array should be instead. Thus, a third argument of ‘0’ would place the 1‘s at the end of the array shape. Negative integers specify where in the new shape tuple the last dimension of upgraded arrays should be placed, so the default is ’-1’.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>Not a function, so takes no parameters</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>A concatenated ndarray or matrix.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>concatenate : Join a sequence of arrays along an existing axis. c_ : Translates slice objects to concatenation along the second axis.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.r_[np.array([1,2,3]), 0, 0, np.array([4,5,6])] array([1, 2, 3, …, 4, 5, 6]) np.r_[-1:1:6j, [0]*3, 5, 6] array([-1. , -0.6, -0.2, 0.2, 0.6, 1. , 0. , 0. , 0. , 5. , 6. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>String integers specify the axis to concatenate along or the minimum number of dimensions to force entries into.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">0, 1, 2], [3, 4, 5</a>) np.r_[‘-1’, a, a] # concatenate along last axis array(<a href="null">0, 1, 2, 0, 1, 2],
-       [3, 4, 5, 3, 4, 5</a>) np.r_[‘0,2’, [1,2,3], [4,5,6]] # concatenate along first axis, dim&gt;=2 array(<a href="null">1, 2, 3],
-       [4, 5, 6</a>)</p>
-      <p>np.r_[‘0,2,0’, [1,2,3], [4,5,6]] array(<a href="null">1],
-       [2],
-       [3],
-       [4],
-       [5],
-       [6</a>) np.r_[‘1,2,0’, [1,2,3], [4,5,6]] array(<a href="null">1, 4],
-       [2, 5],
-       [3, 6</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using ‘r’ or ‘c’ as a first string argument creates a matrix.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.r_[‘r’,[1,2,3], [4,5,6]] matrix(<a href="null">1, 2, 3, 4, 5, 6</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2615">view source</a></div></div><div class="public anchor" id="var-rad2deg"><h3>rad2deg</h3><div class="usage"><code>(rad2deg self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>rad2deg(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Convert angles from radians to degrees.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Angle in radians. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The corresponding angle in degrees.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>deg2rad : Convert angles from degrees to radians. unwrap : Remove large jumps in angle by wrapping.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.3.0</p>
-<p>rad2deg(x) is <code>180 * x / pi</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.rad2deg(np.pi/2) 90.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6268">view source</a></div></div><div class="public anchor" id="var-radians"><h3>radians</h3><div class="usage"><code>(radians self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>radians(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Convert angles from degrees to radians.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array in degrees. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The corresponding radian values.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>deg2rad : equivalent function</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Convert a degree array to radians</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>deg = np.arange(12.) * 30. np.radians(deg) array([ 0. , 0.52359878, 1.04719755, 1.57079633, 2.0943951 ,  2.61799388, 3.14159265, 3.66519143, 4.1887902 , 4.71238898,  5.23598776, 5.75958653])</p>
-      <p>out = np.zeros((deg.shape)) ret = np.radians(deg, out) ret is out True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15574">view source</a></div></div><div class="public anchor" id="var-RAISE"><h3>RAISE</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8772">view source</a></div></div><div class="public anchor" id="var-random"><h3>random</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>========================</p>
-<h1><a href="#random-number-generation" name="random-number-generation"></a>Random Number Generation</h1>
-<p>Use <code>default_rng()</code> to create a <code>Generator</code> and call its methods.</p>
-<p>=============== ========================================================= Generator ————— ——————————————————— Generator Class implementing all of the random number distributions default_rng Default constructor for <code>Generator</code> =============== =========================================================</p>
-<p>============================================= === BitGenerator Streams that work with Generator ——————————————— — MT19937 PCG64 Philox SFC64 ============================================= ===</p>
-<p>============================================= === Getting entropy to initialize a BitGenerator ——————————————— — SeedSequence ============================================= ===</p>
-<h2><a href="#legacy" name="legacy"></a>Legacy</h2>
-<p>For backwards compatibility with previous versions of numpy before 1.17, the various aliases to the global <code>RandomState</code> methods are left alone and do not use the new <code>Generator</code> API.</p>
-<p>==================== ========================================================= Utility functions ——————– ——————————————————— random Uniformly distributed floats over <code>[0, 1)</code> bytes Uniformly distributed random bytes. permutation Randomly permute a sequence / generate a random sequence. shuffle Randomly permute a sequence in place. choice Random sample from 1-D array. ==================== =========================================================</p>
-<p>==================== ========================================================= Compatibility functions - removed in the new API ——————– ——————————————————— rand Uniformly distributed values. randn Normally distributed values. ranf Uniformly distributed floating point numbers. random_integers Uniformly distributed integers in a given range.  (deprecated, use <code>integers(..., closed=True)</code> instead) random_sample Alias for <code>random_sample</code> randint Uniformly distributed integers in a given range seed Seed the legacy random number generator. ==================== =========================================================</p>
-<p>==================== ========================================================= Univariate distributions ——————– ——————————————————— beta Beta distribution over <code>[0, 1]</code>. binomial Binomial distribution. chisquare :math:<code>\chi^2</code> distribution. exponential Exponential distribution. f F (Fisher-Snedecor) distribution. gamma Gamma distribution. geometric Geometric distribution. gumbel Gumbel distribution. hypergeometric Hypergeometric distribution. laplace Laplace distribution. logistic Logistic distribution. lognormal Log-normal distribution. logseries Logarithmic series distribution. negative_binomial Negative binomial distribution. noncentral_chisquare Non-central chi-square distribution. noncentral_f Non-central F distribution. normal Normal / Gaussian distribution. pareto Pareto distribution. poisson Poisson distribution. power Power distribution. rayleigh Rayleigh distribution. triangular Triangular distribution. uniform Uniform distribution. vonmises Von Mises circular distribution. wald Wald (inverse Gaussian) distribution. weibull Weibull distribution. zipf Zipf’s distribution over ranked data. ==================== =========================================================</p>
-<p>==================== ========================================================== Multivariate distributions ——————– ———————————————————- dirichlet Multivariate generalization of Beta distribution. multinomial Multivariate generalization of the binomial distribution. multivariate_normal Multivariate generalization of the normal distribution. ==================== ==========================================================</p>
-<p>==================== ========================================================= Standard distributions ——————– ——————————————————— standard_cauchy Standard Cauchy-Lorentz distribution. standard_exponential Standard exponential distribution. standard_gamma Standard Gamma distribution. standard_normal Standard normal distribution. standard_t Standard Student’s t-distribution. ==================== =========================================================</p>
-<p>==================== ========================================================= Internal functions ——————– ——————————————————— get_state Get tuple representing internal state of generator. set_state Set state of generator. ==================== =========================================================</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1248">view source</a></div></div><div class="public anchor" id="var-RankWarning"><h3>RankWarning</h3><div class="usage"><code>(RankWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Issued by <code>polyfit</code> when the Vandermonde matrix is rank deficient.</p>
-<p>For more information, a way to suppress the warning, and an example of <code>RankWarning</code> being issued, see <code>polyfit</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2544">view source</a></div></div><div class="public anchor" id="var-rate"><h3>rate</h3><div class="usage"><code>(rate &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the rate of interest per period.</p>
-<p>.. deprecated:: 1.18</p>
-<p><code>rate</code> is deprecated; for details, see NEP 32 [1]_.  Use the corresponding function in the numpy-financial library,  <a href="https://pypi.org/project/numpy-financial">https://pypi.org/project/numpy-financial</a>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>nper : array_like  Number of compounding periods pmt : array_like  Payment pv : array_like  Present value fv : array_like  Future value when : {{‘begin’, 1}, {‘end’, 0}}, {string, int}, optional  When payments are due (‘begin’ (1) or ‘end’ (0)) guess : Number, optional  Starting guess for solving the rate of interest, default 0.1 tol : Number, optional  Required tolerance for the solution, default 1e-6 maxiter : int, optional  Maximum iterations in finding the solution</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The rate of interest is computed by iteratively solving the (non-linear) equation::</p>
-<p>fv + pv*(1+rate)**nper + pmt*(1+rate*when)/rate * ((1+rate)**nper - 1) = 0</p>
-<p>for <code>rate</code>.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy Enhancement Proposal (NEP) 32,  <a href="https://numpy.org/neps/nep-0032-remove-financial-functions.html">https://numpy.org/neps/nep-0032-remove-financial-functions.html</a> .. [2] Wheeler, D. A., E. Rathke, and R. Weir (Eds.) (2009, May).  Open Document Format for Office Applications (OpenDocument)v1.2,  Part 2: Recalculated Formula (OpenFormula) Format - Annotated Version,  Pre-Draft 12. Organization for the Advancement of Structured Information  Standards (OASIS). Billerica, MA, USA. [ODT Document].  Available:  <a href="http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula">http://www.oasis-open.org/committees/documents.php?wg_abbrev=office-formula</a>  OpenDocument-formula-20090508.odt</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15098">view source</a></div></div><div class="public anchor" id="var-ravel"><h3>ravel</h3><div class="usage"><code>(ravel &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a contiguous flattened array.</p>
-<p>A 1-D array, containing the elements of the input, is returned. A copy is made only if needed.</p>
-<p>As of NumPy 1.10, the returned array will have the same type as the input array. (for example, a masked array will be returned for a masked array input)</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. The elements in <code>a</code> are read in the order specified by  <code>order</code>, and packed as a 1-D array. order : {‘C’,‘F’, ‘A’, ‘K’}, optional</p>
-<pre><code>The elements of `a` are read using this index order. 'C' means
-to index the elements in row-major, C-style order,
-with the last axis index changing fastest, back to the first
-axis index changing slowest.  'F' means to index the elements
-in column-major, Fortran-style order, with the
-first index changing fastest, and the last index changing
-slowest. Note that the 'C' and 'F' options take no account of
-the memory layout of the underlying array, and only refer to
-the order of axis indexing.  'A' means to read the elements in
-Fortran-like index order if `a` is Fortran *contiguous* in
-memory, C-like order otherwise.  'K' means to read the
-elements in the order they occur in memory, except for
-reversing the data when strides are negative.  By default, 'C'
-index order is used.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : array_like  y is an array of the same subtype as <code>a</code>, with shape <code>(a.size,)</code>.  Note that matrices are special cased for backward compatibility, if <code>a</code>  is a matrix, then y is a 1-D ndarray.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.flat : 1-D iterator over an array. ndarray.flatten : 1-D array copy of the elements of an array  in row-major order. ndarray.reshape : Change the shape of an array without changing its data.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>In row-major, C-style order, in two dimensions, the row index varies the slowest, and the column index the quickest. This can be generalized to multiple dimensions, where row-major order implies that the index along the first axis varies slowest, and the index along the last quickest. The opposite holds for column-major, Fortran-style index ordering.</p>
-<p>When a view is desired in as many cases as possible, <code>arr.reshape(-1)</code> may be preferable.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>It is equivalent to <code>reshape(-1, order=order)</code>.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">1, 2, 3], [4, 5, 6</a>) np.ravel(x) array([1, 2, 3, 4, 5, 6])</p>
-      <p>x.reshape(-1) array([1, 2, 3, 4, 5, 6])</p>
-      <p>np.ravel(x, order=‘F’) array([1, 4, 2, 5, 3, 6])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>When <code>order</code> is ‘A’, it will preserve the array’s ‘C’ or ‘F’ ordering:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.ravel(x.T) array([1, 4, 2, 5, 3, 6]) np.ravel(x.T, order=‘A’) array([1, 2, 3, 4, 5, 6])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>When <code>order</code> is ‘K’, it will preserve orderings that are neither ‘C’ nor ‘F’, but won’t reverse axes:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(3)[::-1]; a array([2, 1, 0]) a.ravel(order=‘C’) array([2, 1, 0]) a.ravel(order=‘K’) array([2, 1, 0])</p>
-      <p>a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a array(<a href="null">[ 0,  2,  4],
-        [ 1,  3,  5</a>,  <a href="null"> 6,  8, 10],
-        [ 7,  9, 11</a>]) a.ravel(order=‘C’) array([ 0, 2, 4, 1, 3, 5, 6, 8, 10, 7, 9, 11]) a.ravel(order=‘K’) array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17704">view source</a></div></div><div class="public anchor" id="var-ravel_multi_index"><h3>ravel_multi_index</h3><div class="usage"><code>(ravel_multi_index &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>ravel_multi_index(multi_index, dims, mode=‘raise’, order=‘C’)</p>
-<p>Converts a tuple of index arrays into an array of flat indices, applying boundary modes to the multi-index.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>multi_index : tuple of array_like  A tuple of integer arrays, one array for each dimension. dims : tuple of ints  The shape of array into which the indices from <code>multi_index</code> apply. mode : {‘raise’, ‘wrap’, ‘clip’}, optional  Specifies how out-of-bounds indices are handled. Can specify  either one mode or a tuple of modes, one mode per index.</p>
-<pre><code>* 'raise' -- raise an error (default)
-* 'wrap' -- wrap around
-* 'clip' -- clip to the range
-
-In 'clip' mode, a negative index which would normally
-wrap will clip to 0 instead.
-</code></pre>
-<p>order : {‘C’, ‘F’}, optional  Determines whether the multi-index should be viewed as  indexing in row-major (C-style) or column-major  (Fortran-style) order.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>raveled_indices : ndarray  An array of indices into the flattened version of an array  of dimensions <code>dims</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>unravel_index</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.6.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>arr = np.array(<a href="null">3,6,6],[4,5,1</a>) np.ravel_multi_index(arr, (7,6)) array([22, 41, 37]) np.ravel_multi_index(arr, (7,6), order=‘F’) array([31, 41, 13]) np.ravel_multi_index(arr, (4,6), mode=‘clip’) array([22, 23, 19]) np.ravel_multi_index(arr, (4,4), mode=(‘clip’,‘wrap’)) array([12, 13, 13])</p>
-      <p>np.ravel_multi_index((3,1,4,1), (6,7,8,9)) 1621</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L82">view source</a></div></div><div class="public anchor" id="var-real"><h3>real</h3><div class="usage"><code>(real &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the real part of the complex argument.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>val : array_like  Input array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  The real component of the complex argument. If <code>val</code> is real, the type  of <code>val</code> is used for the output. If <code>val</code> has complex elements, the  returned type is float.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>real_if_close, imag, angle</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1+2j, 3+4j, 5+6j]) a.real array([1., 3., 5.]) a.real = 9 a array([9.+2.j, 9.+4.j, 9.+6.j]) a.real = np.array([9, 8, 7]) a array([9.+2.j, 8.+4.j, 7.+6.j]) np.real(1 + 1j) 1.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15246">view source</a></div></div><div class="public anchor" id="var-real_if_close"><h3>real_if_close</h3><div class="usage"><code>(real_if_close &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>If complex input returns a real array if complex parts are close to zero.</p>
-<p>“Close to zero” is defined as <code>tol</code> * (machine epsilon of the type for <code>a</code>).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. tol : float  Tolerance in machine epsilons for the complex part of the elements  in the array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  If <code>a</code> is real, the type of <code>a</code> is used for the output. If <code>a</code>  has complex elements, the returned type is float.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>real, imag, angle</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Machine epsilon varies from machine to machine and between data types but Python floats on most platforms have a machine epsilon equal to 2.2204460492503131e-16. You can use ‘np.finfo(float).eps’ to print out the machine epsilon for floats.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.finfo(float).eps 2.2204460492503131e-16 # may vary</p>
-      <p>np.real_if_close([2.1 + 4e-14j], tol=1000) array([2.1]) np.real_if_close([2.1 + 4e-13j], tol=1000) array([2.1+4.e-13j])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6318">view source</a></div></div><div class="public anchor" id="var-rec"><h3>rec</h3><div class="usage"></div><div class="doc"><div class="markdown"><h1><a href="#record-arrays" name="record-arrays"></a>Record Arrays</h1>
-<p>Record arrays expose the fields of structured arrays as properties.</p>
-<p>Most commonly, ndarrays contain elements of a single type, e.g. floats, integers, bools etc. However, it is possible for elements to be combinations of these using structured types, such as::</p>
-<p>&gt;&gt;&gt; a = np.array([(1, 2.0), (1, 2.0)], dtype=[(‘x’, np.int64), (‘y’, np.float64)])  &gt;&gt;&gt; a  array([(1, 2.), (1, 2.)], dtype=[(‘x’, ‘&lt;i8’), (‘y’, ‘&lt;f8’)])</p>
-<p>Here, each element consists of two fields: x (and int), and y (a float). This is known as a structured array. The different fields are analogous to columns in a spread-sheet. The different fields can be accessed as one would a dictionary::</p>
-<p>&gt;&gt;&gt; a[‘x’]  array([1, 1])</p>
-<p>&gt;&gt;&gt; a[‘y’]  array([2., 2.])</p>
-<p>Record arrays allow us to access fields as properties::</p>
-<p>&gt;&gt;&gt; ar = np.rec.array(a)</p>
-<p>&gt;&gt;&gt; ar.x  array([1, 1])</p>
-<p>&gt;&gt;&gt; ar.y  array([2., 2.])</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25729">view source</a></div></div><div class="public anchor" id="var-recarray"><h3>recarray</h3><div class="usage"><code>(recarray self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Construct an ndarray that allows field access using attributes.</p>
-<p>Arrays may have a data-types containing fields, analogous to columns in a spread sheet. An example is <code>[(x, int), (y, float)]</code>, where each entry in the array is a pair of <code>(int, float)</code>. Normally, these attributes are accessed using dictionary lookups such as <code>arr['x']</code> and <code>arr['y']</code>. Record arrays allow the fields to be accessed as members of the array, using <code>arr.x</code> and <code>arr.y</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>shape : tuple  Shape of output array. dtype : data-type, optional  The desired data-type. By default, the data-type is determined  from <code>formats</code>, <code>names</code>, <code>titles</code>, <code>aligned</code> and <code>byteorder</code>. formats : list of data-types, optional  A list containing the data-types for the different columns, e.g.  <code>['i4', 'f8', 'i4']</code>. <code>formats</code> does <em>not</em> support the new  convention of using types directly, i.e. <code>(int, float, int)</code>.  Note that <code>formats</code> must be a list, not a tuple.  Given that <code>formats</code> is somewhat limited, we recommend specifying  <code>dtype</code> instead. names : tuple of str, optional  The name of each column, e.g. <code>('x', 'y', 'z')</code>. buf : buffer, optional  By default, a new array is created of the given shape and data-type.  If <code>buf</code> is specified and is an object exposing the buffer interface,  the array will use the memory from the existing buffer. In this case,  the <code>offset</code> and <code>strides</code> keywords are available.</p>
-<h2><a href="#other-parameters" name="other-parameters"></a>Other Parameters</h2>
-<p>titles : tuple of str, optional  Aliases for column names. For example, if <code>names</code> were  <code>('x', 'y', 'z')</code> and <code>titles</code> is  <code>('x_coordinate', 'y_coordinate', 'z_coordinate')</code>, then  <code>arr['x']</code> is equivalent to both <code>arr.x</code> and <code>arr.x_coordinate</code>. byteorder : {‘&lt;’, ‘&gt;’, ‘=’}, optional  Byte-order for all fields. aligned : bool, optional  Align the fields in memory as the C-compiler would. strides : tuple of ints, optional  Buffer (<code>buf</code>) is interpreted according to these strides (strides  define how many bytes each array element, row, column, etc.  occupy in memory). offset : int, optional  Start reading buffer (<code>buf</code>) from this offset onwards. order : {‘C’, ‘F’}, optional  Row-major (C-style) or column-major (Fortran-style) order.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>rec : recarray  Empty array of the given shape and type.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>rec.fromrecords : Construct a record array from data. record : fundamental data-type for <code>recarray</code>. format_parser : determine a data-type from formats, names, titles.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This constructor can be compared to <code>empty</code>: it creates a new record array but does not fill it with data. To create a record array from data, use one of the following methods:</p>
-<ol>
-  <li>Create a standard ndarray and convert it to a record array,  using <code>arr.view(np.recarray)</code></li>
-  <li>Use the <code>buf</code> keyword.</li>
-  <li>Use <code>np.rec.fromrecords</code>.</li>
-</ol>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Create an array with two fields, <code>x</code> and <code>y</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([(1.0, 2), (3.0, 4)], dtype=[(‘x’, ‘&lt;f8’), (‘y’, ‘&lt;i8’)]) x array([(1., 2), (3., 4)], dtype=[(‘x’, ‘&lt;f8’), (‘y’, ‘&lt;i8’)])</p>
-      <p>x[‘x’] array([1., 3.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>View the array as a record array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = x.view(np.recarray)</p>
-      <p>x.x array([1., 3.])</p>
-      <p>x.y array([2, 4])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Create a new, empty record array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.recarray((2,), … dtype=[(‘x’, int), (‘y’, float), (‘z’, int)]) #doctest: +SKIP rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),  (3471280, 1.2134086255804012e-316, 0)],  dtype=[(‘x’, ‘&lt;i4’), (‘y’, ‘&lt;f8’), (‘z’, ‘&lt;i4’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19072">view source</a></div></div><div class="public anchor" id="var-recfromcsv"><h3>recfromcsv</h3><div class="usage"><code>(recfromcsv fname &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Load ASCII data stored in a comma-separated file.</p>
-<p>The returned array is a record array (if <code>usemask=False</code>, see <code>recarray</code>) or a masked record array (if <code>usemask=True</code>, see <code>ma.mrecords.MaskedRecords</code>).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>fname, kwargs : For a description of input parameters, see <code>genfromtxt</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.genfromtxt : generic function to load ASCII data.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>By default, <code>dtype</code> is None, which means that the data-type of the output array will be determined from the data.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L358">view source</a></div></div><div class="public anchor" id="var-recfromtxt"><h3>recfromtxt</h3><div class="usage"><code>(recfromtxt fname &amp; [{:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Load ASCII data from a file and return it in a record array.</p>
-<p>If <code>usemask=False</code> a standard <code>recarray</code> is returned, if <code>usemask=True</code> a MaskedRecords array is returned.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>fname, kwargs : For a description of input parameters, see <code>genfromtxt</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.genfromtxt : generic function</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>By default, <code>dtype</code> is None, which means that the data-type of the output array will be determined from the data.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17307">view source</a></div></div><div class="public anchor" id="var-reciprocal"><h3>reciprocal</h3><div class="usage"><code>(reciprocal self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>reciprocal(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the reciprocal of the argument, element-wise.</p>
-<p>Calculates <code>1/x</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  Return array.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. note::  This function is not designed to work with integers.</p>
-<p>For integer arguments with absolute value larger than 1 the result is always zero because of the way Python handles integer division. For integer zero the result is an overflow.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.reciprocal(2.) 0.5 np.reciprocal([1, 2., 3.33]) array([ 1. , 0.5 , 0.3003003])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10308">view source</a></div></div><div class="public anchor" id="var-record"><h3>record</h3><div class="usage"><code>(record self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>A data-type scalar that allows field access as attribute lookup.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6495">view source</a></div></div><div class="public anchor" id="var-remainder"><h3>remainder</h3><div class="usage"><code>(remainder self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>remainder(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return element-wise remainder of division.</p>
-<p>Computes the remainder complementary to the <code>floor_divide</code> function. It is equivalent to the Python modulus operator<code>x1 % x2</code> and has the same sign as the divisor <code>x2</code>. The MATLAB function equivalent to <code>np.remainder</code> is <code>mod</code>.</p>
-<p>.. warning::</p>
-<pre><code>This should not be confused with:
-
-* Python 3.7's `math.remainder` and C's ``remainder``, which
-  computes the IEEE remainder, which are the complement to
-  ``round(x1 / x2)``.
-* The MATLAB ``rem`` function and or the C ``%`` operator which is the
-  complement to ``int(x1 / x2)``.
-</code></pre>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  Dividend array. x2 : array_like  Divisor array. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The element-wise remainder of the quotient <code>floor_divide(x1, x2)</code>.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>floor_divide : Equivalent of Python <code>//</code> operator. divmod : Simultaneous floor division and remainder. fmod : Equivalent of the MATLAB <code>rem</code> function. divide, floor</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Returns 0 when <code>x2</code> is 0 and both <code>x1</code> and <code>x2</code> are (arrays of) integers. <code>mod</code> is an alias of <code>remainder</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.remainder([4, 7], [2, 3]) array([0, 1]) np.remainder(np.arange(7), 5) array([0, 1, 2, 3, 4, 0, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16398">view source</a></div></div><div class="public anchor" id="var-repeat"><h3>repeat</h3><div class="usage"><code>(repeat &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Repeat elements of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. repeats : int or array of ints  The number of repetitions for each element. <code>repeats</code> is broadcasted  to fit the shape of the given axis. axis : int, optional  The axis along which to repeat values. By default, use the  flattened input array, and return a flat output array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>repeated_array : ndarray  Output array which has the same shape as <code>a</code>, except along  the given axis.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>tile : Tile an array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.repeat(3, 4) array([3, 3, 3, 3]) x = np.array(<a href="null">1,2],[3,4</a>) np.repeat(x, 2) array([1, 1, 2, 2, 3, 3, 4, 4]) np.repeat(x, 3, axis=1) array(<a href="null">1, 1, 1, 2, 2, 2],
-       [3, 3, 3, 4, 4, 4</a>) np.repeat(x, [1, 2], axis=0) array(<a href="null">1, 2],
-       [3, 4],
-       [3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8322">view source</a></div></div><div class="public anchor" id="var-require"><h3>require</h3><div class="usage"><code>(require a &amp; [{dtype :dtype, requirements :requirements}])</code><code>(require a &amp; [{dtype :dtype}])</code><code>(require a)</code></div><div class="doc"><div class="markdown"><p>Return an ndarray of the provided type that satisfies requirements.</p>
-<p>This function is useful to be sure that an array with the correct flags is returned for passing to compiled code (perhaps through ctypes).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  The object to be converted to a type-and-requirement-satisfying array. dtype : data-type  The required data-type. If None preserve the current dtype. If your  application requires the data to be in native byteorder, include  a byteorder specification as a part of the dtype specification. requirements : str or list of str  The requirements list can be any of the following</p>
-<ul>
-  <li>‘F_CONTIGUOUS’ (‘F’) - ensure a Fortran-contiguous array</li>
-  <li>‘C_CONTIGUOUS’ (‘C’) - ensure a C-contiguous array</li>
-  <li>‘ALIGNED’ (‘A’) - ensure a data-type aligned array</li>
-  <li>‘WRITEABLE’ (‘W’) - ensure a writable array</li>
-  <li>‘OWNDATA’ (‘O’) - ensure an array that owns its own data</li>
-  <li>‘ENSUREARRAY’, (‘E’) - ensure a base array, instead of a subclass</li>
-</ul>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Array with specified requirements and type if given.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>asarray : Convert input to an ndarray. asanyarray : Convert to an ndarray, but pass through ndarray subclasses. ascontiguousarray : Convert input to a contiguous array. asfortranarray : Convert input to an ndarray with column-major  memory order. ndarray.flags : Information about the memory layout of the array.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The returned array will be guaranteed to have the listed requirements by making a copy if needed.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(6).reshape(2,3) x.flags  C_CONTIGUOUS : True  F_CONTIGUOUS : False  OWNDATA : False  WRITEABLE : True  ALIGNED : True  WRITEBACKIFCOPY : False  UPDATEIFCOPY : False</p>
-      <p>y = np.require(x, dtype=np.float32, requirements=[‘A’, ‘O’, ‘W’, ‘F’]) y.flags  C_CONTIGUOUS : False  F_CONTIGUOUS : True  OWNDATA : True  WRITEABLE : True  ALIGNED : True  WRITEBACKIFCOPY : False  UPDATEIFCOPY : False</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10120">view source</a></div></div><div class="public anchor" id="var-reshape"><h3>reshape</h3><div class="usage"><code>(reshape &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Gives a new shape to an array without changing its data.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array to be reshaped. newshape : int or tuple of ints  The new shape should be compatible with the original shape. If  an integer, then the result will be a 1-D array of that length.  One shape dimension can be -1. In this case, the value is  inferred from the length of the array and remaining dimensions. order : {‘C’, ‘F’, ‘A’}, optional  Read the elements of <code>a</code> using this index order, and place the  elements into the reshaped array using this index order. ‘C’  means to read / write the elements using C-like index order,  with the last axis index changing fastest, back to the first  axis index changing slowest. ‘F’ means to read / write the  elements using Fortran-like index order, with the first index  changing fastest, and the last index changing slowest. Note that  the ‘C’ and ‘F’ options take no account of the memory layout of  the underlying array, and only refer to the order of indexing.  ‘A’ means to read / write the elements in Fortran-like index  order if <code>a</code> is Fortran <em>contiguous</em> in memory, C-like order  otherwise.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>reshaped_array : ndarray  This will be a new view object if possible; otherwise, it will  be a copy. Note there is no guarantee of the <em>memory layout</em> (C- or  Fortran- contiguous) of the returned array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.reshape : Equivalent method.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>It is not always possible to change the shape of an array without copying the data. If you want an error to be raised when the data is copied, you should assign the new shape to the shape attribute of the array::</p>
-<p>&gt;&gt;&gt; a = np.zeros((10, 2))</p>
-<p># A transpose makes the array non-contiguous  &gt;&gt;&gt; b = a.T</p>
-<p># Taking a view makes it possible to modify the shape without modifying  # the initial object.  &gt;&gt;&gt; c = b.view()  &gt;&gt;&gt; c.shape = (20)  Traceback (most recent call last):  …  AttributeError: incompatible shape for a non-contiguous array</p>
-<p>The <code>order</code> keyword gives the index ordering both for <em>fetching</em> the values from <code>a</code>, and then <em>placing</em> the values into the output array. For example, let’s say you have an array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(6).reshape((3, 2)) a array(<a href="null">0, 1],
-       [2, 3],
-       [4, 5</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>You can think of reshaping as first raveling the array (using the given index order), then inserting the elements from the raveled array into the new array using the same kind of index ordering as was used for the raveling.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.reshape(a, (2, 3)) # C-like index ordering array(<a href="null">0, 1, 2],
-       [3, 4, 5</a>) np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape array(<a href="null">0, 1, 2],
-       [3, 4, 5</a>) np.reshape(a, (2, 3), order=‘F’) # Fortran-like index ordering array(<a href="null">0, 4, 3],
-       [2, 1, 5</a>) np.reshape(np.ravel(a, order=‘F’), (2, 3), order=‘F’) array(<a href="null">0, 4, 3],
-       [2, 1, 5</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1,2,3], [4,5,6</a>) np.reshape(a, 6) array([1, 2, 3, 4, 5, 6]) np.reshape(a, 6, order=‘F’) array([1, 4, 2, 5, 3, 6])</p>
-      <p>np.reshape(a, (3,-1)) # the unspecified value is inferred to be 2 array(<a href="null">1, 2],
-       [3, 4],
-       [5, 6</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13851">view source</a></div></div><div class="public anchor" id="var-resize"><h3>resize</h3><div class="usage"><code>(resize &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a new array with the specified shape.</p>
-<p>If the new array is larger than the original array, then the new array is filled with repeated copies of <code>a</code>. Note that this behavior is different from a.resize(new_shape) which fills with zeros instead of repeated copies of <code>a</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array to be resized.</p>
-<p>new_shape : int or tuple of int  Shape of resized array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>reshaped_array : ndarray  The new array is formed from the data in the old array, repeated  if necessary to fill out the required number of elements. The  data are repeated in the order that they are stored in memory.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.resize : resize an array in-place.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Warning: This functionality does <strong>not</strong> consider axes separately, i.e. it does not apply interpolation/extrapolation. It fills the return array with the required number of elements, taken from <code>a</code> as they are laid out in memory, disregarding strides and axes. (This is in case the new shape is smaller. For larger, see above.) This functionality is therefore not suitable to resize images, or data where each axis represents a separate and distinct entity.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a=np.array(<a href="null">0,1],[2,3</a>) np.resize(a,(2,3)) array(<a href="null">0, 1, 2],
-       [3, 0, 1</a>) np.resize(a,(1,4)) array(<a href="null">0, 1, 2, 3</a>) np.resize(a,(2,4)) array(<a href="null">0, 1, 2, 3],
-       [0, 1, 2, 3</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23725">view source</a></div></div><div class="public anchor" id="var-result_type"><h3>result_type</h3><div class="usage"><code>(result_type &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>result_type(*arrays_and_dtypes)</p>
-<p>Returns the type that results from applying the NumPy type promotion rules to the arguments.</p>
-<p>Type promotion in NumPy works similarly to the rules in languages like C++, with some slight differences. When both scalars and arrays are used, the array’s type takes precedence and the actual value of the scalar is taken into account.</p>
-<p>For example, calculating 3*a, where a is an array of 32-bit floats, intuitively should result in a 32-bit float output. If the 3 is a 32-bit integer, the NumPy rules indicate it can’t convert losslessly into a 32-bit float, so a 64-bit float should be the result type. By examining the value of the constant, ‘3’, we see that it fits in an 8-bit integer, which can be cast losslessly into the 32-bit float.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arrays_and_dtypes : list of arrays and dtypes  The operands of some operation whose result type is needed.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : dtype  The result type.</p>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>dtype, promote_types, min_scalar_type, can_cast</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.6.0</p>
-<p>The specific algorithm used is as follows.</p>
-<p>Categories are determined by first checking which of boolean, integer (int/uint), or floating point (float/complex) the maximum kind of all the arrays and the scalars are.</p>
-<p>If there are only scalars or the maximum category of the scalars is higher than the maximum category of the arrays, the data types are combined with :func:<code>promote_types</code> to produce the return value.</p>
-<p>Otherwise, <code>min_scalar_type</code> is called on each array, and the resulting data types are all combined with :func:<code>promote_types</code> to produce the return value.</p>
-<p>The set of int values is not a subset of the uint values for types with the same number of bits, something not reflected in :func:<code>min_scalar_type</code>, but handled as a special case in <code>result_type</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.result_type(3, np.arange(7, dtype=‘i1’)) dtype(‘int8’)</p>
-      <p>np.result_type(‘i4’, ‘c8’) dtype(‘complex128’)</p>
-      <p>np.result_type(3.0, -2) dtype(‘float64’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10">view source</a></div></div><div class="public anchor" id="var-right_shift"><h3>right_shift</h3><div class="usage"><code>(right_shift self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>right_shift(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Shift the bits of an integer to the right.</p>
-<p>Bits are shifted to the right <code>x2</code>. Because the internal representation of numbers is in binary format, this operation is equivalent to dividing <code>x1</code> by <code>2**x2</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like, int  Input values. x2 : array_like, int  Number of bits to remove at the right of <code>x1</code>. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray, int  Return <code>x1</code> with bits shifted <code>x2</code> times to the right.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>left_shift : Shift the bits of an integer to the left. binary_repr : Return the binary representation of the input number  as a string.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.binary_repr(10) ‘1010’ np.right_shift(10, 1) 5 np.binary_repr(5) ‘101’</p>
-      <p>np.right_shift(10, [1,2,3]) array([5, 2, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27978">view source</a></div></div><div class="public anchor" id="var-rint"><h3>rint</h3><div class="usage"><code>(rint self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>rint(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Round elements of the array to the nearest integer.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Output array is same shape and type as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ceil, floor, trunc</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.rint(a) array([-2., -2., -0., 0., 2., 2., 2.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28388">view source</a></div></div><div class="public anchor" id="var-roll"><h3>roll</h3><div class="usage"><code>(roll &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Roll array elements along a given axis.</p>
-<p>Elements that roll beyond the last position are re-introduced at the first.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. shift : int or tuple of ints  The number of places by which elements are shifted. If a tuple,  then <code>axis</code> must be a tuple of the same size, and each of the  given axes is shifted by the corresponding number. If an int  while <code>axis</code> is a tuple of ints, then the same value is used for  all given axes. axis : int or tuple of ints, optional  Axis or axes along which elements are shifted. By default, the  array is flattened before shifting, after which the original  shape is restored.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>res : ndarray  Output array, with the same shape as <code>a</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>rollaxis : Roll the specified axis backwards, until it lies in a  given position.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.12.0</p>
-<p>Supports rolling over multiple dimensions simultaneously.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(10) np.roll(x, 2) array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]) np.roll(x, -2) array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])</p>
-      <p>x2 = np.reshape(x, (2,5)) x2 array(<a href="null">0, 1, 2, 3, 4],
-       [5, 6, 7, 8, 9</a>) np.roll(x2, 1) array(<a href="null">9, 0, 1, 2, 3],
-       [4, 5, 6, 7, 8</a>) np.roll(x2, -1) array(<a href="null">1, 2, 3, 4, 5],
-       [6, 7, 8, 9, 0</a>) np.roll(x2, 1, axis=0) array(<a href="null">5, 6, 7, 8, 9],
-       [0, 1, 2, 3, 4</a>) np.roll(x2, -1, axis=0) array(<a href="null">5, 6, 7, 8, 9],
-       [0, 1, 2, 3, 4</a>) np.roll(x2, 1, axis=1) array(<a href="null">4, 0, 1, 2, 3],
-       [9, 5, 6, 7, 8</a>) np.roll(x2, -1, axis=1) array(<a href="null">1, 2, 3, 4, 0],
-       [6, 7, 8, 9, 5</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22212">view source</a></div></div><div class="public anchor" id="var-rollaxis"><h3>rollaxis</h3><div class="usage"><code>(rollaxis &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Roll the specified axis backwards, until it lies in a given position.</p>
-<p>This function continues to be supported for backward compatibility, but you should prefer <code>moveaxis</code>. The <code>moveaxis</code> function was added in NumPy 1.11.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : ndarray  Input array. axis : int  The axis to roll backwards. The positions of the other axes do not  change relative to one another. start : int, optional  The axis is rolled until it lies before this position. The default,  0, results in a “complete” roll.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>res : ndarray  For NumPy &gt;= 1.10.0 a view of <code>a</code> is always returned. For earlier  NumPy versions a view of <code>a</code> is returned only if the order of the  axes is changed, otherwise the input array is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>moveaxis : Move array axes to new positions. roll : Roll the elements of an array by a number of positions along a  given axis.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.ones((3,4,5,6)) np.rollaxis(a, 3, 1).shape (3, 6, 4, 5) np.rollaxis(a, 2).shape (5, 3, 4, 6) np.rollaxis(a, 1, 4).shape (3, 5, 6, 4)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8868">view source</a></div></div><div class="public anchor" id="var-roots"><h3>roots</h3><div class="usage"><code>(roots &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the roots of a polynomial with coefficients given in p.</p>
-<p>The values in the rank-1 array <code>p</code> are coefficients of a polynomial. If the length of <code>p</code> is n+1 then the polynomial is described by::</p>
-<p>p[0] * x**n + p[1] * x**(n-1) + … + p[n-1]*x + p[n]</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>p : array_like  Rank-1 array of polynomial coefficients.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  An array containing the roots of the polynomial.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  When <code>p</code> cannot be converted to a rank-1 array.</p>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>poly : Find the coefficients of a polynomial with a given sequence  of roots. polyval : Compute polynomial values. polyfit : Least squares polynomial fit. poly1d : A one-dimensional polynomial class.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The algorithm relies on computing the eigenvalues of the companion matrix [1]_.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] R. A. Horn &amp; C. R. Johnson, <em>Matrix Analysis</em>. Cambridge, UK:  Cambridge University Press, 1999, pp. 146-7.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>coeff = [3.2, 2, 1] np.roots(coeff) array([-0.3125+0.46351241j, -0.3125-0.46351241j])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L8997">view source</a></div></div><div class="public anchor" id="var-rot90"><h3>rot90</h3><div class="usage"><code>(rot90 &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Rotate an array by 90 degrees in the plane specified by axes.</p>
-<p>Rotation direction is from the first towards the second axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>m : array_like  Array of two or more dimensions. k : integer  Number of times the array is rotated by 90 degrees. axes: (2,) array_like  The array is rotated in the plane defined by the axes.  Axes must be different.</p>
-<pre><code>.. versionadded:: 1.12.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  A rotated view of <code>m</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>flip : Reverse the order of elements in an array along the given axis. fliplr : Flip an array horizontally. flipud : Flip an array vertically.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>rot90(m, k=1, axes=(1,0)) is the reverse of rot90(m, k=1, axes=(0,1)) rot90(m, k=1, axes=(1,0)) is equivalent to rot90(m, k=-1, axes=(0,1))</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>m = np.array(<a href="null">1,2],[3,4</a>, int) m array(<a href="null">1, 2],
-       [3, 4</a>) np.rot90(m) array(<a href="null">2, 4],
-       [1, 3</a>) np.rot90(m, 2) array(<a href="null">4, 3],
-       [2, 1</a>) m = np.arange(8).reshape((2,2,2)) np.rot90(m, 1, (1,2)) array(<a href="null">[1, 3],
-        [0, 2</a>,  <a href="null">5, 7],
-        [4, 6</a>])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24490">view source</a></div></div><div class="public anchor" id="var-round"><h3>round</h3><div class="usage"><code>(round &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Round an array to the given number of decimals.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>around : equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25600">view source</a></div></div><div class="public anchor" id="var-round_"><h3>round_</h3><div class="usage"><code>(round_ &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Round an array to the given number of decimals.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>around : equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22775">view source</a></div></div><div class="public anchor" id="var-row_stack"><h3>row_stack</h3><div class="usage"><code>(row_stack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Stack arrays in sequence vertically (row wise).</p>
-<p>This is equivalent to concatenation along the first axis after 1-D arrays of shape <code>(N,)</code> have been reshaped to <code>(1,N)</code>. Rebuilds arrays divided by <code>vsplit</code>.</p>
-<p>This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions <code>concatenate</code>, <code>stack</code> and <code>block</code> provide more general stacking and concatenation operations.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>tup : sequence of ndarrays  The arrays must have the same shape along all but the first axis.  1-D arrays must have the same length.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>stacked : ndarray  The array formed by stacking the given arrays, will be at least 2-D.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>stack : Join a sequence of arrays along a new axis. hstack : Stack arrays in sequence horizontally (column wise). dstack : Stack arrays in sequence depth wise (along third dimension). concatenate : Join a sequence of arrays along an existing axis. vsplit : Split array into a list of multiple sub-arrays vertically. block : Assemble arrays from blocks.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1, 2, 3]) b = np.array([2, 3, 4]) np.vstack((a,b)) array(<a href="null">1, 2, 3],
-       [2, 3, 4</a>)</p>
-      <p>a = np.array(<a href="null">1], [2], [3</a>) b = np.array(<a href="null">2], [3], [4</a>) np.vstack((a,b)) array(<a href="null">1],
-       [2],
-       [3],
-       [2],
-       [3],
-       [4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27668">view source</a></div></div><div class="public anchor" id="var-s_"><h3>s_</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>A nicer way to build up index tuples for arrays.</p>
-<p>.. note::  Use one of the two predefined instances <code>index_exp</code> or <code>s_</code>  rather than directly using <code>IndexExpression</code>.</p>
-<p>For any index combination, including slicing and axis insertion, <code>a[indices]</code> is the same as <code>a[np.index_exp[indices]]</code> for any array <code>a</code>. However, <code>np.index_exp[indices]</code> can be used anywhere in Python code and returns a tuple of slice objects that can be used in the construction of complex index expressions.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>maketuple : bool  If True, always returns a tuple.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>index_exp : Predefined instance that always returns a tuple:  <code>index_exp = IndexExpression(maketuple=True)</code>. s_ : Predefined instance without tuple conversion:  <code>s_ = IndexExpression(maketuple=False)</code>.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>You can do all this with <code>slice()</code> plus a few special objects, but there’s a lot to remember and this version is simpler because it uses the standard array indexing syntax.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.s_[2::2] slice(2, None, 2) np.index_exp[2::2] (slice(2, None, 2),)</p>
-      <p>np.array([0, 1, 2, 3, 4])[np.s_[2::2]] array([2, 4])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26686">view source</a></div></div><div class="public anchor" id="var-safe_eval"><h3>safe_eval</h3><div class="usage"><code>(safe_eval source)</code></div><div class="doc"><div class="markdown"><p>Protected string evaluation.</p>
-<p>Evaluate a string containing a Python literal expression without allowing the execution of arbitrary non-literal code.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>source : str  The string to evaluate.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>obj : object  The result of evaluating <code>source</code>.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>SyntaxError  If the code has invalid Python syntax, or if it contains  non-literal code.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.safe_eval(‘1’) 1 np.safe_eval(‘[1, 2, 3]’) [1, 2, 3] np.safe_eval(‘{“foo”: (“bar”, 10.0)}’) {‘foo’: (‘bar’, 10.0)}</p>
-      <p>np.safe_eval(‘import os’) Traceback (most recent call last):  … SyntaxError: invalid syntax</p>
-      <p>np.safe_eval(‘open(“/home/user/.ssh/id_dsa”).read()’) Traceback (most recent call last):  … ValueError: malformed node or string: &lt;_ast.Call object at 0x…&gt;</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20137">view source</a></div></div><div class="public anchor" id="var-save"><h3>save</h3><div class="usage"><code>(save &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Save an array to a binary file in NumPy <code>.npy</code> format.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>file : file, str, or pathlib.Path  File or filename to which the data is saved. If file is a file-object,  then the filename is unchanged. If file is a string or Path, a <code>.npy</code>  extension will be appended to the filename if it does not already  have one. arr : array_like  Array data to be saved. allow_pickle : bool, optional  Allow saving object arrays using Python pickles. Reasons for disallowing  pickles include security (loading pickled data can execute arbitrary  code) and portability (pickled objects may not be loadable on different  Python installations, for example if the stored objects require libraries  that are not available, and not all pickled data is compatible between  Python 2 and Python 3).  Default: True fix_imports : bool, optional  Only useful in forcing objects in object arrays on Python 3 to be  pickled in a Python 2 compatible way. If <code>fix_imports</code> is True, pickle  will try to map the new Python 3 names to the old module names used in  Python 2, so that the pickle data stream is readable with Python 2.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>savez : Save several arrays into a <code>.npz</code> archive savetxt, load</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>For a description of the <code>.npy</code> format, see :py:mod:<code>numpy.lib.format</code>.</p>
-<p>Any data saved to the file is appended to the end of the file.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from tempfile import TemporaryFile outfile = TemporaryFile()</p>
-      <p>x = np.arange(10) np.save(outfile, x)</p>
-      <p>_ = outfile.seek(0) # Only needed here to simulate closing &amp; reopening file np.load(outfile) array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])</p>
-      <p>with open(‘test.npy’, ‘wb’) as f: … np.save(f, np.array([1, 2])) … np.save(f, np.array([1, 3])) with open(‘test.npy’, ‘rb’) as f: … a = np.load(f) … b = np.load(f) print(a, b)</p>
-      <h1><a href="#1-2" name="1-2"></a>[1 2] [1 3]</h1>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1427">view source</a></div></div><div class="public anchor" id="var-savetxt"><h3>savetxt</h3><div class="usage"><code>(savetxt &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Save an array to a text file.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>fname : filename or file handle  If the filename ends in <code>.gz</code>, the file is automatically saved in  compressed gzip format. <code>loadtxt</code> understands gzipped files  transparently. X : 1D or 2D array_like  Data to be saved to a text file. fmt : str or sequence of strs, optional  A single format (%10.5f), a sequence of formats, or a  multi-format string, e.g. ‘Iteration %d – %10.5f’, in which  case <code>delimiter</code> is ignored. For complex <code>X</code>, the legal options  for <code>fmt</code> are:</p>
-<pre><code>* a single specifier, `fmt='%.4e'`, resulting in numbers formatted
-  like `' (%s+%sj)' % (fmt, fmt)`
-* a full string specifying every real and imaginary part, e.g.
-  `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns
-* a list of specifiers, one per column - in this case, the real
-  and imaginary part must have separate specifiers,
-  e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns
-</code></pre>
-<p>delimiter : str, optional  String or character separating columns. newline : str, optional  String or character separating lines.</p>
-<pre><code>.. versionadded:: 1.5.0
-</code></pre>
-<p>header : str, optional  String that will be written at the beginning of the file.</p>
-<pre><code>.. versionadded:: 1.7.0
-</code></pre>
-<p>footer : str, optional  String that will be written at the end of the file.</p>
-<pre><code>.. versionadded:: 1.7.0
-</code></pre>
-<p>comments : str, optional  String that will be prepended to the <code>header</code> and <code>footer</code> strings,  to mark them as comments. Default: ‘# ’, as expected by e.g.  <code>numpy.loadtxt</code>.</p>
-<pre><code>.. versionadded:: 1.7.0
-</code></pre>
-<p>encoding : {None, str}, optional  Encoding used to encode the outputfile. Does not apply to output  streams. If the encoding is something other than ‘bytes’ or ‘latin1’  you will not be able to load the file in NumPy versions &lt; 1.14. Default  is ‘latin1’.</p>
-<pre><code>.. versionadded:: 1.14.0
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>save : Save an array to a binary file in NumPy <code>.npy</code> format savez : Save several arrays into an uncompressed <code>.npz</code> archive savez_compressed : Save several arrays into a compressed <code>.npz</code> archive</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Further explanation of the <code>fmt</code> parameter (<code>%[flag]width[.precision]specifier</code>):</p>
-<p>flags:  <code>-</code> : left justify</p>
-<pre><code>``+`` : Forces to precede result with + or -.
-
-``0`` : Left pad the number with zeros instead of space (see width).
-</code></pre>
-<p>width:  Minimum number of characters to be printed. The value is not truncated  if it has more characters.</p>
-<p>precision:  - For integer specifiers (eg. <code>d,i,o,x</code>), the minimum number of  digits.  - For <code>e, E</code> and <code>f</code> specifiers, the number of digits to print  after the decimal point.  - For <code>g</code> and <code>G</code>, the maximum number of significant digits.  - For <code>s</code>, the maximum number of characters.</p>
-<p>specifiers:  <code>c</code> : character</p>
-<pre><code>``d`` or ``i`` : signed decimal integer
-
-``e`` or ``E`` : scientific notation with ``e`` or ``E``.
-
-``f`` : decimal floating point
-
-``g,G`` : use the shorter of ``e,E`` or ``f``
-
-``o`` : signed octal
-
-``s`` : string of characters
-
-``u`` : unsigned decimal integer
-
-``x,X`` : unsigned hexadecimal integer
-</code></pre>
-<p>This explanation of <code>fmt</code> is not complete, for an exhaustive specification see [1]_.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] <code>Format Specification Mini-Language
-       &lt;https://docs.python.org/library/string.html#format-specification-mini-language&gt;</code>_,  Python Documentation.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = y = z = np.arange(0.0,5.0,1.0) np.savetxt(‘test.out’, x, delimiter=‘,’) # X is an array np.savetxt(‘test.out’, (x,y,z)) # x,y,z equal sized 1D arrays np.savetxt(‘test.out’, x, fmt=‘%1.4e’) # use exponential notation</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13223">view source</a></div></div><div class="public anchor" id="var-savez"><h3>savez</h3><div class="usage"><code>(savez &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Save several arrays into a single file in uncompressed <code>.npz</code> format.</p>
-<p>If arguments are passed in with no keywords, the corresponding variable names, in the <code>.npz</code> file, are ‘arr_0’, ‘arr_1’, etc. If keyword arguments are given, the corresponding variable names, in the <code>.npz</code> file will match the keyword names.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>file : str or file  Either the filename (string) or an open file (file-like object)  where the data will be saved. If file is a string or a Path, the  <code>.npz</code> extension will be appended to the filename if it is not  already there. args : Arguments, optional  Arrays to save to the file. Since it is not possible for Python to  know the names of the arrays outside <code>savez</code>, the arrays will be saved  with names “arr_0”, “arr_1”, and so on. These arguments can be any  expression. kwds : Keyword arguments, optional  Arrays to save to the file. Arrays will be saved in the file with the  keyword names.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>None</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>save : Save a single array to a binary file in NumPy format. savetxt : Save an array to a file as plain text. savez_compressed : Save several arrays into a compressed <code>.npz</code> archive</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The <code>.npz</code> file format is a zipped archive of files named after the variables they contain. The archive is not compressed and each file in the archive contains one variable in <code>.npy</code> format. For a description of the <code>.npy</code> format, see :py:mod:<code>numpy.lib.format</code>.</p>
-<p>When opening the saved <code>.npz</code> file with <code>load</code> a <code>NpzFile</code> object is returned. This is a dictionary-like object which can be queried for its list of arrays (with the <code>.files</code> attribute), and for the arrays themselves.</p>
-<p>When saving dictionaries, the dictionary keys become filenames inside the ZIP archive. Therefore, keys should be valid filenames. E.g., avoid keys that begin with <code>/</code> or contain <code>.</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from tempfile import TemporaryFile outfile = TemporaryFile() x = np.arange(10) y = np.sin(x)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using <code>savez</code> with *args, the arrays are saved with default names.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.savez(outfile, x, y) _ = outfile.seek(0) # Only needed here to simulate closing &amp; reopening file npzfile = np.load(outfile) npzfile.files [‘arr_0’, ‘arr_1’] npzfile[‘arr_0’] array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Using <code>savez</code> with **kwds, the arrays are saved with the keyword names.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>outfile = TemporaryFile() np.savez(outfile, x=x, y=y) _ = outfile.seek(0) npzfile = np.load(outfile) sorted(npzfile.files) [‘x’, ‘y’] npzfile[‘x’] array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27721">view source</a></div></div><div class="public anchor" id="var-savez_compressed"><h3>savez_compressed</h3><div class="usage"><code>(savez_compressed &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Save several arrays into a single file in compressed <code>.npz</code> format.</p>
-<p>If keyword arguments are given, then filenames are taken from the keywords. If arguments are passed in with no keywords, then stored filenames are arr_0, arr_1, etc.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>file : str or file  Either the filename (string) or an open file (file-like object)  where the data will be saved. If file is a string or a Path, the  <code>.npz</code> extension will be appended to the filename if it is not  already there. args : Arguments, optional  Arrays to save to the file. Since it is not possible for Python to  know the names of the arrays outside <code>savez</code>, the arrays will be saved  with names “arr_0”, “arr_1”, and so on. These arguments can be any  expression. kwds : Keyword arguments, optional  Arrays to save to the file. Arrays will be saved in the file with the  keyword names.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>None</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.save : Save a single array to a binary file in NumPy format. numpy.savetxt : Save an array to a file as plain text. numpy.savez : Save several arrays into an uncompressed <code>.npz</code> file format numpy.load : Load the files created by savez_compressed.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The <code>.npz</code> file format is a zipped archive of files named after the variables they contain. The archive is compressed with <code>zipfile.ZIP_DEFLATED</code> and each file in the archive contains one variable in <code>.npy</code> format. For a description of the <code>.npy</code> format, see :py:mod:<code>numpy.lib.format</code>.</p>
-<p>When opening the saved <code>.npz</code> file with <code>load</code> a <code>NpzFile</code> object is returned. This is a dictionary-like object which can be queried for its list of arrays (with the <code>.files</code> attribute), and for the arrays themselves.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>test_array = np.random.rand(3, 2) test_vector = np.random.rand(4) np.savez_compressed(‘/tmp/123’, a=test_array, b=test_vector) loaded = np.load(‘/tmp/123.npz’) print(np.array_equal(test_array, loaded[‘a’])) True print(np.array_equal(test_vector, loaded[‘b’])) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5819">view source</a></div></div><div class="public anchor" id="var-ScalarType"><h3>ScalarType</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Built-in immutable sequence.</p>
-<p>If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.</p>
-<p>If the argument is a tuple, the return value is the same object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22011">view source</a></div></div><div class="public anchor" id="var-sctype2char"><h3>sctype2char</h3><div class="usage"><code>(sctype2char sctype)</code></div><div class="doc"><div class="markdown"><p>Return the string representation of a scalar dtype.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>sctype : scalar dtype or object  If a scalar dtype, the corresponding string character is  returned. If an object, <code>sctype2char</code> tries to infer its scalar type  and then return the corresponding string character.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>typechar : str  The string character corresponding to the scalar type.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If <code>sctype</code> is an object for which the type can not be inferred.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>obj2sctype, issctype, issubsctype, mintypecode</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]: … print(np.sctype2char(sctype)) l # may vary d D S O</p>
-      <p>x = np.array([1., 2-1.j]) np.sctype2char(x) ‘D’ np.sctype2char(list) ‘O’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1649">view source</a></div></div><div class="public anchor" id="var-sctypeDict"><h3>sctypeDict</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16794">view source</a></div></div><div class="public anchor" id="var-sctypeNA"><h3>sctypeNA</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11195">view source</a></div></div><div class="public anchor" id="var-sctypes"><h3>sctypes</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2123">view source</a></div></div><div class="public anchor" id="var-searchsorted"><h3>searchsorted</h3><div class="usage"><code>(searchsorted &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find indices where elements should be inserted to maintain order.</p>
-<p>Find the indices into a sorted array <code>a</code> such that, if the corresponding elements in <code>v</code> were inserted before the indices, the order of <code>a</code> would be preserved.</p>
-<p>Assuming that <code>a</code> is sorted:</p>
-<p>====== ============================ <code>side</code> returned index <code>i</code> satisfies ====== ============================ left <code>a[i-1] &lt; v &lt;= a[i]</code> right <code>a[i-1] &lt;= v &lt; a[i]</code> ====== ============================</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : 1-D array_like  Input array. If <code>sorter</code> is None, then it must be sorted in  ascending order, otherwise <code>sorter</code> must be an array of indices  that sort it. v : array_like  Values to insert into <code>a</code>. side : {‘left’, ‘right’}, optional  If ‘left’, the index of the first suitable location found is given.  If ‘right’, return the last such index. If there is no suitable  index, return either 0 or N (where N is the length of <code>a</code>). sorter : 1-D array_like, optional  Optional array of integer indices that sort array a into ascending  order. They are typically the result of argsort.</p>
-<pre><code>.. versionadded:: 1.7.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>indices : array of ints  Array of insertion points with the same shape as <code>v</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>sort : Return a sorted copy of an array. histogram : Produce histogram from 1-D data.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Binary search is used to find the required insertion points.</p>
-<p>As of NumPy 1.4.0 <code>searchsorted</code> works with real/complex arrays containing <code>nan</code> values. The enhanced sort order is documented in <code>sort</code>.</p>
-<p>This function uses the same algorithm as the builtin python <code>bisect.bisect_left</code> (<code>side='left'</code>) and <code>bisect.bisect_right</code> (<code>side='right'</code>) functions, which is also vectorized in the <code>v</code> argument.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.searchsorted([1,2,3,4,5], 3) 2 np.searchsorted([1,2,3,4,5], 3, side=‘right’) 3 np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3]) array([0, 5, 1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15809">view source</a></div></div><div class="public anchor" id="var-select"><h3>select</h3><div class="usage"><code>(select &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an array drawn from elements in choicelist, depending on conditions.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>condlist : list of bool ndarrays  The list of conditions which determine from which array in <code>choicelist</code>  the output elements are taken. When multiple conditions are satisfied,  the first one encountered in <code>condlist</code> is used. choicelist : list of ndarrays  The list of arrays from which the output elements are taken. It has  to be of the same length as <code>condlist</code>. default : scalar, optional  The element inserted in <code>output</code> when all conditions evaluate to False.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>output : ndarray  The output at position m is the m-th element of the array in  <code>choicelist</code> where the m-th element of the corresponding array in  <code>condlist</code> is True.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>where : Return elements from one of two arrays depending on condition. take, choose, compress, diag, diagonal</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(10) condlist = [x&lt;3, x&gt;5] choicelist = [x, x**2] np.select(condlist, choicelist) array([ 0, 1, 2, …, 49, 64, 81])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16860">view source</a></div></div><div class="public anchor" id="var-set_numeric_ops"><h3>set_numeric_ops</h3><div class="usage"><code>(set_numeric_ops self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>set_numeric_ops(op1=func1, op2=func2, …)</p>
-<p>Set numerical operators for array objects.</p>
-<p>.. deprecated:: 1.16</p>
-<pre><code>For the general case, use :c:func:`PyUFunc_ReplaceLoopBySignature`.
-For ndarray subclasses, define the ``__array_ufunc__`` method and
-override the relevant ufunc.
-</code></pre>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>op1, op2, … : callable  Each <code>op = func</code> pair describes an operator to be replaced.  For example, <code>add = lambda x, y: np.add(x, y) % 5</code> would replace  addition by modulus 5 addition.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>saved_ops : list of callables  A list of all operators, stored before making replacements.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. WARNING::  Use with care! Incorrect usage may lead to memory errors.</p>
-<p>A function replacing an operator cannot make use of that operator. For example, when replacing add, you may not use <code>+</code>. Instead, directly call ufuncs.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>def add_mod5(x, y): … return np.add(x, y) % 5 … old_funcs = np.set_numeric_ops(add=add_mod5)</p>
-      <p>x = np.arange(12).reshape((3, 4)) x + x array(<a href="null">0, 2, 4, 1],
-       [3, 0, 2, 4],
-       [1, 3, 0, 2</a>)</p>
-      <p>ignore = np.set_numeric_ops(**old_funcs) # restore operators</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10917">view source</a></div></div><div class="public anchor" id="var-set_printoptions"><h3>set_printoptions</h3><div class="usage"><code>(set_printoptions &amp; [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, sign :sign, formatter :formatter, precision :precision, floatmode :floatmode, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}])</code><code>(set_printoptions &amp; [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, sign :sign, formatter :formatter, precision :precision, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}])</code><code>(set_printoptions &amp; [{infstr :infstr, linewidth :linewidth, suppress :suppress, :as kwarg, formatter :formatter, precision :precision, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, nanstr :nanstr, infstr :infstr, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, nanstr :nanstr, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, edgeitems :edgeitems, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, threshold :threshold, :as kwarg}])</code><code>(set_printoptions &amp; [{precision :precision, :as kwarg}])</code><code>(set_printoptions &amp; [{:as kwarg}])</code></div><div class="doc"><div class="markdown"><p>Set printing options.</p>
-<p>These options determine the way floating point numbers, arrays and other NumPy objects are displayed.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>precision : int or None, optional  Number of digits of precision for floating point output (default 8).  May be None if <code>floatmode</code> is not <code>fixed</code>, to print as many digits as  necessary to uniquely specify the value. threshold : int, optional  Total number of array elements which trigger summarization  rather than full repr (default 1000).  To always use the full repr without summarization, pass <code>sys.maxsize</code>. edgeitems : int, optional  Number of array items in summary at beginning and end of  each dimension (default 3). linewidth : int, optional  The number of characters per line for the purpose of inserting  line breaks (default 75). suppress : bool, optional  If True, always print floating point numbers using fixed point  notation, in which case numbers equal to zero in the current precision  will print as zero. If False, then scientific notation is used when  absolute value of the smallest number is &lt; 1e-4 or the ratio of the
-    maximum absolute value to the minimum is &gt; 1e3. The default is False. nanstr : str, optional  String representation of floating point not-a-number (default nan). infstr : str, optional  String representation of floating point infinity (default inf). sign : string, either ‘-’, ‘+’, or ‘ ’, optional  Controls printing of the sign of floating-point types. If ‘+’, always  print the sign of positive values. If ‘ ’, always prints a space  (whitespace character) in the sign position of positive values. If  ‘-’, omit the sign character of positive values. (default ‘-’) formatter : dict of callables, optional  If not None, the keys should indicate the type(s) that the respective  formatting function applies to. Callables should return a string.  Types that are not specified (by their corresponding keys) are handled  by the default formatters. Individual types for which a formatter  can be set are:</p>
-<pre><code>- 'bool'
-- 'int'
-- 'timedelta' : a `numpy.timedelta64`
-- 'datetime' : a `numpy.datetime64`
-- 'float'
-- 'longfloat' : 128-bit floats
-- 'complexfloat'
-- 'longcomplexfloat' : composed of two 128-bit floats
-- 'numpystr' : types `numpy.string_` and `numpy.unicode_`
-- 'object' : `np.object_` arrays
-- 'str' : all other strings
-
-Other keys that can be used to set a group of types at once are:
-
-- 'all' : sets all types
-- 'int_kind' : sets 'int'
-- 'float_kind' : sets 'float' and 'longfloat'
-- 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
-- 'str_kind' : sets 'str' and 'numpystr'
-</code></pre>
-<p>floatmode : str, optional  Controls the interpretation of the <code>precision</code> option for  floating-point types. Can take the following values  (default maxprec_equal):</p>
-<pre><code>* 'fixed': Always print exactly `precision` fractional digits,
-        even if this would print more or fewer digits than
-        necessary to specify the value uniquely.
-* 'unique': Print the minimum number of fractional digits necessary
-        to represent each value uniquely. Different elements may
-        have a different number of digits. The value of the
-        `precision` option is ignored.
-* 'maxprec': Print at most `precision` fractional digits, but if
-        an element can be uniquely represented with fewer digits
-        only print it with that many.
-* 'maxprec_equal': Print at most `precision` fractional digits,
-        but if every element in the array can be uniquely
-        represented with an equal number of fewer digits, use that
-        many digits for all elements.
-</code></pre>
-<p>legacy : string or <code>False</code>, optional  If set to the string <code>'1.13'</code> enables 1.13 legacy printing mode. This  approximates numpy 1.13 print output by including a space in the sign  position of floats and different behavior for 0d arrays. If set to  <code>False</code>, disables legacy mode. Unrecognized strings will be ignored  with a warning for forward compatibility.</p>
-<pre><code>.. versionadded:: 1.14.0
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>get_printoptions, printoptions, set_string_function, array2string</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>formatter</code> is always reset with a call to <code>set_printoptions</code>.</p>
-<p>Use <code>printoptions</code> as a context manager to set the values temporarily.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Floating point precision can be set:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.set_printoptions(precision=4) np.array([1.123456789]) [1.1235]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Long arrays can be summarised:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.set_printoptions(threshold=5) np.arange(10) array([0, 1, 2, …, 7, 8, 9])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Small results can be suppressed:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>eps = np.finfo(float).eps x = np.arange(4.) x**2 - (x + eps)**2 array([-4.9304e-32, -4.4409e-16, 0.0000e+00, 0.0000e+00]) np.set_printoptions(suppress=True) x**2 - (x + eps)**2 array([-0., -0., 0., 0.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>A custom formatter can be used to display array elements as desired:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.set_printoptions(formatter={‘all’:lambda x: ‘int: ’+str(-x)}) x = np.arange(3) x array([int: 0, int: -1, int: -2]) np.set_printoptions() # formatter gets reset x array([0, 1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>To put back the default options, you can use:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.set_printoptions(edgeitems=3, infstr=‘inf’, … linewidth=75, nanstr=‘nan’, precision=8, … suppress=False, threshold=1000, formatter=None)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Also to temporarily override options, use <code>printoptions</code> as a context manager:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>with np.printoptions(precision=2, suppress=True, threshold=5): … np.linspace(0, 10, 10) array([ 0. , 1.11, 2.22, …, 7.78, 8.89, 10. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2782">view source</a></div></div><div class="public anchor" id="var-set_string_function"><h3>set_string_function</h3><div class="usage"><code>(set_string_function f &amp; [{repr :repr}])</code><code>(set_string_function f)</code></div><div class="doc"><div class="markdown"><p>Set a Python function to be used when pretty printing arrays.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>f : function or None  Function to be used to pretty print arrays. The function should expect  a single array argument and return a string of the representation of  the array. If None, the function is reset to the default NumPy function  to print arrays. repr : bool, optional  If True (default), the function for pretty printing (<code>__repr__</code>)  is set, if False the function that returns the default string  representation (<code>__str__</code>) is set.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>set_printoptions, get_printoptions</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>def pprint(arr): … return ‘HA! - What are you going to do now?’ … np.set_string_function(pprint) a = np.arange(10) a HA! - What are you going to do now? _ = a</p>
-      <h1><a href="#0-1-2-3-4-5-6-7-8-9" name="0-1-2-3-4-5-6-7-8-9"></a>[0 1 2 3 4 5 6 7 8 9]</h1>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>We can reset the function to the default:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.set_string_function(None) a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p><code>repr</code> affects either pretty printing or normal string representation. Note that <code>__repr__</code> is still affected by setting <code>__str__</code> because the width of each array element in the returned string becomes equal to the length of the result of <code>__str__()</code>.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(4) np.set_string_function(lambda x:‘random’, repr=False) x.__str__() ‘random’ x.__repr__() ‘array([0, 1, 2, 3])’</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23940">view source</a></div></div><div class="public anchor" id="var-setbufsize"><h3>setbufsize</h3><div class="usage"><code>(setbufsize size)</code></div><div class="doc"><div class="markdown"><p>Set the size of the buffer used in ufuncs.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>size : int  Size of buffer.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9533">view source</a></div></div><div class="public anchor" id="var-setdiff1d"><h3>setdiff1d</h3><div class="usage"><code>(setdiff1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the set difference of two arrays.</p>
-<p>Return the unique values in <code>ar1</code> that are not in <code>ar2</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>ar1 : array_like  Input array. ar2 : array_like  Input comparison array. assume_unique : bool  If True, the input arrays are both assumed to be unique, which  can speed up the calculation. Default is False.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>setdiff1d : ndarray  1D array of values in <code>ar1</code> that are not in <code>ar2</code>. The result  is sorted when <code>assume_unique=False</code>, but otherwise only sorted  if the input is sorted.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1, 2, 3, 2, 4, 1]) b = np.array([3, 4, 5, 6]) np.setdiff1d(a, b) array([1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16287">view source</a></div></div><div class="public anchor" id="var-seterr"><h3>seterr</h3><div class="usage"><code>(seterr &amp; [{all :all, divide :divide, over :over, under :under, invalid :invalid}])</code><code>(seterr &amp; [{all :all, divide :divide, over :over, under :under}])</code><code>(seterr &amp; [{all :all, divide :divide, over :over}])</code><code>(seterr &amp; [{all :all, divide :divide}])</code><code>(seterr &amp; [{all :all}])</code><code>(seterr)</code></div><div class="doc"><div class="markdown"><p>Set how floating-point errors are handled.</p>
-<p>Note that operations on integer scalar types (such as <code>int16</code>) are handled like floating point, and are affected by these settings.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>all : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional  Set treatment for all types of floating-point errors at once:</p>
-<pre><code>- ignore: Take no action when the exception occurs.
-- warn: Print a `RuntimeWarning` (via the Python `warnings` module).
-- raise: Raise a `FloatingPointError`.
-- call: Call a function specified using the `seterrcall` function.
-- print: Print a warning directly to ``stdout``.
-- log: Record error in a Log object specified by `seterrcall`.
-
-The default is not to change the current behavior.
-</code></pre>
-<p>divide : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional  Treatment for division by zero. over : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional  Treatment for floating-point overflow. under : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional  Treatment for floating-point underflow. invalid : {‘ignore’, ‘warn’, ‘raise’, ‘call’, ‘print’, ‘log’}, optional  Treatment for invalid floating-point operation.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>old_settings : dict  Dictionary containing the old settings.</p>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>seterrcall : Set a callback function for the ‘call’ mode. geterr, geterrcall, errstate</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The floating-point exceptions are defined in the IEEE 754 standard [1]_:</p>
-<ul>
-  <li>Division by zero: infinite result obtained from finite numbers.</li>
-  <li>Overflow: result too large to be expressed.</li>
-  <li>Underflow: result so close to zero that some precision  was lost.</li>
-  <li>Invalid operation: result is not an expressible number, typically  indicates that a NaN was produced.</li>
-</ul>
-<p>.. [1] <a href="https://en.wikipedia.org/wiki/IEEE_754">https://en.wikipedia.org/wiki/IEEE_754</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>old_settings = np.seterr(all=‘ignore’) #seterr to known value np.seterr(over=‘raise’) {‘divide’: ‘ignore’, ‘over’: ‘ignore’, ‘under’: ‘ignore’, ‘invalid’: ‘ignore’} np.seterr(**old_settings) # reset to default {‘divide’: ‘ignore’, ‘over’: ‘raise’, ‘under’: ‘ignore’, ‘invalid’: ‘ignore’}</p>
-      <p>np.int16(32000) * np.int16(3) 30464 old_settings = np.seterr(all=‘warn’, over=‘raise’) np.int16(32000) * np.int16(3) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> FloatingPointError: overflow encountered in short_scalars</module></stdin></p>
-      <p>from collections import OrderedDict old_settings = np.seterr(all=‘print’) OrderedDict(np.geterr()) OrderedDict([(‘divide’, ‘print’), (‘over’, ‘print’), (‘under’, ‘print’), (‘invalid’, ‘print’)]) np.int16(32000) * np.int16(3) 30464</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2347">view source</a></div></div><div class="public anchor" id="var-seterrcall"><h3>seterrcall</h3><div class="usage"><code>(seterrcall func)</code></div><div class="doc"><div class="markdown"><p>Set the floating-point error callback function or log object.</p>
-<p>There are two ways to capture floating-point error messages. The first is to set the error-handler to ‘call’, using <code>seterr</code>. Then, set the function to call using this function.</p>
-<p>The second is to set the error-handler to ‘log’, using <code>seterr</code>. Floating-point errors then trigger a call to the ‘write’ method of the provided object.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>func : callable f(err, flag) or object with write method  Function to call upon floating-point errors (‘call’-mode) or  object whose ‘write’ method is used to log such message (‘log’-mode).</p>
-<pre><code>The call function takes two arguments. The first is a string describing
-the type of error (such as "divide by zero", "overflow", "underflow",
-or "invalid value"), and the second is the status flag.  The flag is a
-byte, whose four least-significant bits indicate the type of error, one
-of "divide", "over", "under", "invalid"::
-
-  [0 0 0 0 divide over under invalid]
-
-In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.
-
-If an object is provided, its write method should take one argument,
-a string.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>h : callable, log instance or None  The old error handler.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>seterr, geterr, geterrcall</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Callback upon error:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>def err_handler(type, flag): … print(“Floating point error (%s), with flag %s” % (type, flag)) …</p>
-      <p>saved_handler = np.seterrcall(err_handler) save_err = np.seterr(all=‘call’) from collections import OrderedDict</p>
-      <p>np.array([1, 2, 3]) / 0.0 Floating point error (divide by zero), with flag 1 array([inf, inf, inf])</p>
-      <p>np.seterrcall(saved_handler) &lt;function err_handler at 0x…&gt; OrderedDict(sorted(np.seterr(**save_err).items())) OrderedDict([(‘divide’, ‘call’), (‘invalid’, ‘call’), (‘over’, ‘call’), (‘under’, ‘call’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Log error message:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>class Log(object): … def write(self, msg): … print(“LOG: %s” % msg) …</p>
-      <p>log = Log() saved_handler = np.seterrcall(log) save_err = np.seterr(all=‘log’)</p>
-      <p>np.array([1, 2, 3]) / 0.0 LOG: Warning: divide by zero encountered in true_divide array([inf, inf, inf])</p>
-      <p>np.seterrcall(saved_handler) &lt;numpy.core.numeric.Log object at 0x…&gt; OrderedDict(sorted(np.seterr(**save_err).items())) OrderedDict([(‘divide’, ‘log’), (‘invalid’, ‘log’), (‘over’, ‘log’), (‘under’, ‘log’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11939">view source</a></div></div><div class="public anchor" id="var-seterrobj"><h3>seterrobj</h3><div class="usage"><code>(seterrobj self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>seterrobj(errobj)</p>
-<p>Set the object that defines floating-point error handling.</p>
-<p>The error object contains all information that defines the error handling behavior in NumPy. <code>seterrobj</code> is used internally by the other functions that set error handling behavior (<code>seterr</code>, <code>seterrcall</code>).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>errobj : list  The error object, a list containing three elements:  [internal numpy buffer size, error mask, error callback function].</p>
-<pre><code>The error mask is a single integer that holds the treatment information
-on all four floating point errors. The information for each error type
-is contained in three bits of the integer. If we print it in base 8, we
-can see what treatment is set for "invalid", "under", "over", and
-"divide" (in that order). The printed string can be interpreted with
-
-* 0 : 'ignore'
-* 1 : 'warn'
-* 2 : 'raise'
-* 3 : 'call'
-* 4 : 'print'
-* 5 : 'log'
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>geterrobj, seterr, geterr, seterrcall, geterrcall getbufsize, setbufsize</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>For complete documentation of the types of floating-point exceptions and treatment options, see <code>seterr</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>old_errobj = np.geterrobj() # first get the defaults old_errobj [8192, 521, None]</p>
-      <p>def err_handler(type, flag): … print(“Floating point error (%s), with flag %s” % (type, flag)) … new_errobj = [20000, 12, err_handler] np.seterrobj(new_errobj) np.base_repr(12, 8) # int for divide=4 (‘print’) and over=1 (‘warn’) ‘14’ np.geterr() {‘over’: ‘warn’, ‘divide’: ‘print’, ‘invalid’: ‘ignore’, ‘under’: ‘ignore’} np.geterrcall() is err_handler True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27456">view source</a></div></div><div class="public anchor" id="var-setxor1d"><h3>setxor1d</h3><div class="usage"><code>(setxor1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the set exclusive-or of two arrays.</p>
-<p>Return the sorted, unique values that are in only one (not both) of the input arrays.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>ar1, ar2 : array_like  Input arrays. assume_unique : bool  If True, the input arrays are both assumed to be unique, which  can speed up the calculation. Default is False.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>setxor1d : ndarray  Sorted 1D array of unique values that are in only one of the input  arrays.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1, 2, 3, 2, 4]) b = np.array([2, 3, 5, 7, 5]) np.setxor1d(a,b) array([1, 4, 5, 7])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4823">view source</a></div></div><div class="public anchor" id="var-shape"><h3>shape</h3><div class="usage"><code>(shape &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the shape of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>shape : tuple of ints  The elements of the shape tuple give the lengths of the  corresponding array dimensions.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>alen ndarray.shape : Equivalent array method.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.shape(np.eye(3)) (3, 3) np.shape(<a href="null">1, 2</a>) (1, 2) np.shape([0]) (1,) np.shape(0) ()</p>
-      <p>a = np.array([(1, 2), (3, 4)], dtype=[(‘x’, ‘i4’), (‘y’, ‘i4’)]) np.shape(a) (2,) a.shape (2,)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5579">view source</a></div></div><div class="public anchor" id="var-shares_memory"><h3>shares_memory</h3><div class="usage"><code>(shares_memory &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>shares_memory(a, b, max_work=None)</p>
-<p>Determine if two arrays share memory</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a, b : ndarray  Input arrays max_work : int, optional  Effort to spend on solving the overlap problem (maximum number  of candidate solutions to consider). The following special  values are recognized:</p>
-<pre><code>max_work=MAY_SHARE_EXACT  (default)
-    The problem is solved exactly. In this case, the function returns
-    True only if there is an element shared between the arrays.
-max_work=MAY_SHARE_BOUNDS
-    Only the memory bounds of a and b are checked.
-</code></pre>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>numpy.TooHardError  Exceeded max_work.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : bool</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>may_share_memory</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.may_share_memory(np.array([1,2]), np.array([5,8,9])) False</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11412">view source</a></div></div><div class="public anchor" id="var-SHIFT_DIVIDEBYZERO"><h3>SHIFT_DIVIDEBYZERO</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16670">view source</a></div></div><div class="public anchor" id="var-SHIFT_INVALID"><h3>SHIFT_INVALID</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2072">view source</a></div></div><div class="public anchor" id="var-SHIFT_OVERFLOW"><h3>SHIFT_OVERFLOW</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12034">view source</a></div></div><div class="public anchor" id="var-SHIFT_UNDERFLOW"><h3>SHIFT_UNDERFLOW</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21615">view source</a></div></div><div class="public anchor" id="var-short"><h3>short</h3><div class="usage"><code>(short self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>short</code>. Character code: <code>'h'</code>. Canonical name: <code>np.short</code>. Alias <em>on this platform</em>: <code>np.int16</code>: 16-bit signed integer (-32768 to 32767).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12397">view source</a></div></div><div class="public anchor" id="var-show_config"><h3>show_config</h3><div class="usage"><code>(show_config)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20946">view source</a></div></div><div class="public anchor" id="var-sign"><h3>sign</h3><div class="usage"><code>(sign self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>sign(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Returns an element-wise indication of the sign of a number.</p>
-<p>The <code>sign</code> function returns <code>-1 if x &lt; 0, 0 if x==0, 1 if x &gt; 0</code>. nan is returned for nan inputs.</p>
-<p>For complex inputs, the <code>sign</code> function returns <code>sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j</code>.</p>
-<p>complex(nan, 0) is returned for complex nan inputs.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input values. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The sign of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>There is more than one definition of sign in common use for complex numbers. The definition used here is equivalent to :math:<code>x/\sqrt{x*x}</code> which is different from a common alternative, :math:<code>x/|x|</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sign([-5., 4.5]) array([-1., 1.]) np.sign(0) 0 np.sign(5-2j) (1+0j)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25917">view source</a></div></div><div class="public anchor" id="var-signbit"><h3>signbit</h3><div class="usage"><code>(signbit self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>signbit(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Returns element-wise True where signbit is set (less than zero).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  The input value(s). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>result : ndarray of bool  Output array, or reference to <code>out</code> if that was supplied.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.signbit(-1.2) True np.signbit(np.array([1, -2.3, 2.1])) array([False, True, False])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23258">view source</a></div></div><div class="public anchor" id="var-signedinteger"><h3>signedinteger</h3><div class="usage"><code>(signedinteger self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all signed integer scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13733">view source</a></div></div><div class="public anchor" id="var-sin"><h3>sin</h3><div class="usage"><code>(sin self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>sin(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Trigonometric sine, element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Angle, in radians (:math:<code>2 \pi</code> rad equals 360 degrees). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : array_like  The sine of each element of x.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>arcsin, sinh, cos</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The sine is one of the fundamental functions of trigonometry (the mathematical study of triangles). Consider a circle of radius 1 centered on the origin. A ray comes in from the :math:<code>+x</code> axis, makes an angle at the origin (measured counter-clockwise from that axis), and departs from the origin. The :math:<code>y</code> coordinate of the outgoing ray’s intersection with the unit circle is the sine of that angle. It ranges from -1 for :math:<code>x=3\pi / 2</code> to +1 for :math:<code>\pi / 2.</code> The function has zeroes where the angle is a multiple of :math:<code>\pi</code>. Sines of angles between :math:<code>\pi</code> and :math:<code>2\pi</code> are negative. The numerous properties of the sine and related functions are included in any standard trigonometry text.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Print sine of one angle:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sin(np.pi/2.) 1.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Print sines of an array of angles given in degrees:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. ) array([ 0. , 0.5 , 0.70710678, 0.8660254 , 1. ])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Plot the sine function:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pylab as plt x = np.linspace(-np.pi, np.pi, 201) plt.plot(x, np.sin(x)) plt.xlabel(‘Angle [rad]’) plt.ylabel(‘sin(x)’) plt.axis(‘tight’) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14648">view source</a></div></div><div class="public anchor" id="var-sinc"><h3>sinc</h3><div class="usage"><code>(sinc &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the sinc function.</p>
-<p>The sinc function is :math:<code>\sin(\pi x)/(\pi x)</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : ndarray  Array (possibly multi-dimensional) of values for which to to  calculate <code>sinc(x)</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  <code>sinc(x)</code>, which has the same shape as the input.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><code>sinc(0)</code> is the limit value 1.</p>
-<p>The name sinc is short for “sine cardinal” or “sinus cardinalis”.</p>
-<p>The sinc function is used in various signal processing applications, including in anti-aliasing, in the construction of a Lanczos resampling filter, and in interpolation.</p>
-<p>For bandlimited interpolation of discrete-time signals, the ideal interpolation kernel is proportional to the sinc function.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Weisstein, Eric W. “Sinc Function.” From MathWorld–A Wolfram Web  Resource. <a href="http://mathworld.wolfram.com/SincFunction.html">http://mathworld.wolfram.com/SincFunction.html</a> .. [2] Wikipedia, “Sinc function”,  <a href="https://en.wikipedia.org/wiki/Sinc_function">https://en.wikipedia.org/wiki/Sinc_function</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import matplotlib.pyplot as plt x = np.linspace(-4, 4, 41) np.sinc(x)  array([-3.89804309e-17, -4.92362781e-02, -8.40918587e-02, # may vary  -8.90384387e-02, -5.84680802e-02, 3.89804309e-17,  6.68206631e-02, 1.16434881e-01, 1.26137788e-01,  8.50444803e-02, -3.89804309e-17, -1.03943254e-01,  -1.89206682e-01, -2.16236208e-01, -1.55914881e-01,  3.89804309e-17, 2.33872321e-01, 5.04551152e-01,  7.56826729e-01, 9.35489284e-01, 1.00000000e+00,  9.35489284e-01, 7.56826729e-01, 5.04551152e-01,  2.33872321e-01, 3.89804309e-17, -1.55914881e-01,  -2.16236208e-01, -1.89206682e-01, -1.03943254e-01,  -3.89804309e-17, 8.50444803e-02, 1.26137788e-01,  1.16434881e-01, 6.68206631e-02, 3.89804309e-17,  -5.84680802e-02, -8.90384387e-02, -8.40918587e-02,  -4.92362781e-02, -3.89804309e-17])</p>
-      <p>plt.plot(x, np.sinc(x)) [&lt;matplotlib.lines.Line2D object at 0x…&gt;] plt.title(“Sinc Function”) Text(0.5, 1.0, ‘Sinc Function’) plt.ylabel(“Amplitude”) Text(0, 0.5, ‘Amplitude’) plt.xlabel(“X”) Text(0.5, 0, ‘X’) plt.show()</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17565">view source</a></div></div><div class="public anchor" id="var-single"><h3>single</h3><div class="usage"><code>(single self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Single-precision floating-point number type, compatible with C <code>float</code>. Character code: <code>'f'</code>. Canonical name: <code>np.single</code>. Alias <em>on this platform</em>: <code>np.float32</code>: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22984">view source</a></div></div><div class="public anchor" id="var-singlecomplex"><h3>singlecomplex</h3><div class="usage"><code>(singlecomplex self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Complex number type composed of two single-precision floating-point numbers. Character code: <code>'F'</code>. Canonical name: <code>np.csingle</code>. Alias: <code>np.singlecomplex</code>. Alias <em>on this platform</em>: <code>np.complex64</code>: Complex number type composed of 2 32-bit-precision floating-point numbers.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24359">view source</a></div></div><div class="public anchor" id="var-sinh"><h3>sinh</h3><div class="usage"><code>(sinh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>sinh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Hyperbolic sine, element-wise.</p>
-<p>Equivalent to <code>1/2 * (np.exp(x) - np.exp(-x))</code> or <code>-1j * np.sin(1j*x)</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The corresponding hyperbolic sine values.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If <code>out</code> is provided, the function writes the result into it, and returns a reference to <code>out</code>. (See Examples)</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. New York, NY: Dover, 1972, pg. 83.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sinh(0) 0.0 np.sinh(np.pi*1j/2) 1j np.sinh(np.pi*1j) # (exact value is 0) 1.2246063538223773e-016j</p>
-      <h1><a href="#discrepancy-due-to-vagaries-of-floating-point-arithmetic-" name="discrepancy-due-to-vagaries-of-floating-point-arithmetic-"></a>Discrepancy due to vagaries of floating point arithmetic.</h1>
-      <h1><a href="#example-of-providing-the-optional-output-parameter" name="example-of-providing-the-optional-output-parameter"></a>Example of providing the optional output parameter</h1>
-      <p>out1 = np.array([0], dtype=‘d’) out2 = np.sinh([0.1], out1) out2 is out1 True</p>
-      <h1><a href="#example-of-valueerror-due-to-provision-of-shape-mis-matched" name="example-of-valueerror-due-to-provision-of-shape-mis-matched"></a>Example of ValueError due to provision of shape mis-matched <code>out</code></h1>
-      <p>np.sinh(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> ValueError: operands could not be broadcast together with shapes (3,3) (2,2)</module></stdin></p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24394">view source</a></div></div><div class="public anchor" id="var-size"><h3>size</h3><div class="usage"><code>(size &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the number of elements along a given axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. axis : int, optional  Axis along which the elements are counted. By default, give  the total number of elements.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>element_count : int  Number of elements along the specified axis.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>shape : dimensions of array ndarray.shape : dimensions of array ndarray.size : number of elements in array</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1,2,3],[4,5,6</a>) np.size(a) 6 np.size(a,1) 3 np.size(a,0) 2</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23777">view source</a></div></div><div class="public anchor" id="var-sometrue"><h3>sometrue</h3><div class="usage"><code>(sometrue &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Check whether some values are true.</p>
-<p>Refer to <code>any</code> for full documentation.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>any : equivalent function; see for details.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24345">view source</a></div></div><div class="public anchor" id="var-sort"><h3>sort</h3><div class="usage"><code>(sort &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return a sorted copy of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array to be sorted. axis : int or None, optional  Axis along which to sort. If None, the array is flattened before  sorting. The default is -1, which sorts along the last axis. kind : {‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}, optional  Sorting algorithm. The default is ‘quicksort’. Note that both ‘stable’  and ‘mergesort’ use timsort or radix sort under the covers and, in general,  the actual implementation will vary with data type. The ‘mergesort’ option  is retained for backwards compatibility.</p>
-<pre><code>.. versionchanged:: 1.15.0.
-   The 'stable' option was added.
-</code></pre>
-<p>order : str or list of str, optional  When <code>a</code> is an array with fields defined, this argument specifies  which fields to compare first, second, etc. A single field can  be specified as a string, and not all fields need be specified,  but unspecified fields will still be used, in the order in which  they come up in the dtype, to break ties.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>sorted_array : ndarray  Array of the same type and shape as <code>a</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.sort : Method to sort an array in-place. argsort : Indirect sort. lexsort : Indirect stable sort on multiple keys. searchsorted : Find elements in a sorted array. partition : Partial sort.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The various sorting algorithms are characterized by their average speed, worst case performance, work space size, and whether they are stable. A stable sort keeps items with the same key in the same relative order. The four algorithms implemented in NumPy have the following properties:</p>
-<p>=========== ======= ============= ============ ========  kind speed worst case work space stable =========== ======= ============= ============ ======== ‘quicksort’ 1 O(n^2) 0 no ‘heapsort’ 3 O(n*log(n)) 0 no ‘mergesort’ 2 O(n*log(n)) ~n/2 yes ‘timsort’ 2 O(n*log(n)) ~n/2 yes =========== ======= ============= ============ ========</p>
-<p>.. note:: The datatype determines which of ‘mergesort’ or ‘timsort’  is actually used, even if ‘mergesort’ is specified. User selection  at a finer scale is not currently available.</p>
-<p>All the sort algorithms make temporary copies of the data when sorting along any but the last axis. Consequently, sorting along the last axis is faster and uses less space than sorting along any other axis.</p>
-<p>The sort order for complex numbers is lexicographic. If both the real and imaginary parts are non-nan then the order is determined by the real parts except when they are equal, in which case the order is determined by the imaginary parts.</p>
-<p>Previous to numpy 1.4.0 sorting real and complex arrays containing nan values led to undefined behaviour. In numpy versions &gt;= 1.4.0 nan values are sorted to the end. The extended sort order is:</p>
-<ul>
-  <li>Real: [R, nan]</li>
-  <li>Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]</li>
-</ul>
-<p>where R is a non-nan real value. Complex values with the same nan placements are sorted according to the non-nan part if it exists. Non-nan values are sorted as before.</p>
-<p>.. versionadded:: 1.12.0</p>
-<p>quicksort has been changed to <code>introsort &lt;https://en.wikipedia.org/wiki/Introsort&gt;</code>_. When sorting does not make enough progress it switches to <code>heapsort &lt;https://en.wikipedia.org/wiki/Heapsort&gt;</code>_. This implementation makes quicksort O(n*log(n)) in the worst case.</p>
-<p>‘stable’ automatically chooses the best stable sorting algorithm for the data type being sorted. It, along with ‘mergesort’ is currently mapped to <code>timsort &lt;https://en.wikipedia.org/wiki/Timsort&gt;</code>_ or <code>radix sort &lt;https://en.wikipedia.org/wiki/Radix_sort&gt;</code>_ depending on the data type. API forward compatibility currently limits the ability to select the implementation and it is hardwired for the different data types.</p>
-<p>.. versionadded:: 1.17.0</p>
-<p>Timsort is added for better performance on already or nearly sorted data. On random data timsort is almost identical to mergesort. It is now used for stable sort while quicksort is still the default sort if none is chosen. For timsort details, refer to <code>CPython listsort.txt &lt;https://github.com/python/cpython/blob/3.7/Objects/listsort.txt&gt;</code>_. ‘mergesort’ and ‘stable’ are mapped to radix sort for integer data types. Radix sort is an O(n) sort instead of O(n log n).</p>
-<p>.. versionchanged:: 1.17.0</p>
-<p>NaT now sorts to the end of arrays for consistency with NaN.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1,4],[3,1</a>) np.sort(a) # sort along the last axis array(<a href="null">1, 4],
-       [1, 3</a>) np.sort(a, axis=None) # sort the flattened array array([1, 1, 3, 4]) np.sort(a, axis=0) # sort along the first axis array(<a href="null">1, 1],
-       [3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Use the <code>order</code> keyword to specify a field to use when sorting a structured array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>dtype = [(‘name’, ‘S10’), (‘height’, float), (‘age’, int)] values = [(‘Arthur’, 1.8, 41), (‘Lancelot’, 1.9, 38), … (‘Galahad’, 1.7, 38)] a = np.array(values, dtype=dtype) # create a structured array np.sort(a, order=‘height’) # doctest: +SKIP array([(‘Galahad’, 1.7, 38), (‘Arthur’, 1.8, 41),  (‘Lancelot’, 1.8999999999999999, 38)],  dtype=[(‘name’, ‘|S10’), (‘height’, ‘&lt;f8’), (‘age’, ‘&lt;i4’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Sort by age, then height if ages are equal:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sort(a, order=[‘age’, ‘height’]) # doctest: +SKIP array([(‘Galahad’, 1.7, 38), (‘Lancelot’, 1.8999999999999999, 38),  (‘Arthur’, 1.8, 41)],  dtype=[(‘name’, ‘|S10’), (‘height’, ‘&lt;f8’), (‘age’, ‘&lt;i4’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12643">view source</a></div></div><div class="public anchor" id="var-sort_complex"><h3>sort_complex</h3><div class="usage"><code>(sort_complex &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Sort a complex array using the real part first, then the imaginary part.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : complex ndarray  Always returns a sorted complex array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sort_complex([5, 3, 6, 2, 1]) array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])</p>
-      <p>np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j]) array([1.+2.j, 2.-1.j, 3.-3.j, 3.-2.j, 3.+5.j])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20437">view source</a></div></div><div class="public anchor" id="var-source"><h3>source</h3><div class="usage"><code>(source object &amp; [{output :output}])</code><code>(source object)</code></div><div class="doc"><div class="markdown"><p>Print or write to a file the source code for a NumPy object.</p>
-<p>The source code is only returned for objects written in Python. Many functions and classes are defined in C and will therefore not return useful information.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>object : numpy object  Input object. This can be any object (function, class, module,  …). output : file object, optional  If <code>output</code> not supplied then source code is printed to screen  (sys.stdout). File object must be created with either write ‘w’ or  append ‘a’ modes.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>lookfor, info</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.source(np.interp) #doctest: +SKIP In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py def interp(x, xp, fp, left=None, right=None):  ""“…. (full docstring printed)”""  if isinstance(x, (float, int, number)):  return compiled_interp([x], xp, fp, left, right).item()  else:  return compiled_interp(x, xp, fp, left, right)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The source code is only returned for objects written in Python.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.source(np.array) #doctest: +SKIP Not available for this object.</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20351">view source</a></div></div><div class="public anchor" id="var-spacing"><h3>spacing</h3><div class="usage"><code>(spacing self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>spacing(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the distance between x and the nearest adjacent number.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Values to find the spacing of. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  The spacing of values of <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>It can be considered as a generalization of EPS: <code>spacing(np.float64(1)) == np.finfo(np.float64).eps</code>, and there should not be any representable number between <code>x + spacing(x)</code> and x for any finite x.</p>
-<p>Spacing of +- inf and NaN is NaN.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.spacing(1) == np.finfo(np.float64).eps True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2491">view source</a></div></div><div class="public anchor" id="var-split"><h3>split</h3><div class="usage"><code>(split &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Split an array into multiple sub-arrays as views into <code>ary</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>ary : ndarray  Array to be divided into sub-arrays. indices_or_sections : int or 1-D array  If <code>indices_or_sections</code> is an integer, N, the array will be divided  into N equal arrays along <code>axis</code>. If such a split is not possible,  an error is raised.</p>
-<pre><code>If `indices_or_sections` is a 1-D array of sorted integers, the entries
-indicate where along `axis` the array is split.  For example,
-``[2, 3]`` would, for ``axis=0``, result in
-
-  - ary[:2]
-  - ary[2:3]
-  - ary[3:]
-
-If an index exceeds the dimension of the array along `axis`,
-an empty sub-array is returned correspondingly.
-</code></pre>
-<p>axis : int, optional  The axis along which to split, default is 0.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>sub-arrays : list of ndarrays  A list of sub-arrays as views into <code>ary</code>.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If <code>indices_or_sections</code> is given as an integer, but  a split does not result in equal division.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>array_split : Split an array into multiple sub-arrays of equal or  near-equal size. Does not raise an exception if  an equal division cannot be made. hsplit : Split array into multiple sub-arrays horizontally (column-wise). vsplit : Split array into multiple sub-arrays vertically (row wise). dsplit : Split array into multiple sub-arrays along the 3rd axis (depth). concatenate : Join a sequence of arrays along an existing axis. stack : Join a sequence of arrays along a new axis. hstack : Stack arrays in sequence horizontally (column wise). vstack : Stack arrays in sequence vertically (row wise). dstack : Stack arrays in sequence depth wise (along third dimension).</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(9.0) np.split(x, 3) [array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7., 8.])]</p>
-      <p>x = np.arange(8.0) np.split(x, [3, 5, 6, 10]) [array([0., 1., 2.]),  array([3., 4.]),  array([5.]),  array([6., 7.]),  array([], dtype=float64)]</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17212">view source</a></div></div><div class="public anchor" id="var-sqrt"><h3>sqrt</h3><div class="usage"><code>(sqrt self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>sqrt(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the non-negative square-root of an array, element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  The values whose square-roots are required. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  An array of the same shape as <code>x</code>, containing the positive  square-root of each element in <code>x</code>. If any element in <code>x</code> is  complex, a complex array is returned (and the square-roots of  negative reals are calculated). If all of the elements in <code>x</code>  are real, so is <code>y</code>, with negative elements returning <code>nan</code>.  If <code>out</code> was provided, <code>y</code> is a reference to it.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>lib.scimath.sqrt  A version which returns complex numbers when given negative reals.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p><em>sqrt</em> has–consistent with common convention–as its branch cut the real “interval” [<code>-inf</code>, 0), and is continuous from above on it. A branch cut is a curve in the complex plane across which a given complex function fails to be continuous.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sqrt([1,4,9]) array([ 1., 2., 3.])</p>
-      <p>np.sqrt([4, -1, -3+4J]) array([ 2.+0.j, 0.+1.j, 1.+2.j])</p>
-      <p>np.sqrt([4, -1, np.inf]) array([ 2., nan, inf])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18184">view source</a></div></div><div class="public anchor" id="var-square"><h3>square</h3><div class="usage"><code>(square self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>square(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the element-wise square of the input.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input data. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  Element-wise <code>x*x</code>, of the same shape and dtype as <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.linalg.matrix_power sqrt power</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.square([-1j, 1]) array([-1.-0.j, 1.+0.j])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20252">view source</a></div></div><div class="public anchor" id="var-squeeze"><h3>squeeze</h3><div class="usage"><code>(squeeze &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Remove single-dimensional entries from the shape of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input data. axis : None or int or tuple of ints, optional  .. versionadded:: 1.7.0</p>
-<pre><code>Selects a subset of the single-dimensional entries in the
-shape. If an axis is selected with shape entry greater than
-one, an error is raised.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>squeezed : ndarray  The input array, but with all or a subset of the  dimensions of length 1 removed. This is always <code>a</code> itself  or a view into <code>a</code>.</p>
-<h2><a href="#raises" name="raises"></a>Raises</h2>
-<p>ValueError  If <code>axis</code> is not None, and an axis being squeezed is not of length 1</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>expand_dims : The inverse operation, adding singleton dimensions reshape : Insert, remove, and combine dimensions, and resize existing ones</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">[0], [1], [2</a>]) x.shape (1, 3, 1) np.squeeze(x).shape (3,) np.squeeze(x, axis=0).shape (3, 1) np.squeeze(x, axis=1).shape Traceback (most recent call last): … ValueError: cannot select an axis to squeeze out which has size not equal to one np.squeeze(x, axis=2).shape (1, 3)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3628">view source</a></div></div><div class="public anchor" id="var-stack"><h3>stack</h3><div class="usage"><code>(stack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Join a sequence of arrays along a new axis.</p>
-<p>The <code>axis</code> parameter specifies the index of the new axis in the dimensions of the result. For example, if <code>axis=0</code> it will be the first dimension and if <code>axis=-1</code> it will be the last dimension.</p>
-<p>.. versionadded:: 1.10.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arrays : sequence of array_like  Each array must have the same shape.</p>
-<p>axis : int, optional  The axis in the result array along which the input arrays are stacked.</p>
-<p>out : ndarray, optional  If provided, the destination to place the result. The shape must be  correct, matching that of what stack would have returned if no  out argument were specified.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>stacked : ndarray  The stacked array has one more dimension than the input arrays.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>concatenate : Join a sequence of arrays along an existing axis. split : Split array into a list of multiple sub-arrays of equal size. block : Assemble arrays from blocks.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>arrays = [np.random.randn(3, 4) for _ in range(10)] np.stack(arrays, axis=0).shape (10, 3, 4)</p>
-      <p>np.stack(arrays, axis=1).shape (3, 10, 4)</p>
-      <p>np.stack(arrays, axis=2).shape (3, 4, 10)</p>
-      <p>a = np.array([1, 2, 3]) b = np.array([2, 3, 4]) np.stack((a, b)) array(<a href="null">1, 2, 3],
-       [2, 3, 4</a>)</p>
-      <p>np.stack((a, b), axis=-1) array(<a href="null">1, 2],
-       [2, 3],
-       [3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27919">view source</a></div></div><div class="public anchor" id="var-std"><h3>std</h3><div class="usage"><code>(std &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the standard deviation along the specified axis.</p>
-<p>Returns the standard deviation, a measure of the spread of a distribution, of the array elements. The standard deviation is computed for the flattened array by default, otherwise over the specified axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Calculate the standard deviation of these values. axis : None or int or tuple of ints, optional  Axis or axes along which the standard deviation is computed. The  default is to compute the standard deviation of the flattened array.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If this is a tuple of ints, a standard deviation is performed over
-multiple axes, instead of a single axis or all the axes as before.
-</code></pre>
-<p>dtype : dtype, optional  Type to use in computing the standard deviation. For arrays of  integer type the default is float64, for arrays of float types it is  the same as the array type. out : ndarray, optional  Alternative output array in which to place the result. It must have  the same shape as the expected output but the type (of the calculated  values) will be cast if necessary. ddof : int, optional  Means Delta Degrees of Freedom. The divisor used in calculations  is <code>N - ddof</code>, where <code>N</code> represents the number of elements.  By default <code>ddof</code> is zero. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `std` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>standard_deviation : ndarray, see dtype parameter above.  If <code>out</code> is None, return a new array containing the standard deviation,  otherwise return a reference to the output array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>var, mean, nanmean, nanstd, nanvar ufuncs-output-type</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The standard deviation is the square root of the average of the squared deviations from the mean, i.e., <code>std = sqrt(mean(abs(x - x.mean())**2))</code>.</p>
-<p>The average squared deviation is normally calculated as <code>x.sum() / N</code>, where <code>N = len(x)</code>. If, however, <code>ddof</code> is specified, the divisor <code>N - ddof</code> is used instead. In standard statistical practice, <code>ddof=1</code> provides an unbiased estimator of the variance of the infinite population. <code>ddof=0</code> provides a maximum likelihood estimate of the variance for normally distributed variables. The standard deviation computed in this function is the square root of the estimated variance, so even with <code>ddof=1</code>, it will not be an unbiased estimate of the standard deviation per se.</p>
-<p>Note that, for complex numbers, <code>std</code> takes the absolute value before squaring, so that the result is always real and nonnegative.</p>
-<p>For floating-point input, the <em>std</em> is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for float32 (see example below). Specifying a higher-accuracy accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 2], [3, 4</a>) np.std(a) 1.1180339887498949 # may vary np.std(a, axis=0) array([1., 1.]) np.std(a, axis=1) array([0.5, 0.5])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>In single precision, std() can be inaccurate:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.zeros((2, 512*512), dtype=np.float32) a[0, :] = 1.0 a[1, :] = 0.1 np.std(a) 0.45000005</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Computing the standard deviation in float64 is more accurate:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.std(a, dtype=np.float64) 0.44999999925494177 # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3383">view source</a></div></div><div class="public anchor" id="var-str"><h3>str</h3><div class="usage"><code>(str self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>str(object=’’) -&gt; str str(bytes_or_buffer[, encoding[, errors]]) -&gt; str</p>
-<p>Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to ‘strict’.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7592">view source</a></div></div><div class="public anchor" id="var-str0"><h3>str0</h3><div class="usage"><code>(str0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17522">view source</a></div></div><div class="public anchor" id="var-str_"><h3>str_</h3><div class="usage"><code>(str_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24356">view source</a></div></div><div class="public anchor" id="var-string_"><h3>string_</h3><div class="usage"><code>(string_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L18536">view source</a></div></div><div class="public anchor" id="var-subtract"><h3>subtract</h3><div class="usage"><code>(subtract self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>subtract(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Subtract arguments, element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1, x2 : array_like  The arrays to be subtracted from each other. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The difference of <code>x1</code> and <code>x2</code>, element-wise.  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Equivalent to <code>x1 - x2</code> in terms of array broadcasting.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.subtract(1.0, 4.0) -3.0</p>
-      <p>x1 = np.arange(9.0).reshape((3, 3)) x2 = np.arange(3.0) np.subtract(x1, x2) array(<a href="null"> 0.,  0.,  0.],
-       [ 3.,  3.,  3.],
-       [ 6.,  6.,  6.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16748">view source</a></div></div><div class="public anchor" id="var-sum"><h3>sum</h3><div class="usage"><code>(sum &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Sum of array elements over a given axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Elements to sum. axis : None or int or tuple of ints, optional  Axis or axes along which a sum is performed. The default,  axis=None, will sum all of the elements of the input array. If  axis is negative it counts from the last to the first axis.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If axis is a tuple of ints, a sum is performed on all of the axes
-specified in the tuple instead of a single axis or all the axes as
-before.
-</code></pre>
-<p>dtype : dtype, optional  The type of the returned array and of the accumulator in which the  elements are summed. The dtype of <code>a</code> is used by default unless <code>a</code>  has an integer dtype of less precision than the default platform  integer. In that case, if <code>a</code> is signed then the platform integer  is used while if <code>a</code> is unsigned then an unsigned integer of the  same precision as the platform integer is used. out : ndarray, optional  Alternative output array in which to place the result. It must have  the same shape as the expected output, but the type of the output  values will be cast if necessary. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `sum` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<p>initial : scalar, optional  Starting value for the sum. See <code>~numpy.ufunc.reduce</code> for details.</p>
-<pre><code>.. versionadded:: 1.15.0
-</code></pre>
-<p>where : array_like of bool, optional  Elements to include in the sum. See <code>~numpy.ufunc.reduce</code> for details.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>sum_along_axis : ndarray  An array with the same shape as <code>a</code>, with the specified  axis removed. If <code>a</code> is a 0-d array, or if <code>axis</code> is None, a scalar  is returned. If an output array is specified, a reference to  <code>out</code> is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ndarray.sum : Equivalent method.</p>
-<p>add.reduce : Equivalent functionality of <code>add</code>.</p>
-<p>cumsum : Cumulative sum of array elements.</p>
-<p>trapz : Integration of array values using the composite trapezoidal rule.</p>
-<p>mean, average</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Arithmetic is modular when using integer types, and no error is raised on overflow.</p>
-<p>The sum of an empty array is the neutral element 0:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sum([]) 0.0</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>For floating point numbers the numerical precision of sum (and <code>np.add.reduce</code>) is in general limited by directly adding each number individually to the result causing rounding errors in every step. However, often numpy will use a numerically better approach (partial pairwise summation) leading to improved precision in many use-cases. This improved precision is always provided when no <code>axis</code> is given. When <code>axis</code> is given, it will depend on which axis is summed. Technically, to provide the best speed possible, the improved precision is only used when the summation is along the fast axis in memory. Note that the exact precision may vary depending on other parameters. In contrast to NumPy, Python’s <code>math.fsum</code> function uses a slower but more precise approach to summation. Especially when summing a large number of lower precision floating point numbers, such as <code>float32</code>, numerical errors can become significant. In such cases it can be advisable to use <code>dtype="float64"</code> to use a higher precision for the output.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sum([0.5, 1.5]) 2.0 np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32) 1 np.sum(<a href="null">0, 1], [0, 5</a>) 6 np.sum(<a href="null">0, 1], [0, 5</a>, axis=0) array([0, 6]) np.sum(<a href="null">0, 1], [0, 5</a>, axis=1) array([1, 5]) np.sum(<a href="null">0, 1], [np.nan, 5</a>, where=[False, True], axis=1) array([1., 5.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>If the accumulator is too small, overflow occurs:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.ones(128, dtype=np.int8).sum(dtype=np.int8) -128</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>You can also start the sum with a value other than zero:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sum([10], initial=5) 15</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7470">view source</a></div></div><div class="public anchor" id="var-swapaxes"><h3>swapaxes</h3><div class="usage"><code>(swapaxes &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Interchange two axes of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. axis1 : int  First axis. axis2 : int  Second axis.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>a_swapped : ndarray  For NumPy &gt;= 1.10.0, if <code>a</code> is an ndarray, then a view of <code>a</code> is  returned; otherwise a new array is created. For earlier NumPy  versions a view of <code>a</code> is returned only if the order of the  axes is changed, otherwise the input array is returned.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array(<a href="null">1,2,3</a>) np.swapaxes(x,0,1) array(<a href="null">1],
-       [2],
-       [3</a>)</p>
-      <p>x = np.array(<a href="null">[0,1],[2,3</a>,<a href="null">4,5],[6,7</a>]) x array(<a href="null">[0, 1],
-        [2, 3</a>,  <a href="null">4, 5],
-        [6, 7</a>])</p>
-      <p>np.swapaxes(x,0,2) array(<a href="null">[0, 4],
-        [2, 6</a>,  <a href="null">1, 5],
-        [3, 7</a>])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20391">view source</a></div></div><div class="public anchor" id="var-sys"><h3>sys</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>This module provides access to some objects used or maintained by the interpreter and to functions that interact strongly with the interpreter.</p>
-<p>Dynamic objects:</p>
-<p>argv – command line arguments; argv[0] is the script pathname if known path – module search path; path[0] is the script directory, else ’’ modules – dictionary of loaded modules</p>
-<p>displayhook – called to show results in an interactive session excepthook – called to handle any uncaught exception other than SystemExit  To customize printing in an interactive session or to install a custom  top-level exception handler, assign other functions to replace these.</p>
-<p>stdin – standard input file object; used by input() stdout – standard output file object; used by print() stderr – standard error object; used for error messages  By assigning other file objects (or objects that behave like files)  to these, it is possible to redirect all of the interpreter’s I/O.</p>
-<p>last_type – type of last uncaught exception last_value – value of last uncaught exception last_traceback – traceback of last uncaught exception  These three are only available in an interactive session after a  traceback has been printed.</p>
-<p>Static objects:</p>
-<p>builtin_module_names – tuple of module names built into this interpreter copyright – copyright notice pertaining to this interpreter exec_prefix – prefix used to find the machine-specific Python library executable – absolute path of the executable binary of the Python interpreter float_info – a named tuple with information about the float implementation. float_repr_style – string indicating the style of repr() output for floats hash_info – a named tuple with information about the hash algorithm. hexversion – version information encoded as a single integer implementation – Python implementation information. int_info – a named tuple with information about the int implementation. maxsize – the largest supported length of containers. maxunicode – the value of the largest Unicode code point platform – platform identifier prefix – prefix used to find the Python library thread_info – a named tuple with information about the thread implementation. version – the version of this interpreter as a string version_info – version information as a named tuple <strong>stdin</strong> – the original stdin; don’t touch! <strong>stdout</strong> – the original stdout; don’t touch! <strong>stderr</strong> – the original stderr; don’t touch! <strong>displayhook</strong> – the original displayhook; don’t touch! <strong>excepthook</strong> – the original excepthook; don’t touch!</p>
-<p>Functions:</p>
-<p>displayhook() – print an object to the screen, and save it in builtins._ excepthook() – print an exception and its traceback to sys.stderr exc_info() – return thread-safe information about the current exception exit() – exit the interpreter by raising SystemExit getdlopenflags() – returns flags to be used for dlopen() calls getprofile() – get the global profiling function getrefcount() – return the reference count for an object (plus one :-) getrecursionlimit() – return the max recursion depth for the interpreter getsizeof() – return the size of an object in bytes gettrace() – get the global debug tracing function setcheckinterval() – control how often the interpreter checks for events setdlopenflags() – set the flags to be used for dlopen() calls setprofile() – set the global profiling function setrecursionlimit() – set the max recursion depth for the interpreter settrace() – set the global debug tracing function</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23485">view source</a></div></div><div class="public anchor" id="var-take"><h3>take</h3><div class="usage"><code>(take &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Take elements from an array along an axis.</p>
-<p>When axis is not None, this function does the same thing as “fancy” indexing (indexing arrays using arrays); however, it can be easier to use if you need elements along a given axis. A call such as <code>np.take(arr, indices, axis=3)</code> is equivalent to <code>arr[:,:,:,indices,...]</code>.</p>
-<p>Explained without fancy indexing, this is equivalent to the following use of <code>ndindex</code>, which sets each of <code>ii</code>, <code>jj</code>, and <code>kk</code> to a tuple of indices::</p>
-<pre><code>Ni, Nk = a.shape[:axis], a.shape[axis+1:]
-Nj = indices.shape
-for ii in ndindex(Ni):
-    for jj in ndindex(Nj):
-        for kk in ndindex(Nk):
-            out[ii + jj + kk] = a[ii + (indices[jj],) + kk]
-</code></pre>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like (Ni…, M, Nk…)  The source array. indices : array_like (Nj…)  The indices of the values to extract.</p>
-<pre><code>.. versionadded:: 1.8.0
-
-Also allow scalars for indices.
-</code></pre>
-<p>axis : int, optional  The axis over which to select values. By default, the flattened  input array is used. out : ndarray, optional (Ni…, Nj…, Nk…)  If provided, the result will be placed in this array. It should  be of the appropriate shape and dtype. Note that <code>out</code> is always  buffered if <code>mode='raise'</code>; use other modes for better performance. mode : {‘raise’, ‘wrap’, ‘clip’}, optional  Specifies how out-of-bounds indices will behave.</p>
-<pre><code>* 'raise' -- raise an error (default)
-* 'wrap' -- wrap around
-* 'clip' -- clip to the range
-
-'clip' mode means that all indices that are too large are replaced
-by the index that addresses the last element along that axis. Note
-that this disables indexing with negative numbers.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray (Ni…, Nj…, Nk…)  The returned array has the same type as <code>a</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>compress : Take elements using a boolean mask ndarray.take : equivalent method take_along_axis : Take elements by matching the array and the index arrays</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>By eliminating the inner loop in the description above, and using <code>s_</code> to build simple slice objects, <code>take</code> can be expressed in terms of applying fancy indexing to each 1-d slice::</p>
-<pre><code>Ni, Nk = a.shape[:axis], a.shape[axis+1:]
-for ii in ndindex(Ni):
-    for kk in ndindex(Nj):
-        out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices]
-</code></pre>
-<p>For this reason, it is equivalent to (but faster than) the following use of <code>apply_along_axis</code>::</p>
-<pre><code>out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a)
-</code></pre>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = [4, 3, 5, 7, 6, 8] indices = [0, 1, 4] np.take(a, indices) array([4, 3, 6])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>In this example if <code>a</code> is an ndarray, “fancy” indexing can be used.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(a) a[indices] array([4, 3, 6])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>If <code>indices</code> is not one dimensional, the output also has these dimensions.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.take(a, <a href="null">0, 1], [2, 3</a>) array(<a href="null">4, 3],
-       [5, 7</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11788">view source</a></div></div><div class="public anchor" id="var-take_along_axis"><h3>take_along_axis</h3><div class="usage"><code>(take_along_axis &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Take values from the input array by matching 1d index and data slices.</p>
-<p>This iterates over matching 1d slices oriented along the specified axis in the index and data arrays, and uses the former to look up values in the latter. These slices can be different lengths.</p>
-<p>Functions returning an index along an axis, like <code>argsort</code> and <code>argpartition</code>, produce suitable indices for this function.</p>
-<p>.. versionadded:: 1.15.0</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr: ndarray (Ni…, M, Nk…)  Source array indices: ndarray (Ni…, J, Nk…)  Indices to take along each 1d slice of <code>arr</code>. This must match the  dimension of arr, but dimensions Ni and Nj only need to broadcast  against <code>arr</code>. axis: int  The axis to take 1d slices along. If axis is None, the input array is  treated as if it had first been flattened to 1d, for consistency with  <code>sort</code> and <code>argsort</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out: ndarray (Ni…, J, Nk…)  The indexed result.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>This is equivalent to (but faster than) the following use of <code>ndindex</code> and <code>s_</code>, which sets each of <code>ii</code> and <code>kk</code> to a tuple of indices::</p>
-<pre><code>Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
-J = indices.shape[axis]  # Need not equal M
-out = np.empty(Ni + (J,) + Nk)
-
-for ii in ndindex(Ni):
-    for kk in ndindex(Nk):
-        a_1d       = a      [ii + s_[:,] + kk]
-        indices_1d = indices[ii + s_[:,] + kk]
-        out_1d     = out    [ii + s_[:,] + kk]
-        for j in range(J):
-            out_1d[j] = a_1d[indices_1d[j]]
-</code></pre>
-<p>Equivalently, eliminating the inner loop, the last two lines would be::</p>
-<pre><code>        out_1d[:] = a_1d[indices_1d]
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>take : Take along an axis, using the same indices for every 1d slice put_along_axis :  Put values into the destination array by matching 1d index and data slices</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>For this sample array</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">10, 30, 20], [60, 40, 50</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>We can sort either by using sort directly, or argsort and this function</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.sort(a, axis=1) array(<a href="null">10, 20, 30],
-       [40, 50, 60</a>) ai = np.argsort(a, axis=1); ai array(<a href="null">0, 2, 1],
-       [1, 2, 0</a>) np.take_along_axis(a, ai, axis=1) array(<a href="null">10, 20, 30],
-       [40, 50, 60</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The same works for max and min, if you expand the dimensions:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.expand_dims(np.max(a, axis=1), axis=1) array(<a href="null">30],
-       [60</a>) ai = np.expand_dims(np.argmax(a, axis=1), axis=1) ai array(<a href="null">1],
-       [0</a>) np.take_along_axis(a, ai, axis=1) array(<a href="null">30],
-       [60</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>If we want to get the max and min at the same time, we can stack the indices first</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>ai_min = np.expand_dims(np.argmin(a, axis=1), axis=1) ai_max = np.expand_dims(np.argmax(a, axis=1), axis=1) ai = np.concatenate([ai_min, ai_max], axis=1) ai array(<a href="null">0, 1],
-       [1, 0</a>) np.take_along_axis(a, ai, axis=1) array(<a href="null">10, 30],
-       [40, 60</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7138">view source</a></div></div><div class="public anchor" id="var-tan"><h3>tan</h3><div class="usage"><code>(tan self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>tan(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute tangent element-wise.</p>
-<p>Equivalent to <code>np.sin(x)/np.cos(x)</code> element-wise.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The corresponding tangent values.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If <code>out</code> is provided, the function writes the result into it, and returns a reference to <code>out</code>. (See Examples)</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions. New York, NY: Dover, 1972.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from math import pi np.tan(np.array([-pi,pi/2,pi])) array([ 1.22460635e-16, 1.63317787e+16, -1.22460635e-16])</p>
-      <h1><a href="#example-of-providing-the-optional-output-parameter-illustrating" name="example-of-providing-the-optional-output-parameter-illustrating"></a>Example of providing the optional output parameter illustrating</h1>
-      <h1><a href="#that-what-is-returned-is-a-reference-to-said-parameter" name="that-what-is-returned-is-a-reference-to-said-parameter"></a>that what is returned is a reference to said parameter</h1>
-      <p>out1 = np.array([0], dtype=‘d’) out2 = np.cos([0.1], out1) out2 is out1 True</p>
-      <h1><a href="#example-of-valueerror-due-to-provision-of-shape-mis-matched" name="example-of-valueerror-due-to-provision-of-shape-mis-matched"></a>Example of ValueError due to provision of shape mis-matched <code>out</code></h1>
-      <p>np.cos(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> ValueError: operands could not be broadcast together with shapes (3,3) (2,2)</module></stdin></p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19003">view source</a></div></div><div class="public anchor" id="var-tanh"><h3>tanh</h3><div class="usage"><code>(tanh self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>tanh(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Compute hyperbolic tangent element-wise.</p>
-<p>Equivalent to <code>np.sinh(x)/np.cosh(x)</code> or <code>-1j * np.tan(1j*x)</code>.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input array. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray  The corresponding hyperbolic tangent values.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If <code>out</code> is provided, the function writes the result into it, and returns a reference to <code>out</code>. (See Examples)</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.  New York, NY: Dover, 1972, pg. 83.  <a href="http://www.math.sfu.ca/~cbm/aands/">http://www.math.sfu.ca/~cbm/aands/</a></p>
-<p>.. [2] Wikipedia, “Hyperbolic function”,  <a href="https://en.wikipedia.org/wiki/Hyperbolic_function">https://en.wikipedia.org/wiki/Hyperbolic_function</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.tanh((0, np.pi*1j, np.pi*1j/2)) array([ 0. +0.00000000e+00j, 0. -1.22460635e-16j, 0. +1.63317787e+16j])</p>
-      <h1><a href="#example-of-providing-the-optional-output-parameter-illustrating" name="example-of-providing-the-optional-output-parameter-illustrating"></a>Example of providing the optional output parameter illustrating</h1>
-      <h1><a href="#that-what-is-returned-is-a-reference-to-said-parameter" name="that-what-is-returned-is-a-reference-to-said-parameter"></a>that what is returned is a reference to said parameter</h1>
-      <p>out1 = np.array([0], dtype=‘d’) out2 = np.tanh([0.1], out1) out2 is out1 True</p>
-      <h1><a href="#example-of-valueerror-due-to-provision-of-shape-mis-matched" name="example-of-valueerror-due-to-provision-of-shape-mis-matched"></a>Example of ValueError due to provision of shape mis-matched <code>out</code></h1>
-      <p>np.tanh(np.zeros((3,3)),np.zeros((2,2))) Traceback (most recent call last):  File “<stdin>”, line 1, in <module> ValueError: operands could not be broadcast together with shapes (3,3) (2,2)</module></stdin></p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26875">view source</a></div></div><div class="public anchor" id="var-tensordot"><h3>tensordot</h3><div class="usage"><code>(tensordot &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute tensor dot product along specified axes.</p>
-<p>Given two tensors, <code>a</code> and <code>b</code>, and an array_like object containing two array_like objects, <code>(a_axes, b_axes)</code>, sum the products of <code>a</code>’s and <code>b</code>’s elements (components) over the axes specified by <code>a_axes</code> and <code>b_axes</code>. The third argument can be a single non-negative integer_like scalar, <code>N</code>; if it is such, then the last <code>N</code> dimensions of <code>a</code> and the first <code>N</code> dimensions of <code>b</code> are summed over.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a, b : array_like  Tensors to “dot”.</p>
-<p>axes : int or (2,) array_like  * integer_like  If an int N, sum over the last N axes of <code>a</code> and the first N axes  of <code>b</code> in order. The sizes of the corresponding axes must match.  * (2,) array_like  Or, a list of axes to be summed over, first sequence applying to <code>a</code>,  second to <code>b</code>. Both elements array_like must be of the same length.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>output : ndarray  The tensor dot product of the input.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>dot, einsum</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Three common use cases are:  * <code>axes = 0</code> : tensor product :math:<code>a\otimes b</code>  * <code>axes = 1</code> : tensor dot product :math:<code>a\cdot b</code>  * <code>axes = 2</code> : (default) tensor double contraction :math:<code>a:b</code></p>
-<p>When <code>axes</code> is integer_like, the sequence for evaluation will be: first the -Nth axis in <code>a</code> and 0th axis in <code>b</code>, and the -1th axis in <code>a</code> and Nth axis in <code>b</code> last.</p>
-<p>When there is more than one axis to sum over - and they are not the last (first) axes of <code>a</code> (<code>b</code>) - the argument <code>axes</code> should consist of two sequences of the same length, with the first axis to sum over given first in both sequences, the second axis second, and so forth.</p>
-<p>The shape of the result consists of the non-contracted axes of the first tensor, followed by the non-contracted axes of the second.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>A “traditional” example:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(60.).reshape(3,4,5) b = np.arange(24.).reshape(4,3,2) c = np.tensordot(a,b, axes=([1,0],[0,1])) c.shape (5, 2) c array(<a href="null">4400., 4730.],
-       [4532., 4874.],
-       [4664., 5018.],
-       [4796., 5162.],
-       [4928., 5306.</a>)</p>
-      <h1><a href="#a-slower-but-equivalent-way-of-computing-the-same" name="a-slower-but-equivalent-way-of-computing-the-same"></a>A slower but equivalent way of computing the same…</h1>
-      <p>d = np.zeros((5,2)) for i in range(5): … for j in range(2): … for k in range(3): … for n in range(4): … d[i,j] += a[k,n,i] * b[n,k,j] c == d array(<a href="null"> True,  True],
-       [ True,  True],
-       [ True,  True],
-       [ True,  True],
-       [ True,  True</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>An extended example taking advantage of the overloading of + and *:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(range(1, 9)) a.shape = (2, 2, 2) A = np.array((‘a’, ‘b’, ‘c’, ‘d’), dtype=object) A.shape = (2, 2) a; A array(<a href="null">[1, 2],
-        [3, 4</a>,  <a href="null">5, 6],
-        [7, 8</a>]) array(<a href="null">'a', 'b'],
-       ['c', 'd'</a>, dtype=object)</p>
-      <p>np.tensordot(a, A) # third argument default is 2 for double-contraction array([‘abbcccdddd’, ‘aaaaabbbbbbcccccccdddddddd’], dtype=object)</p>
-      <p>np.tensordot(a, A, 1) array(<a href="null">['acc', 'bdd'],
-        ['aaacccc', 'bbbdddd'</a>,  <a href="null">'aaaaacccccc', 'bbbbbdddddd'],
-        ['aaaaaaacccccccc', 'bbbbbbbdddddddd'</a>], dtype=object)</p>
-      <p>np.tensordot(a, A, 0) # tensor product (result too long to incl.) array(<a href="null">[[['a', 'b'],
-          ['c', 'd'</a>,  …</p>
-      <p>np.tensordot(a, A, (0, 1)) array(<a href="null">['abbbbb', 'cddddd'],
-        ['aabbbbbb', 'ccdddddd'</a>,  <a href="null">'aaabbbbbbb', 'cccddddddd'],
-        ['aaaabbbbbbbb', 'ccccdddddddd'</a>], dtype=object)</p>
-      <p>np.tensordot(a, A, (2, 1)) array(<a href="null">['abb', 'cdd'],
-        ['aaabbbb', 'cccdddd'</a>,  <a href="null">'aaaaabbbbbb', 'cccccdddddd'],
-        ['aaaaaaabbbbbbbb', 'cccccccdddddddd'</a>], dtype=object)</p>
-      <p>np.tensordot(a, A, ((0, 1), (0, 1))) array([‘abbbcccccddddddd’, ‘aabbbbccccccdddddddd’], dtype=object)</p>
-      <p>np.tensordot(a, A, ((2, 1), (1, 0))) array([‘acccbbdddd’, ‘aaaaacccccccbbbbbbdddddddd’], dtype=object)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19235">view source</a></div></div><div class="public anchor" id="var-test"><h3>test</h3><div class="usage"><code>(test self module_name)</code></div><div class="doc"><div class="markdown"><p>Pytest test runner.</p>
-<p>A test function is typically added to a package’s <strong>init</strong>.py like so::</p>
-<p>from numpy._pytesttester import PytestTester  test = PytestTester(__name__).test  del PytestTester</p>
-<p>Calling this test function finds and runs all tests associated with the module and all its sub-modules.</p>
-<h2><a href="#attributes" name="attributes"></a>Attributes</h2>
-<p>module_name : str  Full path to the package to test.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>module_name : module name  The name of the module to test.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Unlike the previous <code>nose</code>-based implementation, this class is not publicly exposed as it performs some <code>numpy</code>-specific warning suppression.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27850">view source</a></div></div><div class="public anchor" id="var-tile"><h3>tile</h3><div class="usage"><code>(tile &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Construct an array by repeating A the number of times given by reps.</p>
-<p>If <code>reps</code> has length <code>d</code>, the result will have dimension of <code>max(d, A.ndim)</code>.</p>
-<p>If <code>A.ndim &lt; d</code>, <code>A</code> is promoted to be d-dimensional by prepending new axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication, or shape (1, 1, 3) for 3-D replication. If this is not the desired behavior, promote <code>A</code> to d-dimensions manually before calling this function.</p>
-<p>If <code>A.ndim &gt; d</code>, <code>reps</code> is promoted to <code>A</code>.ndim by pre-pending 1’s to it. Thus for an <code>A</code> of shape (2, 3, 4, 5), a <code>reps</code> of (2, 2) is treated as (1, 1, 2, 2).</p>
-<p>Note : Although tile may be used for broadcasting, it is strongly recommended to use numpy’s broadcasting operations and functions.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>A : array_like  The input array. reps : array_like  The number of repetitions of <code>A</code> along each axis.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>c : ndarray  The tiled output array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>repeat : Repeat elements of an array. broadcast_to : Broadcast an array to a new shape</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([0, 1, 2]) np.tile(a, 2) array([0, 1, 2, 0, 1, 2]) np.tile(a, (2, 2)) array(<a href="null">0, 1, 2, 0, 1, 2],
-       [0, 1, 2, 0, 1, 2</a>) np.tile(a, (2, 1, 2)) array(<a href="null">[0, 1, 2, 0, 1, 2</a>,  <a href="null">0, 1, 2, 0, 1, 2</a>])</p>
-      <p>b = np.array(<a href="null">1, 2], [3, 4</a>) np.tile(b, 2) array(<a href="null">1, 2, 1, 2],
-       [3, 4, 3, 4</a>) np.tile(b, (2, 1)) array(<a href="null">1, 2],
-       [3, 4],
-       [1, 2],
-       [3, 4</a>)</p>
-      <p>c = np.array([1,2,3,4]) np.tile(c,(4,1)) array(<a href="null">1, 2, 3, 4],
-       [1, 2, 3, 4],
-       [1, 2, 3, 4],
-       [1, 2, 3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16170">view source</a></div></div><div class="public anchor" id="var-timedelta64"><h3>timedelta64</h3><div class="usage"><code>(timedelta64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L13344">view source</a></div></div><div class="public anchor" id="var-TooHardError"><h3>TooHardError</h3><div class="usage"><code>(TooHardError self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1646">view source</a></div></div><div class="public anchor" id="var-trace"><h3>trace</h3><div class="usage"><code>(trace &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the sum along diagonals of the array.</p>
-<p>If <code>a</code> is 2-D, the sum along its diagonal with the given offset is returned, i.e., the sum of elements <code>a[i,i+offset]</code> for all i.</p>
-<p>If <code>a</code> has more than two dimensions, then the axes specified by axis1 and axis2 are used to determine the 2-D sub-arrays whose traces are returned. The shape of the resulting array is the same as that of <code>a</code> with <code>axis1</code> and <code>axis2</code> removed.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array, from which the diagonals are taken. offset : int, optional  Offset of the diagonal from the main diagonal. Can be both positive  and negative. Defaults to 0. axis1, axis2 : int, optional  Axes to be used as the first and second axis of the 2-D sub-arrays  from which the diagonals should be taken. Defaults are the first two  axes of <code>a</code>. dtype : dtype, optional  Determines the data-type of the returned array and of the accumulator  where the elements are summed. If dtype has the value None and <code>a</code> is  of integer type of precision less than the default integer  precision, then the default integer precision is used. Otherwise,  the precision is the same as that of <code>a</code>. out : ndarray, optional  Array into which the output is placed. Its type is preserved and  it must be of the right shape to hold the output.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>sum_along_diagonals : ndarray  If <code>a</code> is 2-D, the sum along the diagonal is returned. If <code>a</code> has  larger dimensions, then an array of sums along diagonals is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>diag, diagonal, diagflat</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.trace(np.eye(3)) 3.0 a = np.arange(8).reshape((2,2,2)) np.trace(a) array([6, 8])</p>
-      <p>a = np.arange(24).reshape((2,2,2,3)) np.trace(a).shape (2, 3)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7909">view source</a></div></div><div class="public anchor" id="var-tracemalloc_domain"><h3>tracemalloc_domain</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L436">view source</a></div></div><div class="public anchor" id="var-transpose"><h3>transpose</h3><div class="usage"><code>(transpose &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Permute the dimensions of an array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Input array. axes : list of ints, optional  By default, reverse the dimensions, otherwise permute the axes  according to the values given.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>p : ndarray  <code>a</code> with its axes permuted. A view is returned whenever  possible.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>moveaxis argsort</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Use <code>transpose(a, argsort(axes))</code> to invert the transposition of tensors when using the <code>axes</code> keyword argument.</p>
-<p>Transposing a 1-D array returns an unchanged view of the original array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(4).reshape((2,2)) x array(<a href="null">0, 1],
-       [2, 3</a>)</p>
-      <p>np.transpose(x) array(<a href="null">0, 2],
-       [1, 3</a>)</p>
-      <p>x = np.ones((1, 2, 3)) np.transpose(x, (1, 0, 2)).shape (2, 1, 3)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26425">view source</a></div></div><div class="public anchor" id="var-trapz"><h3>trapz</h3><div class="usage"><code>(trapz &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Integrate along the given axis using the composite trapezoidal rule.</p>
-<p>Integrate <code>y</code> (<code>x</code>) along given axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>y : array_like  Input array to integrate. x : array_like, optional  The sample points corresponding to the <code>y</code> values. If <code>x</code> is None,  the sample points are assumed to be evenly spaced <code>dx</code> apart. The  default is None. dx : scalar, optional  The spacing between sample points when <code>x</code> is None. The default is 1. axis : int, optional  The axis along which to integrate.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>trapz : float  Definite integral as approximated by trapezoidal rule.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>sum, cumsum</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Image [2]_ illustrates trapezoidal rule – y-axis locations of points will be taken from <code>y</code> array, by default x-axis distances between points will be 1.0, alternatively they can be provided with <code>x</code> array or with <code>dx</code> scalar. Return value will be equal to combined area under the red lines.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] Wikipedia page: <a href="https://en.wikipedia.org/wiki/Trapezoidal_rule">https://en.wikipedia.org/wiki/Trapezoidal_rule</a></p>
-<p>.. [2] Illustration image:  <a href="https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png">https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png</a></p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.trapz([1,2,3]) 4.0 np.trapz([1,2,3], x=[4,6,8]) 8.0 np.trapz([1,2,3], dx=2) 8.0 a = np.arange(6).reshape(2, 3) a array(<a href="null">0, 1, 2],
-       [3, 4, 5</a>) np.trapz(a, axis=0) array([1.5, 2.5, 3.5]) np.trapz(a, axis=1) array([2., 8.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5039">view source</a></div></div><div class="public anchor" id="var-tri"><h3>tri</h3><div class="usage"><code>(tri N &amp; [{M :M, k :k, dtype :dtype}])</code><code>(tri N &amp; [{M :M, k :k}])</code><code>(tri N &amp; [{M :M}])</code><code>(tri N)</code></div><div class="doc"><div class="markdown"><p>An array with ones at and below the given diagonal and zeros elsewhere.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>N : int  Number of rows in the array. M : int, optional  Number of columns in the array.  By default, <code>M</code> is taken equal to <code>N</code>. k : int, optional  The sub-diagonal at and below which the array is filled.  <code>k</code> = 0 is the main diagonal, while <code>k</code> &lt; 0 is below it,  and <code>k</code> &gt; 0 is above. The default is 0. dtype : dtype, optional  Data type of the returned array. The default is float.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>tri : ndarray of shape (N, M)  Array with its lower triangle filled with ones and zero elsewhere;  in other words <code>T[i,j] == 1</code> for <code>j &lt;= i + k</code>, 0 otherwise.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.tri(3, 5, 2, dtype=int) array(<a href="null">1, 1, 1, 0, 0],
-       [1, 1, 1, 1, 0],
-       [1, 1, 1, 1, 1</a>)</p>
-      <p>np.tri(3, 5, -1) array(<a href="null">0.,  0.,  0.,  0.,  0.],
-       [1.,  0.,  0.,  0.,  0.],
-       [1.,  1.,  0.,  0.,  0.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27112">view source</a></div></div><div class="public anchor" id="var-tril"><h3>tril</h3><div class="usage"><code>(tril &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Lower triangle of an array.</p>
-<p>Return a copy of an array with elements above the <code>k</code>-th diagonal zeroed.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>m : array_like, shape (M, N)  Input array. k : int, optional  Diagonal above which to zero elements. <code>k = 0</code> (the default) is the  main diagonal, <code>k &lt; 0</code> is below it and <code>k &gt; 0</code> is above.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>tril : ndarray, shape (M, N)  Lower triangle of <code>m</code>, of same shape and data-type as <code>m</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>triu : same thing, only for the upper triangle</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.tril(<a href="null">1,2,3],[4,5,6],[7,8,9],[10,11,12</a>, -1) array(<a href="null"> 0,  0,  0],
-       [ 4,  0,  0],
-       [ 7,  8,  0],
-       [10, 11, 12</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14615">view source</a></div></div><div class="public anchor" id="var-tril_indices"><h3>tril_indices</h3><div class="usage"><code>(tril_indices n &amp; [{k :k, m :m}])</code><code>(tril_indices n &amp; [{k :k}])</code><code>(tril_indices n)</code></div><div class="doc"><div class="markdown"><p>Return the indices for the lower-triangle of an (n, m) array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>n : int  The row dimension of the arrays for which the returned  indices will be valid. k : int, optional  Diagonal offset (see <code>tril</code> for details). m : int, optional  .. versionadded:: 1.9.0</p>
-<pre><code>The column dimension of the arrays for which the returned
-arrays will be valid.
-By default `m` is taken equal to `n`.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>inds : tuple of arrays  The indices for the triangle. The returned tuple contains two arrays,  each with the indices along one dimension of the array.</p>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>triu_indices : similar function, for upper-triangular. mask_indices : generic function accepting an arbitrary mask function. tril, triu</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.4.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Compute two different sets of indices to access 4x4 arrays, one for the lower triangular part starting at the main diagonal, and one starting two diagonals further right:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>il1 = np.tril_indices(4) il2 = np.tril_indices(4, 2)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Here is how they can be used with a sample array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(16).reshape(4, 4) a array(<a href="null"> 0,  1,  2,  3],
-       [ 4,  5,  6,  7],
-       [ 8,  9, 10, 11],
-       [12, 13, 14, 15</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Both for indexing:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a[il1] array([ 0, 4, 5, …, 13, 14, 15])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>And for assigning values:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a[il1] = -1 a array(<a href="null">-1,  1,  2,  3],
-       [-1, -1,  6,  7],
-       [-1, -1, -1, 11],
-       [-1, -1, -1, -1</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>These cover almost the whole array (two diagonals right of the main one):</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a[il2] = -10 a array(<a href="null">-10, -10, -10,   3],
-       [-10, -10, -10, -10],
-       [-10, -10, -10, -10],
-       [-10, -10, -10, -10</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L26472">view source</a></div></div><div class="public anchor" id="var-tril_indices_from"><h3>tril_indices_from</h3><div class="usage"><code>(tril_indices_from &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices for the lower-triangle of arr.</p>
-<p>See <code>tril_indices</code> for full details.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr : array_like  The indices will be valid for square arrays whose dimensions are  the same as arr. k : int, optional  Diagonal offset (see <code>tril</code> for details).</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>tril_indices, tril</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.4.0</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20777">view source</a></div></div><div class="public anchor" id="var-trim_zeros"><h3>trim_zeros</h3><div class="usage"><code>(trim_zeros &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Trim the leading and/or trailing zeros from a 1-D array or sequence.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>filt : 1-D array or sequence  Input array. trim : str, optional  A string with ‘f’ representing trim from front and ‘b’ to trim from  back. Default is ‘fb’, trim zeros from both front and back of the  array.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>trimmed : 1-D array or sequence  The result of trimming the input. The input data type is preserved.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0)) np.trim_zeros(a) array([1, 2, 3, 0, 2, 1])</p>
-      <p>np.trim_zeros(a, ‘b’) array([0, 0, 0, …, 0, 2, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The input data type is preserved, list/tuple in means list/tuple out.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.trim_zeros([0, 1, 2, 0]) [1, 2]</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21775">view source</a></div></div><div class="public anchor" id="var-triu"><h3>triu</h3><div class="usage"><code>(triu &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Upper triangle of an array.</p>
-<p>Return a copy of a matrix with the elements below the <code>k</code>-th diagonal zeroed.</p>
-<p>Please refer to the documentation for <code>tril</code> for further details.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>tril : lower triangle of an array</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.triu(<a href="null">1,2,3],[4,5,6],[7,8,9],[10,11,12</a>, -1) array(<a href="null"> 1,  2,  3],
-       [ 4,  5,  6],
-       [ 0,  8,  9],
-       [ 0,  0, 12</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25622">view source</a></div></div><div class="public anchor" id="var-triu_indices"><h3>triu_indices</h3><div class="usage"><code>(triu_indices n &amp; [{k :k, m :m}])</code><code>(triu_indices n &amp; [{k :k}])</code><code>(triu_indices n)</code></div><div class="doc"><div class="markdown"><p>Return the indices for the upper-triangle of an (n, m) array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>n : int  The size of the arrays for which the returned indices will  be valid. k : int, optional  Diagonal offset (see <code>triu</code> for details). m : int, optional  .. versionadded:: 1.9.0</p>
-<pre><code>The column dimension of the arrays for which the returned
-arrays will be valid.
-By default `m` is taken equal to `n`.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>inds : tuple, shape(2) of ndarrays, shape(<code>n</code>)  The indices for the triangle. The returned tuple contains two arrays,  each with the indices along one dimension of the array. Can be used  to slice a ndarray of shape(<code>n</code>, <code>n</code>).</p>
-<h2><a href="#see-also" name="see-also"></a>See also</h2>
-<p>tril_indices : similar function, for lower-triangular. mask_indices : generic function accepting an arbitrary mask function. triu, tril</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.4.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<p>Compute two different sets of indices to access 4x4 arrays, one for the upper triangular part starting at the main diagonal, and one starting two diagonals further right:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>iu1 = np.triu_indices(4) iu2 = np.triu_indices(4, 2)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Here is how they can be used with a sample array:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(16).reshape(4, 4) a array(<a href="null"> 0,  1,  2,  3],
-       [ 4,  5,  6,  7],
-       [ 8,  9, 10, 11],
-       [12, 13, 14, 15</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Both for indexing:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a[iu1] array([ 0, 1, 2, …, 10, 11, 15])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>And for assigning values:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a[iu1] = -1 a array(<a href="null">-1, -1, -1, -1],
-       [ 4, -1, -1, -1],
-       [ 8,  9, -1, -1],
-       [12, 13, 14, -1</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>These cover only a small part of the whole array (two diagonals right of the main one):</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a[iu2] = -10 a array(<a href="null"> -1,  -1, -10, -10],
-       [  4,  -1,  -1, -10],
-       [  8,   9,  -1,  -1],
-       [ 12,  13,  14,  -1</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19814">view source</a></div></div><div class="public anchor" id="var-triu_indices_from"><h3>triu_indices_from</h3><div class="usage"><code>(triu_indices_from &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return the indices for the upper-triangle of arr.</p>
-<p>See <code>triu_indices</code> for full details.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>arr : ndarray, shape(N, N)  The indices will be valid for square arrays. k : int, optional  Diagonal offset (see <code>triu</code> for details).</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>triu_indices_from : tuple, shape(2) of ndarray, shape(N)  Indices for the upper-triangle of <code>arr</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>triu_indices, triu</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.4.0</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L24460">view source</a></div></div><div class="public anchor" id="var-True_"><h3>True_</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L11014">view source</a></div></div><div class="public anchor" id="var-true_divide"><h3>true_divide</h3><div class="usage"><code>(true_divide self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>true_divide(x1, x2, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Returns a true division of the inputs, element-wise.</p>
-<p>Instead of the Python traditional ‘floor division’, this returns a true division. True division adjusts the output type to present the best answer, regardless of input types.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x1 : array_like  Dividend array. x2 : array_like  Divisor array. If <code>x1.shape != x2.shape</code>, they must be broadcastable to a common shape (which becomes the shape of the output). out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray or scalar  This is a scalar if both <code>x1</code> and <code>x2</code> are scalars.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The floor division operator <code>//</code> was added in Python 2.2 making <code>//</code> and <code>/</code> equivalent operators. The default floor division operation of <code>/</code> can be replaced by true division with <code>from
-__future__ import division</code>.</p>
-<p>In Python 3.0, <code>//</code> is the floor division operator and <code>/</code> the true division operator. The <code>true_divide(x1, x2)</code> function is equivalent to true division in Python.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(5) np.true_divide(x, 4) array([ 0. , 0.25, 0.5 , 0.75, 1. ])</p>
-      <p>x//4 array([0, 0, 0, 0, 1])</p>
-      <p>from <strong>future</strong> import division x/4 array([ 0. , 0.25, 0.5 , 0.75, 1. ]) x//4 array([0, 0, 0, 0, 1])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23555">view source</a></div></div><div class="public anchor" id="var-trunc"><h3>trunc</h3><div class="usage"><code>(trunc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>trunc(x, /, out=None, *, where=True, casting=‘same_kind’, order=‘K’, dtype=None, subok=True[, signature, extobj])</p>
-<p>Return the truncated value of the input, element-wise.</p>
-<p>The truncated value of the scalar <code>x</code> is the nearest integer <code>i</code> which is closer to zero than <code>x</code> is. In short, the fractional part of the signed number <code>x</code> is discarded.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  Input data. out : ndarray, None, or tuple of ndarray and None, optional  A location into which the result is stored. If provided, it must have  a shape that the inputs broadcast to. If not provided or None,  a freshly-allocated array is returned. A tuple (possible only as a  keyword argument) must have length equal to the number of outputs. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the  :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>y : ndarray or scalar  The truncated value of each element in <code>x</code>.  This is a scalar if <code>x</code> is a scalar.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ceil, floor, rint</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>.. versionadded:: 1.3.0</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0]) np.trunc(a) array([-1., -1., -0., 0., 1., 1., 2.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L19521">view source</a></div></div><div class="public anchor" id="var-typecodes"><h3>typecodes</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14605">view source</a></div></div><div class="public anchor" id="var-typeDict"><h3>typeDict</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>dict() -&gt; new empty dictionary dict(mapping) -&gt; new dictionary initialized from a mapping object’s  (key, value) pairs dict(iterable) -&gt; new dictionary initialized as if via:  d = {}  for k, v in iterable:  d[k] = v dict(**kwargs) -&gt; new dictionary initialized with the name=value pairs  in the keyword argument list. For example: dict(one=1, two=2)</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17202">view source</a></div></div><div class="public anchor" id="var-typeNA"><h3>typeNA</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3139">view source</a></div></div><div class="public anchor" id="var-typename"><h3>typename</h3><div class="usage"><code>(typename char)</code></div><div class="doc"><div class="markdown"><p>Return a description for the given data type code.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>char : str  Data type code.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : str  Description of the input data type code.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>dtype, typecodes</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>typechars = [‘S1’, ‘?’, ‘B’, ‘D’, ‘G’, ‘F’, ‘I’, ‘H’, ‘L’, ‘O’, ‘Q’, … ‘S’, ‘U’, ‘V’, ‘b’, ‘d’, ‘g’, ‘f’, ‘i’, ‘h’, ‘l’, ‘q’] for typechar in typechars: … print(typechar, ‘ : ’, np.typename(typechar)) … S1 : character ? : bool B : unsigned char D : complex double precision G : complex long double precision F : complex single precision I : unsigned integer H : unsigned short L : unsigned long integer O : object Q : unsigned long long integer S : string U : unicode V : void b : signed char d : double precision g : long precision f : single precision i : integer h : short l : long integer q : long long integer</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L27800">view source</a></div></div><div class="public anchor" id="var-ubyte"><h3>ubyte</h3><div class="usage"><code>(ubyte self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned char</code>. Character code: <code>'B'</code>. Canonical name: <code>np.ubyte</code>. Alias <em>on this platform</em>: <code>np.uint8</code>: 8-bit unsigned integer (0 to 255).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25616">view source</a></div></div><div class="public anchor" id="var-ufunc"><h3>ufunc</h3><div class="usage"><code>(ufunc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Functions that operate element by element on whole arrays.</p>
-<p>To see the documentation for a specific ufunc, use <code>info</code>. For example, <code>np.info(np.sin)</code>. Because ufuncs are written in C (for speed) and linked into Python with NumPy’s ufunc facility, Python’s help() function finds this page whenever help() is called on a ufunc.</p>
-<p>A detailed explanation of ufuncs can be found in the docs for :ref:<code>ufuncs</code>.</p>
-<h1><a href="#calling-ufuncs-" name="calling-ufuncs-"></a>Calling ufuncs:</h1>
-<p>op(*x[, out], where=True, **kwargs) Apply <code>op</code> to the arguments <code>*x</code> elementwise, broadcasting the arguments.</p>
-<p>The broadcasting rules are:</p>
-<ul>
-  <li>Dimensions of length 1 may be prepended to either array.</li>
-  <li>Arrays may be repeated along dimensions of length 1.</li>
-</ul>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>*x : array_like  Input arrays. out : ndarray, None, or tuple of ndarray and None, optional  Alternate array object(s) in which to put the result; if provided, it  must have a shape that the inputs broadcast to. A tuple of arrays  (possible only as a keyword argument) must have length equal to the  number of outputs; use None for uninitialized outputs to be  allocated by the ufunc. where : array_like, optional  This condition is broadcast over the input. At locations where the  condition is True, the <code>out</code> array will be set to the ufunc result.  Elsewhere, the <code>out</code> array will retain its original value.  Note that if an uninitialized <code>out</code> array is created via the default  <code>out=None</code>, locations within it where the condition is False will  remain uninitialized. **kwargs  For other keyword-only arguments, see the :ref:<code>ufunc docs &lt;ufuncs.kwargs&gt;</code>.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>r : ndarray or tuple of ndarray  <code>r</code> will have the shape that the arrays in <code>x</code> broadcast to; if <code>out</code> is  provided, it will be returned. If not, <code>r</code> will be allocated and  may contain uninitialized values. If the function has more than one  output, then the result will be a tuple of arrays.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1596">view source</a></div></div><div class="public anchor" id="var-UFUNC_BUFSIZE_DEFAULT"><h3>UFUNC_BUFSIZE_DEFAULT</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1395">view source</a></div></div><div class="public anchor" id="var-UFUNC_PYVALS_NAME"><h3>UFUNC_PYVALS_NAME</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15736">view source</a></div></div><div class="public anchor" id="var-uint"><h3>uint</h3><div class="usage"><code>(uint self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned long</code>. Character code: <code>'L'</code>. Canonical name: <code>np.uint</code>. Alias <em>on this platform</em>: <code>np.uint64</code>: 64-bit unsigned integer (0 to 18446744073709551615). Alias <em>on this platform</em>: <code>np.uintp</code>: Unsigned integer large enough to fit pointer, compatible with C <code>uintptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5411">view source</a></div></div><div class="public anchor" id="var-uint0"><h3>uint0</h3><div class="usage"><code>(uint0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned long</code>. Character code: <code>'L'</code>. Canonical name: <code>np.uint</code>. Alias <em>on this platform</em>: <code>np.uint64</code>: 64-bit unsigned integer (0 to 18446744073709551615). Alias <em>on this platform</em>: <code>np.uintp</code>: Unsigned integer large enough to fit pointer, compatible with C <code>uintptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2277">view source</a></div></div><div class="public anchor" id="var-uint16"><h3>uint16</h3><div class="usage"><code>(uint16 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned short</code>. Character code: <code>'H'</code>. Canonical name: <code>np.ushort</code>. Alias <em>on this platform</em>: <code>np.uint16</code>: 16-bit unsigned integer (0 to 65535).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L5702">view source</a></div></div><div class="public anchor" id="var-uint32"><h3>uint32</h3><div class="usage"><code>(uint32 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned int</code>. Character code: <code>'I'</code>. Canonical name: <code>np.uintc</code>. Alias <em>on this platform</em>: <code>np.uint32</code>: 32-bit unsigned integer (0 to 4294967295).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L6901">view source</a></div></div><div class="public anchor" id="var-uint64"><h3>uint64</h3><div class="usage"><code>(uint64 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned long</code>. Character code: <code>'L'</code>. Canonical name: <code>np.uint</code>. Alias <em>on this platform</em>: <code>np.uint64</code>: 64-bit unsigned integer (0 to 18446744073709551615). Alias <em>on this platform</em>: <code>np.uintp</code>: Unsigned integer large enough to fit pointer, compatible with C <code>uintptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15910">view source</a></div></div><div class="public anchor" id="var-uint8"><h3>uint8</h3><div class="usage"><code>(uint8 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned char</code>. Character code: <code>'B'</code>. Canonical name: <code>np.ubyte</code>. Alias <em>on this platform</em>: <code>np.uint8</code>: 8-bit unsigned integer (0 to 255).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16626">view source</a></div></div><div class="public anchor" id="var-uintc"><h3>uintc</h3><div class="usage"><code>(uintc self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned int</code>. Character code: <code>'I'</code>. Canonical name: <code>np.uintc</code>. Alias <em>on this platform</em>: <code>np.uint32</code>: 32-bit unsigned integer (0 to 4294967295).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23719">view source</a></div></div><div class="public anchor" id="var-uintp"><h3>uintp</h3><div class="usage"><code>(uintp self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned long</code>. Character code: <code>'L'</code>. Canonical name: <code>np.uint</code>. Alias <em>on this platform</em>: <code>np.uint64</code>: 64-bit unsigned integer (0 to 18446744073709551615). Alias <em>on this platform</em>: <code>np.uintp</code>: Unsigned integer large enough to fit pointer, compatible with C <code>uintptr_t</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25609">view source</a></div></div><div class="public anchor" id="var-ulonglong"><h3>ulonglong</h3><div class="usage"><code>(ulonglong self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Signed integer type, compatible with C <code>unsigned long long</code>. Character code: <code>'Q'</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L17199">view source</a></div></div><div class="public anchor" id="var-unicode"><h3>unicode</h3><div class="usage"><code>(unicode self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>str(object=’’) -&gt; str str(bytes_or_buffer[, encoding[, errors]]) -&gt; str</p>
-<p>Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to ‘strict’.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12022">view source</a></div></div><div class="public anchor" id="var-unicode_"><h3>unicode_</h3><div class="usage"><code>(unicode_ self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L14993">view source</a></div></div><div class="public anchor" id="var-union1d"><h3>union1d</h3><div class="usage"><code>(union1d &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the union of two arrays.</p>
-<p>Return the unique, sorted array of values that are in either of the two input arrays.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>ar1, ar2 : array_like  Input arrays. They are flattened if they are not already 1D.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>union1d : ndarray  Unique, sorted union of the input arrays.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.union1d([-1, 0, 1], [-2, 0, 2]) array([-2, -1, 0, 1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>To find the union of more than two arrays, use functools.reduce:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>from functools import reduce reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2])) array([1, 2, 3, 4, 6])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20587">view source</a></div></div><div class="public anchor" id="var-unique"><h3>unique</h3><div class="usage"><code>(unique &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Find the unique elements of an array.</p>
-<p>Returns the sorted unique elements of an array. There are three optional outputs in addition to the unique elements:</p>
-<ul>
-  <li>the indices of the input array that give the unique values</li>
-  <li>the indices of the unique array that reconstruct the input array</li>
-  <li>the number of times each unique value comes up in the input array</li>
-</ul>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>ar : array_like  Input array. Unless <code>axis</code> is specified, this will be flattened if it  is not already 1-D. return_index : bool, optional  If True, also return the indices of <code>ar</code> (along the specified axis,  if provided, or in the flattened array) that result in the unique array. return_inverse : bool, optional  If True, also return the indices of the unique array (for the specified  axis, if provided) that can be used to reconstruct <code>ar</code>. return_counts : bool, optional  If True, also return the number of times each unique item appears  in <code>ar</code>.</p>
-<pre><code>.. versionadded:: 1.9.0
-</code></pre>
-<p>axis : int or None, optional  The axis to operate on. If None, <code>ar</code> will be flattened. If an integer,  the subarrays indexed by the given axis will be flattened and treated  as the elements of a 1-D array with the dimension of the given axis,  see the notes for more details. Object arrays or structured arrays  that contain objects are not supported if the <code>axis</code> kwarg is used. The  default is None.</p>
-<pre><code>.. versionadded:: 1.13.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>unique : ndarray  The sorted unique values. unique_indices : ndarray, optional  The indices of the first occurrences of the unique values in the  original array. Only provided if <code>return_index</code> is True. unique_inverse : ndarray, optional  The indices to reconstruct the original array from the  unique array. Only provided if <code>return_inverse</code> is True. unique_counts : ndarray, optional  The number of times each of the unique values comes up in the  original array. Only provided if <code>return_counts</code> is True.</p>
-<pre><code>.. versionadded:: 1.9.0
-</code></pre>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>numpy.lib.arraysetops : Module with a number of other functions for  performing set operations on arrays.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>When an axis is specified the subarrays indexed by the axis are sorted. This is done by making the specified axis the first dimension of the array (move the axis to the first dimension to keep the order of the other axes) and then flattening the subarrays in C order. The flattened subarrays are then viewed as a structured type with each element given a label, with the effect that we end up with a 1-D array of structured types that can be treated in the same way as any other 1-D array. The result is that the flattened subarrays are sorted in lexicographic order starting with the first element.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.unique([1, 1, 2, 2, 3, 3]) array([1, 2, 3]) a = np.array(<a href="null">1, 1], [2, 3</a>) np.unique(a) array([1, 2, 3])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Return the unique rows of a 2D array</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 0, 0], [1, 0, 0], [2, 3, 4</a>) np.unique(a, axis=0) array(<a href="null">1, 0, 0], [2, 3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Return the indices of the original array that give the unique values:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([‘a’, ‘b’, ‘b’, ‘c’, ‘a’]) u, indices = np.unique(a, return_index=True) u array([‘a’, ‘b’, ‘c’], dtype=‘&lt;U1’) indices array([0, 1, 3]) a[indices] array([‘a’, ‘b’, ‘c’], dtype=‘&lt;U1’)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Reconstruct the input array from the unique values:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1, 2, 6, 4, 2, 3, 2]) u, indices = np.unique(a, return_inverse=True) u array([1, 2, 3, 4, 6]) indices array([0, 1, 4, …, 1, 2, 1]) u[indices] array([1, 2, 6, …, 2, 3, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L1692">view source</a></div></div><div class="public anchor" id="var-unpackbits"><h3>unpackbits</h3><div class="usage"><code>(unpackbits &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>unpackbits(a, axis=None, count=None, bitorder=‘big’)</p>
-<p>Unpacks elements of a uint8 array into a binary-valued output array.</p>
-<p>Each element of <code>a</code> represents a bit-field that should be unpacked into a binary-valued output array. The shape of the output array is either 1-D (if <code>axis</code> is <code>None</code>) or the same shape as the input array with unpacking done along the axis specified.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : ndarray, uint8 type  Input array. axis : int, optional  The dimension over which bit-unpacking is done.  <code>None</code> implies unpacking the flattened array. count : int or None, optional  The number of elements to unpack along <code>axis</code>, provided as a way  of undoing the effect of packing a size that is not a multiple  of eight. A non-negative number means to only unpack <code>count</code>  bits. A negative number means to trim off that many bits from  the end. <code>None</code> means to unpack the entire array (the  default). Counts larger than the available number of bits will  add zero padding to the output. Negative counts must not  exceed the available number of bits.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<p>bitorder : {‘big’, ‘little’}, optional  The order of the returned bits. ‘big’ will mimic bin(val),  <code>3 = 0b00000011 =&gt; [0, 0, 0, 0, 0, 0, 1, 1]</code>, ‘little’ will reverse  the order to <code>[1, 1, 0, 0, 0, 0, 0, 0]</code>.  Defaults to ‘big’.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>unpacked : ndarray, uint8 type  The elements are binary-valued (0 or 1).</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>packbits : Packs the elements of a binary-valued array into bits in  a uint8 array.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">2], [7], [23</a>, dtype=np.uint8) a array(<a href="null"> 2],
-       [ 7],
-       [23</a>, dtype=uint8) b = np.unpackbits(a, axis=1) b array(<a href="null">0, 0, 0, 0, 0, 0, 1, 0],
-       [0, 0, 0, 0, 0, 1, 1, 1],
-       [0, 0, 0, 1, 0, 1, 1, 1</a>, dtype=uint8) c = np.unpackbits(a, axis=1, count=-3) c array(<a href="null">0, 0, 0, 0, 0],
-       [0, 0, 0, 0, 0],
-       [0, 0, 0, 1, 0</a>, dtype=uint8)</p>
-      <p>p = np.packbits(b, axis=0) np.unpackbits(p, axis=0) array(<a href="null">0, 0, 0, 0, 0, 0, 1, 0],
-       [0, 0, 0, 0, 0, 1, 1, 1],
-       [0, 0, 0, 1, 0, 1, 1, 1],
-       [0, 0, 0, 0, 0, 0, 0, 0],
-       [0, 0, 0, 0, 0, 0, 0, 0],
-       [0, 0, 0, 0, 0, 0, 0, 0],
-       [0, 0, 0, 0, 0, 0, 0, 0],
-       [0, 0, 0, 0, 0, 0, 0, 0</a>, dtype=uint8) np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0])) True</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L20506">view source</a></div></div><div class="public anchor" id="var-unravel_index"><h3>unravel_index</h3><div class="usage"><code>(unravel_index &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>unravel_index(indices, shape, order=‘C’)</p>
-<p>Converts a flat index or array of flat indices into a tuple of coordinate arrays.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>indices : array_like  An integer array whose elements are indices into the flattened  version of an array of dimensions <code>shape</code>. Before version 1.6.0,  this function accepted just one index value. shape : tuple of ints  The shape of the array to use for unraveling <code>indices</code>.</p>
-<pre><code>.. versionchanged:: 1.16.0
-    Renamed from ``dims`` to ``shape``.
-</code></pre>
-<p>order : {‘C’, ‘F’}, optional  Determines whether the indices should be viewed as indexing in  row-major (C-style) or column-major (Fortran-style) order.</p>
-<pre><code>.. versionadded:: 1.6.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>unraveled_coords : tuple of ndarray  Each array in the tuple has the same shape as the <code>indices</code>  array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>ravel_multi_index</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.unravel_index([22, 41, 37], (7,6)) (array([3, 6, 6]), array([4, 5, 1])) np.unravel_index([31, 41, 13], (7,6), order=‘F’) (array([3, 6, 6]), array([4, 5, 1]))</p>
-      <p>np.unravel_index(1621, (6,7,8,9)) (3, 1, 4, 1)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L16006">view source</a></div></div><div class="public anchor" id="var-unsignedinteger"><h3>unsignedinteger</h3><div class="usage"><code>(unsignedinteger self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Abstract base class of all unsigned integer scalar types.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23812">view source</a></div></div><div class="public anchor" id="var-unwrap"><h3>unwrap</h3><div class="usage"><code>(unwrap &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unwrap by changing deltas between values to 2*pi complement.</p>
-<p>Unwrap radian phase <code>p</code> by changing absolute jumps greater than <code>discont</code> to their 2*pi complement along the given axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>p : array_like  Input array. discont : float, optional  Maximum discontinuity between values, default is <code>pi</code>. axis : int, optional  Axis along which unwrap will operate, default is the last axis.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Output array.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>rad2deg, deg2rad</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If the discontinuity in <code>p</code> is smaller than <code>pi</code>, but larger than <code>discont</code>, no unwrapping is done because taking the 2*pi complement would only make the discontinuity larger.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>phase = np.linspace(0, np.pi, num=5) phase[3:] += np.pi phase array([ 0. , 0.78539816, 1.57079633, 5.49778714, 6.28318531]) # may vary np.unwrap(phase) array([ 0. , 0.78539816, 1.57079633, -0.78539816, 0. ]) # may vary</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12353">view source</a></div></div><div class="public anchor" id="var-ushort"><h3>ushort</h3><div class="usage"><code>(ushort self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Unsigned integer type, compatible with C <code>unsigned short</code>. Character code: <code>'H'</code>. Canonical name: <code>np.ushort</code>. Alias <em>on this platform</em>: <code>np.uint16</code>: 16-bit unsigned integer (0 to 65535).</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L12066">view source</a></div></div><div class="public anchor" id="var-vander"><h3>vander</h3><div class="usage"><code>(vander &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Generate a Vandermonde matrix.</p>
-<p>The columns of the output matrix are powers of the input vector. The order of the powers is determined by the <code>increasing</code> boolean argument. Specifically, when <code>increasing</code> is False, the <code>i</code>-th output column is the input vector raised element-wise to the power of <code>N - i - 1</code>. Such a matrix with a geometric progression in each row is named for Alexandre- Theophile Vandermonde.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>x : array_like  1-D input array. N : int, optional  Number of columns in the output. If <code>N</code> is not specified, a square  array is returned (<code>N = len(x)</code>). increasing : bool, optional  Order of the powers of the columns. If True, the powers increase  from left to right, if False (the default) they are reversed.</p>
-<pre><code>.. versionadded:: 1.9.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Vandermonde matrix. If <code>increasing</code> is False, the first column is  <code>x^(N-1)</code>, the second <code>x^(N-2)</code> and so forth. If <code>increasing</code> is  True, the columns are <code>x^0, x^1, ..., x^(N-1)</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>polynomial.polynomial.polyvander</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.array([1, 2, 3, 5]) N = 3 np.vander(x, N) array(<a href="null"> 1,  1,  1],
-       [ 4,  2,  1],
-       [ 9,  3,  1],
-       [25,  5,  1</a>)</p>
-      <p>np.column_stack([x**(N-1-i) for i in range(N)]) array(<a href="null"> 1,  1,  1],
-       [ 4,  2,  1],
-       [ 9,  3,  1],
-       [25,  5,  1</a>)</p>
-      <p>x = np.array([1, 2, 3, 5]) np.vander(x) array(<a href="null">  1,   1,   1,   1],
-       [  8,   4,   2,   1],
-       [ 27,   9,   3,   1],
-       [125,  25,   5,   1</a>) np.vander(x, increasing=True) array(<a href="null">  1,   1,   1,   1],
-       [  1,   2,   4,   8],
-       [  1,   3,   9,  27],
-       [  1,   5,  25, 125</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The determinant of a square Vandermonde matrix is the product of the differences between the values of the input vector:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.linalg.det(np.vander(x)) 48.000000000000043 # may vary (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1) 48</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21007">view source</a></div></div><div class="public anchor" id="var-var"><h3>var</h3><div class="usage"><code>(var &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Compute the variance along the specified axis.</p>
-<p>Returns the variance of the array elements, a measure of the spread of a distribution. The variance is computed for the flattened array by default, otherwise over the specified axis.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  Array containing numbers whose variance is desired. If <code>a</code> is not an  array, a conversion is attempted. axis : None or int or tuple of ints, optional  Axis or axes along which the variance is computed. The default is to  compute the variance of the flattened array.</p>
-<pre><code>.. versionadded:: 1.7.0
-
-If this is a tuple of ints, a variance is performed over multiple axes,
-instead of a single axis or all the axes as before.
-</code></pre>
-<p>dtype : data-type, optional  Type to use in computing the variance. For arrays of integer type  the default is <code>float64</code>; for arrays of float types it is the same as  the array type. out : ndarray, optional  Alternate output array in which to place the result. It must have  the same shape as the expected output, but the type is cast if  necessary. ddof : int, optional  “Delta Degrees of Freedom”: the divisor used in the calculation is  <code>N - ddof</code>, where <code>N</code> represents the number of elements. By  default <code>ddof</code> is zero. keepdims : bool, optional  If this is set to True, the axes which are reduced are left  in the result as dimensions with size one. With this option,  the result will broadcast correctly against the input array.</p>
-<pre><code>If the default value is passed, then `keepdims` will not be
-passed through to the `var` method of sub-classes of
-`ndarray`, however any non-default value will be.  If the
-sub-class' method does not implement `keepdims` any
-exceptions will be raised.
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>variance : ndarray, see dtype parameter above  If <code>out=None</code>, returns a new array containing the variance;  otherwise, a reference to the output array is returned.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>std, mean, nanmean, nanstd, nanvar ufuncs-output-type</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The variance is the average of the squared deviations from the mean, i.e., <code>var = mean(abs(x - x.mean())**2)</code>.</p>
-<p>The mean is normally calculated as <code>x.sum() / N</code>, where <code>N = len(x)</code>. If, however, <code>ddof</code> is specified, the divisor <code>N - ddof</code> is used instead. In standard statistical practice, <code>ddof=1</code> provides an unbiased estimator of the variance of a hypothetical infinite population. <code>ddof=0</code> provides a maximum likelihood estimate of the variance for normally distributed variables.</p>
-<p>Note that for complex numbers, the absolute value is taken before squaring, so that the result is always real and nonnegative.</p>
-<p>For floating-point input, the variance is computed using the same precision the input has. Depending on the input data, this can cause the results to be inaccurate, especially for <code>float32</code> (see example below). Specifying a higher-accuracy accumulator using the <code>dtype</code> keyword can alleviate this issue.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 2], [3, 4</a>) np.var(a) 1.25 np.var(a, axis=0) array([1., 1.]) np.var(a, axis=1) array([0.25, 0.25])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>In single precision, var() can be inaccurate:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.zeros((2, 512*512), dtype=np.float32) a[0, :] = 1.0 a[1, :] = 0.1 np.var(a) 0.20250003</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Computing the variance in float64 is more accurate:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.var(a, dtype=np.float64) 0.20249999932944759 # may vary ((1-0.55)**2 + (0.1-0.55)**2)/2 0.2025</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L7035">view source</a></div></div><div class="public anchor" id="var-vdot"><h3>vdot</h3><div class="usage"><code>(vdot &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>vdot(a, b)</p>
-<p>Return the dot product of two vectors.</p>
-<p>The vdot(<code>a</code>, <code>b</code>) function handles complex numbers differently than dot(<code>a</code>, <code>b</code>). If the first argument is complex the complex conjugate of the first argument is used for the calculation of the dot product.</p>
-<p>Note that <code>vdot</code> handles multidimensional arrays differently than <code>dot</code>: it does <em>not</em> perform a matrix product, but flattens input arguments to 1-D vectors first. Consequently, it should only be used for vectors.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  If <code>a</code> is complex the complex conjugate is taken before calculation  of the dot product. b : array_like  Second argument to the dot product.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>output : ndarray  Dot product of <code>a</code> and <code>b</code>. Can be an int, float, or  complex depending on the types of <code>a</code> and <code>b</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>dot : Return the dot product without using the complex conjugate of the  first argument.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1+2j,3+4j]) b = np.array([5+6j,7+8j]) np.vdot(a, b) (70-8j) np.vdot(b, a) (70+8j)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Note that higher-dimensional arrays are flattened!</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array(<a href="null">1, 4], [5, 6</a>) b = np.array(<a href="null">4, 1], [2, 2</a>) np.vdot(a, b) 30 np.vdot(b, a) 30 1*4 + 4*1 + 5*2 + 6*2 30</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L140">view source</a></div></div><div class="public anchor" id="var-vectorize"><h3>vectorize</h3><div class="usage"><code>(vectorize self pyfunc &amp; [{otypes :otypes, doc :doc, excluded :excluded, cache :cache, signature :signature}])</code><code>(vectorize self pyfunc &amp; [{otypes :otypes, doc :doc, excluded :excluded, cache :cache}])</code><code>(vectorize self pyfunc &amp; [{otypes :otypes, doc :doc, excluded :excluded}])</code><code>(vectorize self pyfunc &amp; [{otypes :otypes, doc :doc}])</code><code>(vectorize self pyfunc &amp; [{otypes :otypes}])</code><code>(vectorize self pyfunc)</code></div><div class="doc"><div class="markdown"><p>vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False,  signature=None)</p>
-<p>Generalized function class.</p>
-<p>Define a vectorized function which takes a nested sequence of objects or numpy arrays as inputs and returns a single numpy array or a tuple of numpy arrays. The vectorized function evaluates <code>pyfunc</code> over successive tuples of the input arrays like the python map function, except it uses the broadcasting rules of numpy.</p>
-<p>The data type of the output of <code>vectorized</code> is determined by calling the function with the first element of the input. This can be avoided by specifying the <code>otypes</code> argument.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>pyfunc : callable  A python function or method. otypes : str or list of dtypes, optional  The output data type. It must be specified as either a string of  typecode characters or a list of data type specifiers. There should  be one data type specifier for each output. doc : str, optional  The docstring for the function. If None, the docstring will be the  <code>pyfunc.__doc__</code>. excluded : set, optional  Set of strings or integers representing the positional or keyword  arguments for which the function will not be vectorized. These will be  passed directly to <code>pyfunc</code> unmodified.</p>
-<pre><code>.. versionadded:: 1.7.0
-</code></pre>
-<p>cache : bool, optional  If <code>True</code>, then cache the first function call that determines the number  of outputs if <code>otypes</code> is not provided.</p>
-<pre><code>.. versionadded:: 1.7.0
-</code></pre>
-<p>signature : string, optional  Generalized universal function signature, e.g., <code>(m,n),(n)-&gt;(m)</code> for  vectorized matrix-vector multiplication. If provided, <code>pyfunc</code> will  be called with (and expected to return) arrays with shapes given by the  size of corresponding core dimensions. By default, <code>pyfunc</code> is  assumed to take scalars as input and output.</p>
-<pre><code>.. versionadded:: 1.12.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>vectorized : callable  Vectorized function.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>frompyfunc : Takes an arbitrary Python function and returns a ufunc</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>The <code>vectorize</code> function is provided primarily for convenience, not for performance. The implementation is essentially a for loop.</p>
-<p>If <code>otypes</code> is not specified, then a call to the function with the first argument will be used to determine the number of outputs. The results of this call will be cached if <code>cache</code> is <code>True</code> to prevent calling the function twice. However, to implement the cache, the original function must be wrapped which will slow down subsequent calls, so only do this if your function is expensive.</p>
-<p>The new keyword argument interface and <code>excluded</code> argument support further degrades performance.</p>
-<h2><a href="#references" name="references"></a>References</h2>
-<p>.. [1] NumPy Reference, section <code>Generalized Universal Function API
-       &lt;https://docs.scipy.org/doc/numpy/reference/c-api.generalized-ufuncs.html&gt;</code>_.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>def myfunc(a, b): … “Return a-b if a&gt;b, otherwise return a+b” … if a &gt; b: … return a - b … else: … return a + b</p>
-      <p>vfunc = np.vectorize(myfunc) vfunc([1, 2, 3, 4], 2) array([3, 4, 1, 2])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The docstring is taken from the input function to <code>vectorize</code> unless it is specified:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>vfunc.__doc__ ‘Return a-b if a&gt;b, otherwise return a+b’ vfunc = np.vectorize(myfunc, doc=‘Vectorized <code>myfunc</code>’) vfunc.__doc__ ‘Vectorized <code>myfunc</code>’</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The output type is determined by evaluating the first element of the input, unless it is specified:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>out = vfunc([1, 2, 3, 4], 2) type(out[0]) &lt;class ‘numpy.int64’&gt; vfunc = np.vectorize(myfunc, otypes=[float]) out = vfunc([1, 2, 3, 4], 2) type(out[0]) &lt;class ‘numpy.float64’&gt;</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The <code>excluded</code> argument can be used to prevent vectorizing over certain arguments. This can be useful for array-like arguments of a fixed length such as the coefficients for a polynomial as in <code>polyval</code>:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>def mypolyval(p, x): … _p = list(p) … res = _p.pop(0) … while _p: … res = res*x + _p.pop(0) … return res vpolyval = np.vectorize(mypolyval, excluded=[‘p’]) vpolyval(p=[1, 2, 3], x=[0, 1]) array([3, 6])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Positional arguments may also be excluded by specifying their position:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>vpolyval.excluded.add(0) vpolyval([1, 2, 3], x=[0, 1]) array([3, 6])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The <code>signature</code> argument allows for vectorizing functions that act on non-scalar arrays of fixed length. For example, you can use it for a vectorized calculation of Pearson correlation coefficient and its p-value:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>import scipy.stats pearsonr = np.vectorize(scipy.stats.pearsonr, … signature=‘(n),(n)-&gt;(),()’) pearsonr(<a href="null">0, 1, 2, 3</a>, <a href="null">1, 2, 3, 4], [4, 3, 2, 1</a>) (array([ 1., -1.]), array([ 0., 0.]))</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>Or for a vectorized convolution:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>convolve = np.vectorize(np.convolve, signature=‘(n),(m)-&gt;(k)’) convolve(np.eye(4), [1, 2, 1]) array(<a href="null">1., 2., 1., 0., 0., 0.],
-       [0., 1., 2., 1., 0., 0.],
-       [0., 0., 1., 2., 1., 0.],
-       [0., 0., 0., 1., 2., 1.</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L15421">view source</a></div></div><div class="public anchor" id="var-version"><h3>version</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21265">view source</a></div></div><div class="public anchor" id="var-VisibleDeprecationWarning"><h3>VisibleDeprecationWarning</h3><div class="usage"><code>(VisibleDeprecationWarning self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Visible deprecation warning.</p>
-<p>By default, python will not show deprecation warnings, so this class can be used when a very visible warning is helpful, for example because the usage is most likely a user bug.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L25026">view source</a></div></div><div class="public anchor" id="var-void"><h3>void</h3><div class="usage"><code>(void self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L4380">view source</a></div></div><div class="public anchor" id="var-void0"><h3>void0</h3><div class="usage"><code>(void0 self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2341">view source</a></div></div><div class="public anchor" id="var-vsplit"><h3>vsplit</h3><div class="usage"><code>(vsplit &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Split an array into multiple sub-arrays vertically (row-wise).</p>
-<p>Please refer to the <code>split</code> documentation. <code>vsplit</code> is equivalent to <code>split</code> with <code>axis=0</code> (default), the array is always split along the first axis regardless of the array dimension.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>split : Split an array into multiple sub-arrays of equal size.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(16.0).reshape(4, 4) x array(<a href="null"> 0.,   1.,   2.,   3.],
-       [ 4.,   5.,   6.,   7.],
-       [ 8.,   9.,  10.,  11.],
-       [12.,  13.,  14.,  15.</a>) np.vsplit(x, 2) [array([[0., 1., 2., 3.],  [4., 5., 6., 7.]]), array([[ 8., 9., 10., 11.],  [12., 13., 14., 15.]])] np.vsplit(x, np.array([3, 6])) [array([[ 0., 1., 2., 3.],  [ 4., 5., 6., 7.],  [ 8., 9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([], shape=(0, 4), dtype=float64)]</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>With a higher dimensional array the split is still along the first axis.</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(8.0).reshape(2, 2, 2) x array(<a href="null">[0.,  1.],
-        [2.,  3.</a>,  <a href="null">4.,  5.],
-        [6.,  7.</a>]) np.vsplit(x, 2) [array([[[0., 1.],  [2., 3.]]]), array([[[4., 5.],  [6., 7.]]])]</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L9223">view source</a></div></div><div class="public anchor" id="var-vstack"><h3>vstack</h3><div class="usage"><code>(vstack &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Stack arrays in sequence vertically (row wise).</p>
-<p>This is equivalent to concatenation along the first axis after 1-D arrays of shape <code>(N,)</code> have been reshaped to <code>(1,N)</code>. Rebuilds arrays divided by <code>vsplit</code>.</p>
-<p>This function makes most sense for arrays with up to 3 dimensions. For instance, for pixel-data with a height (first axis), width (second axis), and r/g/b channels (third axis). The functions <code>concatenate</code>, <code>stack</code> and <code>block</code> provide more general stacking and concatenation operations.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>tup : sequence of ndarrays  The arrays must have the same shape along all but the first axis.  1-D arrays must have the same length.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>stacked : ndarray  The array formed by stacking the given arrays, will be at least 2-D.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>stack : Join a sequence of arrays along a new axis. hstack : Stack arrays in sequence horizontally (column wise). dstack : Stack arrays in sequence depth wise (along third dimension). concatenate : Join a sequence of arrays along an existing axis. vsplit : Split array into a list of multiple sub-arrays vertically. block : Assemble arrays from blocks.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.array([1, 2, 3]) b = np.array([2, 3, 4]) np.vstack((a,b)) array(<a href="null">1, 2, 3],
-       [2, 3, 4</a>)</p>
-      <p>a = np.array(<a href="null">1], [2], [3</a>) b = np.array(<a href="null">2], [3], [4</a>) np.vstack((a,b)) array(<a href="null">1],
-       [2],
-       [3],
-       [2],
-       [3],
-       [4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L21212">view source</a></div></div><div class="public anchor" id="var-warnings"><h3>warnings</h3><div class="usage"></div><div class="doc"><div class="markdown"><p>Python part of the warnings subsystem.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L23717">view source</a></div></div><div class="public anchor" id="var-where"><h3>where</h3><div class="usage"><code>(where &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>where(condition, [x, y])</p>
-<p>Return elements chosen from <code>x</code> or <code>y</code> depending on <code>condition</code>.</p>
-<p>.. note::  When only <code>condition</code> is provided, this function is a shorthand for  <code>np.asarray(condition).nonzero()</code>. Using <code>nonzero</code> directly should be  preferred, as it behaves correctly for subclasses. The rest of this  documentation covers only the case where all three arguments are  provided.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>condition : array_like, bool  Where True, yield <code>x</code>, otherwise yield <code>y</code>. x, y : array_like  Values from which to choose. <code>x</code>, <code>y</code> and <code>condition</code> need to be  broadcastable to some shape.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  An array with elements from <code>x</code> where <code>condition</code> is True, and elements  from <code>y</code> elsewhere.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>choose nonzero : The function that is called when x and y are omitted</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>If all the arrays are 1-D, <code>where</code> is equivalent to::</p>
-<pre><code>[xv if c else yv
- for c, xv, yv in zip(condition, x, y)]
-</code></pre>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(10) a array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) np.where(a &lt; 5, a, 10*a) array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90])</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>This can be used on multidimensional arrays too:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.where(<a href="null">True, False], [True, True</a>, … <a href="null">1, 2], [3, 4</a>, … <a href="null">9, 8], [7, 6</a>) array(<a href="null">1, 8],
-       [3, 4</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote>
-<p>The shapes of x, y, and the condition are broadcast together:</p>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x, y = np.ogrid[:3, :4] np.where(x &lt; y, x, 10 + y) # both x and 10+y are broadcast array(<a href="null">10,  0,  0,  0],
-       [10, 11,  1,  1],
-       [10, 11, 12,  2</a>)</p>
-      <p>a = np.array(<a href="null">0, 1, 2],
-...               [0, 2, 4],
-...               [0, 3, 6</a>) np.where(a &lt; 4, a, -1) # -1 is broadcast array(<a href="null"> 0,  1,  2],
-       [ 0,  2, -1],
-       [ 0,  3, -1</a>)</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L10439">view source</a></div></div><div class="public anchor" id="var-who"><h3>who</h3><div class="usage"><code>(who &amp; [{vardict :vardict}])</code><code>(who)</code></div><div class="doc"><div class="markdown"><p>Print the NumPy arrays in the given dictionary.</p>
-<p>If there is no dictionary passed in or <code>vardict</code> is None then returns NumPy arrays in the globals() dictionary (all NumPy arrays in the namespace).</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>vardict : dict, optional  A dictionary possibly containing ndarrays. Default is globals().</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : None  Returns ‘None’.</p>
-<h2><a href="#notes" name="notes"></a>Notes</h2>
-<p>Prints out the name, shape, bytes and type of all of the ndarrays present in <code>vardict</code>.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>a = np.arange(10) b = np.ones(20) np.who()</p>
-      <h1><a href="#name-shape-bytes-type" name="name-shape-bytes-type"></a>Name Shape Bytes Type</h1>
-      <p>a 10 80 int64 b 20 160 float64 Upper bound on total bytes = 240</p>
-      <p>d = {‘x’: np.arange(2.0), ‘y’: np.arange(3.0), ‘txt’: ‘Some str’, … ‘idx’:5} np.who(d)</p>
-      <h1><a href="#name-shape-bytes-type" name="name-shape-bytes-type"></a>Name Shape Bytes Type</h1>
-      <p>x 2 16 float64 y 3 24 float64 Upper bound on total bytes = 40</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L3141">view source</a></div></div><div class="public anchor" id="var-WRAP"><h3>WRAP</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L22283">view source</a></div></div><div class="public anchor" id="var-zeros"><h3>zeros</h3><div class="usage"><code>(zeros self &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>zeros(shape, dtype=float, order=‘C’)</p>
-<p>Return a new array of given shape and type, filled with zeros.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>shape : int or tuple of ints  Shape of the new array, e.g., <code>(2, 3)</code> or <code>2</code>. dtype : data-type, optional  The desired data-type for the array, e.g., <code>numpy.int8</code>. Default is  <code>numpy.float64</code>. order : {‘C’, ‘F’}, optional, default: ‘C’  Whether to store multi-dimensional data in row-major  (C-style) or column-major (Fortran-style) order in  memory.</p>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Array of zeros with the given shape, dtype, and order.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>zeros_like : Return an array of zeros with shape and type of input. empty : Return a new uninitialized array. ones : Return a new array setting values to one. full : Return a new array of given shape filled with value.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>np.zeros(5) array([ 0., 0., 0., 0., 0.])</p>
-      <p>np.zeros((5,), dtype=int) array([0, 0, 0, 0, 0])</p>
-      <p>np.zeros((2, 1)) array(<a href="null"> 0.],
-       [ 0.</a>)</p>
-      <p>s = (2,2) np.zeros(s) array(<a href="null"> 0.,  0.],
-       [ 0.,  0.</a>)</p>
-      <p>np.zeros((2,), dtype=[(‘x’, ‘i4’), (‘y’, ‘i4’)]) # custom dtype array([(0, 0), (0, 0)],  dtype=[(‘x’, ‘&lt;i4’), (‘y’, ‘&lt;i4’)])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L2074">view source</a></div></div><div class="public anchor" id="var-zeros_like"><h3>zeros_like</h3><div class="usage"><code>(zeros_like &amp; [args {:as kwargs}])</code></div><div class="doc"><div class="markdown"><p>Return an array of zeros with the same shape and type as a given array.</p>
-<h2><a href="#parameters" name="parameters"></a>Parameters</h2>
-<p>a : array_like  The shape and data-type of <code>a</code> define these same attributes of  the returned array. dtype : data-type, optional  Overrides the data type of the result.</p>
-<pre><code>.. versionadded:: 1.6.0
-</code></pre>
-<p>order : {‘C’, ‘F’, ‘A’, or ‘K’}, optional  Overrides the memory layout of the result. ‘C’ means C-order,  ‘F’ means F-order, ‘A’ means ‘F’ if <code>a</code> is Fortran contiguous,  ‘C’ otherwise. ‘K’ means match the layout of <code>a</code> as closely  as possible.</p>
-<pre><code>.. versionadded:: 1.6.0
-</code></pre>
-<p>subok : bool, optional.  If True, then the newly created array will use the sub-class  type of ‘a’, otherwise it will be a base-class array. Defaults  to True. shape : int or sequence of ints, optional.  Overrides the shape of the result. If order=‘K’ and the number of  dimensions is unchanged, will try to keep order, otherwise,  order=‘C’ is implied.</p>
-<pre><code>.. versionadded:: 1.17.0
-</code></pre>
-<h2><a href="#returns" name="returns"></a>Returns</h2>
-<p>out : ndarray  Array of zeros with the same shape and type as <code>a</code>.</p>
-<h2><a href="#see-also" name="see-also"></a>See Also</h2>
-<p>empty_like : Return an empty array with shape and type of input. ones_like : Return an array of ones with shape and type of input. full_like : Return a new array with shape of input filled with value. zeros : Return a new array setting values to zero.</p>
-<h2><a href="#examples" name="examples"></a>Examples</h2>
-<blockquote>
-  <blockquote>
-    <blockquote>
-      <p>x = np.arange(6) x = x.reshape((2, 3)) x array(<a href="null">0, 1, 2],
-       [3, 4, 5</a>) np.zeros_like(x) array(<a href="null">0, 0, 0],
-       [0, 0, 0</a>)</p>
-      <p>y = np.arange(3, dtype=float) y array([0., 1., 2.]) np.zeros_like(y) array([0., 0., 0.])</p>
-    </blockquote>
-  </blockquote>
-</blockquote></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/python/numpy.clj#L28326">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index b145cfe..9f2c445 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index c2250dc..7c1ec3f 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-19</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree" style="top: -176px;"><span class="top" style="height: 185px;"></span><span class="bottom"></span></span><span>python</span></div></div></li><li class="depth-2 branch"><a href="python.builtins.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>builtins</span></div></a></li><li class="depth-2"><a href="python.numpy.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>numpy</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From 46152f802eb398f114f0b46d9adaaddb6294565a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 21 May 2021 07:08:47 -0600
Subject: [PATCH 344/456] snap

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 0b48830..2efd91b 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-20"
+                        :version "2.00-beta-21-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From 0cad303b6703d455c8705a98be1271f6a38ee129 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 21 May 2021 07:12:05 -0600
Subject: [PATCH 345/456] Updating changelog.

---
 CHANGELOG.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 94f2401..7ac19d2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-20
+ * [Issue 167] - `py.` fails in a go-loop.
+ * [PR 166](https://github.com/clj-python/libpython-clj/pull/166) - Fix codegen for special double values such
+   as Nan and infinity.
+ * [PR 165](https://github.com/clj-python/libpython-clj/pull/165) - remove codegen builtins and numpy due to
+   codegen pathway not being stable and potential version conflicts between e.g. numpy versions.
+
 ## 2.00-beta-19
  * [issue 126](https://github.com/clj-python/libpython-clj/issues/126) - Python maps sometimes fail to destructure.
 

From e590bb9053537f58b7d7de0d5d2056693d6361ac Mon Sep 17 00:00:00 2001
From: Stephen Hopper <stephenmhopper@gmail.com>
Date: Sat, 22 May 2021 09:44:49 -0500
Subject: [PATCH 346/456] Fix codegen quotes (#169)

* Remove codegen builtins and numpy namespaces to avoid collisions and version conflicts.

* Update codegen to pass string values through the escape-quotes function.
---
 src/libpython_clj2/codegen.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libpython_clj2/codegen.clj b/src/libpython_clj2/codegen.clj
index 7f0ea7b..f03197e 100644
--- a/src/libpython_clj2/codegen.clj
+++ b/src/libpython_clj2/codegen.clj
@@ -70,7 +70,7 @@
                        ;;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\"" vv)
+                       (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

From 576cdc2bed69490482b45f04fbb8ea9b710e9428 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 22 May 2021 08:48:06 -0600
Subject: [PATCH 347/456] 2.00-beta-21

---
 deps.edn                                 | 2 +-
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 14 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/deps.edn b/deps.edn
index 2efd91b..d914459 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-21-SNAPSHOT"
+                        :version "2.00-beta-21"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 3fd76a0..6fb599a 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index bf1fd69..5d5f2e9 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 2a6b4dd..cba967c 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 16d9c5c..0af3e6a 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index b55524c..52a22a8 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-20</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-21</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index fddad9a..37e96ca 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 0af1bc7..0f00e98 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index f3d8571..122752c 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 8bcfd77..aefd6b1 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 9616d3f..1bb34b2 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 7826bcc..1dbbc62 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 9f2c445..387a404 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 7c1ec3f..557db48 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-20</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From e0e780febe68900303f38650fd123e2a8bc0fe4c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 22 May 2021 08:48:19 -0600
Subject: [PATCH 348/456] snap

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index d914459..e900d19 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-21"
+                        :version "2.00-beta-22-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From 5147b83ff58beecf308064de3d27836fb7346248 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 22 May 2021 08:50:57 -0600
Subject: [PATCH 349/456] 2.00-beta-22

---
 deps.edn                                 | 2 +-
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 14 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/deps.edn b/deps.edn
index e900d19..e97ec14 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-22-SNAPSHOT"
+                        :version "2.00-beta-22"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 6fb599a..af138d2 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 5d5f2e9..843e174 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index cba967c..0bc9e1c 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 0af3e6a..79d451a 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 52a22a8..dfcbeda 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-21</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-22</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 37e96ca..3f87c8d 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 0f00e98..a8219fe 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 122752c..bfc0463 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index aefd6b1..a22c303 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 1bb34b2..a8c0e7c 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 1dbbc62..b10fbb0 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 387a404..777b820 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 557db48..9d9b2ca 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-21</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From acf905062d6e73e79ca7cbb986d32e93e9e6d0cf Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 22 May 2021 08:51:09 -0600
Subject: [PATCH 350/456] snap

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index e97ec14..c0188f3 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-22"
+                        :version "2.00-beta-23-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From e66c3dd3094410739befd43806ff6a75852fe234 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 22 May 2021 08:51:54 -0600
Subject: [PATCH 351/456] Updating changelog.

---
 CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7ac19d2..88eb908 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,8 @@
 # Time for a ChangeLog!
 
+## 2.00-beta-22
+ * Fix to PR-166 - strings in docs weren't properly escaped.
+
 ## 2.00-beta-20
  * [Issue 167] - `py.` fails in a go-loop.
  * [PR 166](https://github.com/clj-python/libpython-clj/pull/166) - Fix codegen for special double values such

From f37e62f3c03f464d0483c59f3b5863ae203ddda7 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sun, 30 May 2021 09:02:33 -0400
Subject: [PATCH 352/456] fix warning messages (#171)

---
 src/libpython_clj2/metadata.clj | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/libpython_clj2/metadata.clj b/src/libpython_clj2/metadata.clj
index 6cfa8d1..4ee76b4 100644
--- a/src/libpython_clj2/metadata.clj
+++ b/src/libpython_clj2/metadata.clj
@@ -347,6 +347,7 @@
                  (map? v)
                  (has-attr? target-item k))
         (let [att-val (get-attr target-item k)]
+          (ns-unmap ns-symbol (symbol k))
           (intern ns-symbol
                   (with-meta (symbol k)
                     (if no-arglists?
@@ -370,9 +371,13 @@
     (when (map? v)
       (cond
         (contains? (:flags v) :callable?)
-        (intern ns-symbol (with-meta (symbol k) v)
-                (fn [inst & args]
-                  (apply (get-attr inst k) args)))
+        (do
+          (ns-unmap ns-symbol (symbol k))
+          (intern ns-symbol (with-meta (symbol k) v)
+                  (fn [inst & args]
+                    (apply (get-attr inst k) args))))
         (contains? v :value)
-        (intern ns-symbol (with-meta (symbol k) v) (:value v)))))
+        (do
+          (ns-unmap ns-symbol (symbol k))
+          (intern ns-symbol (with-meta (symbol k) v) (:value v))))))
   ns-symbol)

From 0b85a1a71e50d8091f8fb287cc74c4be5c6e0e67 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 2 Aug 2021 09:42:18 -0600
Subject: [PATCH 353/456] Upgrade to latest dtype-next

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index c0188f3..c9b4677 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "8.00"}
+        cnuernber/dtype-next {:mvn/version "8.022"}
         net.java.dev.jna/jna {:mvn/version "5.7.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 

From 3a0a6267504c28207e5da08319d7b61b63c93159 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 4 Aug 2021 08:19:13 -0600
Subject: [PATCH 354/456] Fixes #174

---
 src/libpython_clj2/python/bridge_as_jvm.clj | 5 ++++-
 test/libpython_clj2/python_test.clj         | 9 +++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/libpython_clj2/python/bridge_as_jvm.clj b/src/libpython_clj2/python/bridge_as_jvm.clj
index 21829a9..f2e5ca2 100644
--- a/src/libpython_clj2/python/bridge_as_jvm.clj
+++ b/src/libpython_clj2/python/bridge_as_jvm.clj
@@ -15,7 +15,8 @@
   (:import [java.util Map Set]
            [clojure.lang IFn MapEntry Fn]
            [tech.v3.datatype.ffi Pointer]
-           [tech.v3.datatype ObjectBuffer]))
+           [tech.v3.datatype ObjectBuffer]
+           [libpython_clj2.python.protocols PBridgeToPython]))
 
 
 (extend-protocol py-proto/PBridgeToJVM
@@ -241,6 +242,8 @@
   "Slightly clever so we can pass ranges and such as function arguments."
   ([item opts]
    (cond
+     (instance? PBridgeToPython item)
+     (py-proto/as-python item opts)
      (dt-proto/convertible-to-range? item)
      (py-copy/->py-range item)
      (dtype/reader? item)
diff --git a/test/libpython_clj2/python_test.clj b/test/libpython_clj2/python_test.clj
index 4761cf6..bc50c6d 100644
--- a/test/libpython_clj2/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -414,6 +414,15 @@ class Foo:
     (is (nil? b))))
 
 
+(deftest incorrect-numpy-marshal
+  (let [np (py/import-module "numpy")
+        p (py/$a np full [2 5] 7)
+        tp (py/get-attr np "transpose")
+        pp (tp p)]
+    (is (= [5 2]
+           (py/->jvm (py/get-attr pp "shape"))))))
+
+
 (comment
   (require '[libpython-clj.require :refer [require-python]])
 

From 423ed6a0c967f0dfc44ec84927d67d317069adf3 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 4 Aug 2021 08:22:53 -0600
Subject: [PATCH 355/456] 2.00-beta-23

---
 deps.edn                                 | 2 +-
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 14 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/deps.edn b/deps.edn
index c9b4677..766876a 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-23-SNAPSHOT"
+                        :version "2.00-beta-23"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index af138d2..26108c3 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 843e174..aaefb38 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 0bc9e1c..82e26e5 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 79d451a..99e30f6 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index dfcbeda..1594385 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-22</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.00-beta-23</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 3f87c8d..9fb5a29 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index a8219fe..6e5806f 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index bfc0463..0fb10b7 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index a22c303..5663664 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index a8c0e7c..5100711 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index b10fbb0..b5e8bef 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 777b820..c42028b 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 9d9b2ca..7cd5827 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-22</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From c4e9f7b388155a28b1c5c9c5cc8a487a9a7e9cc1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 4 Aug 2021 08:23:06 -0600
Subject: [PATCH 356/456] snap

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 766876a..f9d5a0f 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-23"
+                        :version "2.00-beta-24-SNAPSHOT"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy

From 7db63ec8ea876a7384d70ed6b9b47ec7f175d654 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 18 Aug 2021 13:55:25 -0600
Subject: [PATCH 357/456] Allow kw argument instance functions.  2.000 Release

---
 CHANGELOG.md                                |   9 +-
 deps.edn                                    |   4 +-
 src/libpython_clj2/python.clj               |  13 +-
 src/libpython_clj2/python/bridge_as_jvm.clj |  27 +--
 src/libpython_clj2/python/class.clj         |  32 +++-
 src/libpython_clj2/python/fn.clj            | 173 +++++++++++++++-----
 test/libpython_clj2/classes_test.clj        |  10 +-
 7 files changed, 193 insertions(+), 75 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 88eb908..ed2abdb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,11 @@
 # Time for a ChangeLog!
+## 2.000
+ * You can now create instance functions that accept both positional and keyword arguments -
+   libpython-clj2.python/make-kw-instance-fn.  See test at
+   test/libpython-clj2.python.classes-test.
+ * latest dtype-next - see documentation for tech.v3.datatype/set-value!.
+ * Fix for using ffi on arm64 platforms.
+
 
 ## 2.00-beta-22
  * Fix to PR-166 - strings in docs weren't properly escaped.
@@ -17,7 +24,7 @@
  * Additional fix for 162 to allow booleans to be considered primitives and be output inline.
  * Experimental fix for [issue 164](https://github.com/clj-python/libpython-clj/issues/164) - Unsigned int64 fails with
    `OverflowError: int too big to convert`.
- 
+
 ## 2.00-beta-17
  * Almost fix fo [issue 163](https://github.com/clj-python/libpython-clj/issues/163) - codegen fails with JVM primitives.
 
diff --git a/deps.edn b/deps.edn
index f9d5a0f..75955d7 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "8.022"}
+        cnuernber/dtype-next {:mvn/version "8.024"}
         net.java.dev.jna/jna {:mvn/version "5.7.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.00-beta-24-SNAPSHOT"
+                        :version "2.000"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index f0a35a1..80c0006 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -384,11 +384,22 @@ Options:
   "Make an callable instance function - a function which will be passed the 'this'
   object as it's first argument.  In addition, this function calls `make-callable`
   with a `arg-converter` defaulted to `as-jvm`.  See documentation for
-  make-callable."
+  [[libpython-clj2.python.class/make-instance-fn."
   ([ifn options] (py-class/make-tuple-instance-fn ifn options))
   ([ifn] (make-instance-fn ifn nil)))
 
 
+(defn make-kw-instance-fn
+  "Make an kw callable instance function - function by default is passed 2 arguments,
+  the positional argument vector and a map of keyword arguments.  Results are marshalled
+  back to python using [[libpython-clj2.python.fn/bridged-fn-arg->python]] which is also
+  used when bridging an object into python.  See documentation for
+  [[libpython-clj2.python.class/make-kw-instance-fn]]."
+  ([ifn options] (py-class/make-kw-instance-fn ifn options))
+  ([ifn] (make-kw-instance-fn ifn nil)))
+
+
+
 (defn ^:no-doc make-tuple-instance-fn
   [ifn & {:as options}]
   (make-instance-fn ifn options))
diff --git a/src/libpython_clj2/python/bridge_as_jvm.clj b/src/libpython_clj2/python/bridge_as_jvm.clj
index f2e5ca2..49e446f 100644
--- a/src/libpython_clj2/python/bridge_as_jvm.clj
+++ b/src/libpython_clj2/python/bridge_as_jvm.clj
@@ -201,7 +201,7 @@
          py-proto/PyCall
          (call [callable# arglist# kw-arg-map#]
            (with-gil
-             (-> (py-fn/call-py-fn @pyobj*# arglist# kw-arg-map# fn-arg->python)
+             (-> (py-fn/call-py-fn @pyobj*# arglist# kw-arg-map# py-fn/bridged-fn-arg->python)
                  (py-base/as-jvm))))
          (marshal-return [callable# retval#]
            (with-gil
@@ -238,35 +238,12 @@
   (.write ^java.io.Writer w ^String (.toString ^Object pyobj)))
 
 
-(defn fn-arg->python
-  "Slightly clever so we can pass ranges and such as function arguments."
-  ([item opts]
-   (cond
-     (instance? PBridgeToPython item)
-     (py-proto/as-python item opts)
-     (dt-proto/convertible-to-range? item)
-     (py-copy/->py-range item)
-     (dtype/reader? item)
-     (py-proto/->python (dtype/->reader item) opts)
-     ;;There is one more case here for iterables that aren't anything else -
-     ;; - specifically for sequences.
-     (and (instance? Iterable item)
-          (not (instance? Map item))
-          (not (instance? String item))
-          (not (instance? Set item)))
-     (py-proto/as-python item opts)
-     :else
-     (py-base/->python item opts)))
-  ([item]
-   (fn-arg->python item nil)))
-
-
 (defn call-impl-fn
   [fn-name att-map args]
   (if-let [py-fn* (get att-map fn-name)]
     ;;laziness is carefully constructed here in order to allow the arguments to
     ;;be released within the context of the function call during fn.clj call-py-fn.
-    (-> (py-fn/call-py-fn @py-fn* args nil fn-arg->python)
+    (-> (py-fn/call-py-fn @py-fn* args nil py-fn/bridged-fn-arg->python)
         (py-base/as-jvm))
     (throw (UnsupportedOperationException.
             (format "Python object has no attribute: %s"
diff --git a/src/libpython_clj2/python/class.clj b/src/libpython_clj2/python/class.clj
index 4e53310..5cc6587 100644
--- a/src/libpython_clj2/python/class.clj
+++ b/src/libpython_clj2/python/class.clj
@@ -10,7 +10,7 @@
   (:import [clojure.lang IFn]))
 
 
-(defn- py-fn->instance-fn
+(defn py-fn->instance-fn
   "Given a python callable, return an instance function meant to be used
   in class definitions."
   [py-fn]
@@ -39,6 +39,36 @@
          (py-fn->instance-fn)))))
 
 
+(defn make-kw-instance-fn
+  "Make an instance function - a function which will be passed the 'this' object as
+  it's first argument.  In this case the default behavior is to
+  pass as-jvm bridged python object ptr args and kw dict args to the clojure function without
+  marshalling.  Self will be the first argument of the arg vector.
+
+
+
+  Options:
+
+  * `:kw-arg-converter` - passed two arguments, the positional arguments as a python ptr
+  and the keyword arguments as a python pointer.  The clj-fn is 'applied' to the result
+  of `:arg-converter` which has the same default as [[make-tuple-fn]].
+
+  * `:result-converter` - defaults to the same argument conversion rules of bridged
+     objects."
+  ([clj-fn & [{:keys [arg-converter
+                      result-converter]
+               :or {arg-converter py-base/as-jvm}
+               :as options}]]
+   (let [options (assoc options :arg-converter arg-converter)
+         result-converter (or result-converter #(py-fn/bridged-fn-arg->python % options))]
+     (py-ffi/with-gil
+       ;;Explicity set arg-converter to override make-tuple-fn's default
+       ;;->jvm arg-converter.
+       (-> (py-fn/make-kw-fn clj-fn (assoc options :result-converter result-converter))
+           ;;Mark this as an instance function.
+           (py-fn->instance-fn))))))
+
+
 (defn create-class
   "Create a new class object.  Any callable values in the cls-hashmap
   will be presented as instance methods.
diff --git a/src/libpython_clj2/python/fn.clj b/src/libpython_clj2/python/fn.clj
index 3f8a86a..31e0485 100644
--- a/src/libpython_clj2/python/fn.clj
+++ b/src/libpython_clj2/python/fn.clj
@@ -9,12 +9,17 @@
             [libpython-clj2.python.base :as py-base]
             [libpython-clj2.python.protocols :as py-proto]
             [libpython-clj2.python.gc :as pygc]
+            [libpython-clj2.python.copy :as py-copy]
             [tech.v3.datatype.ffi :as dt-ffi]
             [tech.v3.datatype.ffi.size-t :as ffi-size-t]
             [tech.v3.datatype.struct :as dt-struct]
+            [tech.v3.datatype :as dtype]
+            [tech.v3.datatype.protocols :as dt-proto]
             [clojure.tools.logging :as log]
             [clojure.stacktrace :as st])
-  (:import [tech.v3.datatype.ffi Pointer]))
+  (:import [tech.v3.datatype.ffi Pointer]
+           [java.util Map Set]
+           [libpython_clj2.python.protocols PBridgeToPython]))
 
 (set! *warn-on-reflection* true)
 
@@ -26,7 +31,10 @@
                        {:name :ml_doc :datatype (ffi-size-t/ptr-t-type)}]))
 
 
-(def tuple-fn-iface* (delay  (dt-ffi/define-foreign-interface :pointer? [:pointer :pointer])))
+(def tuple-fn-iface*
+  (delay (dt-ffi/define-foreign-interface :pointer? [:pointer :pointer])))
+(def kw-fn-iface*
+  (delay (dt-ffi/define-foreign-interface :pointer? [:pointer :pointer :pointer])))
 
 
 (def ^{:tag 'long} METH_VARARGS  0x0001)
@@ -35,6 +43,87 @@
 (def ^{:tag 'long} METH_NOARGS   0x0004)
 
 
+(defn- internal-make-py-c-fn
+  [ifn fn-iface raw-arg-converter meth-type
+   {:keys [name doc result-converter]
+    :or {name "_unamed"
+         doc "no documentation provided"}}]
+  (py-ffi/with-gil
+    (let [fn-inst
+          (dt-ffi/instantiate-foreign-interface
+           fn-iface
+           (fn [self tuple-args & [kw-args]]
+             (try
+               (let [retval (apply ifn (raw-arg-converter tuple-args kw-args))]
+                 (if result-converter
+                   (py-ffi/untracked->python retval result-converter)
+                   retval))
+               (catch Throwable e
+                 (log/error e "Error executing clojure function.")
+                 (py-ffi/PyErr_SetString
+                  (py-ffi/py-exc-type)
+                  (format "%s:%s" e (with-out-str
+                                      (st/print-stack-trace e))))))))
+          fn-ptr (dt-ffi/foreign-interface-instance->c fn-iface fn-inst)
+          ;;no resource tracking - we leak the struct
+          method-def (dt-struct/new-struct :pymethoddef {:resource-type nil
+                                                         :container-type :native-heap})
+          name (dt-ffi/string->c name {:resource-type nil})
+          doc (dt-ffi/string->c doc {:resource-type nil})]
+      (.put method-def :ml_name (.address (dt-ffi/->pointer name)))
+      (.put method-def :ml_meth (.address (dt-ffi/->pointer fn-ptr)))
+      (.put method-def :ml_flags meth-type)
+      (.put method-def :ml_doc (.address (dt-ffi/->pointer doc)))
+      ;;the method def cannot ever go out of scope
+      (py-ffi/retain-forever (gensym) {:md method-def
+                                       :name name
+                                       :doc doc
+                                       :fn-ptr fn-ptr
+                                       :fn-inst fn-inst})
+      ;;no self, no module reference
+      (-> (py-ffi/PyCFunction_NewEx method-def nil nil)
+          (py-ffi/track-pyobject)))))
+
+
+(defn raw-tuple-arg-converter
+  [arg-converter tuple-args kw-args]
+  ;;no kw arguments
+  (->> (range (py-ffi/PyTuple_Size tuple-args))
+       (mapv (fn [idx]
+               (-> (py-ffi/PyTuple_GetItem tuple-args idx)
+                   (arg-converter))))))
+
+
+(defn bridged-fn-arg->python
+  "Slightly clever so we can pass ranges and such as function arguments."
+  ([item opts]
+   (cond
+     (instance? PBridgeToPython item)
+     (py-proto/as-python item opts)
+     (dt-proto/convertible-to-range? item)
+     (py-copy/->py-range item)
+     (dtype/reader? item)
+     (py-proto/->python (dtype/->reader item) opts)
+     ;;There is one more case here for iterables that aren't anything else -
+     ;; - specifically for sequences.
+     (and (instance? Iterable item)
+          (not (instance? Map item))
+          (not (instance? String item))
+          (not (instance? Set item)))
+     (py-proto/as-python item opts)
+     :else
+     (py-base/->python item opts)))
+  ([item]
+   (bridged-fn-arg->python item nil)))
+
+
+(defn convert-kw-args
+  [{:keys [arg-converter] :as options} tuple-args kw-args]
+  [(raw-tuple-arg-converter arg-converter tuple-args nil)
+   (->> (py-proto/as-jvm kw-args options)
+        (into {}))])
+
+
 (defn make-tuple-fn
   ([ifn {:keys [arg-converter
                 result-converter
@@ -42,52 +131,48 @@
          :or {arg-converter py-base/->jvm
               result-converter py-base/->python
               name "_unamed"
-              doc "no documentation provided"}}]
-   (py-ffi/with-gil
-     (let [arg-converter (or arg-converter identity)
-           fn-inst
-           (dt-ffi/instantiate-foreign-interface
-            @tuple-fn-iface*
-            (fn [self tuple-args]
-              (try
-                (let [retval
-                      (apply ifn
-                             (->> (range (py-ffi/PyTuple_Size tuple-args))
-                                  (map (fn [idx]
-                                         (-> (py-ffi/PyTuple_GetItem tuple-args idx)
-                                             (arg-converter))))))]
-                  (if result-converter
-                    (py-ffi/untracked->python retval result-converter)
-                    retval))
-                (catch Throwable e
-                  (log/error e "Error executing clojure function.")
-                  (py-ffi/PyErr_SetString
-                   (py-ffi/py-exc-type)
-                   (format "%s:%s" e (with-out-str
-                                       (st/print-stack-trace e))))))))
-           fn-ptr (dt-ffi/foreign-interface-instance->c @tuple-fn-iface* fn-inst)
-           ;;no resource tracking - we leak the struct
-           method-def (dt-struct/new-struct :pymethoddef {:resource-type nil
-                                                          :container-type :native-heap})
-           name (dt-ffi/string->c name {:resource-type nil})
-           doc (dt-ffi/string->c doc {:resource-type nil})]
-       (.put method-def :ml_name (.address (dt-ffi/->pointer name)))
-       (.put method-def :ml_meth (.address (dt-ffi/->pointer fn-ptr)))
-       (.put method-def :ml_flags METH_VARARGS)
-       (.put method-def :ml_doc (.address (dt-ffi/->pointer doc)))
-       ;;the method def cannot ever go out of scope
-       (py-ffi/retain-forever (gensym) {:md method-def
-                                        :name name
-                                        :doc doc
-                                        :fn-ptr fn-ptr
-                                        :fn-inst fn-inst})
-       ;;no self, no module reference
-       (-> (py-ffi/PyCFunction_NewEx method-def nil nil)
-           (py-ffi/track-pyobject)))))
+              doc "no documentation provided"}
+         :as options}]
+   (let [arg-converter (or arg-converter identity)
+         ;;apply defaults to options map.
+         options (assoc options
+                        :arg-converter arg-converter
+                        :result-converter result-converter
+                        :name name
+                        :doc doc)]
+     (internal-make-py-c-fn ifn @tuple-fn-iface*
+                            #(raw-tuple-arg-converter arg-converter %1 %2)
+                            METH_VARARGS
+                            options)))
   ([ifn]
    (make-tuple-fn ifn nil)))
 
 
+(defn make-kw-fn
+  ([ifn {:keys [arg-converter
+                result-converter
+                name doc
+                kw-arg-converter]
+         :or {arg-converter py-base/->jvm
+              result-converter py-base/->python
+              name "_unamed"
+              doc "no documentation provided"}
+         :as options}]
+   (let [arg-converter (or arg-converter :identity)
+         options (assoc options
+                        :arg-converter arg-converter
+                        :result-converter result-converter
+                        :name name
+                        :doc doc)
+         kw-arg-converter (or kw-arg-converter #(convert-kw-args options %1 %2))]
+     (internal-make-py-c-fn ifn @kw-fn-iface*
+                            kw-arg-converter
+                            (bit-or METH_VARARGS METH_KEYWORDS)
+                            options)))
+  ([ifn]
+   (make-kw-fn ifn nil)))
+
+
 (defn call-py-fn
   [callable arglist kw-arg-map arg-converter]
   (py-ffi/with-gil
diff --git a/test/libpython_clj2/classes_test.clj b/test/libpython_clj2/classes_test.clj
index 600229d..4bc64ae 100644
--- a/test/libpython_clj2/classes_test.clj
+++ b/test/libpython_clj2/classes_test.clj
@@ -33,10 +33,18 @@
                                (pr-str {"name" (py/py.- self name)
                                         "shares" (py/py.- self shares)
                                         "price" (py/py.- self price)})))
+                  "kw_clj_fn" (py/make-kw-instance-fn
+                               (fn [pos-args kw-args]
+                                 (let [self (first pos-args)
+                                       price (double (py/py.- self price))]
+                                   ;;keywords become strings!!
+                                   (apply + price (kw-args "a")
+                                          (drop 1 pos-args)))))
                   "clsattr" 55})
         new-instance (cls-obj "ACME" 50 90)]
     (is (= 4500
            (py/$a new-instance cost)))
     (is (= 55 (py/py.- new-instance clsattr)))
     (is (= {"name" "ACME", "shares" 50, "price" 90}
-           (edn/read-string (.toString new-instance))))))
+           (edn/read-string (.toString new-instance))))
+    (is (= 116.0 (py/call-attr-kw new-instance "kw_clj_fn" [1 2 3] {:a 20})))))

From d20942d72a5a364d2816ad53d943e6446c127bcc Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 18 Aug 2021 13:58:14 -0600
Subject: [PATCH 358/456] 2.000

---
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.python.html          | 22 +++++++++++-----------
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 13 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index 26108c3..3c14be1 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index aaefb38..93f3ad9 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 82e26e5..b4b9b6a 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 99e30f6..1a46a3e 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 1594385..eb9ab63 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.00-beta-23</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.000</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 9fb5a29..11166f0 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 6e5806f..9aa97d4 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 0fb10b7..e9dfa0b 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -12,9 +12,9 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L462">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L473">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L249">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L320">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L308">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L314">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L237">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L157">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L443">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L255">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L267">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L261">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L243">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L180">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L291">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L432">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L473">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L484">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L249">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L320">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L308">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L314">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L237">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L157">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L454">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L255">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L267">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L261">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L243">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L180">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L291">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L443">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -38,7 +38,7 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L397">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L408">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
 #'user/c
@@ -48,7 +48,7 @@
 2
 user&gt; c
 3
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L633">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L644">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -64,15 +64,15 @@
     </ul>
   </li>
 </ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L279">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L359">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for make-callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L383">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L166">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L359">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L383">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L392">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L166">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
 <p>Options:</p>
 <ul>
   <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L610">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L621">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L499">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L521">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L490">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L510">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L532">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L501">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L494">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -82,8 +82,8 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L556">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L273">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L567">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L273">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L326">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L110">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L454">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L326">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L110">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L465">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 5663664..a68fd28 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 5100711..136dd75 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index b5e8bef..ace86fc 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index c42028b..bf92ae0 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 7cd5827..c11733e 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.00-beta-23</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From bd586da8541a2c359153eca40b241106c74f671d Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Fri, 22 Oct 2021 09:31:33 -0400
Subject: [PATCH 359/456] possible fix (#177)

throw if empty path to reveal more debug info
---
 src/libpython_clj2/python.clj | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 80c0006..f1bcc78 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -629,7 +629,9 @@ user> (py/call-attr inst \"addarg\" 10)
   (when (seq item-path)
     (if-let [module-retval (try
                              (import-module item-path)
-                             (catch Throwable e nil))]
+                             (catch Exception e
+                               (when-not (seq (module-path-string item-path))
+                                 (throw e))))]
       (if reload?
         (let [import-lib (import-module "importlib")]
           (call-attr import-lib "reload" module-retval))

From 7d74009a1caea0b98d4150ef8b11707733b549ce Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 22 Oct 2021 07:35:51 -0600
Subject: [PATCH 360/456] Attempting fixes for m-1 mac.

---
 deps.edn | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/deps.edn b/deps.edn
index 75955d7..b0a32df 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,7 +1,7 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "8.024"}
-        net.java.dev.jna/jna {:mvn/version "5.7.0"}
+        cnuernber/dtype-next {:mvn/version "8.033"}
+        net.java.dev.jna/jna {:mvn/version "5.9.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
  :aliases {:dev

From d647b853f609c396c08e5a058e634de10764e175 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 22 Oct 2021 07:43:15 -0600
Subject: [PATCH 361/456] Fixes #179

---
 src/libpython_clj2/python.clj | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 80c0006..cb7f7dc 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -227,6 +227,12 @@ user> (py/py. np linspace 2 3 :num 10)
   pyobj)
 
 
+(defn has-item?
+  "Return true if the python object has an item.  Calls __hasitem__."
+  [pyobj item-name]
+  (with-gil (py-proto/has-item? pyobj item-name)))
+
+
 (defn set-items!
   "Set a sequence of [name value]. Returns pyobj"
   [pyobj item-seq]
@@ -276,6 +282,29 @@ user> (py/py. np linspace 2 3 :num 10)
   (py-ffi/with-gil (py-proto/python-type v)))
 
 
+(defmacro import-as
+  "Import a module and assign it to a var.  Documentation is included."
+  [module-path varname]
+  `(let [~'mod-data (import-module ~(name module-path))]
+     (def ~varname (import-module ~(name module-path)))
+     (alter-meta! #'~varname assoc :doc (get-attr ~'mod-data "__doc__"))
+     #'~varname))
+
+
+(defmacro from-import
+  "Support for the from a import b,c style of importing modules and symbols in python.
+  Documentation is included."
+  [module-path item & args]
+  `(do
+     (let [~'mod-data (import-module ~(name module-path))]
+       ~@(map (fn [varname]
+                `(let [~'var-data (get-attr ~'mod-data ~(name varname))]
+                   (def ~varname ~'var-data)
+                   (alter-meta! #'~varname assoc :doc (get-attr ~'var-data "__doc__"))
+                   #'~varname))
+              (concat [item] args)))))
+
+
 (defn is-instance?
   "Return true if inst is an instance of cls.  Note that arguments
   are reversed as compared to `instance?`"

From 245bbff6fb24f214e974cd17fbf4aa802bfe2c6b Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 22 Oct 2021 07:46:20 -0600
Subject: [PATCH 362/456] 2.001

---
 deps.edn                                 |  2 +-
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.python.html          | 24 ++++++++++++------------
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 14 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/deps.edn b/deps.edn
index b0a32df..f4ecd87 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.000"
+                        :version "2.001"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 3c14be1..8057f32 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 93f3ad9..f6c37b3 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index b4b9b6a..3710304 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 1a46a3e..09e98d7 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index eb9ab63..f1dce34 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.000</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.001</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 11166f0..061ccfd 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 9aa97d4..213f37c 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index e9dfa0b..8bc816f 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -12,9 +12,9 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L473">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L484">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L249">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L320">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L308">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L314">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L237">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L157">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L454">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L255">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L267">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L261">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L243">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L180">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L291">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L443">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L502">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L513">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L255">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L349">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L337">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L343">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L243">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L157">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L261">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L273">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L267">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L249">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L180">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L320">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L472">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -38,7 +38,7 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L408">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L437">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
 #'user/c
@@ -48,7 +48,7 @@
 2
 user&gt; c
 3
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L644">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L673">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L294">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L285">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -63,16 +63,16 @@
       <li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
     </ul>
   </li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L279">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L359">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L383">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L392">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L166">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L308">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L388">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L412">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L421">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L166">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
 <p>Options:</p>
 <ul>
   <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L621">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L650">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L510">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L532">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L501">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L494">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L539">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L561">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L530">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L523">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -82,8 +82,8 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L567">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L273">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L596">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L279">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L326">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L110">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L465">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L355">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L236">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L110">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L494">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index a68fd28..d8532a6 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 136dd75..fc52417 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index ace86fc..79f5677 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index bf92ae0..62b5fb9 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index c11733e..86ec08e 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.000</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From 81fa2d73d1e6cfc614accc2a92d1eca54dc6138f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 22 Oct 2021 07:51:15 -0600
Subject: [PATCH 363/456] 2.002

---
 deps.edn                                 | 2 +-
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.python.html          | 4 ++--
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 14 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/deps.edn b/deps.edn
index f4ecd87..ce57e11 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.001"
+                        :version "2.002"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index 8057f32..ba12858 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index f6c37b3..435ac59 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 3710304..968dd93 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 09e98d7..33090cc 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index f1dce34..7ba05c9 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.001</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.002</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 061ccfd..3796b35 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 213f37c..e3b509a 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 8bc816f..734697f 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -48,7 +48,7 @@
 2
 user&gt; c
 3
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L673">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L294">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L285">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L675">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L294">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L285">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index d8532a6..d7b74ae 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index fc52417..e346c45 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 79f5677..e89552c 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 62b5fb9..9c83fa6 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 86ec08e..8ee6e1c 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.001</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From dcdcc77ba582a7a09d698d80c2a991cf3d8e151a Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Fri, 22 Oct 2021 17:24:42 +0200
Subject: [PATCH 364/456] added load-file function (#176)

* added load-file function

* added docu for loading clojure file in embedded

* added finally

* proposal of single clojure-init function

* fixed fn name and args

* added load_clojure_file
---
 cljbridge.py       | 32 +++++++++++++++++++++++++++++---
 topics/embedded.md |  9 +++++++++
 2 files changed, 38 insertions(+), 3 deletions(-)

diff --git a/cljbridge.py b/cljbridge.py
index 1385047..720a857 100644
--- a/cljbridge.py
+++ b/cljbridge.py
@@ -138,7 +138,7 @@ def py_dict_to_keyword_map(py_dict):
     return hash_map
 
 
-def init_clojure_repl(**kw_args):
+def init_jvm(**kw_args):
     """Initialize clojure with extra arguments specifically for embedding a cider-nrepl
     server.  Then start an nrepl server.  The port will both be printed to stdout and
     output to a .nrepl_server file.  This function does not return as it leaves the GIL
@@ -157,10 +157,36 @@ def init_clojure_repl(**kw_args):
       bind=\"0.0.0.0\""""
     javabridge.start_vm(run_headless=True, class_path=repl_classpath(**kw_args))
     init_clojure_runtime()
+    if "load_user_clj" in kw_args:
+        resolve_call_fn("clojure.core/load-file",
+                            "user.clj")
     init_libpy_embedded()
-    resolve_call_fn("libpython-clj2.embedded/start-repl!",
-                    py_dict_to_keyword_map(kw_args))
 
+    if "start_repl" in kw_args:
+        resolve_call_fn("libpython-clj2.embedded/start-repl!",
+                        py_dict_to_keyword_map(kw_args))
+
+    if "kill_vm_after" in kw_args:
+        javabridge.kill_vm()
+
+def load_clojure_file(**kw_args):
+    """Initializes clojure and loads and runs a Clojure file. This function load the specified clojure file
+    and kills then the jvm and returns.
+
+    Keyword arguments are:
+
+     * `classpath_args` - List of additional arguments that be passed to the clojure
+      process when building the classpath.
+     * `clj_file` Clojure file to be loaded with Clojure `load-file` fn
+    """
+    javabridge.start_vm(run_headless=True, class_path=repl_classpath(**kw_args))
+    init_clojure_runtime()
+    init_libpy_embedded()
+    try:
+        resolve_call_fn("clojure.core/load-file",
+                        kw_args["clj_file"])
+    finally:
+        javabridge.kill_vm()
 
 class GenericJavaObj:
     __str__ = javabridge.make_method("toString", "()Ljava/lang/String;")
diff --git a/topics/embedded.md b/topics/embedded.md
index 039894b..c4384d3 100644
--- a/topics/embedded.md
+++ b/topics/embedded.md
@@ -154,6 +154,15 @@ in the main module -
 Printing from Clojure:  [1 2 3 4 Embedded Clojure FTW!!]
 >>>
 ```
+## Loading and running a Clojure file in embedded mode
+
+We can runs as well a .clj file in embedded mode. 
+The following does this without an interactive pytho shell, it just runs the provided clj file with
+`clojure.core/load-file`
+
+```bash
+python3 -c 'import cljbridge;cljbridge.load_clojure_file(clj_file="my-file.clj")'
+```
 
 
 ## Are You Not Entertained???

From 6e7368b44aaabddf565a5bbf3a240e60bf3dcbf8 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 22 Oct 2021 09:30:45 -0600
Subject: [PATCH 365/456] 2.003

---
 deps.edn                                 | 9 +++++----
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 6 +++++-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 14 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/deps.edn b/deps.edn
index ce57e11..af2847a 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,14 +1,15 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "8.033"}
+        cnuernber/dtype-next {:mvn/version "8.034"}
         net.java.dev.jna/jna {:mvn/version "5.9.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
  :aliases {:dev
            {:extra-deps {criterium/criterium {:mvn/version"0.4.5"}
                          ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}}
-           :jdk-16
-           {:jvm-opts ["--add-modules" "jdk.incubator.foreign" "-Dforeign.restricted=permit"]}
+           :jdk-17
+           {:jvm-opts ["--add-modules" "jdk.incubator.foreign"
+                       "--enable-native-access=ALL-UNNAMED"]}
            :codox
            {:extra-deps {codox-theme-rdash/codox-theme-rdash {:mvn/version "0.1.2"}
                          nrepl/nrepl {:mvn/version "0.8.3"}
@@ -46,7 +47,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.002"
+                        :version "2.003"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index ba12858..e9b3147 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 435ac59..d61b5a0 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 968dd93..fee567b 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
@@ -95,6 +95,10 @@ <h2><a href="#and-back-to-python-" name="and-back-to-python-"></a>And Back to Py
 Printing from Clojure:  [1 2 3 4 Embedded Clojure FTW!!]
 &gt;&gt;&gt;
 </code></pre>
+<h2><a href="#loading-and-running-a-clojure-file-in-embedded-mode" name="loading-and-running-a-clojure-file-in-embedded-mode"></a>Loading and running a Clojure file in embedded mode</h2>
+<p>We can runs as well a .clj file in embedded mode. The following does this without an interactive pytho shell, it just runs the provided clj file with <code>clojure.core/load-file</code></p>
+<pre><code class="bash">python3 -c 'import cljbridge;cljbridge.load_clojure_file(clj_file="my-file.clj")'
+</code></pre>
 <h2><a href="#are-you-not-entertained-" name="are-you-not-entertained-"></a>Are You Not Entertained???</h2>
 <p>So there you have it, embedding a Clojure repl in a Python process and passing data in between these two systems. This sidesteps a <em>ton</em> of issues with embedding Python and provides another interesting set of possibilities, essentially extending existing Python systems with some of the greatest tech the JVM has to offer :-).</p>
 <ul>
diff --git a/docs/environments.html b/docs/environments.html
index 33090cc..9f133cf 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 7ba05c9..dec84f0 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.002</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.003</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 3796b35..c43ef48 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index e3b509a..94e5acf 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 734697f..316c88e 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index d7b74ae..e8f1151 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index e346c45..6d32c7b 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index e89552c..aba01d1 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 9c83fa6..30c73c9 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 8ee6e1c..887fb85 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.002</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From 0d703b7bea42414a195f8823c6ab78e95fba6c22 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 23 Oct 2021 13:07:07 -0600
Subject: [PATCH 366/456] Updating readme.

---
 README.md | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index 8006dce..6d4f8c7 100644
--- a/README.md
+++ b/README.md
@@ -6,8 +6,11 @@
 [![travis integration](https://travis-ci.com/clj-python/libpython-clj.svg?branch=master)](https://travis-ci.com/clj-python/libpython-clj)
 
 
- ## BETA Versions Are HOT!  Huge New Features! You Can't Afford To Miss Out!
- 
+ ## New Versions Are HOT!  Huge New Features! You Can't Afford To Miss Out!
+
+ * JDK-17 and Mac M-1 support.  To use libpython-clj2 with jdk-17 you need to enable the foreign module -
+   see [deps.edn](https://github.com/clj-python/libpython-clj/blob/6e7368b44aaabddf565a5bbf3a240e60bf3dcbf8/deps.edn#L10)
+   for a working alias.
  * You can now [Embed Clojure in Python](https://clj-python.github.io/libpython-clj/embedded.html) - you can launch a Clojure REPL from a Python host process.
  * Main namespace is now `libpython-clj2` -- docs have not been updated.
  * **32 bit support**!!
@@ -18,12 +21,12 @@
  * - Note - Please avoid deprecated versions such as `[cnuernber/libpython-clj "1.36"]` (***note name change***).
  * [API Documentation](https://clj-python.github.io/libpython-clj/)
  * This library, which has received the efforts of many excellent people, is built mainly upon
-   [cnuernber/dtype-next](https://github.com/cnuernber/dtype-next/) and the 
+   [cnuernber/dtype-next](https://github.com/cnuernber/dtype-next/) and the
    [JNA library](https://github.com/java-native-access/jna).
- * [Static code generation](https://clj-python.github.io/libpython-clj/libpython-clj2.codegen.html#var-write-namespace.21) - generate clojure namespaces 
+ * [Static code generation](https://clj-python.github.io/libpython-clj/libpython-clj2.codegen.html#var-write-namespace.21) - generate clojure namespaces
    wrapping python modules that are safe to use with AOT and load much faster than analogous `require-python` calls.  These namespace will not
    automatically initialize the python subsystem -- initialize! must be called first (or a nice exception is throw).
-   
+
 
 ## libpython-clj features
 
@@ -115,7 +118,7 @@ This code is a concrete example that generates an
 #### Update project.clj
 ```clojure
 {...
-  ;; This namespace going to run when the REPL is up. 
+  ;; This namespace going to run when the REPL is up.
   :repl-options {:init-ns my-py-clj.config}
 ...}
 ```

From 1ee4f97b3f248e9f9093f4fbdccb131054440555 Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Sun, 7 Nov 2021 15:23:56 +0100
Subject: [PATCH 367/456] fixed start repl in example code (#181)

---
 topics/embedded.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/topics/embedded.md b/topics/embedded.md
index c4384d3..9c13b8f 100644
--- a/topics/embedded.md
+++ b/topics/embedded.md
@@ -62,7 +62,7 @@ Python 3.8.5 (default, Jan 27 2021, 15:41:15)
 Type "help", "copyright", "credits" or "license" for more information.
 >>> import cljbridge
 >>> test_var=10
->>> cljbridge.init_clojure_repl()
+>>> cljbridge.init_jvm(start_repl=True)
 Mar 11, 2021 9:08:47 AM clojure.tools.logging$eval3186$fn__3189 invoke
 INFO: nREPL server started on port 40241 on host localhost - nrepl://localhost:40241
 ```

From ec73d6de53b54057d111e41c2fdc2dffab44f614 Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Sun, 28 Nov 2021 20:37:17 +0100
Subject: [PATCH 368/456] instructions for using cljbridge package (#184)

---
 topics/embedded.md | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/topics/embedded.md b/topics/embedded.md
index 9c13b8f..c89db20 100644
--- a/topics/embedded.md
+++ b/topics/embedded.md
@@ -49,10 +49,17 @@ If the installation cannot find 'jni.h' then most likely you have the Java runti
 ## From the Python REPL
 
 
-The next step involves starting a python repl from our libpython-clj base directory.
-This is only required because we have a special
-[python script](https://github.com/clj-python/libpython-clj/blob/master/cljbridge.py)
-that has code to start a Java VM with a correct classpath.  So we start by importing
+The next step involves starting a python repl.
+
+This requires a python library `cljbridge`,
+which can be installed via
+
+```
+export JAVA_HOME=<--YOUR JAVA HOME-->
+python3 -m pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple  cljbridge
+```
+
+So we start by importing
 that script:
 
 
@@ -60,7 +67,7 @@ that script:
 Python 3.8.5 (default, Jan 27 2021, 15:41:15)
 [GCC 9.3.0] on linux
 Type "help", "copyright", "credits" or "license" for more information.
->>> import cljbridge
+>>> from clojurebridge import cljbridge
 >>> test_var=10
 >>> cljbridge.init_jvm(start_repl=True)
 Mar 11, 2021 9:08:47 AM clojure.tools.logging$eval3186$fn__3189 invoke

From 51e78e1b0cb2272773c5adfe123980cd688f87e1 Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Sun, 12 Dec 2021 20:27:14 +0100
Subject: [PATCH 369/456] Use cljbridge python lib (#185)

* instructions for using cljbridge package

* remove instrucions for javabridge

gets installed as deps of clojurebridge

* fixed wording

* cljbridge is now in pypi

* deleted bridge.py
---
 cljbridge.py       | 212 ---------------------------------------------
 topics/embedded.md |  25 +++---
 2 files changed, 13 insertions(+), 224 deletions(-)
 delete mode 100644 cljbridge.py

diff --git a/cljbridge.py b/cljbridge.py
deleted file mode 100644
index 720a857..0000000
--- a/cljbridge.py
+++ /dev/null
@@ -1,212 +0,0 @@
-"""Python bindings to start a Clojure repl from a python process.  Relies on
-libpython-clj being in a deps.edn pathway as clojure is called from the command
- line to build the classpath.  Expects javabridge to be installed and functional.
-
-Javabridge will dynamically find the java library that corresponds with calling 'java'
- from the command line and load it.  We then initialize Clojure and provide pathways
-to require namespaces, find symbols, and call functions.
-
-There are two import initialization methods - init_clojure and init_clojure_repl - these
-take care of starting up everything in the correct order.
-"""
-import subprocess
-import javabridge
-
-try:
-    from collections.abc import Callable  # noqa
-except ImportError:
-    from collections import Callable
-
-
-def init_clojure_runtime():
-    """Initialize the clojure runtime.  This needs to happen at least once before
-attempting to require a namespace or lookup a clojure var."""
-    javabridge.static_call("clojure/lang/RT", "init", "()V")
-
-
-def find_clj_var(fn_ns, fn_name):
-    """Use the clojure runtime to find a var.  Clojure vars are placeholders in
-namespaces that forward their operations to the data they point to.  This allows
-someone to hold a var and but recompile a namespace to get different behavior.  They
-implement both `clojure.lang.IFn` and `clojure.lang.IDeref` so they can act like a
-function and you can dereference them to get to their original value."""
-    return javabridge.static_call("clojure/lang/RT",
-                                  "var",
-                                  "(Ljava/lang/String;Ljava/lang/String;)Lclojure/lang/Var;",
-                                  fn_ns,
-                                  fn_name)
-
-
-class CLJFn(Callable):
-    """Construct a python callable from a clojure object.  This callable will forward
-function calls to it's Clojure object expecting a clojure.lang.IFn interface."""
-    applyTo = javabridge.make_method("applyTo", "(clojure/lang/ISeq;)Ljava/lang/Object;")
-    def __init__(self, ifn_obj):
-        self.o = ifn_obj
-
-    def __call__(self, *args, **kw_args):
-        if not kw_args:
-            invoker = getattr(self, "invoke"+str(len(args)))
-            return invoker(*args)
-        else:
-            raise Exception("Unable to handle kw_args for now")
-        print(len(args), len(kw_args))
-
-
-for i in range(20):
-    opargs = ""
-    for j in range(i):
-        opargs += "Ljava/lang/Object;"
-    setattr(CLJFn, "invoke" + str(i),
-            javabridge.make_method("invoke", "(" + opargs + ")Ljava/lang/Object;" ))
-
-
-def resolve_fn(namespaced_name):
-    """Resolve a clojure var given a fully qualified namespace name.  The return value
-    is callable.  Note that the namespace itself needs to be required first."""
-    ns_name, sym_name = namespaced_name.split("/")
-    return CLJFn(find_clj_var(ns_name, sym_name))
-
-
-def resolve_call_fn(namespaced_fn_name, *args):
-    """Resolve a function given a fully qualified namespace name and call it."""
-    return resolve_fn(namespaced_fn_name)(*args)
-
-def symbol(sym_name):
-    """Create a clojure symbol from a string"""
-    return javabridge.static_call("clojure/lang/Symbol", "intern",
-                                  "(Ljava/lang/String;)Lclojure/lang/Symbol;", sym_name)
-
-__REQUIRE_FN = None
-
-def require(ns_name):
-    """Require a clojure namespace.  This needs to happen before you find symbols
-    in that namespace else you will be uninitialized var errors."""
-    if not __REQUIRE_FN:
-        _REQUIRE_FN = resolve_fn("clojure.core/require")
-    return _REQUIRE_FN(symbol(ns_name))
-
-
-def init_libpy_embedded():
-    """Initialize libpy on a mode where it looks for symbols in the local process and
-    it itself doesn't attempt to run the python intialization procedures but expects
-    the python system to be previously initialized."""
-    require("libpython-clj2.embedded")
-    return resolve_call_fn("libpython-clj2.embedded/initialize!")
-
-
-def classpath(classpath_args=[]):
-    """Call clojure at the command line and return the classpath in as a list of
-    strings.  Clojure will pick up a local deps.edn or deps can be specified inline."""
-    return subprocess.check_output(['clojure'] + list(classpath_args) + ['-Spath']).decode("utf-8").strip().split(':')
-
-
-DEFAULT_NREPL_VERSION = "0.8.3"
-DEFAULT_CIDER_NREPL_VERSION = "0.25.5"
-
-
-def repl_classpath(nrepl_version=DEFAULT_NREPL_VERSION,
-                   cider_nrepl_version=DEFAULT_CIDER_NREPL_VERSION,
-                   classpath_args=[], **kw_args):
-    """Return the classpath with the correct deps to run nrepl and cider.
-    Positional arguments are added after the -Sdeps argument to start the
-    nrepl server."""
-    return classpath(classpath_args=["-Sdeps", '{:deps {nrepl/nrepl {:mvn/version "%s"} cider/cider-nrepl {:mvn/version "%s"}}}' % (nrepl_version, cider_nrepl_version)]
-                        + list(classpath_args))
-
-
-def init_clojure(classpath_args=[]):
-    """Initialize a vanilla clojure process using the clojure command line to output
-    the classpath to use for the java vm. At the return of this function clojure is
-    initialized and libpython-clj2.python's public functions will work.
-
-    * classpath_args - List of arguments that will be passed to the clojure command
-    line process when building the classpath. """
-    javabridge.start_vm(run_headless=True,
-                        class_path=classpath(classpath_args=classpath_args))
-    init_clojure_runtime()
-    init_libpy_embedded()
-    return True
-
-
-def py_dict_to_keyword_map(py_dict):
-    hash_map = None
-    keyword = resolve_fn("clojure.core/keyword")
-    assoc  = resolve_fn("clojure.core/assoc")
-    for k in py_dict:
-        hash_map = assoc(hash_map, keyword(k), py_dict[k])
-    return hash_map
-
-
-def init_jvm(**kw_args):
-    """Initialize clojure with extra arguments specifically for embedding a cider-nrepl
-    server.  Then start an nrepl server.  The port will both be printed to stdout and
-    output to a .nrepl_server file.  This function does not return as it leaves the GIL
-    released so that repl threads have access to Python.  libpython-clj2.python is
-    initialized 'require-python' pathways should work.
-
-
-    Keyword arguments in python are mapped to a hash-map of keyword options and
-    passed directly to clojure so any nrepl are valid arguments to this function.
-
-    * `classpath_args` - List of additional arguments that be passed to the clojure
-      process when building the classpath.
-    * `port` - Integer port to open up repl.  A random port will be found if not 
-      provided.
-    * `bind` - Bind address.  If you are having connectivity issues try 
-      bind=\"0.0.0.0\""""
-    javabridge.start_vm(run_headless=True, class_path=repl_classpath(**kw_args))
-    init_clojure_runtime()
-    if "load_user_clj" in kw_args:
-        resolve_call_fn("clojure.core/load-file",
-                            "user.clj")
-    init_libpy_embedded()
-
-    if "start_repl" in kw_args:
-        resolve_call_fn("libpython-clj2.embedded/start-repl!",
-                        py_dict_to_keyword_map(kw_args))
-
-    if "kill_vm_after" in kw_args:
-        javabridge.kill_vm()
-
-def load_clojure_file(**kw_args):
-    """Initializes clojure and loads and runs a Clojure file. This function load the specified clojure file
-    and kills then the jvm and returns.
-
-    Keyword arguments are:
-
-     * `classpath_args` - List of additional arguments that be passed to the clojure
-      process when building the classpath.
-     * `clj_file` Clojure file to be loaded with Clojure `load-file` fn
-    """
-    javabridge.start_vm(run_headless=True, class_path=repl_classpath(**kw_args))
-    init_clojure_runtime()
-    init_libpy_embedded()
-    try:
-        resolve_call_fn("clojure.core/load-file",
-                        kw_args["clj_file"])
-    finally:
-        javabridge.kill_vm()
-
-class GenericJavaObj:
-    __str__ = javabridge.make_method("toString", "()Ljava/lang/String;")
-    get_class = javabridge.make_method("getClass", "()Ljava/lang/Class;")
-    __repl__ = javabridge.make_method("toString", "()Ljava/lang/String;")
-    def __init__(self, jobj):
-        self.o = jobj
-
-
-def longCast(jobj):
-    "Cast a java object to a primitive long value."
-    return javabridge.static_call("clojure/lang/RT", "longCast",
-                                  "(Ljava/lang/Object;)J", jobj)
-
-
-def to_ptr(pyobj):
-    """Create a tech.v3.datatype.ffi.Pointer java object from a python object.  This
-    allows you to pass python objects directly into libpython-clj2.python-derived
-    pathways (such as ->jvm).  If java is going to hold onto the python data for
-    a long time and it will fall out of Python scope  object should be
-    'incref-tracked' - 'libpython-clj2.python.ffi/incref-track-pyobject'."""
-    return javabridge.static_call("tech/v3/datatype/ffi/Pointer", "constructNonZero",
-                                  "(J)Ltech/v3/datatype/ffi/Pointer;", id(pyobj))
diff --git a/topics/embedded.md b/topics/embedded.md
index c89db20..4a0c520 100644
--- a/topics/embedded.md
+++ b/topics/embedded.md
@@ -27,24 +27,20 @@ Due to the above reasons there is a solid argument for, if possible, embedding
 Clojure into Python allowing the Python executable to be the host process.
 
 
-## Enter: javabridge
+## Enter: cljbridge
 
 
 Python already had a nascent system for embedding Java in Python - the
-[javabridge module](https://pypi.org/project/javabridge/).  You will need to have
-javabridge installed in your Python environment.  In order to compile `javabridge`
-requires the JDK installed and **not just the JRE**.  [tristanstraub](https://github.com/tristanstraub/)
+[javabridge module](https://pypi.org/project/javabridge/). 
+
+We went a step further and provide `cljbridge` python module.
+
+In order to compile `javabridge`
+a JDK is required and **not just the JRE**.  [tristanstraub](https://github.com/tristanstraub/)
 had found a way to use this in order to work with [Blender](https://github.com/tristanstraub/blender-clj/).
 We took a bit more time and worked out ways to smooth out these interactions
 and make sure they were supported throughout the system.
 
-```console
-python3 -m pip install javabridge
-```
-
-If the installation cannot find 'jni.h' then most likely you have the Java runtime
-(JRE) installed as opposed to the Java development kit (JDK).
-
 
 ## From the Python REPL
 
@@ -56,9 +52,14 @@ which can be installed via
 
 ```
 export JAVA_HOME=<--YOUR JAVA HOME-->
-python3 -m pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple  cljbridge
+python3 -m pip install cljbridge
 ```
 
+This will install and eventually compile `javabridge` as well.
+
+If the installation cannot find 'jni.h' then most likely you have the Java runtime
+(JRE) installed as opposed to the Java development kit (JDK).
+
 So we start by importing
 that script:
 

From 9a4d7068f52e3894035fcf28fb3feaf168ae4dd4 Mon Sep 17 00:00:00 2001
From: Mohanadas Harish Chandar <harishcm.pals@gmail.com>
Date: Sat, 25 Dec 2021 02:51:43 +0800
Subject: [PATCH 370/456] Improve autodetection of :python-home (#190)

Co-authored-by: Harish Mohanadas <harish.mohanadas@outlook.com>
---
 src/libpython_clj2/python/info.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libpython_clj2/python/info.clj b/src/libpython_clj2/python/info.clj
index 2004ba9..df8688d 100644
--- a/src/libpython_clj2/python/info.clj
+++ b/src/libpython_clj2/python/info.clj
@@ -69,7 +69,7 @@ print(json.dumps(
     (seq (System/getenv "PYTHONHOME"))
     (System/getenv "PYTHONHOME")
     :else
-    (:prefix system-info)))
+    (:base-prefix system-info)))
 
 
 (defn java-library-path-addendum

From 199c352c48ff4159ccae18d64d35aba68dcb3680 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 24 Dec 2021 11:56:31 -0700
Subject: [PATCH 371/456] Update dependencies.

---
 .gitignore | 4 +++-
 deps.edn   | 4 ++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/.gitignore b/.gitignore
index 8776644..1ccfa12 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,4 +17,6 @@ a.out
 *.pom
 *.pom.asc
 /.idea
-*.iml
\ No newline at end of file
+*.iml
+.lsp
+.clj-kondo
\ No newline at end of file
diff --git a/deps.edn b/deps.edn
index af2847a..e207e3e 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,7 +1,7 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "8.034"}
-        net.java.dev.jna/jna {:mvn/version "5.9.0"}
+        cnuernber/dtype-next {:mvn/version "8.053"}
+        net.java.dev.jna/jna {:mvn/version "5.10.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
  :aliases {:dev

From 15c965bd060a07d8c7e5d55cb2ea5cbf0e546d22 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 24 Dec 2021 11:59:42 -0700
Subject: [PATCH 372/456] Release 2.004

---
 deps.edn                                 |  2 +-
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       | 22 ++++++++++++++--------
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.python.html          |  2 +-
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 14 files changed, 27 insertions(+), 21 deletions(-)

diff --git a/deps.edn b/deps.edn
index e207e3e..a25e34b 100644
--- a/deps.edn
+++ b/deps.edn
@@ -47,7 +47,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.003"
+                        :version "2.004"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index e9b3147..50052e6 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index d61b5a0..b7cf71e 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index fee567b..0c04994 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
@@ -9,19 +9,25 @@
   <li>Replicating the exact python environment is error prone especially when Python environment managers such as <code>pyenv</code> and <code>Conda</code> are taken into account.</li>
 </ol>
 <p>Due to the above reasons there is a solid argument for, if possible, embedding Clojure into Python allowing the Python executable to be the host process.</p>
-<h2><a href="#enter-javabridge" name="enter-javabridge"></a>Enter: javabridge</h2>
-<p>Python already had a nascent system for embedding Java in Python - the <a href="https://pypi.org/project/javabridge/">javabridge module</a>. You will need to have javabridge installed in your Python environment. In order to compile <code>javabridge</code> requires the JDK installed and <strong>not just the JRE</strong>. <a href="https://github.com/tristanstraub/">tristanstraub</a> had found a way to use this in order to work with <a href="https://github.com/tristanstraub/blender-clj/">Blender</a>. We took a bit more time and worked out ways to smooth out these interactions and make sure they were supported throughout the system.</p>
-<pre><code class="console">python3 -m pip install javabridge
+<h2><a href="#enter-cljbridge" name="enter-cljbridge"></a>Enter: cljbridge</h2>
+<p>Python already had a nascent system for embedding Java in Python - the <a href="https://pypi.org/project/javabridge/">javabridge module</a>. </p>
+<p>We went a step further and provide <code>cljbridge</code> python module.</p>
+<p>In order to compile <code>javabridge</code> a JDK is required and <strong>not just the JRE</strong>. <a href="https://github.com/tristanstraub/">tristanstraub</a> had found a way to use this in order to work with <a href="https://github.com/tristanstraub/blender-clj/">Blender</a>. We took a bit more time and worked out ways to smooth out these interactions and make sure they were supported throughout the system.</p>
+<h2><a href="#from-the-python-repl" name="from-the-python-repl"></a>From the Python REPL</h2>
+<p>The next step involves starting a python repl.</p>
+<p>This requires a python library <code>cljbridge</code>, which can be installed via</p>
+<pre><code>export JAVA_HOME=&lt;--YOUR JAVA HOME--&gt;
+python3 -m pip install cljbridge
 </code></pre>
+<p>This will install and eventually compile <code>javabridge</code> as well.</p>
 <p>If the installation cannot find ‘jni.h’ then most likely you have the Java runtime (JRE) installed as opposed to the Java development kit (JDK).</p>
-<h2><a href="#from-the-python-repl" name="from-the-python-repl"></a>From the Python REPL</h2>
-<p>The next step involves starting a python repl from our libpython-clj base directory. This is only required because we have a special <a href="https://github.com/clj-python/libpython-clj/blob/master/cljbridge.py">python script</a> that has code to start a Java VM with a correct classpath. So we start by importing that script:</p>
+<p>So we start by importing that script:</p>
 <pre><code class="python">Python 3.8.5 (default, Jan 27 2021, 15:41:15)
 [GCC 9.3.0] on linux
 Type "help", "copyright", "credits" or "license" for more information.
-&gt;&gt;&gt; import cljbridge
+&gt;&gt;&gt; from clojurebridge import cljbridge
 &gt;&gt;&gt; test_var=10
-&gt;&gt;&gt; cljbridge.init_clojure_repl()
+&gt;&gt;&gt; cljbridge.init_jvm(start_repl=True)
 Mar 11, 2021 9:08:47 AM clojure.tools.logging$eval3186$fn__3189 invoke
 INFO: nREPL server started on port 40241 on host localhost - nrepl://localhost:40241
 </code></pre>
diff --git a/docs/environments.html b/docs/environments.html
index 9f133cf..fd95473 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index dec84f0..f0f267e 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.003</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.004</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index c43ef48..e028605 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 94e5acf..771c314 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 316c88e..14053e3 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index e8f1151..1cd657d 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 6d32c7b..b268626 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index aba01d1..d841612 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 30c73c9..f4832ba 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 887fb85..ac5aa8e 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.003</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From af59adbc2c697c244ec37c16d22e8b30ce04fd22 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 27 Dec 2021 08:41:14 -0700
Subject: [PATCH 373/456] Initial AOT java api.

---
 deps.edn                               |  23 +++-
 src/libpython_clj2/java_api.clj        | 155 +++++++++++++++++++++++++
 src/libpython_clj2/python.clj          |   3 +-
 src/libpython_clj2/python/np_array.clj |   4 +-
 test/libpython_clj2/java_api_test.clj  |  24 ++++
 5 files changed, 204 insertions(+), 5 deletions(-)
 create mode 100644 src/libpython_clj2/java_api.clj
 create mode 100644 test/libpython_clj2/java_api_test.clj

diff --git a/deps.edn b/deps.edn
index a25e34b..4880933 100644
--- a/deps.edn
+++ b/deps.edn
@@ -31,6 +31,7 @@
                                      libpython-clj2.python.np-array
                                      libpython-clj2.require
                                      libpython-clj2.embedded
+                                     libpython-clj2.java-api
                                      python.builtins
                                      python.numpy]}}
            :test
@@ -55,4 +56,24 @@
             :exec-fn deps-deploy.deps-deploy/deploy
             :exec-args {:installer :remote
                         :sign-releases? true
-                        :artifact "target/libpython-clj.jar"}}}}
+                        :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"}}
+
+           }}
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
new file mode 100644
index 0000000..2372a23
--- /dev/null
+++ b/src/libpython_clj2/java_api.clj
@@ -0,0 +1,155 @@
+(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
+  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."
+  [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
+  a java.util.Map of the respective contexts.  See documentation under
+  [[libpython-clj2.python/run-simple-string]] - specifically this will never return
+  the result of the last statement ran - you need to set a value in the global or local
+  context."
+  ^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
+  will be deallocated once the context is released.  The code must not return references
+  to live python objects."
+  [^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
+  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`."
+  [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
+  a python object."
+  [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` - One of \"int8\" \"uint8\"  "
+  [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\",
+  \"shape\", and \"data\"."
+  [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)}))
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 1b63f34..295e29c 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -144,8 +144,7 @@ user> (py/py. np linspace 2 3 :num 10)
 
 
 (defn import-module
-  "Import a python module returning an implementation of java.util.Map wrapping
-  the module object and consisting of module attributes."
+  "Import a python module.  Module entries can be accessed via get-attr."
   [modname]
   (with-gil
     (if-let [mod (py-ffi/PyImport_ImportModule modname)]
diff --git a/src/libpython_clj2/python/np_array.clj b/src/libpython_clj2/python/np_array.clj
index c6b211e..9152288 100644
--- a/src/libpython_clj2/python/np_array.clj
+++ b/src/libpython_clj2/python/np_array.clj
@@ -139,8 +139,8 @@
     :uint8 "c_ubyte"
     :int16 "c_short"
     :uint16 "c_ushort"
-    :int32 "c_long"
-    :uint32 "c_ulong"
+    :int32 "c_int"
+    :uint32 "c_uint"
     :int64 "c_longlong"
     :uint64 "c_ulonglong"
     :float32 "c_float"
diff --git a/test/libpython_clj2/java_api_test.clj b/test/libpython_clj2/java_api_test.clj
new file mode 100644
index 0000000..e15e2f9
--- /dev/null
+++ b/test/libpython_clj2/java_api_test.clj
@@ -0,0 +1,24 @@
+(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")))))))

From 1b679c4ddadd0e8b0d380da2b723d82cb6881233 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 27 Dec 2021 08:47:26 -0700
Subject: [PATCH 374/456] Initial AOT deploy

---
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        |  3 +++
 docs/libpython-clj2.python.html          | 24 ++++++++++++------------
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 scripts/deploy-aot                       |  9 +++++++++
 15 files changed, 36 insertions(+), 24 deletions(-)
 create mode 100644 docs/libpython-clj2.java-api.html
 create mode 100755 scripts/deploy-aot

diff --git a/docs/Usage.html b/docs/Usage.html
index 50052e6..a25b98b 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index b7cf71e..7581490 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 0c04994..b389c69 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index fd95473..daf6451 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index f0f267e..17af816 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.004</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.004</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index e028605..73a231f 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 771c314..6fb5071 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
new file mode 100644
index 0000000..2631e29
--- /dev/null
+++ b/docs/libpython-clj2.java-api.html
@@ -0,0 +1,3 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L148">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L115">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L133">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L126">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L139">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L76">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L99">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L70">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L88">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L109">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L34">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L60">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L47">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L82">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L104">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 14053e3..f0783c3 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -12,9 +12,9 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L502">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L513">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L255">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L349">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L337">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L343">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L243">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L157">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L261">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L273">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L267">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L249">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L180">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L320">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L472">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L501">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L512">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L254">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L348">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L336">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L342">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L242">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L156">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L482">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L260">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L272">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L266">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L248">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L179">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L185">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L319">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L471">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -38,7 +38,7 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L437">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L436">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
 #'user/c
@@ -48,7 +48,7 @@
 2
 user&gt; c
 3
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L675">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L294">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L217">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L285">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module returning an implementation of java.util.Map wrapping the module object and consisting of module attributes.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L674">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L174">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L293">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L190">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L210">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L229">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L284">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via get-attr.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -63,16 +63,16 @@
       <li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
     </ul>
   </li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L308">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L388">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L412">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L421">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L166">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L307">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L387">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L411">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L420">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L165">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
 <p>Options:</p>
 <ul>
   <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L650">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L649">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L539">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L561">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L530">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L523">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L538">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L560">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L529">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L522">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -82,8 +82,8 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L596">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L279">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L595">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L278">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L355">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L223">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L236">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L110">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L494">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L354">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L196">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L203">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L222">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L235">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L110">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L493">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 1cd657d..c3edc26 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index b268626..fb081df 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index d841612..586986b 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index f4832ba..41295c1 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index ac5aa8e..f0fbd03 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/scripts/deploy-aot b/scripts/deploy-aot
new file mode 100755
index 0000000..1aa0ea1
--- /dev/null
+++ b/scripts/deploy-aot
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+
+set -e
+
+rm -rf classes
+clj -X:codox
+clj -X:depstar-aot
+clj -X:deploy-aot

From 20656c118a9b3e81fc70a5d6ff42d4d8e9dfdbba Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 28 Dec 2021 08:10:11 -0700
Subject: [PATCH 375/456] Updated java api to include manual lock/unlock gil
 fns.

---
 deps.edn                          |  2 +-
 docs/index.html                   |  2 +-
 docs/libpython-clj2.java-api.html |  4 +++-
 src/libpython_clj2/java_api.clj   | 34 +++++++++++++++++++++++++------
 4 files changed, 33 insertions(+), 9 deletions(-)

diff --git a/deps.edn b/deps.edn
index 4880933..10d583a 100644
--- a/deps.edn
+++ b/deps.edn
@@ -64,7 +64,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.004-aot"
+                        :version "2.004-aot-1"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/index.html b/docs/index.html
index 17af816..2920936 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.004</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.004</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 2631e29..1d571f7 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,3 +1,5 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L148">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L115">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L133">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L126">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L139">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L76">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L99">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L70">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L88">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L109">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L34">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L60">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L47">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L82">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L104">view source</a></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L170">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L137">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L155">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L148">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L161">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L103">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L121">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L97">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L115">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L131">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L38">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L87">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an integer representing the gil state that must be passed into unlockGIL.</p>
+<p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L51">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L74">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L109">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L126">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L64">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index 2372a23..e274283 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -4,6 +4,8 @@
             [tech.v3.datatype.jvm-map :as jvm-map]
             [libpython-clj2.python :as py]
             [libpython-clj2.python.fn :as py-fn]
+            [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python.gc :as pygc]
             ;; numpy support
             [libpython-clj2.python.np-array])
   (:import [java.util Map]
@@ -13,6 +15,8 @@
    :main false
    :methods [#^{:static true} [initialize [java.util.Map] Object]
              #^{:static true} [runString [String] java.util.Map]
+             #^{:static true} [lockGIL [] int]
+             #^{:static true} [unlockGIL [int] Object]
              #^{:static true} [inPyContext [java.util.function.Supplier] Object]
              #^{:static true} [hasAttr [Object String] Boolean]
              #^{:static true} [getAttr [Object String] Object]
@@ -44,6 +48,29 @@
                                         (jvm-map/entry-value entry)])))))
 
 
+(defn -lockGIL
+  "Attempt to lock the gil.  This is safe to call in a reentrant manner.
+  Returns an integer representing the gil state that must be passed into unlockGIL.
+
+  See documentation for [pyGILState_Ensure](https://docs.python.org/3/c-api/init.html#c.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."
+  []
+  (int (py-ffi/PyGILState_Ensure)))
+
+
+(defn -unlockGIL
+  "Unlock the gil passing in the gilstate returned from lockGIL.  Each call to lockGIL must
+  be paired to a call to unlockGIL."
+  [gilstate]
+  (let [gilstate (int gilstate)]
+    (when (== 1 gilstate)
+      (pygc/clear-reference-queue))
+    (py-ffi/PyGILState_Release gilstate)))
+
+
 (defn -runString
   "Run a string returning a map of two keys -\"globals\" and \"locals\" which each point to
   a java.util.Map of the respective contexts.  See documentation under
@@ -96,14 +123,9 @@
   (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))
+  (py/set-item! pyobj itemName itemVal))
 
 
 (defn -importModule

From f8a4dcd257de7094f08f4267aeacaba93d41a822 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 28 Dec 2021 09:26:08 -0700
Subject: [PATCH 376/456] Release 2.005

---
 deps.edn                                 | 22 +-----
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        |  4 +-
 docs/libpython-clj2.python.html          | 24 +++---
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 scripts/{deploy-aot => deploy}           |  5 +-
 src/libpython_clj2/java_api.clj          | 97 +++++++++++++-----------
 src/libpython_clj2/python.clj            | 10 ++-
 src/libpython_clj2/python/info.clj       | 13 +++-
 test/libpython_clj2/java_api_test.clj    | 10 ++-
 20 files changed, 114 insertions(+), 95 deletions(-)
 rename scripts/{deploy-aot => deploy} (54%)

diff --git a/deps.edn b/deps.edn
index 10d583a..7f5077a 100644
--- a/deps.edn
+++ b/deps.edn
@@ -45,10 +45,12 @@
            {:replace-deps
             {com.github.seancorfield/depstar {:mvn/version "2.0.193"}}
             :ns-default hf.depstar
+            :aot true
+            :compile-ns [libpython-clj2.java-api]
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.004"
+                        :version "2.005"
                         :sync-pom true
                         :jar "target/libpython-clj.jar"}}
            :deploy
@@ -57,23 +59,5 @@
             :exec-args {:installer :remote
                         :sign-releases? true
                         :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-1"
-                        :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"}}
 
            }}
diff --git a/docs/Usage.html b/docs/Usage.html
index a25b98b..6a9f91b 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 7581490..2aa576c 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index b389c69..654dc92 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index daf6451..744a540 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 2920936..1b47e38 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.004</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.005</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 73a231f..3b29e28 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 6fb5071..ff9ec72 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 1d571f7..861fbf4 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,5 +1,5 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L170">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L137">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L155">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L148">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L161">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L103">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L121">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L97">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L115">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L131">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L38">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L87">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an integer representing the gil state that must be passed into unlockGIL.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L181">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L140">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L164">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L157">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L170">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L106">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L124">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L100">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L118">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L134">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L42">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L92">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an integer representing the gil state that must be passed into unlockGIL.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L51">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L74">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L109">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L126">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L64">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L56">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L79">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L112">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L129">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L69">view source</a></div></div><div class="public anchor" id="var-requires*"><h3>requires*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L30">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index f0783c3..8692b56 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -12,9 +12,9 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L501">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L512">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L254">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L348">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L336">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L342">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L242">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L156">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L482">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L260">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L272">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L266">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L248">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L179">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L185">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L319">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L471">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L509">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L520">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L262">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L356">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L344">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L350">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L250">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L164">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L490">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L268">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L280">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L274">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L256">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L187">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L193">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L327">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L479">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -38,7 +38,7 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L436">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L444">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
 #'user/c
@@ -48,7 +48,7 @@
 2
 user&gt; c
 3
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L674">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L174">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L293">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L190">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L216">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L210">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L229">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L284">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via get-attr.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L146">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L682">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L182">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L301">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L198">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L224">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L218">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L237">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L292">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via get-attr.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L154">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -63,16 +63,16 @@
       <li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
     </ul>
   </li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L307">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L387">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L411">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L420">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L165">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L315">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L395">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L419">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L428">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L173">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
 <p>Options:</p>
 <ul>
   <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L649">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L657">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L538">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L560">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L529">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L522">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L546">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L568">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L537">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L530">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -82,8 +82,8 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L595">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L278">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L603">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L286">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L354">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L196">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L203">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L222">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L235">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L110">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L493">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L362">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L243">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L110">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L501">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index c3edc26..cca9e8d 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index fb081df..334e40d 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 586986b..53f0016 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 41295c1..1bc5c96 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index f0fbd03..ac1641c 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.004</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/scripts/deploy-aot b/scripts/deploy
similarity index 54%
rename from scripts/deploy-aot
rename to scripts/deploy
index 1aa0ea1..0d2b368 100755
--- a/scripts/deploy-aot
+++ b/scripts/deploy
@@ -4,6 +4,7 @@
 set -e
 
 rm -rf classes
+clj -M:test
 clj -X:codox
-clj -X:depstar-aot
-clj -X:deploy-aot
+clj -X:depstar
+clj -X:deploy
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index e274283..ae091f5 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -1,15 +1,7 @@
 (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]
-            [libpython-clj2.python.ffi :as py-ffi]
-            [libpython-clj2.python.gc :as pygc]
-            ;; numpy support
-            [libpython-clj2.python.np-array])
-  (:import [java.util Map]
-           [java.util.function Supplier])
+  (:import [java.util Map Map$Entry]
+           [java.util.function Supplier]
+           [clojure.java.api Clojure])
   (:gen-class
    :name libpython_clj2.java_api
    :main false
@@ -35,6 +27,18 @@
 (set! *warn-on-reflection* true)
 
 
+(def requires* (delay
+                 (let [require (Clojure/var "clojure.core" "require")]
+                   (doseq [clj-ns ["tech.v3.datatype"
+                                   "tech.v3.tensor"
+                                   "libpython-clj2.python"
+                                   "libpython-clj2.python.fn"
+                                   "libpython-clj2.python.ffi"
+                                   "libpython-clj2.python.gc"
+                                   "libpython-clj2.python.np-array"]]
+                     (require (Clojure/read clj-ns))))))
+
+
 (defn -initialize
   "See options for [[libpython-clj2.python/initialize!]].  Note that the keyword
   option arguments can be provided by using strings so `:library-path` becomes
@@ -42,10 +46,11 @@
   all of the further operations so java should access python via single-threaded
   pathways."
   [options]
-  (apply py/initialize! (->> options
-                             (mapcat (fn [entry]
-                                       [(keyword (jvm-map/entry-key entry))
-                                        (jvm-map/entry-value entry)])))))
+  @requires*
+  (apply (Clojure/var "libpython-clj2.python" "initialize!")
+         (->> options
+              (mapcat (fn [^Map$Entry entry]
+                        [(keyword (.getKey entry)) (.getValue entry)])))))
 
 
 (defn -lockGIL
@@ -58,7 +63,7 @@
   the GIL before doing a string of operations is faster than having each operation lock
   the GIL individually."
   []
-  (int (py-ffi/PyGILState_Ensure)))
+  (int ((Clojure/var "libpython-clj2.python.ffi" "PyGILState_Ensure"))))
 
 
 (defn -unlockGIL
@@ -67,8 +72,8 @@
   [gilstate]
   (let [gilstate (int gilstate)]
     (when (== 1 gilstate)
-      (pygc/clear-reference-queue))
-    (py-ffi/PyGILState_Release gilstate)))
+      ((Clojure/var "libpython-clj2.python.gc" "clear-reference-queue")))
+    ((Clojure/var "libpython-clj2.python.ffi" "PyGILState_Release") gilstate)))
 
 
 (defn -runString
@@ -78,7 +83,7 @@
   the result of the last statement ran - you need to set a value in the global or local
   context."
   ^java.util.Map [^String code]
-  (->> (py/run-simple-string code)
+  (->> ((Clojure/var "libpython-clj2.python" "run-simple-string") code)
        (map (fn [[k v]]
               [(name k) v]))
        (into {})))
@@ -89,49 +94,47 @@
   will be deallocated once the context is released.  The code must not return references
   to live python objects."
   [^Supplier fn]
-  (py/with-gil-stack-rc-context
-    (-> (.get fn)
-        (py/->jvm))))
+  ((Clojure/var "libpython-clj2.python" "in-py-ctx") fn))
 
 
 (defn -hasAttr
   "Returns true if this python object has this attribute."
   [pyobj attname]
-  (boolean (py/has-attr? pyobj attname)))
+  (boolean ((Clojure/var "libpython-clj2.python" "has-attr?") pyobj attname)))
 
 
 (defn -getAttr
   "Get a python attribute.  This corresponds to the python '.' operator."
   [pyobj attname]
-  (py/get-attr pyobj attname))
+  ((Clojure/var "libpython-clj2.python" "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))
+  ((Clojure/var "libpython-clj2.python" "set-attr!") pyobj attname objval))
 
 
 (defn -hasItem
   "Return true if this pyobj has this item"
   [pyobj itemName]
-  (boolean (py/has-item? pyobj itemName)))
+  (boolean ((Clojure/var "libpython-clj2.python" "has-item?") pyobj itemName)))
 
 
 (defn -getItem
   [pyobj itemName]
-  (py/get-item pyobj itemName))
+  ((Clojure/var "libpython-clj2.python" "get-item") pyobj itemName))
 
 
 (defn -setItem
   [pyobj itemName itemVal]
-  (py/set-item! pyobj itemName itemVal))
+  ((Clojure/var "libpython-clj2.python" "set-item!") pyobj itemName itemVal))
 
 
 (defn -importModule
   "Import a python module.  Module entries can be accessed via `getAttr`."
   [modname]
-  (py/import-module modname))
+  ((Clojure/var "libpython-clj2.python" "import-module") modname))
 
 
 (defn -callKw
@@ -139,39 +142,47 @@
   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`."
   [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 {})))))
+  (let [gstate (-lockGIL)]
+    (try
+      ((Clojure/var "libpython-clj2.python.fn" "call-kw")
+       pyobj pos-args (->> kw-args
+                           (map (fn [^Map$Entry entry]
+                                  [(.getKey entry)
+                                   (.getValue entry)]))
+                           (into {})))
+      (finally
+        (-unlockGIL gstate)))))
+
 
 (defn -copyToPy
   "Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to
   a python object."
   [object]
-  (py/->python object))
+  ((Clojure/var "libpython-clj2.python" "->python") object))
 
 
 (defn -copyToJVM
   "Copy a python object such as a dict or a list into a comparable JVM object."
   [object]
-  (py/->jvm object))
+  ((Clojure/var "libpython-clj2.python" "->jvm") object))
 
 
 (defn -createArray
   "Create a numpy array from a tuple of string datatype, shape and data.
   * `datatype` - One of \"int8\" \"uint8\"  "
   [datatype shape data]
-  (-> (dtt/->tensor data :datatype (keyword datatype))
-      (dtt/reshape shape)
-      (py/->python)))
+  (let [reshape (Clojure/var "tech.v3.tensor" "reshape")
+        ->python (Clojure/var "libpython-clj2" "->python")]
+    (-> ((Clojure/var "tech.v3.tensor" "->tensor") data :datatype (keyword datatype))
+        (reshape shape)
+        (->python))))
 
 
 (defn -arrayToJVM
   "Copy (efficiently) a numeric numpy array into a jvm map containing keys \"datatype\",
   \"shape\", and \"data\"."
   [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)}))
+  (let [tens-data ((Clojure/var "libpython-clj2.python" "as-jvm") pyobj)]
+    {"datatype" (name ((Clojure/var "tech.v3.datatype" "elemwise-datatype") tens-data))
+     "shape" (int-array ((Clojure/var "tech.v3.datatype" "shape") tens-data))
+     "data" ((Clojure/var "tech.v3.datatype" "->array") tens-data)}))
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 295e29c..e21a419 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -140,7 +140,15 @@ user> (py/py. np linspace 2 3 :num 10)
   [& body]
   `(py-ffi/with-gil
      (pygc/with-stack-context
-      ~@body)))
+       ~@body)))
+
+(declare ->jvm)
+
+(defn ^:no-doc in-py-ctx
+  [^java.util.function.Supplier supplier]
+  (with-gil-stack-rc-context
+    (-> (.get supplier)
+        (->jvm))))
 
 
 (defn import-module
diff --git a/src/libpython_clj2/python/info.clj b/src/libpython_clj2/python/info.clj
index df8688d..5667f0b 100644
--- a/src/libpython_clj2/python/info.clj
+++ b/src/libpython_clj2/python/info.clj
@@ -52,8 +52,9 @@ print(json.dumps(
 
 (defn find-python-info
   [& [{:keys [python-executable]}]]
-  (->> (concat (when python-executable [python-executable])
-               default-python-executables)
+  (->> (if python-executable
+         [python-executable]
+         default-python-executables)
        (map #(try
                (python-system-info %)
                (catch Throwable e nil)))
@@ -86,6 +87,14 @@ print(json.dumps(
     (log/infof "Detecting startup info for Python executable %s" python-executable)
     (log/info "Detecting startup info"))
   (let [system-info (find-python-info options)
+        _ (when-not system-info
+            (if python-executable
+              (throw (Exception. (format
+                                  "Failed to find value python executable.  Tried \"%s\""
+                                  python-executable)))
+              (throw (Exception. (format
+                                  "Failed to find value python executable.  Tried %s"
+                                  default-python-executables)))))
         python-home (find-python-home system-info options)
         java-lib-path (java-library-path-addendum python-home)
         [ver-maj ver-med _ver-min] (:version system-info)
diff --git a/test/libpython_clj2/java_api_test.clj b/test/libpython_clj2/java_api_test.clj
index e15e2f9..9469dcc 100644
--- a/test/libpython_clj2/java_api_test.clj
+++ b/test/libpython_clj2/java_api_test.clj
@@ -1,5 +1,6 @@
 (ns libpython-clj2.java-api-test
   (:require [libpython-clj2.java-api :as japi]
+            [libpython-clj2.python.ffi :as py-ffi]
             [tech.v3.datatype.jvm-map :as jvm-map]
             [clojure.test :refer [deftest is]]))
 
@@ -8,7 +9,10 @@
   (japi/-initialize nil)
   (let [rs-retval (japi/-runString "data = 5")
         globals (get rs-retval "globals")]
-    (is (= 5 (get globals "data"))))
+    (is (= 5 (get globals "data")))
+    (japi/-setItem globals "data" 6)
+    (is (= 6 (get globals "data"))))
+  (is (= 0 (py-ffi/PyGILState_Check)))
   (let [np (japi/-importModule "numpy")
         ones-fn (japi/-getAttr np "ones")
         ;;also works with int-array
@@ -17,8 +21,10 @@
     (is (= "float64" (get jvm-data "datatype")))
     (is (= (vec (repeat 6 1.0))
            (vec (get jvm-data "data"))))
+    (is (= 0 (py-ffi/PyGILState_Check)))
     (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")))))))
+                 (vec (get jvm-data "data"))))
+          (is (= 0 (py-ffi/PyGILState_Check))))))

From 39337a827d59da86535030b08af314a72a44b9c1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 28 Dec 2021 09:40:13 -0700
Subject: [PATCH 377/456] Updating namespace docs for the java api.

---
 src/libpython_clj2/java_api.clj | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index ae091f5..bea0da4 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -1,4 +1,23 @@
 (ns libpython-clj2.java-api
+  "A java api is exposed for libpython-clj2.  The methods below are statically callable without the leading '-'.
+  Note that returned python objects implement the respective java interfaces so a python dict will implement
+  java.util.Map, etc.  There is some startup time as Clojure dynamically compiles the source code but
+  this binding should have great runtime characteristics in comparison to any other java python engine.
+
+```java
+import libpython_clj2.java_api;
+
+
+
+  java_api.initialize(null);
+  np = java_api.importModule(\"numpy\");
+  clojure.lang.IFn ones = (clojure.lang.IFn)java_api.getAttr(np, \"ones\");
+  ArrayList dims = new ArrayList();
+  dims.add(2);
+  dims.add(3);
+  Object npArray = ones.invoke(dims);
+
+```"
   (:import [java.util Map Map$Entry]
            [java.util.function Supplier]
            [clojure.java.api Clojure])

From a95abdfe4ace00948b863c538a66004247e94bf6 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 28 Dec 2021 10:57:04 -0700
Subject: [PATCH 378/456] Release 2.006

---
 deps.edn                                 |  6 +++---
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        | 17 +++++++++++++++--
 docs/libpython-clj2.python.html          |  2 +-
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 15 files changed, 31 insertions(+), 18 deletions(-)

diff --git a/deps.edn b/deps.edn
index 7f5077a..63e4c7e 100644
--- a/deps.edn
+++ b/deps.edn
@@ -45,13 +45,13 @@
            {:replace-deps
             {com.github.seancorfield/depstar {:mvn/version "2.0.193"}}
             :ns-default hf.depstar
-            :aot true
-            :compile-ns [libpython-clj2.java-api]
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.005"
+                        :version "2.006"
                         :sync-pom true
+                        :aot true
+                        :compile-ns [libpython-clj2.java-api]
                         :jar "target/libpython-clj.jar"}}
            :deploy
            {:replace-deps {slipset/deps-deploy {:mvn/version "0.1.5"}}
diff --git a/docs/Usage.html b/docs/Usage.html
index 6a9f91b..59a7f32 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 2aa576c..95cc054 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 654dc92..9b5109a 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 744a540..6527531 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 1b47e38..9747fad 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.005</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.006</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable without the leading ‘-’.  Note that returned python objects implement the respective java interfaces so a python dict will implement  java.util.Map, etc. There is some startup time as Clojure dynamically compiles the source code but  this binding should have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 3b29e28..1cf7a95 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index ff9ec72..c11c824 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 861fbf4..ce4c8b1 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,5 +1,18 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L181">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L140">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L164">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L157">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L170">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L106">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L124">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L100">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L118">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L134">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L42">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L92">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an integer representing the gil state that must be passed into unlockGIL.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable without the leading ‘-’.  Note that returned python objects implement the respective java interfaces so a python dict will implement  java.util.Map, etc. There is some startup time as Clojure dynamically compiles the source code but  this binding should have great runtime characteristics in comparison to any other java python engine.</p>
+<pre><code class="java">import libpython_clj2.java_api;
+
+
+
+  java_api.initialize(null);
+  np = java_api.importModule("numpy");
+  clojure.lang.IFn ones = (clojure.lang.IFn)java_api.getAttr(np, "ones");
+  ArrayList dims = new ArrayList();
+  dims.add(2);
+  dims.add(3);
+  Object npArray = ones.invoke(dims);
+
+</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L200">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L159">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L183">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L176">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L189">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L125">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L143">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L119">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L137">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L153">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L61">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L111">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an integer representing the gil state that must be passed into unlockGIL.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L56">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L79">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L112">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L129">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L69">view source</a></div></div><div class="public anchor" id="var-requires*"><h3>requires*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L30">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L75">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L98">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L131">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L148">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L88">view source</a></div></div><div class="public anchor" id="var-requires*"><h3>requires*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L49">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 8692b56..9ca41e5 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index cca9e8d..e31eb0e 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 334e40d..ceec8d6 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 53f0016..471d0fe 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 1bc5c96..bf8c10b 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index ac1641c..10f094a 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.005</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From 2d07698f9ea3a63462cf25c89dfc67316b54c9a0 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 31 Dec 2021 15:14:05 -0700
Subject: [PATCH 379/456] Added a fastcall pathway with optional hair on fire
 mode.

---
 deps.edn                              |   4 +-
 src/libpython_clj2/java_api.clj       | 121 ++++++++++++++++++++++----
 src/libpython_clj2/python.clj         |  14 +--
 src/libpython_clj2/python/ffi.clj     |  51 ++++++++---
 src/libpython_clj2/python/fn.clj      |  51 +++++++++++
 test/libpython_clj2/java_api_test.clj |  20 ++++-
 test/libpython_clj2/stress_test.clj   |  22 +++++
 7 files changed, 246 insertions(+), 37 deletions(-)

diff --git a/deps.edn b/deps.edn
index 63e4c7e..bcda284 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,4 +1,4 @@
-{:paths ["src"]
+{:paths ["src" "classes"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
         cnuernber/dtype-next {:mvn/version "8.053"}
         net.java.dev.jna/jna {:mvn/version "5.10.0"}
@@ -7,6 +7,8 @@
  :aliases {:dev
            {:extra-deps {criterium/criterium {:mvn/version"0.4.5"}
                          ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}}
+           :fastcall
+           {:jvm-opts ["-Dlibpython_clj.manual_gil=false"]}
            :jdk-17
            {:jvm-opts ["--add-modules" "jdk.incubator.foreign"
                        "--enable-native-access=ALL-UNNAMED"]}
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index bea0da4..32b843d 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -1,24 +1,37 @@
 (ns libpython-clj2.java-api
-  "A java api is exposed for libpython-clj2.  The methods below are statically callable without the leading '-'.
-  Note that returned python objects implement the respective java interfaces so a python dict will implement
-  java.util.Map, etc.  There is some startup time as Clojure dynamically compiles the source code but
-  this binding should have great runtime characteristics in comparison to any other java python engine.
+  "A java api is exposed for libpython-clj2.  The methods below are statically callable
+  without the leading '-'.  Note that returned python objects implement the respective
+  java interfaces so a python dict will implement java.util.Map, etc.  There is some
+  startup time as Clojure dynamically compiles the source code but this binding should
+  have great runtime characteristics in comparison to any other java python engine.
 
-```java
-import libpython_clj2.java_api;
+
+  Performance:
+
+  * If you are certain you are correctly calling lockGIL and unlockGIL then you can
+  define a variable, `-Dlibpython_clj.manual_gil=true` that will disable automatic GIL
+  lock/unlock.  This is useful, for instance, if you are going to lock libpython-clj to
+  a thread and control all access to it yourself.
+
+  * `fastcall` - For the use case of repeatedly calling a single function, for instance
+  for each row of a table or in a tight loop, use `allocateFastcallContext` before the loop,
+  use fastcall to call your function noting that it takes an additional context parameter
+  the user can pass in as the first argument, and use `releaseFastcallContext` afterwords.  This
+  pathway eliminates nearly all of the overhead of calling python from Java and uses the
+  absolutely minimal number of C api calls in order to call a python function.
 
 
+```java
 
   java_api.initialize(null);
   np = java_api.importModule(\"numpy\");
-  clojure.lang.IFn ones = (clojure.lang.IFn)java_api.getAttr(np, \"ones\");
+  Object ones = java_api.getAttr(np, \"ones\");
   ArrayList dims = new ArrayList();
   dims.add(2);
   dims.add(3);
-  Object npArray = ones.invoke(dims);
-
+  Object npArray = java_api.call(ones dims); //see fastcall notes above
 ```"
-  (:import [java.util Map Map$Entry]
+  (:import [java.util Map Map$Entry List]
            [java.util.function Supplier]
            [clojure.java.api Clojure])
   (:gen-class
@@ -37,10 +50,26 @@ import libpython_clj2.java_api;
              #^{: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} [callPos [Object java.util.List] Object]
+             #^{:static true} [call [Object] Object]
+             #^{:static true} [call [Object Object] Object]
+             #^{:static true} [call [Object Object Object] Object]
+             #^{:static true} [call [Object Object Object Object] Object]
+             #^{:static true} [call [Object Object Object Object Object] Object]
+             #^{:static true} [allocateFastcallContext [] Object]
+             #^{:static true} [releaseFastcallContext [Object] Object]
+             ;;args require context
+             #^{:static true} [fastcall [Object Object] Object]
+             #^{:static true} [fastcall [Object Object Object] Object] ;;1
+             #^{:static true} [fastcall [Object Object Object Object] Object] ;;2
+             #^{:static true} [fastcall [Object Object Object Object Object] Object] ;;3
+             #^{:static true} [fastcall [Object Object Object Object Object Object] Object] ;;4
              #^{:static true} [copyToPy [Object] Object]
              #^{:static true} [copyToJVM [Object] Object]
              #^{:static true} [createArray [String Object Object] Object]
-             #^{:static true} [arrayToJVM [Object] java.util.Map]]))
+             #^{:static true} [arrayToJVM [Object] java.util.Map]
+
+             ]))
 
 
 (set! *warn-on-reflection* true)
@@ -58,6 +87,11 @@ import libpython_clj2.java_api;
                      (require (Clojure/read clj-ns))))))
 
 
+(def fastcall* (delay (Clojure/var "libpython-clj2.python.fn" "fastcall")))
+(def allocate-fastcall-context* (delay (Clojure/var "libpython-clj2.python.fn" "allocate-fastcall-context")))
+(def release-fastcall-context* (delay (Clojure/var "libpython-clj2.python.fn" "release-fastcall-context")))
+
+
 (defn -initialize
   "See options for [[libpython-clj2.python/initialize!]].  Note that the keyword
   option arguments can be provided by using strings so `:library-path` becomes
@@ -82,17 +116,14 @@ import libpython_clj2.java_api;
   the GIL before doing a string of operations is faster than having each operation lock
   the GIL individually."
   []
-  (int ((Clojure/var "libpython-clj2.python.ffi" "PyGILState_Ensure"))))
+  (int ((Clojure/var "libpython-clj2.python.ffi" "lock-gil"))))
 
 
 (defn -unlockGIL
   "Unlock the gil passing in the gilstate returned from lockGIL.  Each call to lockGIL must
   be paired to a call to unlockGIL."
   [gilstate]
-  (let [gilstate (int gilstate)]
-    (when (== 1 gilstate)
-      ((Clojure/var "libpython-clj2.python.gc" "clear-reference-queue")))
-    ((Clojure/var "libpython-clj2.python.ffi" "PyGILState_Release") gilstate)))
+  ((Clojure/var "libpython-clj2.python.ffi" "unlock-gil") gilstate))
 
 
 (defn -runString
@@ -173,6 +204,64 @@ import libpython_clj2.java_api;
         (-unlockGIL gstate)))))
 
 
+(defn -callPos
+  "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`."
+  [pyobj pos-args]
+  (apply pyobj pos-args))
+
+
+(defn -call
+  "Call a python callable.  Note this can also be done by by calling the python object's
+  implementation of clojure.lang.IFn directly.  Overloaded for up to 4 arities."
+  ([item]
+   (item))
+  ([item arg1]
+   (item arg1))
+  ([item arg1 arg2]
+   (item arg1 arg2))
+  ([item arg1 arg2 arg3]
+   (item arg1 arg2 arg3))
+  ([item arg1 arg2 arg3 arg4]
+   (item arg1 arg2 arg3 arg4))
+  ([item arg1 arg2 arg3 arg4 & args]))
+
+
+(defn -allocateFastcallContext
+  "Allocate a fastcall context.  See docs for [[-fastcall]]."
+  []
+  (@allocate-fastcall-context*))
+
+
+(defn -releaseFastcallContext
+  "Release a fastcall context.  See docs for [[-fastcall]].  This is safe to call with
+  null and to call multiple times on the same context."
+  [ctx]
+  (when ctx
+    (@release-fastcall-context* ctx)))
+
+
+(defn -fastcall
+  "Call a python function as fast as possible using a fixed number of positional arguments.
+  The caller must provide an allocated fastcall context
+  via [[-allocateFastcallContext]] and furthermore the caller may choose to deallocate the
+  fastcall context with [[-releaseFastcallContext]].
+
+  Current overloads support arities up to 4 arguments."
+  ([ctx item]
+   ;;ctx is unused but placed here to allow rapid search/replace to be correct.
+   (@fastcall* item))
+  ([ctx item arg1]
+   (@fastcall* ctx item arg1))
+  ([ctx item arg1 arg2]
+   (@fastcall* ctx item arg1 arg2))
+  ([ctx item arg1 arg2 arg3]
+   (@fastcall* ctx item arg1 arg2 arg3))
+  ([ctx item arg1 arg2 arg3 arg4]
+   (@fastcall* ctx item arg1 arg2 arg3 arg4)))
+
+
 (defn -copyToPy
   "Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to
   a python object."
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index e21a419..73294dd 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -96,13 +96,17 @@ user> (py/py. np linspace 2 3 :num 10)
               :java-library-path-addendum (:java-library-path-addendum
                                            options
                                            (:java-library-path-addendum info))))
+      (let [gilstate (py-ffi/lock-gil)]
+        (try
 
-      (when-not (nil? windows-anaconda-activate-bat)
-        (win/setup-windows-conda! windows-anaconda-activate-bat
-                                  py-ffi/run-simple-string))
+          (when-not (nil? windows-anaconda-activate-bat)
+            (win/setup-windows-conda! windows-anaconda-activate-bat
+                                      py-ffi/run-simple-string))
 
-      (when-not no-io-redirect?
-        (io-redirect/redirect-io!))
+          (when-not no-io-redirect?
+            (io-redirect/redirect-io!))
+          (finally
+            (py-ffi/unlock-gil gilstate))))
       :ok)
     :already-initialized))
 
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index 0062236..429fc6e 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -362,12 +362,16 @@ Each call must be matched with PyGILState_Release"}
   @library*)
 
 
+(def manual-gil (= "true" (System/getProperty "libpython_clj.manual_gil")))
+
+
 (defmacro check-gil
   "Maybe the most important insurance policy"
   []
-  `(errors/when-not-error
-    (= 1 (PyGILState_Check))
-    "GIL is not captured"))
+  (when-not manual-gil
+    `(errors/when-not-error
+      (= 1 (PyGILState_Check))
+      "GIL is not captured")))
 
 
 ;;When this is true, generated functions will throw an exception if called when the
@@ -701,20 +705,39 @@ Each call must be matched with PyGILState_Release"}
     (check-error-throw)))
 
 
+(defn ^:no-doc lock-gil
+  ^long []
+  (if-not (== 1 (unchecked-long (PyGILState_Check)))
+    (PyGILState_Ensure)
+    (Long/MIN_VALUE)))
+
+
+(defn ^:no-doc unlock-gil
+  [^long gilstate]
+  (when-not (== Long/MIN_VALUE gilstate)
+    (when (== 1 gilstate)
+      (pygc/clear-reference-queue))
+    (PyGILState_Release gilstate)))
+
+
 (defmacro with-gil
   "Grab the gil and use the main interpreter using reentrant acquire-gil pathway."
   [& body]
-  `(let [gil-state# (when-not (== 1 (long (PyGILState_Check)))
-                      (PyGILState_Ensure))]
-     (try
-       (let [retval# (do ~@body)]
-         (check-error-throw)
-         retval#)
-       (finally
-         (when gil-state#
-           #_(System/gc)
-           (pygc/clear-reference-queue)
-           (PyGILState_Release gil-state#))))))
+  (if manual-gil
+    `(let [retval# (do ~@body)]
+       (check-error-throw)
+       retval#)
+    `(let [gil-state# (when-not (== 1 (unchecked-long (PyGILState_Check)))
+                        (PyGILState_Ensure))]
+       (try
+         (let [retval# (do ~@body)]
+           (check-error-throw)
+           retval#)
+         (finally
+           (when gil-state#
+             #_(System/gc)
+             (pygc/clear-reference-queue)
+             (PyGILState_Release gil-state#)))))))
 
 
 (defn pyobject-type
diff --git a/src/libpython_clj2/python/fn.clj b/src/libpython_clj2/python/fn.clj
index 31e0485..35afc50 100644
--- a/src/libpython_clj2/python/fn.clj
+++ b/src/libpython_clj2/python/fn.clj
@@ -281,6 +281,57 @@
     (call-kw item pos-args kw-args)))
 
 
+(defn allocate-fastcall-context
+  ^objects []
+  (object-array 1))
+
+
+(defn release-fastcall-context
+  [call-ctx]
+  (when-let [arglist (aget ^objects call-ctx 0)]
+    (py-ffi/Py_DecRef arglist)
+    (aset ^objects call-ctx 0 nil)))
+
+
+(defmacro implement-fastcall
+  []
+  `(defn ~'fastcall
+     "Call a python function as fast as possible reusing the argument tuple.  This function
+  takes an object array of length 1 for the call context cache.
+
+  Use allocate-fastcall-context and release-fastcall-context in order to manage the
+  context's lifetime.  Do not use same context with fastcall invokations of differing
+  arities."
+     ([~'item]
+      (py-ffi/with-gil
+        (-> (py-ffi/PyObject_CallObject ~'item nil)
+            (py-ffi/simplify-or-track))))
+     ~@(->> (range 10)
+            (map
+             (fn [n-args]
+               (let [arity-args (map (comp symbol #(str "arg-" %)) (range n-args))
+                     argdef (->> (concat [(with-meta 'call-ctx
+                                            {:tag 'objects})
+                                          'item] arity-args)
+                                 (vec))]
+                 `(~argdef
+                   (py-ffi/with-gil
+                     (let [~'arglist (if-let [call-tuple# (aget ^objects ~'call-ctx 0)]
+                                       call-tuple#
+                                       (let [new-t# (py-ffi/PyTuple_New ~n-args)]
+                                         (aset ^objects ~'call-ctx 0 new-t#)))
+                           ~@(mapcat (fn [argsym]
+                                       [argsym `(py-ffi/untracked->python ~argsym)])
+                                     arity-args)]
+                       ~@(map-indexed (fn [idx argsym]
+                                        `(py-ffi/PyTuple_SetItem ~'arglist ~idx ~argsym))
+                                      arity-args)
+                       (-> (py-ffi/PyObject_CallObject ~'item ~'arglist)
+                           (py-ffi/simplify-or-track)))))))))))
+
+(implement-fastcall)
+
+
 (defn key-sym-str->str
   [attr-name]
   (cond
diff --git a/test/libpython_clj2/java_api_test.clj b/test/libpython_clj2/java_api_test.clj
index 9469dcc..6720d65 100644
--- a/test/libpython_clj2/java_api_test.clj
+++ b/test/libpython_clj2/java_api_test.clj
@@ -27,4 +27,22 @@
           (is (= "int32" (get jvm-data "datatype")))
           (is (= (vec (repeat 6 1))
                  (vec (get jvm-data "data"))))
-          (is (= 0 (py-ffi/PyGILState_Check))))))
+          (is (= 0 (py-ffi/PyGILState_Check)))))
+  (let [gilstate (japi/-lockGIL)]
+    (try
+      (let [test-fn (-> (japi/-runString "def calcSpread(bid,ask):\n\treturn bid-ask\n\n")
+                        (get "globals")
+                        (get "calcSpread"))
+            call-ctx (japi/-allocateFastcallContext)
+            _ (println test-fn)
+            n-calls 100000
+            start-ns (System/nanoTime)
+            _ (is (= -1  (japi/-fastcall call-ctx test-fn 1 2)))
+            _ (dotimes [iter n-calls]
+                (japi/-fastcall call-ctx test-fn 1 2))
+            end-ns (System/nanoTime)
+            ms (/ (- end-ns start-ns) 10e6)]
+        (japi/-releaseFastcallContext call-ctx)
+        (println "Python fn calls/ms" (/ n-calls ms)))
+      (finally
+        (japi/-unlockGIL gilstate)))))
diff --git a/test/libpython_clj2/stress_test.clj b/test/libpython_clj2/stress_test.clj
index aae3893..45f8224 100644
--- a/test/libpython_clj2/stress_test.clj
+++ b/test/libpython_clj2/stress_test.clj
@@ -2,6 +2,8 @@
   "A set of tests meant to crash the system or just run the system out of
   memory if it isn't setup correctly."
   (:require [libpython-clj2.python :as py]
+            [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python.fn :as py-fn]
             [libpython-clj2.python.class :as py-class]
             [clojure.test :refer :all]
             [clojure.edn :as edn]))
@@ -137,3 +139,23 @@ def getmultidata():
 
         (is (= {"name" "ACME", "shares" 50, "price" 90}
                (edn/read-string (.toString new-inst))))))))
+
+
+(deftest fastcall
+  (let [gilstate (py-ffi/lock-gil)]
+    (try
+      (let [test-fn (-> (py/run-simple-string "def calcSpread(bid,ask):\n\treturn bid-ask\n\n")
+                        :globals
+                        (get "calcSpread"))
+            call-ctx (py-fn/allocate-fastcall-context)
+            n-calls 100000
+            start-ns (System/nanoTime)
+            _ (is (= -1  (py-fn/fastcall call-ctx test-fn 1 2)))
+            _ (dotimes [iter n-calls]
+                (py-fn/fastcall call-ctx test-fn 1 2))
+            end-ns (System/nanoTime)
+            ms (/ (- end-ns start-ns) 10e6)]
+        (py-fn/release-fastcall-context call-ctx)
+        (println "Python fn calls/ms" (/ n-calls ms)))
+      (finally
+        (py-ffi/unlock-gil gilstate)))))

From be79a22ddd1501fc2999f4f01bbbfeaf3b27302a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 31 Dec 2021 15:19:05 -0700
Subject: [PATCH 380/456] More documentation on fastcall.

---
 src/libpython_clj2/java_api.clj | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index 32b843d..16be74c 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -8,18 +8,20 @@
 
   Performance:
 
-  * If you are certain you are correctly calling lockGIL and unlockGIL then you can
-  define a variable, `-Dlibpython_clj.manual_gil=true` that will disable automatic GIL
-  lock/unlock.  This is useful, for instance, if you are going to lock libpython-clj to
-  a thread and control all access to it yourself.
-
   * `fastcall` - For the use case of repeatedly calling a single function, for instance
   for each row of a table or in a tight loop, use `allocateFastcallContext` before the loop,
   use fastcall to call your function noting that it takes an additional context parameter
   the user can pass in as the first argument, and use `releaseFastcallContext` afterwords.  This
   pathway eliminates nearly all of the overhead of calling python from Java and uses the
-  absolutely minimal number of C api calls in order to call a python function.
+  absolutely minimal number of C api calls in order to call a python function.  This is
+  about twice as fast as using the generic architecture to call a python function.
+
 
+  * HAIR ON FIRE MODE - If you are certain you are correctly calling lockGIL and unlockGIL
+  then you can define a variable, `-Dlibpython_clj.manual_gil=true` that will disable
+  automatic GIL lock/unlock checking.  This is useful, for instance, if you are going to
+  lock libpython-clj to a thread and control all access to it yourself.  This pathway
+  will get at most 10% above using fastcall by itself.
 
 ```java
 
@@ -29,7 +31,7 @@
   ArrayList dims = new ArrayList();
   dims.add(2);
   dims.add(3);
-  Object npArray = java_api.call(ones dims); //see fastcall notes above
+  Object npArray = java_api.call(ones, dims); //see fastcall notes above
 ```"
   (:import [java.util Map Map$Entry List]
            [java.util.function Supplier]
@@ -229,7 +231,8 @@
 
 
 (defn -allocateFastcallContext
-  "Allocate a fastcall context.  See docs for [[-fastcall]]."
+  "Allocate a fastcall context.  See docs for [[-fastcall]].  The returned context must be
+  release via [[-releaseFastcallContext]]."
   []
   (@allocate-fastcall-context*))
 
@@ -248,7 +251,8 @@
   via [[-allocateFastcallContext]] and furthermore the caller may choose to deallocate the
   fastcall context with [[-releaseFastcallContext]].
 
-  Current overloads support arities up to 4 arguments."
+  Current overloads support arities up to 4 arguments.  You must not use the same context
+  with different arities - contexts are allocated in an arity-specific manner."
   ([ctx item]
    ;;ctx is unused but placed here to allow rapid search/replace to be correct.
    (@fastcall* item))

From 32fbd41e21d82d618a65f01fca382196e069aa9a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 1 Jan 2022 08:13:07 -0700
Subject: [PATCH 381/456] Making a fastcall auto-closeable object.

---
 src/libpython_clj2/java_api.clj       | 29 ++++++++--
 src/libpython_clj2/python/fn.clj      | 76 +++++++++++++++++++++++++--
 test/libpython_clj2/java_api_test.clj | 32 +++++++----
 test/libpython_clj2/stress_test.clj   | 38 ++++++++++----
 4 files changed, 145 insertions(+), 30 deletions(-)

diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index 16be74c..b8ddc0d 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -16,15 +16,17 @@
   absolutely minimal number of C api calls in order to call a python function.  This is
   about twice as fast as using the generic architecture to call a python function.
 
+  * `makeFastcallable` - A simplified version of fastcall to be used with try-with-resources.
+  This is a safer but equally-as-fast pathway as `fastcall`.
 
   * HAIR ON FIRE MODE - If you are certain you are correctly calling lockGIL and unlockGIL
   then you can define a variable, `-Dlibpython_clj.manual_gil=true` that will disable
-  automatic GIL lock/unlock checking.  This is useful, for instance, if you are going to
-  lock libpython-clj to a thread and control all access to it yourself.  This pathway
-  will get at most 10% above using fastcall by itself.
+  automatic GIL lock/unlock system and correctness checking.  This is useful, for instance,
+  if you are going to lock libpython-clj to a thread and control all access to it yourself.
+  This pathway will get at most 10% above using fastcall by itself.
 
-```java
 
+```java
   java_api.initialize(null);
   np = java_api.importModule(\"numpy\");
   Object ones = java_api.getAttr(np, \"ones\");
@@ -66,6 +68,7 @@
              #^{:static true} [fastcall [Object Object Object Object] Object] ;;2
              #^{:static true} [fastcall [Object Object Object Object Object] Object] ;;3
              #^{:static true} [fastcall [Object Object Object Object Object Object] Object] ;;4
+             #^{:static true} [makeFastcallable [Object] java.lang.AutoCloseable]
              #^{:static true} [copyToPy [Object] Object]
              #^{:static true} [copyToJVM [Object] Object]
              #^{:static true} [createArray [String Object Object] Object]
@@ -92,6 +95,7 @@
 (def fastcall* (delay (Clojure/var "libpython-clj2.python.fn" "fastcall")))
 (def allocate-fastcall-context* (delay (Clojure/var "libpython-clj2.python.fn" "allocate-fastcall-context")))
 (def release-fastcall-context* (delay (Clojure/var "libpython-clj2.python.fn" "release-fastcall-context")))
+(def make-fastcallable* (delay (Clojure/var "libpython-clj2.python.fn" "make-fastcallable")))
 
 
 (defn -initialize
@@ -266,6 +270,23 @@
    (@fastcall* ctx item arg1 arg2 arg3 arg4)))
 
 
+(defn -makeFastcallable
+  "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.  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.
+
+```java
+  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
+     tightloop {
+       java_api.call(fastcaller, arg1, arg2);
+     }
+  }
+```"
+  ^java.lang.AutoCloseable [item]
+  (@make-fastcallable* item))
+
+
 (defn -copyToPy
   "Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to
   a python object."
diff --git a/src/libpython_clj2/python/fn.clj b/src/libpython_clj2/python/fn.clj
index 35afc50..72e2193 100644
--- a/src/libpython_clj2/python/fn.clj
+++ b/src/libpython_clj2/python/fn.clj
@@ -19,7 +19,8 @@
             [clojure.stacktrace :as st])
   (:import [tech.v3.datatype.ffi Pointer]
            [java.util Map Set]
-           [libpython_clj2.python.protocols PBridgeToPython]))
+           [libpython_clj2.python.protocols PBridgeToPython]
+           [java.lang AutoCloseable]))
 
 (set! *warn-on-reflection* true)
 
@@ -281,6 +282,9 @@
     (call-kw item pos-args kw-args)))
 
 
+(def ^{:tag 'long} max-fastcall-args 10)
+
+
 (defn allocate-fastcall-context
   ^objects []
   (object-array 1))
@@ -288,9 +292,10 @@
 
 (defn release-fastcall-context
   [call-ctx]
-  (when-let [arglist (aget ^objects call-ctx 0)]
-    (py-ffi/Py_DecRef arglist)
-    (aset ^objects call-ctx 0 nil)))
+  (when call-ctx
+    (when-let [arglist (aget ^objects call-ctx 0)]
+      (py-ffi/Py_DecRef arglist)
+      (aset ^objects call-ctx 0 nil))))
 
 
 (defmacro implement-fastcall
@@ -306,7 +311,7 @@
       (py-ffi/with-gil
         (-> (py-ffi/PyObject_CallObject ~'item nil)
             (py-ffi/simplify-or-track))))
-     ~@(->> (range 10)
+     ~@(->> (range 1 (inc max-fastcall-args))
             (map
              (fn [n-args]
                (let [arity-args (map (comp symbol #(str "arg-" %)) (range n-args))
@@ -332,6 +337,67 @@
 (implement-fastcall)
 
 
+(defmacro reify-fastcallable
+  [item]
+  `(let [~'ctx-list (object-array max-fastcall-args)]
+     (reify
+       AutoCloseable
+       (close [this#] (dotimes [idx# (alength ~'ctx-list)]
+                        (release-fastcall-context (aget ~'ctx-list idx#))
+                        (aset ~'ctx-list idx# nil)))
+       clojure.lang.IFn
+       (invoke [this#] (fastcall ~item))
+       ~@(->> (range 1 (inc max-fastcall-args))
+           (map
+            (fn [argc]
+              (let [arglist (mapv #(symbol (str "arg-" %)) (range argc))
+                    ctx-idx (dec argc)]
+                `(invoke [this# ~@arglist]
+                         (let [~'ctx (if-let [ctx# (aget ~'ctx-list ~ctx-idx)]
+                                       ctx#
+                                       (let [ctx# (allocate-fastcall-context)]
+                                         (aset ~'ctx-list ~ctx-idx ctx#)
+                                         ctx#))]
+                           (fastcall ~'ctx ~item ~@arglist)))))))
+
+       (applyTo [this# ~'argseq]
+         (let [~'argseq (vec ~'argseq)
+               ~'n-args (count ~'argseq)]
+           (when (> ~'n-args max-fastcall-args)
+             (throw (Exception. (format "Maximum fastcall arguments is %d - %d provided"
+                                        max-fastcall-args ~'n-args))))
+           (if (== 0 ~'n-args)
+             (fastcall ~item)
+             (let [~'ctx-idx (dec ~'n-args)
+                   ~'ctx (if-let [ctx# (aget ~'ctx-list ~'ctx-idx)]
+                           ctx#
+                           (let [ctx# (allocate-fastcall-context)]
+                             (aset ~'ctx-list ~'ctx-idx ctx#)
+                             ctx#))]
+               (case ~'n-args
+                 ~@(->> (range 1 max-fastcall-args)
+                        (mapcat
+                         (fn [argc]
+                           [argc `(fastcall ~'ctx ~item
+                                            ~@(->> (range argc)
+                                                   (map (fn [idx]
+                                                          `(~'argseq ~idx)))))])))))))))))
+
+
+(defn make-fastcallable
+  "Make an auto-disposable fastcallable object that will override the IFn interface and
+  always use the fastcall pathways.  This object *must* be closed and thus should be used
+  in a with-open scenario but there is no need to specifically allocate fastcall context
+  objects.
+
+  See [[fastcall]] for more information."
+  ^AutoCloseable [item]
+  (py-ffi/with-gil
+    (when-not (= 1 (py-ffi/PyCallable_Check item))
+      (throw (Exception. "Item passed in does not appear to be a callable python object")))
+    (reify-fastcallable item)))
+
+
 (defn key-sym-str->str
   [attr-name]
   (cond
diff --git a/test/libpython_clj2/java_api_test.clj b/test/libpython_clj2/java_api_test.clj
index 6720d65..91fd982 100644
--- a/test/libpython_clj2/java_api_test.clj
+++ b/test/libpython_clj2/java_api_test.clj
@@ -33,16 +33,26 @@
       (let [test-fn (-> (japi/-runString "def calcSpread(bid,ask):\n\treturn bid-ask\n\n")
                         (get "globals")
                         (get "calcSpread"))
-            call-ctx (japi/-allocateFastcallContext)
-            _ (println test-fn)
-            n-calls 100000
-            start-ns (System/nanoTime)
-            _ (is (= -1  (japi/-fastcall call-ctx test-fn 1 2)))
-            _ (dotimes [iter n-calls]
-                (japi/-fastcall call-ctx test-fn 1 2))
-            end-ns (System/nanoTime)
-            ms (/ (- end-ns start-ns) 10e6)]
-        (japi/-releaseFastcallContext call-ctx)
-        (println "Python fn calls/ms" (/ n-calls ms)))
+            n-calls 100000]
+        ;;low level api
+        (let [call-ctx (japi/-allocateFastcallContext)
+              _ (println test-fn)
+              _ (is (= -1  (japi/-fastcall call-ctx test-fn 1 2)))
+              start-ns (System/nanoTime)
+              _ (dotimes [iter n-calls]
+                  (japi/-fastcall call-ctx test-fn 1 2))
+              end-ns (System/nanoTime)
+              ms (/ (- end-ns start-ns) 10e6)]
+          (japi/-releaseFastcallContext call-ctx)
+          (println "Python fastcall calls/ms" (/ n-calls ms)))
+        ;;high level api
+        (with-open [fcall (japi/-makeFastcallable test-fn)]
+          (is (= -1 (japi/-call fcall 1 2)))
+          (let [start-ns (System/nanoTime)
+                _ (dotimes [iter n-calls]
+                    (japi/-call fcall 1 2))
+                end-ns (System/nanoTime)
+                ms (/ (- end-ns start-ns) 10e6)]
+            (println "Python fastcallable calls/ms" (/ n-calls ms)))))
       (finally
         (japi/-unlockGIL gilstate)))))
diff --git a/test/libpython_clj2/stress_test.clj b/test/libpython_clj2/stress_test.clj
index 45f8224..9d1390d 100644
--- a/test/libpython_clj2/stress_test.clj
+++ b/test/libpython_clj2/stress_test.clj
@@ -144,18 +144,36 @@ def getmultidata():
 (deftest fastcall
   (let [gilstate (py-ffi/lock-gil)]
     (try
+      ;;Without fastcall callsite optimization
       (let [test-fn (-> (py/run-simple-string "def calcSpread(bid,ask):\n\treturn bid-ask\n\n")
                         :globals
                         (get "calcSpread"))
-            call-ctx (py-fn/allocate-fastcall-context)
-            n-calls 100000
-            start-ns (System/nanoTime)
-            _ (is (= -1  (py-fn/fastcall call-ctx test-fn 1 2)))
-            _ (dotimes [iter n-calls]
-                (py-fn/fastcall call-ctx test-fn 1 2))
-            end-ns (System/nanoTime)
-            ms (/ (- end-ns start-ns) 10e6)]
-        (py-fn/release-fastcall-context call-ctx)
-        (println "Python fn calls/ms" (/ n-calls ms)))
+            n-calls 100000]
+        (let [start-ns (System/nanoTime)
+              _ (dotimes [iter n-calls]
+                  (test-fn 1 2))
+              end-ns (System/nanoTime)
+              ms (/ (- end-ns start-ns) 10e6)]
+          (println "Python calls/ms" (/ n-calls ms)))
+        ;;low level api
+        (let [call-ctx (py-fn/allocate-fastcall-context)
+              _ (is (= -1  (py-fn/fastcall call-ctx test-fn 1 2)))
+              start-ns (System/nanoTime)
+
+              _ (dotimes [iter n-calls]
+                  (py-fn/fastcall call-ctx test-fn 1 2))
+              end-ns (System/nanoTime)
+              ms (/ (- end-ns start-ns) 10e6)]
+          (py-fn/release-fastcall-context call-ctx)
+          (println "Python fastcall calls/ms" (/ n-calls ms)))
+        ;;high level api
+        (with-open [callable (py-fn/make-fastcallable test-fn)]
+          (is (= -1  (callable 1 2)))
+          (let [start-ns (System/nanoTime)
+                _ (dotimes [iter n-calls]
+                    (callable 1 2))
+                end-ns (System/nanoTime)
+                ms (/ (- end-ns start-ns) 10e6)]
+            (println "Python fastcallable calls/ms" (/ n-calls ms)))))
       (finally
         (py-ffi/unlock-gil gilstate)))))

From 4ea70f8f28fe9f1e53b255119906a2cd2dc3ebf9 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 1 Jan 2022 08:26:29 -0700
Subject: [PATCH 382/456] Release 2.007

---
 deps.edn                                 |  2 +-
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        | 33 ++++++++++++++++--------
 docs/libpython-clj2.python.html          | 24 ++++++++---------
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 15 files changed, 47 insertions(+), 36 deletions(-)

diff --git a/deps.edn b/deps.edn
index bcda284..27e97d3 100644
--- a/deps.edn
+++ b/deps.edn
@@ -50,7 +50,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.006"
+                        :version "2.007"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 59a7f32..eb44680 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 95cc054..59041f9 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 9b5109a..2cee275 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 6527531..41b562b 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 9747fad..b88578a 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.006</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable without the leading ‘-’.  Note that returned python objects implement the respective java interfaces so a python dict will implement  java.util.Map, etc. There is some startup time as Clojure dynamically compiles the source code but  this binding should have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.007</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--callPos">-callPos</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*">allocate-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fastcall*">fastcall*</a> </li><li> <a href="libpython-clj2.java-api.html#var-make-fastcallable*">make-fastcallable*</a> </li><li> <a href="libpython-clj2.java-api.html#var-release-fastcall-context*">release-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 1cf7a95..8b0d7ea 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index c11c824..d7bf6f3 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index ce4c8b1..84e323d 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,18 +1,29 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable without the leading ‘-’.  Note that returned python objects implement the respective java interfaces so a python dict will implement  java.util.Map, etc. There is some startup time as Clojure dynamically compiles the source code but  this binding should have great runtime characteristics in comparison to any other java python engine.</p>
-<pre><code class="java">import libpython_clj2.java_api;
-
-
-
-  java_api.initialize(null);
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--allocateFastcallContext"><div class="inner"><span>-allocateFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callPos"><div class="inner"><span>-callPos</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--fastcall"><div class="inner"><span>-fastcall</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--releaseFastcallContext"><div class="inner"><span>-releaseFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*"><div class="inner"><span>allocate-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fastcall*"><div class="inner"><span>fastcall*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-make-fastcallable*"><div class="inner"><span>make-fastcallable*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-release-fastcall-context*"><div class="inner"><span>release-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
+<p>Performance:</p>
+<ul>
+  <li>
+  <p><code>fastcall</code> - For the use case of repeatedly calling a single function, for instance  for each row of a table or in a tight loop, use <code>allocateFastcallContext</code> before the loop,  use fastcall to call your function noting that it takes an additional context parameter  the user can pass in as the first argument, and use <code>releaseFastcallContext</code> afterwords. This  pathway eliminates nearly all of the overhead of calling python from Java and uses the  absolutely minimal number of C api calls in order to call a python function. This is  about twice as fast as using the generic architecture to call a python function.</p></li>
+  <li>
+  <p><code>makeFastcallable</code> - A simplified version of fastcall to be used with try-with-resources.  This is a safer but equally-as-fast pathway as <code>fastcall</code>.</p></li>
+  <li>
+  <p>HAIR ON FIRE MODE - If you are certain you are correctly calling lockGIL and unlockGIL  then you can define a variable, <code>-Dlibpython_clj.manual_gil=true</code> that will disable  automatic GIL lock/unlock system and correctness checking. This is useful, for instance,  if you are going to lock libpython-clj to a thread and control all access to it yourself.  This pathway will get at most 10% above using fastcall by itself.</p></li>
+</ul>
+<pre><code class="java">  java_api.initialize(null);
   np = java_api.importModule("numpy");
-  clojure.lang.IFn ones = (clojure.lang.IFn)java_api.getAttr(np, "ones");
+  Object ones = java_api.getAttr(np, "ones");
   ArrayList dims = new ArrayList();
   dims.add(2);
   dims.add(3);
-  Object npArray = ones.invoke(dims);
-
-</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L200">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L159">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L183">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L176">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L189">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L125">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L143">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L119">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L137">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L153">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L61">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L111">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an integer representing the gil state that must be passed into unlockGIL.</p>
+  Object npArray = java_api.call(ones, dims); //see fastcall notes above
+</code></pre></div></div><div class="public anchor" id="var--allocateFastcallContext"><h3>-allocateFastcallContext</h3><div class="usage"><code>(-allocateFastcallContext)</code></div><div class="doc"><div class="markdown"><p>Allocate a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. The returned context must be release via <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L237">view source</a></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L314">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python callable. Note this can also be done by by calling the python object’s implementation of clojure.lang.IFn directly. Overloaded for up to 4 arities.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L221">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L196">view source</a></div></div><div class="public anchor" id="var--callPos"><h3>-callPos</h3><div class="usage"><code>(-callPos pyobj pos-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L213">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L297">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L290">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L303">view source</a></div></div><div class="public anchor" id="var--fastcall"><h3>-fastcall</h3><div class="usage"><code>(-fastcall ctx item)</code><code>(-fastcall ctx item arg1)</code><code>(-fastcall ctx item arg1 arg2)</code><code>(-fastcall ctx item arg1 arg2 arg3)</code><code>(-fastcall ctx item arg1 arg2 arg3 arg4)</code></div><div class="doc"><div class="markdown"><p>Call a python function as fast as possible using a fixed number of positional arguments. The caller must provide an allocated fastcall context via <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> and furthermore the caller may choose to deallocate the fastcall context with <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p>
+<p>Current overloads support arities up to 4 arguments. You must not use the same context with different arities - contexts are allocated in an arity-specific manner.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L252">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L162">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L180">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L156">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L174">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L190">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L101">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L148">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an integer representing the gil state that must be passed into unlockGIL.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L75">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L98">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L131">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L148">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L88">view source</a></div></div><div class="public anchor" id="var-requires*"><h3>requires*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L49">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L115">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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. 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.</p>
+<pre><code class="java">  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
+     tightloop {
+       java_api.call(fastcaller, arg1, arg2);
+     }
+  }
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L273">view source</a></div></div><div class="public anchor" id="var--releaseFastcallContext"><h3>-releaseFastcallContext</h3><div class="usage"><code>(-releaseFastcallContext ctx)</code></div><div class="doc"><div class="markdown"><p>Release a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. This is safe to call with null and to call multiple times on the same context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L244">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L135">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L168">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L185">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L128">view source</a></div></div><div class="public anchor" id="var-allocate-fastcall-context*"><h3>allocate-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L96">view source</a></div></div><div class="public anchor" id="var-fastcall*"><h3>fastcall*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L95">view source</a></div></div><div class="public anchor" id="var-make-fastcallable*"><h3>make-fastcallable*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L98">view source</a></div></div><div class="public anchor" id="var-release-fastcall-context*"><h3>release-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L97">view source</a></div></div><div class="public anchor" id="var-requires*"><h3>requires*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L83">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 9ca41e5..4a654d2 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -12,9 +12,9 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L509">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L520">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L262">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L356">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L344">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L350">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L250">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L164">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L490">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L268">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L280">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L274">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L256">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L187">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L193">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L327">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L479">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L513">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L524">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L266">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L360">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L348">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L354">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L254">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L168">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L494">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L272">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L284">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L278">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L260">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L331">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -38,7 +38,7 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L444">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L448">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
 #'user/c
@@ -48,7 +48,7 @@
 2
 user&gt; c
 3
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L682">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L182">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L301">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L198">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L224">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L218">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L237">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L292">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via get-attr.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L154">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L686">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L202">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L222">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L241">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L296">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via get-attr.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L158">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -63,16 +63,16 @@
       <li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
     </ul>
   </li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L315">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L395">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L419">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L428">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L173">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L319">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L399">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L423">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L432">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
 <p>Options:</p>
 <ul>
   <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L657">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L661">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L546">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L568">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L537">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L530">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L550">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L572">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L541">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L534">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -82,8 +82,8 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L603">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L286">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L607">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L290">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L362">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L211">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L230">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L243">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L110">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L501">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L123">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L132">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L366">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L208">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L215">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L114">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L505">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L127">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L136">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index e31eb0e..ee19e87 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index ceec8d6..dd2bfac 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 471d0fe..447dc84 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index bf8c10b..590c268 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 10f094a..4057151 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.006</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])

From 4cb7ba432e10a6d30f592611a2ca8eb537fc45e2 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 1 Jan 2022 08:52:20 -0700
Subject: [PATCH 383/456] Release 2.008

---
 deps.edn                                 |  2 +-
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        | 12 ++++---
 docs/libpython-clj2.python.html          |  2 +-
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 src/libpython_clj2/java_api.clj          | 44 +++++++++++++++++-------
 16 files changed, 52 insertions(+), 32 deletions(-)

diff --git a/deps.edn b/deps.edn
index 27e97d3..43a2e9b 100644
--- a/deps.edn
+++ b/deps.edn
@@ -50,7 +50,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.007"
+                        :version "2.008"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index eb44680..7ebdf0c 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 59041f9..92abf2c 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 2cee275..50fda1d 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 41b562b..edd8e46 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index b88578a..e9a78d4 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.007</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--callPos">-callPos</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*">allocate-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fastcall*">fastcall*</a> </li><li> <a href="libpython-clj2.java-api.html#var-make-fastcallable*">make-fastcallable*</a> </li><li> <a href="libpython-clj2.java-api.html#var-release-fastcall-context*">release-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.008</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--callPos">-callPos</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*">allocate-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fastcall*">fastcall*</a> </li><li> <a href="libpython-clj2.java-api.html#var-make-fastcallable*">make-fastcallable*</a> </li><li> <a href="libpython-clj2.java-api.html#var-release-fastcall-context*">release-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 8b0d7ea..d135695 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index d7bf6f3..4cf4078 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 84e323d..8b0f37f 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,6 +1,7 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--allocateFastcallContext"><div class="inner"><span>-allocateFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callPos"><div class="inner"><span>-callPos</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--fastcall"><div class="inner"><span>-fastcall</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--releaseFastcallContext"><div class="inner"><span>-releaseFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*"><div class="inner"><span>allocate-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fastcall*"><div class="inner"><span>fastcall*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-make-fastcallable*"><div class="inner"><span>make-fastcallable*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-release-fastcall-context*"><div class="inner"><span>release-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--allocateFastcallContext"><div class="inner"><span>-allocateFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callPos"><div class="inner"><span>-callPos</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--fastcall"><div class="inner"><span>-fastcall</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--releaseFastcallContext"><div class="inner"><span>-releaseFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*"><div class="inner"><span>allocate-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fastcall*"><div class="inner"><span>fastcall*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-make-fastcallable*"><div class="inner"><span>make-fastcallable*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-release-fastcall-context*"><div class="inner"><span>release-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
+<p>Note that you can pass java objects into python. An implementation of java.util.Map will  appear to python as a dict-like object an implementation of java.util.List will look  like a sequence and if the thing is iterable then it will be iterable in python.  To receive callbacks from python you can provide an implementation of the  interface <code>clojure.lang.IFn</code> - see <code>clojure.lang.AFn</code> for a base class that makes this  easier.</p>
 <p>Performance:</p>
 <ul>
   <li>
@@ -17,13 +18,14 @@
   dims.add(2);
   dims.add(3);
   Object npArray = java_api.call(ones, dims); //see fastcall notes above
-</code></pre></div></div><div class="public anchor" id="var--allocateFastcallContext"><h3>-allocateFastcallContext</h3><div class="usage"><code>(-allocateFastcallContext)</code></div><div class="doc"><div class="markdown"><p>Allocate a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. The returned context must be release via <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L237">view source</a></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L314">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call a python callable. Note this can also be done by by calling the python object’s implementation of clojure.lang.IFn directly. Overloaded for up to 4 arities.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L221">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L196">view source</a></div></div><div class="public anchor" id="var--callPos"><h3>-callPos</h3><div class="usage"><code>(-callPos pyobj pos-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L213">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L297">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L290">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” </p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L303">view source</a></div></div><div class="public anchor" id="var--fastcall"><h3>-fastcall</h3><div class="usage"><code>(-fastcall ctx item)</code><code>(-fastcall ctx item arg1)</code><code>(-fastcall ctx item arg1 arg2)</code><code>(-fastcall ctx item arg1 arg2 arg3)</code><code>(-fastcall ctx item arg1 arg2 arg3 arg4)</code></div><div class="doc"><div class="markdown"><p>Call a python function as fast as possible using a fixed number of positional arguments. The caller must provide an allocated fastcall context via <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> and furthermore the caller may choose to deallocate the fastcall context with <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p>
-<p>Current overloads support arities up to 4 arguments. You must not use the same context with different arities - contexts are allocated in an arity-specific manner.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L252">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L162">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L180">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L156">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L174">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L190">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L101">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L148">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an integer representing the gil state that must be passed into unlockGIL.</p>
+</code></pre></div></div><div class="public anchor" id="var--allocateFastcallContext"><h3>-allocateFastcallContext</h3><div class="usage"><code>(-allocateFastcallContext)</code></div><div class="doc"><div class="markdown"><p>Allocate a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. The returned context must be release via <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L249">view source</a></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L332">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <code>clojure.lang.IFn</code> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L229">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L204">view source</a></div></div><div class="public anchor" id="var--callPos"><h3>-callPos</h3><div class="usage"><code>(-callPos pyobj pos-args)</code></div><div class="doc"><div class="markdown"><p>Call a python callable with only positional arguments. Note that you don’t need this pathway to call python methods - you can also cast the python object to <code>clojure.lang.IFn</code> and call <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L221">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L311">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L304">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of shapes. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L317">view source</a></div></div><div class="public anchor" id="var--fastcall"><h3>-fastcall</h3><div class="usage"><code>(-fastcall ctx item)</code><code>(-fastcall ctx item arg1)</code><code>(-fastcall ctx item arg1 arg2)</code><code>(-fastcall ctx item arg1 arg2 arg3)</code><code>(-fastcall ctx item arg1 arg2 arg3 arg4)</code></div><div class="doc"><div class="markdown"><p>Call a python function as fast as possible using a fixed number of positional arguments. The caller must provide an allocated fastcall context via <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> and furthermore the caller may choose to deallocate the fastcall context with <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p>
+<p>Current overloads support arities up to 4 arguments. You must not use the same context with different arities - contexts are allocated in an arity-specific manner.</p>
+<p>For a more condensed version see <a href="null">makeFastcallable</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L264">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L170">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L188">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L164">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L182">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L198">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L109">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L156">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an integer representing the gil state that must be passed into unlockGIL.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L115">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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. 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.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L123">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <pre><code class="java">  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
      tightloop {
        java_api.call(fastcaller, arg1, arg2);
      }
   }
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L273">view source</a></div></div><div class="public anchor" id="var--releaseFastcallContext"><h3>-releaseFastcallContext</h3><div class="usage"><code>(-releaseFastcallContext ctx)</code></div><div class="doc"><div class="markdown"><p>Release a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. This is safe to call with null and to call multiple times on the same context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L244">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L135">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L168">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L185">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L128">view source</a></div></div><div class="public anchor" id="var-allocate-fastcall-context*"><h3>allocate-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L96">view source</a></div></div><div class="public anchor" id="var-fastcall*"><h3>fastcall*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L95">view source</a></div></div><div class="public anchor" id="var-make-fastcallable*"><h3>make-fastcallable*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L98">view source</a></div></div><div class="public anchor" id="var-release-fastcall-context*"><h3>release-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L97">view source</a></div></div><div class="public anchor" id="var-requires*"><h3>requires*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L83">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L287">view source</a></div></div><div class="public anchor" id="var--releaseFastcallContext"><h3>-releaseFastcallContext</h3><div class="usage"><code>(-releaseFastcallContext ctx)</code></div><div class="doc"><div class="markdown"><p>Release a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. This is safe to call with null and to call multiple times on the same context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L256">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L143">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L176">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L193">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L136">view source</a></div></div><div class="public anchor" id="var-allocate-fastcall-context*"><h3>allocate-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L104">view source</a></div></div><div class="public anchor" id="var-fastcall*"><h3>fastcall*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L103">view source</a></div></div><div class="public anchor" id="var-make-fastcallable*"><h3>make-fastcallable*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L106">view source</a></div></div><div class="public anchor" id="var-release-fastcall-context*"><h3>release-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L105">view source</a></div></div><div class="public anchor" id="var-requires*"><h3>requires*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L91">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 4a654d2..0d35652 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index ee19e87..447464f 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index dd2bfac..c1d8c6c 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 447dc84..4dbcf14 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 590c268..daf2485 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 4057151..045b5f4 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.007</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index b8ddc0d..6891c93 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -6,6 +6,14 @@
   have great runtime characteristics in comparison to any other java python engine.
 
 
+  Note that you can pass java objects into python.  An implementation of java.util.Map will
+  appear to python as a dict-like object an implementation of java.util.List will look
+  like a sequence and if the thing is iterable then it will be iterable in python.
+  To receive callbacks from python you can provide an implementation of the
+  interface `clojure.lang.IFn` - see `clojure.lang.AFn` for a base class that makes this
+  easier.
+
+
   Performance:
 
   * `fastcall` - For the use case of repeatedly calling a single function, for instance
@@ -60,6 +68,8 @@
              #^{:static true} [call [Object Object Object] Object]
              #^{:static true} [call [Object Object Object Object] Object]
              #^{:static true} [call [Object Object Object Object Object] Object]
+             #^{:static true} [call [Object Object Object Object Object Object] Object]
+             #^{:static true} [call [Object Object Object Object Object Object Object] Object]
              #^{:static true} [allocateFastcallContext [] Object]
              #^{:static true} [releaseFastcallContext [Object] Object]
              ;;args require context
@@ -72,9 +82,7 @@
              #^{:static true} [copyToPy [Object] Object]
              #^{:static true} [copyToJVM [Object] Object]
              #^{:static true} [createArray [String Object Object] Object]
-             #^{:static true} [arrayToJVM [Object] java.util.Map]
-
-             ]))
+             #^{:static true} [arrayToJVM [Object] java.util.Map]]))
 
 
 (set! *warn-on-reflection* true)
@@ -211,16 +219,17 @@
 
 
 (defn -callPos
-  "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`."
+  "Call a python callable with only positional arguments.  Note that you don't need this pathway
+  to call python methods - you can also cast the python object to `clojure.lang.IFn` and call
+  `invoke` directly."
   [pyobj pos-args]
   (apply pyobj pos-args))
 
 
 (defn -call
-  "Call a python callable.  Note this can also be done by by calling the python object's
-  implementation of clojure.lang.IFn directly.  Overloaded for up to 4 arities."
+  "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."
   ([item]
    (item))
   ([item arg1]
@@ -231,7 +240,10 @@
    (item arg1 arg2 arg3))
   ([item arg1 arg2 arg3 arg4]
    (item arg1 arg2 arg3 arg4))
-  ([item arg1 arg2 arg3 arg4 & args]))
+  ([item arg1 arg2 arg3 arg4 arg5]
+   (item item arg1 arg2 arg3 arg4 arg5))
+  ([item arg1 arg2 arg3 arg4 arg5 arg6]
+   (item item arg1 arg2 arg3 arg4 arg5 arg6)))
 
 
 (defn -allocateFastcallContext
@@ -256,7 +268,9 @@
   fastcall context with [[-releaseFastcallContext]].
 
   Current overloads support arities up to 4 arguments.  You must not use the same context
-  with different arities - contexts are allocated in an arity-specific manner."
+  with different arities - contexts are allocated in an arity-specific manner.
+
+  For a more condensed version see [[makeFastcallable]]."
   ([ctx item]
    ;;ctx is unused but placed here to allow rapid search/replace to be correct.
    (@fastcall* item))
@@ -273,8 +287,8 @@
 (defn -makeFastcallable
   "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.  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.
+  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.
 
 ```java
   try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
@@ -302,7 +316,11 @@
 
 (defn -createArray
   "Create a numpy array from a tuple of string datatype, shape and data.
-  * `datatype` - One of \"int8\" \"uint8\"  "
+  * `datatype` - One of \"int8\" \"uint8\" \"int16\" \"uint16\" \"int32\" \"uint32\"
+  \"int64\" \"uint64\" \"float32\" \"float64\".
+  * `shape` - integer array of shapes.
+  * `data` - list or array of data.  This will of course be fastest if the datatype
+  of the array matches the datatype."
   [datatype shape data]
   (let [reshape (Clojure/var "tech.v3.tensor" "reshape")
         ->python (Clojure/var "libpython-clj2" "->python")]

From 80dddaf1d5626bc2b634f864ba4a8c212670d21f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 1 Jan 2022 10:30:07 -0700
Subject: [PATCH 384/456] re-enabling the ability to test a limit set of
 functionality without auto gil management.

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 43a2e9b..6698997 100644
--- a/deps.edn
+++ b/deps.edn
@@ -8,7 +8,7 @@
            {:extra-deps {criterium/criterium {:mvn/version"0.4.5"}
                          ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}}
            :fastcall
-           {:jvm-opts ["-Dlibpython_clj.manual_gil=false"]}
+           {:jvm-opts ["-Dlibpython_clj.manual_gil=true"]}
            :jdk-17
            {:jvm-opts ["--add-modules" "jdk.incubator.foreign"
                        "--enable-native-access=ALL-UNNAMED"]}

From 583652ea52794807b3b5bf2759b76aa92f19fd45 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 1 Jan 2022 13:41:41 -0700
Subject: [PATCH 385/456] Release 2.009

---
 deps.edn                                 |   2 +-
 docs/Usage.html                          |   2 +-
 docs/design.html                         |   2 +-
 docs/embedded.html                       |   2 +-
 docs/environments.html                   |   2 +-
 docs/index.html                          |   2 +-
 docs/libpython-clj2.codegen.html         |   2 +-
 docs/libpython-clj2.embedded.html        |   2 +-
 docs/libpython-clj2.java-api.html        |  25 +++-
 docs/libpython-clj2.python.html          |   2 +-
 docs/libpython-clj2.python.np-array.html |   2 +-
 docs/libpython-clj2.require.html         |   2 +-
 docs/new-to-clojure.html                 |   2 +-
 docs/scopes-and-gc.html                  |   2 +-
 docs/slicing.html                        |   2 +-
 src/libpython_clj2/java_api.clj          | 143 ++++++++++++++++++++---
 src/libpython_clj2/python/ffi.clj        |   9 ++
 test/libpython_clj2/java_api_test.clj    |  76 ++++++++----
 18 files changed, 218 insertions(+), 63 deletions(-)

diff --git a/deps.edn b/deps.edn
index 6698997..6198652 100644
--- a/deps.edn
+++ b/deps.edn
@@ -50,7 +50,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.008"
+                        :version "2.009"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 7ebdf0c..bafd559 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 92abf2c..54065fc 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 50fda1d..8d36349 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index edd8e46..ecc88fd 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index e9a78d4..4808726 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.008</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--callPos">-callPos</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--runString">-runString</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*">allocate-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fastcall*">fastcall*</a> </li><li> <a href="libpython-clj2.java-api.html#var-make-fastcallable*">make-fastcallable*</a> </li><li> <a href="libpython-clj2.java-api.html#var-release-fastcall-context*">release-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.009</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--.3Epython*">-&gt;python*</a> </li><li> <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--callPos">-callPos</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*">allocate-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-as-jvm*">as-jvm*</a> </li><li> <a href="libpython-clj2.java-api.html#var-check-error-throw*">check-error-throw*</a> </li><li> <a href="libpython-clj2.java-api.html#var-compile-cache">compile-cache</a> </li><li> <a href="libpython-clj2.java-api.html#var-compile-string">compile-string</a> </li><li> <a href="libpython-clj2.java-api.html#var-compiler*">compiler*</a> </li><li> <a href="libpython-clj2.java-api.html#var-eval-code*">eval-code*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fast-dict-set-item*">fast-dict-set-item*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fastcall*">fastcall*</a> </li><li> <a href="libpython-clj2.java-api.html#var-globals*">globals*</a> </li><li> <a href="libpython-clj2.java-api.html#var-make-fastcallable*">make-fastcallable*</a> </li><li> <a href="libpython-clj2.java-api.html#var-release-fastcall-context*">release-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li><li> <a href="libpython-clj2.java-api.html#var-simplify-or-track*">simplify-or-track*</a> </li><li> <a href="libpython-clj2.java-api.html#var-strcomp*">strcomp*</a> </li><li> <a href="libpython-clj2.java-api.html#var-string-cache">string-cache</a> </li><li> <a href="libpython-clj2.java-api.html#var-untracked-.3Epython*">untracked-&gt;python*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index d135695..cbe7f72 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 4cf4078..a3db1ce 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 8b0f37f..a6cef3b 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--allocateFastcallContext"><div class="inner"><span>-allocateFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callPos"><div class="inner"><span>-callPos</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--fastcall"><div class="inner"><span>-fastcall</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--releaseFastcallContext"><div class="inner"><span>-releaseFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runString"><div class="inner"><span>-runString</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*"><div class="inner"><span>allocate-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fastcall*"><div class="inner"><span>fastcall*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-make-fastcallable*"><div class="inner"><span>make-fastcallable*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-release-fastcall-context*"><div class="inner"><span>release-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--.3Epython*"><div class="inner"><span>-&gt;python*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--allocateFastcallContext"><div class="inner"><span>-allocateFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callPos"><div class="inner"><span>-callPos</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--fastcall"><div class="inner"><span>-fastcall</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--releaseFastcallContext"><div class="inner"><span>-releaseFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*"><div class="inner"><span>allocate-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-as-jvm*"><div class="inner"><span>as-jvm*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-check-error-throw*"><div class="inner"><span>check-error-throw*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compile-cache"><div class="inner"><span>compile-cache</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compile-string"><div class="inner"><span>compile-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compiler*"><div class="inner"><span>compiler*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-eval-code*"><div class="inner"><span>eval-code*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fast-dict-set-item*"><div class="inner"><span>fast-dict-set-item*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fastcall*"><div class="inner"><span>fastcall*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-globals*"><div class="inner"><span>globals*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-make-fastcallable*"><div class="inner"><span>make-fastcallable*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-release-fastcall-context*"><div class="inner"><span>release-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-simplify-or-track*"><div class="inner"><span>simplify-or-track*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-strcomp*"><div class="inner"><span>strcomp*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-string-cache"><div class="inner"><span>string-cache</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-untracked-.3Epython*"><div class="inner"><span>untracked-&gt;python*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
 <p>Note that you can pass java objects into python. An implementation of java.util.Map will  appear to python as a dict-like object an implementation of java.util.List will look  like a sequence and if the thing is iterable then it will be iterable in python.  To receive callbacks from python you can provide an implementation of the  interface <code>clojure.lang.IFn</code> - see <code>clojure.lang.AFn</code> for a base class that makes this  easier.</p>
 <p>Performance:</p>
 <ul>
@@ -18,14 +18,29 @@
   dims.add(2);
   dims.add(3);
   Object npArray = java_api.call(ones, dims); //see fastcall notes above
-</code></pre></div></div><div class="public anchor" id="var--allocateFastcallContext"><h3>-allocateFastcallContext</h3><div class="usage"><code>(-allocateFastcallContext)</code></div><div class="doc"><div class="markdown"><p>Allocate a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. The returned context must be release via <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L249">view source</a></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L332">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <code>clojure.lang.IFn</code> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L229">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L204">view source</a></div></div><div class="public anchor" id="var--callPos"><h3>-callPos</h3><div class="usage"><code>(-callPos pyobj pos-args)</code></div><div class="doc"><div class="markdown"><p>Call a python callable with only positional arguments. Note that you don’t need this pathway to call python methods - you can also cast the python object to <code>clojure.lang.IFn</code> and call <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L221">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L311">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L304">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of shapes. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L317">view source</a></div></div><div class="public anchor" id="var--fastcall"><h3>-fastcall</h3><div class="usage"><code>(-fastcall ctx item)</code><code>(-fastcall ctx item arg1)</code><code>(-fastcall ctx item arg1 arg2)</code><code>(-fastcall ctx item arg1 arg2 arg3)</code><code>(-fastcall ctx item arg1 arg2 arg3 arg4)</code></div><div class="doc"><div class="markdown"><p>Call a python function as fast as possible using a fixed number of positional arguments. The caller must provide an allocated fastcall context via <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> and furthermore the caller may choose to deallocate the fastcall context with <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p>
+</code></pre></div></div><div class="public anchor" id="var--.3Epython*"><h3>-&gt;python*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L106">view source</a></div></div><div class="public anchor" id="var--allocateFastcallContext"><h3>-allocateFastcallContext</h3><div class="usage"><code>(-allocateFastcallContext)</code></div><div class="doc"><div class="markdown"><p>Allocate a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. The returned context must be release via <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L354">view source</a></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L437">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <code>clojure.lang.IFn</code> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L334">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L309">view source</a></div></div><div class="public anchor" id="var--callPos"><h3>-callPos</h3><div class="usage"><code>(-callPos pyobj pos-args)</code></div><div class="doc"><div class="markdown"><p>Call a python callable with only positional arguments. Note that you don’t need this pathway to call python methods - you can also cast the python object to <code>clojure.lang.IFn</code> and call <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L326">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L416">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L409">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of shapes. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L422">view source</a></div></div><div class="public anchor" id="var--fastcall"><h3>-fastcall</h3><div class="usage"><code>(-fastcall ctx item)</code><code>(-fastcall ctx item arg1)</code><code>(-fastcall ctx item arg1 arg2)</code><code>(-fastcall ctx item arg1 arg2 arg3)</code><code>(-fastcall ctx item arg1 arg2 arg3 arg4)</code></div><div class="doc"><div class="markdown"><p>Call a python function as fast as possible using a fixed number of positional arguments. The caller must provide an allocated fastcall context via <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> and furthermore the caller may choose to deallocate the fastcall context with <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p>
 <p>Current overloads support arities up to 4 arguments. You must not use the same context with different arities - contexts are allocated in an arity-specific manner.</p>
-<p>For a more condensed version see <a href="null">makeFastcallable</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L264">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L170">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L188">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L164">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L182">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L198">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L109">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L156">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an integer representing the gil state that must be passed into unlockGIL.</p>
+<p>For a more condensed version see <a href="null">makeFastcallable</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L369">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L215">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L251">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L233">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L209">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L227">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L303">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L167">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L201">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an long representing the gil state that must be passed into unlockGIL.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L123">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L181">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <pre><code class="java">  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
      tightloop {
        java_api.call(fastcaller, arg1, arg2);
      }
   }
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L287">view source</a></div></div><div class="public anchor" id="var--releaseFastcallContext"><h3>-releaseFastcallContext</h3><div class="usage"><code>(-releaseFastcallContext ctx)</code></div><div class="doc"><div class="markdown"><p>Release a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. This is safe to call with null and to call multiple times on the same context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L256">view source</a></div></div><div class="public anchor" id="var--runString"><h3>-runString</h3><div class="usage"><code>(-runString code)</code></div><div class="doc"><div class="markdown"><p>Run a string returning a map of two keys -“globals” and “locals” which each point to a java.util.Map of the respective contexts. See documentation under <a href="libpython-clj2.python.html#var-run-simple-string">libpython-clj2.python/run-simple-string</a> - specifically this will never return the result of the last statement ran - you need to set a value in the global or local context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L143">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L176">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L193">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L136">view source</a></div></div><div class="public anchor" id="var-allocate-fastcall-context*"><h3>allocate-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L104">view source</a></div></div><div class="public anchor" id="var-fastcall*"><h3>fastcall*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L103">view source</a></div></div><div class="public anchor" id="var-make-fastcallable*"><h3>make-fastcallable*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L106">view source</a></div></div><div class="public anchor" id="var-release-fastcall-context*"><h3>release-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L105">view source</a></div></div><div class="public anchor" id="var-requires*"><h3>requires*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L91">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L392">view source</a></div></div><div class="public anchor" id="var--releaseFastcallContext"><h3>-releaseFastcallContext</h3><div class="usage"><code>(-releaseFastcallContext ctx)</code></div><div class="doc"><div class="markdown"><p>Release a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. This is safe to call with null and to call multiple times on the same context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L361">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>Run a string returning the result of the last expression. Strings are compiled and  live for the life of the interpreter.</p>
+<p>The global context is returned as a java map.</p>
+<p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
+<pre><code class="java">   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
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L280">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>Run a string returning the result of the last expression. Strings are compiled and  live for the life of the interpreter.</p>
+<p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
+<p>Example:</p>
+<pre><code class="java">  java_api.setGlobal("bid", 1);
+  java_api.setGlobal("ask", 2);
+  java_api.runStringAsInput("bid-ask"); //Returns -1
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L258">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L221">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L243">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L238">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L194">view source</a></div></div><div class="public anchor" id="var-allocate-fastcall-context*"><h3>allocate-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L108">view source</a></div></div><div class="public anchor" id="var-as-jvm*"><h3>as-jvm*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L113">view source</a></div></div><div class="public anchor" id="var-check-error-throw*"><h3>check-error-throw*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L111">view source</a></div></div><div class="public anchor" id="var-compile-cache"><h3>compile-cache</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L150">view source</a></div></div><div class="public anchor" id="var-compile-string"><h3>compile-string</h3><div class="usage"><code>(compile-string strval run-type)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L161">view source</a></div></div><div class="public anchor" id="var-compiler*"><h3>compiler*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L152">view source</a></div></div><div class="public anchor" id="var-eval-code*"><h3>eval-code*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L114">view source</a></div></div><div class="public anchor" id="var-fast-dict-set-item*"><h3>fast-dict-set-item*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L132">view source</a></div></div><div class="public anchor" id="var-fastcall*"><h3>fastcall*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L107">view source</a></div></div><div class="public anchor" id="var-globals*"><h3>globals*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L119">view source</a></div></div><div class="public anchor" id="var-make-fastcallable*"><h3>make-fastcallable*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L110">view source</a></div></div><div class="public anchor" id="var-release-fastcall-context*"><h3>release-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L109">view source</a></div></div><div class="public anchor" id="var-requires*"><h3>requires*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L94">view source</a></div></div><div class="public anchor" id="var-simplify-or-track*"><h3>simplify-or-track*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L112">view source</a></div></div><div class="public anchor" id="var-strcomp*"><h3>strcomp*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L126">view source</a></div></div><div class="public anchor" id="var-string-cache"><h3>string-cache</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L117">view source</a></div></div><div class="public anchor" id="var-untracked-.3Epython*"><h3>untracked-&gt;python*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L115">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 0d35652..93cdcb1 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 447464f..75f1b31 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index c1d8c6c..98f5b82 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 4dbcf14..e2ccde0 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index daf2485..db4b6da 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 045b5f4..f48650e 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.008</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index 6891c93..7237eee 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -43,16 +43,15 @@
   dims.add(3);
   Object npArray = java_api.call(ones, dims); //see fastcall notes above
 ```"
-  (:import [java.util Map Map$Entry List]
+  (:import [java.util Map Map$Entry List HashMap]
            [java.util.function Supplier]
            [clojure.java.api Clojure])
   (: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} [lockGIL [] int]
-             #^{:static true} [unlockGIL [int] Object]
+             #^{:static true} [lockGIL [] long]
+             #^{:static true} [unlockGIL [long] Object]
              #^{:static true} [inPyContext [java.util.function.Supplier] Object]
              #^{:static true} [hasAttr [Object String] Boolean]
              #^{:static true} [getAttr [Object String] Object]
@@ -60,6 +59,10 @@
              #^{:static true} [hasItem [Object Object] Boolean]
              #^{:static true} [getItem [Object Object] Object]
              #^{:static true} [setItem [Object Object Object] Object]
+             #^{:static true} [getGlobal [Object String] Object]
+             #^{:static true} [setGlobal [Object String Object] Object]
+             #^{:static true} [runStringAsInput [String] Object]
+             #^{:static true} [runStringAsFile [String] java.util.Map]
              #^{:static true} [importModule [String] Object]
              #^{:static true} [callKw [Object java.util.List java.util.Map] Object]
              #^{:static true} [callPos [Object java.util.List] Object]
@@ -100,10 +103,65 @@
                      (require (Clojure/read clj-ns))))))
 
 
+(def ->python* (delay (Clojure/var "libpython-clj2.python" "->python")))
 (def fastcall* (delay (Clojure/var "libpython-clj2.python.fn" "fastcall")))
 (def allocate-fastcall-context* (delay (Clojure/var "libpython-clj2.python.fn" "allocate-fastcall-context")))
 (def release-fastcall-context* (delay (Clojure/var "libpython-clj2.python.fn" "release-fastcall-context")))
 (def make-fastcallable* (delay (Clojure/var "libpython-clj2.python.fn" "make-fastcallable")))
+(def check-error-throw* (delay (Clojure/var "libpython-clj2.python.ffi" "check-error-throw")))
+(def simplify-or-track* (delay (Clojure/var "libpython-clj2.python.ffi" "simplify-or-track")))
+(def as-jvm* (delay (Clojure/var "libpython-clj2.python" "as-jvm")))
+(def eval-code* (delay (Clojure/var "libpython-clj2.python.ffi" "PyEval_EvalCode")))
+(def untracked->python* (delay (Clojure/var "libpython-clj2.python.ffi" "untracked->python")))
+
+(def ^{:tag HashMap} string-cache (HashMap.))
+(declare -lockGIL -unlockGIL)
+(def globals*
+  (delay
+    (let [gstate (-lockGIL)
+          main-mod ((Clojure/var "libpython-clj2.python.ffi" "PyImport_AddModule") "__main__")]
+      (-> ((Clojure/var "libpython-clj2.python.ffi" "PyModule_GetDict") main-mod)
+          (@as-jvm*)))))
+
+(def strcomp* (delay (let [->python @->python*]
+                       (reify java.util.function.Function
+                         (apply [this data]
+                           (->python data))))))
+
+
+(def fast-dict-set-item*
+  (delay (let [untracked->python (Clojure/var "libpython-clj2.python.ffi"
+                                              "untracked->python")
+               decref (Clojure/var "libpython-clj2.python.ffi"
+                                   "Py_DecRef")
+               pydict-setitem (Clojure/var "libpython-clj2.python.ffi"
+                                           "PyDict_SetItem")]
+           (fn [dict k v]
+             (let [v (untracked->python v)]
+               (pydict-setitem dict k v)
+               (decref v))))))
+
+(defn- cached-string
+  [strval]
+  (when strval
+    (.computeIfAbsent string-cache strval @strcomp*)))
+
+
+(def ^{:tag HashMap} compile-cache (HashMap.))
+
+(def compiler* (delay
+                 (let [compile-fn (Clojure/var "libpython-clj2.python.ffi"
+                                               "Py_CompileString")]
+                   (reify java.util.function.Function
+                     (apply [this [strdata run-type]]
+                       (compile-fn strdata "unnamed.py" (case run-type
+                                                          :file 257
+                                                          :input 258)))))))
+
+(defn compile-string
+  [strval run-type]
+  (when strval
+    (.computeIfAbsent compile-cache [strval run-type] @compiler*)))
 
 
 (defn -initialize
@@ -122,7 +180,7 @@
 
 (defn -lockGIL
   "Attempt to lock the gil.  This is safe to call in a reentrant manner.
-  Returns an integer representing the gil state that must be passed into unlockGIL.
+  Returns an long representing the gil state that must be passed into unlockGIL.
 
   See documentation for [pyGILState_Ensure](https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure).
 
@@ -130,7 +188,7 @@
   the GIL before doing a string of operations is faster than having each operation lock
   the GIL individually."
   []
-  (int ((Clojure/var "libpython-clj2.python.ffi" "lock-gil"))))
+  ((Clojure/var "libpython-clj2.python.ffi" "lock-gil")))
 
 
 (defn -unlockGIL
@@ -140,19 +198,6 @@
   ((Clojure/var "libpython-clj2.python.ffi" "unlock-gil") gilstate))
 
 
-(defn -runString
-  "Run a string returning a map of two keys -\"globals\" and \"locals\" which each point to
-  a java.util.Map of the respective contexts.  See documentation under
-  [[libpython-clj2.python/run-simple-string]] - specifically this will never return
-  the result of the last statement ran - you need to set a value in the global or local
-  context."
-  ^java.util.Map [^String code]
-  (->> ((Clojure/var "libpython-clj2.python" "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
   will be deallocated once the context is released.  The code must not return references
@@ -195,6 +240,66 @@
   ((Clojure/var "libpython-clj2.python" "set-item!") pyobj itemName itemVal))
 
 
+(defn -setGlobal
+  "Set a value in the global dict.  This function expects the GIL to be locked - it will
+  not lock/unlock it for you."
+  [^String varname varval]
+  (@fast-dict-set-item* @globals* (cached-string varname) varval)
+  nil)
+
+
+(defn -getGlobal
+  "Get a value from the global dict.  This function expects the GIL to be locked - it will
+  not lock/unlock it for you."
+  [^String varname]
+  (-getItem @globals* (cached-string varname)))
+
+
+(defn -runStringAsInput
+  "Run a string returning the result of the last expression.  Strings are compiled and
+  live for the life of the interpreter.
+
+  This function expects the GIL to be locked - it will not lock/unlock it for you.
+
+  Example:
+
+```java
+  java_api.setGlobal(\"bid\", 1);
+  java_api.setGlobal(\"ask\", 2);
+  java_api.runStringAsInput(\"bid-ask\"); //Returns -1
+```
+  "
+  [strdata]
+  (let [pyobj (compile-string strdata :input)]
+    (when-not pyobj
+      (@check-error-throw*))
+    (if-let [script-rt (@eval-code* pyobj @globals* @globals*)]
+      (@simplify-or-track* script-rt))))
+
+
+(defn -runStringAsFile
+  "Run a string returning the result of the last expression.  Strings are compiled and
+  live for the life of the interpreter.
+
+  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.
+
+```java
+   Map globals = java_api.runStringAsFile(\"def calcSpread(bid,ask):\n\treturn bid-ask\n\n\");
+   Object spreadFn = globals.get(\"calcSpread\");
+   java_api.call(spreadFn, 1 2); // Returns -1
+```
+  "
+  [strdata]
+  (let [pyobj (compile-string strdata :file)]
+    (when-not pyobj
+      (@check-error-throw*))
+    (@eval-code* pyobj @globals* @globals*)
+    (@check-error-throw*)
+    @globals*))
+
+
 (defn -importModule
   "Import a python module.  Module entries can be accessed via `getAttr`."
   [modname]
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index 429fc6e..25c32ac 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -137,6 +137,15 @@ Each call must be matched with PyGILState_Release"}
    :PyImport_AddModule {:rettype :pointer
                         :argtypes [['modname :string]]
                         :doc "Add a python module"}
+   :Py_CompileString {:rettype :pointer
+                      :argtypes [['strdata :string]
+                                 ['filename :string]
+                                 ['start :int32]]}
+
+   :PyEval_EvalCode {:rettype :pointer
+                     :argtypes [['co :pointer]
+                                ['globals :pointer]
+                                ['locals :pointer]]}
    :PyModule_GetDict {:rettype :pointer
                       :argtypes [['module :pointer]]
                       :doc "Get the module dictionary"}
diff --git a/test/libpython_clj2/java_api_test.clj b/test/libpython_clj2/java_api_test.clj
index 91fd982..74558a0 100644
--- a/test/libpython_clj2/java_api_test.clj
+++ b/test/libpython_clj2/java_api_test.clj
@@ -7,36 +7,37 @@
 
 (deftest base-japi-test
   (japi/-initialize nil)
-  (let [rs-retval (japi/-runString "data = 5")
-        globals (get rs-retval "globals")]
-    (is (= 5 (get globals "data")))
-    (japi/-setItem globals "data" 6)
-    (is (= 6 (get globals "data"))))
-  (is (= 0 (py-ffi/PyGILState_Check)))
-  (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"))))
-    (is (= 0 (py-ffi/PyGILState_Check)))
-    (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"))))
-          (is (= 0 (py-ffi/PyGILState_Check)))))
   (let [gilstate (japi/-lockGIL)]
+    (japi/-runStringAsFile "data = 5")
+    (is (= 5 (japi/-getGlobal "data")))
+    (japi/-setGlobal "data" 6)
+    (is (= 6 (japi/-getGlobal "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"))))))
     (try
-      (let [test-fn (-> (japi/-runString "def calcSpread(bid,ask):\n\treturn bid-ask\n\n")
-                        (get "globals")
+      (let [test-fn (-> (japi/-runStringAsFile "def calcSpread(bid,ask):\n\treturn bid-ask\n\n")
                         (get "calcSpread"))
             n-calls 100000]
+        (let [start-ns (System/nanoTime)
+              _ (dotimes [iter n-calls]
+                  (japi/-call test-fn 1 2))
+              end-ns (System/nanoTime)
+              ms (/ (- end-ns start-ns) 10e6)]
+          (println "Python fn calls/ms" (/ n-calls ms)))
         ;;low level api
         (let [call-ctx (japi/-allocateFastcallContext)
-              _ (println test-fn)
               _ (is (= -1  (japi/-fastcall call-ctx test-fn 1 2)))
               start-ns (System/nanoTime)
               _ (dotimes [iter n-calls]
@@ -53,6 +54,31 @@
                     (japi/-call fcall 1 2))
                 end-ns (System/nanoTime)
                 ms (/ (- end-ns start-ns) 10e6)]
-            (println "Python fastcallable calls/ms" (/ n-calls ms)))))
+            (println "Python fastcallable calls/ms" (/ n-calls ms))))
+        ;;Global setitem pathway
+        (japi/-setGlobal "bid" 1)
+        (japi/-setGlobal "ask" 2)
+        (is (= -1 (japi/-runStringAsInput "bid-ask")))
+        (let [start-ns (System/nanoTime)
+              _ (dotimes [iter n-calls]
+                  (japi/-setGlobal "bid" 1)
+                  (japi/-setGlobal "ask" 2)
+                  (japi/-runStringAsInput "bid-ask"))
+              end-ns (System/nanoTime)
+              ms (/ (- end-ns start-ns) 10e6)]
+          (println "Python setglobal pathway calls/ms" (/ n-calls ms))))
+      (finally
+        (japi/-unlockGIL gilstate)))))
+
+
+(defn only-string-input
+  []
+  (let [gilstate (japi/-lockGIL)
+        n-calls 5000000]
+    (try
+      (dotimes [iter n-calls]
+        (japi/-setGlobal "bid" 1.1)
+        (japi/-setGlobal "ask" 2.2)
+        (japi/-runStringAsInput "bid-ask"))
       (finally
         (japi/-unlockGIL gilstate)))))

From 1d6a1fcfd2eca68e80c8734b17046bde7a2289a3 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 1 Jan 2022 17:47:06 -0700
Subject: [PATCH 386/456] Release 2.010

---
 deps.edn                                 | 2 +-
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 2 +-
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.java-api.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 src/libpython_clj2/java_api.clj          | 4 ++--
 16 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/deps.edn b/deps.edn
index 6198652..a1fcd5b 100644
--- a/deps.edn
+++ b/deps.edn
@@ -50,7 +50,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.009"
+                        :version "2.010"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index bafd559..82de8d1 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 54065fc..5f98be0 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 8d36349..9b32f8e 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index ecc88fd..b68cddb 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 4808726..2186920 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.009</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--.3Epython*">-&gt;python*</a> </li><li> <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--callPos">-callPos</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*">allocate-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-as-jvm*">as-jvm*</a> </li><li> <a href="libpython-clj2.java-api.html#var-check-error-throw*">check-error-throw*</a> </li><li> <a href="libpython-clj2.java-api.html#var-compile-cache">compile-cache</a> </li><li> <a href="libpython-clj2.java-api.html#var-compile-string">compile-string</a> </li><li> <a href="libpython-clj2.java-api.html#var-compiler*">compiler*</a> </li><li> <a href="libpython-clj2.java-api.html#var-eval-code*">eval-code*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fast-dict-set-item*">fast-dict-set-item*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fastcall*">fastcall*</a> </li><li> <a href="libpython-clj2.java-api.html#var-globals*">globals*</a> </li><li> <a href="libpython-clj2.java-api.html#var-make-fastcallable*">make-fastcallable*</a> </li><li> <a href="libpython-clj2.java-api.html#var-release-fastcall-context*">release-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li><li> <a href="libpython-clj2.java-api.html#var-simplify-or-track*">simplify-or-track*</a> </li><li> <a href="libpython-clj2.java-api.html#var-strcomp*">strcomp*</a> </li><li> <a href="libpython-clj2.java-api.html#var-string-cache">string-cache</a> </li><li> <a href="libpython-clj2.java-api.html#var-untracked-.3Epython*">untracked-&gt;python*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.010</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--.3Epython*">-&gt;python*</a> </li><li> <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--callPos">-callPos</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*">allocate-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-as-jvm*">as-jvm*</a> </li><li> <a href="libpython-clj2.java-api.html#var-check-error-throw*">check-error-throw*</a> </li><li> <a href="libpython-clj2.java-api.html#var-compile-cache">compile-cache</a> </li><li> <a href="libpython-clj2.java-api.html#var-compile-string">compile-string</a> </li><li> <a href="libpython-clj2.java-api.html#var-compiler*">compiler*</a> </li><li> <a href="libpython-clj2.java-api.html#var-eval-code*">eval-code*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fast-dict-set-item*">fast-dict-set-item*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fastcall*">fastcall*</a> </li><li> <a href="libpython-clj2.java-api.html#var-globals*">globals*</a> </li><li> <a href="libpython-clj2.java-api.html#var-make-fastcallable*">make-fastcallable*</a> </li><li> <a href="libpython-clj2.java-api.html#var-release-fastcall-context*">release-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li><li> <a href="libpython-clj2.java-api.html#var-simplify-or-track*">simplify-or-track*</a> </li><li> <a href="libpython-clj2.java-api.html#var-strcomp*">strcomp*</a> </li><li> <a href="libpython-clj2.java-api.html#var-string-cache">string-cache</a> </li><li> <a href="libpython-clj2.java-api.html#var-untracked-.3Epython*">untracked-&gt;python*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index cbe7f72..3f29c2c 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index a3db1ce..cc7cfe5 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index a6cef3b..39dbe8c 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--.3Epython*"><div class="inner"><span>-&gt;python*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--allocateFastcallContext"><div class="inner"><span>-allocateFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callPos"><div class="inner"><span>-callPos</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--fastcall"><div class="inner"><span>-fastcall</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--releaseFastcallContext"><div class="inner"><span>-releaseFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*"><div class="inner"><span>allocate-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-as-jvm*"><div class="inner"><span>as-jvm*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-check-error-throw*"><div class="inner"><span>check-error-throw*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compile-cache"><div class="inner"><span>compile-cache</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compile-string"><div class="inner"><span>compile-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compiler*"><div class="inner"><span>compiler*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-eval-code*"><div class="inner"><span>eval-code*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fast-dict-set-item*"><div class="inner"><span>fast-dict-set-item*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fastcall*"><div class="inner"><span>fastcall*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-globals*"><div class="inner"><span>globals*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-make-fastcallable*"><div class="inner"><span>make-fastcallable*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-release-fastcall-context*"><div class="inner"><span>release-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-simplify-or-track*"><div class="inner"><span>simplify-or-track*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-strcomp*"><div class="inner"><span>strcomp*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-string-cache"><div class="inner"><span>string-cache</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-untracked-.3Epython*"><div class="inner"><span>untracked-&gt;python*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--.3Epython*"><div class="inner"><span>-&gt;python*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--allocateFastcallContext"><div class="inner"><span>-allocateFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callPos"><div class="inner"><span>-callPos</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--fastcall"><div class="inner"><span>-fastcall</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--releaseFastcallContext"><div class="inner"><span>-releaseFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*"><div class="inner"><span>allocate-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-as-jvm*"><div class="inner"><span>as-jvm*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-check-error-throw*"><div class="inner"><span>check-error-throw*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compile-cache"><div class="inner"><span>compile-cache</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compile-string"><div class="inner"><span>compile-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compiler*"><div class="inner"><span>compiler*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-eval-code*"><div class="inner"><span>eval-code*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fast-dict-set-item*"><div class="inner"><span>fast-dict-set-item*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fastcall*"><div class="inner"><span>fastcall*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-globals*"><div class="inner"><span>globals*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-make-fastcallable*"><div class="inner"><span>make-fastcallable*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-release-fastcall-context*"><div class="inner"><span>release-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-simplify-or-track*"><div class="inner"><span>simplify-or-track*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-strcomp*"><div class="inner"><span>strcomp*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-string-cache"><div class="inner"><span>string-cache</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-untracked-.3Epython*"><div class="inner"><span>untracked-&gt;python*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
 <p>Note that you can pass java objects into python. An implementation of java.util.Map will  appear to python as a dict-like object an implementation of java.util.List will look  like a sequence and if the thing is iterable then it will be iterable in python.  To receive callbacks from python you can provide an implementation of the  interface <code>clojure.lang.IFn</code> - see <code>clojure.lang.AFn</code> for a base class that makes this  easier.</p>
 <p>Performance:</p>
 <ul>
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 93cdcb1..f74df65 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 75f1b31..f9e7266 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 98f5b82..d5d48a8 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index e2ccde0..f7496da 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index db4b6da..d78b32d 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index f48650e..48ad0f6 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.009</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index 7237eee..a864aca 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -59,8 +59,8 @@
              #^{:static true} [hasItem [Object Object] Boolean]
              #^{:static true} [getItem [Object Object] Object]
              #^{:static true} [setItem [Object Object Object] Object]
-             #^{:static true} [getGlobal [Object String] Object]
-             #^{:static true} [setGlobal [Object String Object] Object]
+             #^{:static true} [getGlobal [String] Object]
+             #^{:static true} [setGlobal [String Object] Object]
              #^{:static true} [runStringAsInput [String] Object]
              #^{:static true} [runStringAsFile [String] java.util.Map]
              #^{:static true} [importModule [String] Object]

From 8343e7ee00aa79f32c2e4f3f0d2e5b5cde923ecf Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Jan 2022 09:00:20 -0700
Subject: [PATCH 387/456] Release 2.011

---
 deps.edn                                 |   4 +-
 docs/Usage.html                          |   2 +-
 docs/design.html                         |   2 +-
 docs/embedded.html                       |   2 +-
 docs/environments.html                   |   2 +-
 docs/index.html                          |   2 +-
 docs/libpython-clj2.codegen.html         |   2 +-
 docs/libpython-clj2.embedded.html        |   2 +-
 docs/libpython-clj2.java-api.html        |  33 ++--
 docs/libpython-clj2.python.html          |  47 ++++-
 docs/libpython-clj2.python.np-array.html |   2 +-
 docs/libpython-clj2.require.html         |   2 +-
 docs/new-to-clojure.html                 |   2 +-
 docs/scopes-and-gc.html                  |   2 +-
 docs/slicing.html                        |   2 +-
 src/libpython_clj2/java_api.clj          | 223 ++++++++++++++---------
 src/libpython_clj2/python.clj            |  38 ++++
 src/libpython_clj2/python/fn.clj         |   8 +-
 test/libpython_clj2/java_api_test.clj    |  10 +-
 19 files changed, 254 insertions(+), 133 deletions(-)

diff --git a/deps.edn b/deps.edn
index a1fcd5b..526748b 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,4 +1,4 @@
-{:paths ["src" "classes"]
+{:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
         cnuernber/dtype-next {:mvn/version "8.053"}
         net.java.dev.jna/jna {:mvn/version "5.10.0"}
@@ -50,7 +50,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.010"
+                        :version "2.011"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 82de8d1..3f9e748 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 5f98be0..642ff9f 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 9b32f8e..40a7398 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index b68cddb..dbad6cf 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 2186920..0c7f12f 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.010</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--.3Epython*">-&gt;python*</a> </li><li> <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--callPos">-callPos</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--inPyContext">-inPyContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*">allocate-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-as-jvm*">as-jvm*</a> </li><li> <a href="libpython-clj2.java-api.html#var-check-error-throw*">check-error-throw*</a> </li><li> <a href="libpython-clj2.java-api.html#var-compile-cache">compile-cache</a> </li><li> <a href="libpython-clj2.java-api.html#var-compile-string">compile-string</a> </li><li> <a href="libpython-clj2.java-api.html#var-compiler*">compiler*</a> </li><li> <a href="libpython-clj2.java-api.html#var-eval-code*">eval-code*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fast-dict-set-item*">fast-dict-set-item*</a> </li><li> <a href="libpython-clj2.java-api.html#var-fastcall*">fastcall*</a> </li><li> <a href="libpython-clj2.java-api.html#var-globals*">globals*</a> </li><li> <a href="libpython-clj2.java-api.html#var-make-fastcallable*">make-fastcallable*</a> </li><li> <a href="libpython-clj2.java-api.html#var-release-fastcall-context*">release-fastcall-context*</a> </li><li> <a href="libpython-clj2.java-api.html#var-requires*">requires*</a> </li><li> <a href="libpython-clj2.java-api.html#var-simplify-or-track*">simplify-or-track*</a> </li><li> <a href="libpython-clj2.java-api.html#var-strcomp*">strcomp*</a> </li><li> <a href="libpython-clj2.java-api.html#var-string-cache">string-cache</a> </li><li> <a href="libpython-clj2.java-api.html#var-untracked-.3Epython*">untracked-&gt;python*</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.011</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 3f29c2c..bbe9132 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index cc7cfe5..8d01118 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 39dbe8c..9a93b9f 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,15 +1,18 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--.3Epython*"><div class="inner"><span>-&gt;python*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--allocateFastcallContext"><div class="inner"><span>-allocateFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callPos"><div class="inner"><span>-callPos</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--fastcall"><div class="inner"><span>-fastcall</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--inPyContext"><div class="inner"><span>-inPyContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--releaseFastcallContext"><div class="inner"><span>-releaseFastcallContext</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-allocate-fastcall-context*"><div class="inner"><span>allocate-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-as-jvm*"><div class="inner"><span>as-jvm*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-check-error-throw*"><div class="inner"><span>check-error-throw*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compile-cache"><div class="inner"><span>compile-cache</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compile-string"><div class="inner"><span>compile-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-compiler*"><div class="inner"><span>compiler*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-eval-code*"><div class="inner"><span>eval-code*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fast-dict-set-item*"><div class="inner"><span>fast-dict-set-item*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-fastcall*"><div class="inner"><span>fastcall*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-globals*"><div class="inner"><span>globals*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-make-fastcallable*"><div class="inner"><span>make-fastcallable*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-release-fastcall-context*"><div class="inner"><span>release-fastcall-context*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-requires*"><div class="inner"><span>requires*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-simplify-or-track*"><div class="inner"><span>simplify-or-track*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-strcomp*"><div class="inner"><span>strcomp*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-string-cache"><div class="inner"><span>string-cache</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var-untracked-.3Epython*"><div class="inner"><span>untracked-&gt;python*</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
-<p>Note that you can pass java objects into python. An implementation of java.util.Map will  appear to python as a dict-like object an implementation of java.util.List will look  like a sequence and if the thing is iterable then it will be iterable in python.  To receive callbacks from python you can provide an implementation of the  interface <code>clojure.lang.IFn</code> - see <code>clojure.lang.AFn</code> for a base class that makes this  easier.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
+<p>Note that you can pass java objects into python. An implementation of java.util.Map will  appear to python as a dict-like object an implementation of java.util.List will look  like a sequence and if the thing is iterable then it will be iterable in python.  To receive callbacks from python you can provide an implementation of the  interface <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a>  - see <a href="https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/AFn.java">clojure.lang.AFn</a> for a base class that makes this easier.</p>
 <p>Performance:</p>
+<p>There are a two logical ways to repeatedly invoking python functionality. The first is  to set some globals and repeatedly <a href="null">runStringAsInput</a> a script. The second is  ’exec’ing a script, finding an exported function in the global dict and calling  that. With libpython-clj, the second pathway – repeatedly calling a function –  is going to be faster than the first if the user makes a fastcallable out of the function  to be invoked. Here are some sample timings for an extremely simple function with two  arguments:</p>
+<pre><code class="console">Python fn calls/ms 1923.2490094806021
+Python fastcallable calls/ms 3776.767751742239
+Python eval pathway calls/ms 2646.0478013509883
+</code></pre>
 <ul>
   <li>
-  <p><code>fastcall</code> - For the use case of repeatedly calling a single function, for instance  for each row of a table or in a tight loop, use <code>allocateFastcallContext</code> before the loop,  use fastcall to call your function noting that it takes an additional context parameter  the user can pass in as the first argument, and use <code>releaseFastcallContext</code> afterwords. This  pathway eliminates nearly all of the overhead of calling python from Java and uses the  absolutely minimal number of C api calls in order to call a python function. This is  about twice as fast as using the generic architecture to call a python function.</p></li>
+  <p><a href="null">makeFastcallable</a> - - For the use case of repeatedly calling a single function - this  will cache the argument tuple for repeated use as opposed to allocating the argument tuple  every call. This can be a surprising amount faster – 2x-3x – than directly calling the  python callable. Once a fastcallable object is made you can either cast it to a  <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a>  or call it via the provided <code>call</code> static method.</p></li>
   <li>
-  <p><code>makeFastcallable</code> - A simplified version of fastcall to be used with try-with-resources.  This is a safer but equally-as-fast pathway as <code>fastcall</code>.</p></li>
-  <li>
-  <p>HAIR ON FIRE MODE - If you are certain you are correctly calling lockGIL and unlockGIL  then you can define a variable, <code>-Dlibpython_clj.manual_gil=true</code> that will disable  automatic GIL lock/unlock system and correctness checking. This is useful, for instance,  if you are going to lock libpython-clj to a thread and control all access to it yourself.  This pathway will get at most 10% above using fastcall by itself.</p></li>
+  <p>HAIR ON FIRE MODE - If you are certain you are correctly calling lockGIL and unlockGIL  then you can define a variable, <code>-Dlibpython_clj.manual_gil=true</code> that will disable  automatic GIL lock/unlock system and gil correctness checking. This is useful, for instance,  if you are going to lock libpython-clj to a thread and control all access to it yourself.  This pathway will get at most 10% above using fastcall by itself.</p></li>
 </ul>
 <pre><code class="java">  java_api.initialize(null);
   np = java_api.importModule("numpy");
@@ -18,29 +21,29 @@
   dims.add(2);
   dims.add(3);
   Object npArray = java_api.call(ones, dims); //see fastcall notes above
-</code></pre></div></div><div class="public anchor" id="var--.3Epython*"><h3>-&gt;python*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L106">view source</a></div></div><div class="public anchor" id="var--allocateFastcallContext"><h3>-allocateFastcallContext</h3><div class="usage"><code>(-allocateFastcallContext)</code></div><div class="doc"><div class="markdown"><p>Allocate a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. The returned context must be release via <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L354">view source</a></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and “data”.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L437">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <code>clojure.lang.IFn</code> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L334">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <code>clojure.lang.IFn</code> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L309">view source</a></div></div><div class="public anchor" id="var--callPos"><h3>-callPos</h3><div class="usage"><code>(-callPos pyobj pos-args)</code></div><div class="doc"><div class="markdown"><p>Call a python callable with only positional arguments. Note that you don’t need this pathway to call python methods - you can also cast the python object to <code>clojure.lang.IFn</code> and call <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L326">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L416">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L409">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of shapes. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L422">view source</a></div></div><div class="public anchor" id="var--fastcall"><h3>-fastcall</h3><div class="usage"><code>(-fastcall ctx item)</code><code>(-fastcall ctx item arg1)</code><code>(-fastcall ctx item arg1 arg2)</code><code>(-fastcall ctx item arg1 arg2 arg3)</code><code>(-fastcall ctx item arg1 arg2 arg3 arg4)</code></div><div class="doc"><div class="markdown"><p>Call a python function as fast as possible using a fixed number of positional arguments. The caller must provide an allocated fastcall context via <a href="libpython-clj2.java-api.html#var--allocateFastcallContext">-allocateFastcallContext</a> and furthermore the caller may choose to deallocate the fastcall context with <a href="libpython-clj2.java-api.html#var--releaseFastcallContext">-releaseFastcallContext</a>.</p>
-<p>Current overloads support arities up to 4 arguments. You must not use the same context with different arities - contexts are allocated in an arity-specific manner.</p>
-<p>For a more condensed version see <a href="null">makeFastcallable</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L369">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L215">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L251">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L233">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L209">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L227">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L303">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L167">view source</a></div></div><div class="public anchor" id="var--inPyContext"><h3>-inPyContext</h3><div class="usage"><code>(-inPyContext fn)</code></div><div class="doc"><div class="markdown"><p>Run some code in a python context where all python objects allocated within the context will be deallocated once the context is released. The code must not return references to live python objects.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L201">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>Attempt to lock the gil. This is safe to call in a reentrant manner. Returns an long representing the gil state that must be passed into unlockGIL.</p>
+</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L462">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L358">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L341">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>Note this copies <em>from</em> the first argument <em>to</em> the second argument – this is reverse the normal memcpy argument order!!. Returns the destination (to) argument.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L475">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L441">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L434">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L447">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L245">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L281">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L263">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L239">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L257">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L335">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L196">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L210">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L181">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L219">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <pre><code class="java">  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
-     tightloop {
+     tightloop: {
        java_api.call(fastcaller, arg1, arg2);
      }
   }
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L392">view source</a></div></div><div class="public anchor" id="var--releaseFastcallContext"><h3>-releaseFastcallContext</h3><div class="usage"><code>(-releaseFastcallContext ctx)</code></div><div class="doc"><div class="markdown"><p>Release a fastcall context. See docs for <a href="libpython-clj2.java-api.html#var--fastcall">-fastcall</a>. This is safe to call with null and to call multiple times on the same context.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L361">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>Run a string returning the result of the last expression. Strings are compiled and  live for the life of the interpreter.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L417">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
 <p>The global context is returned as a java map.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
+<p>Example:</p>
 <pre><code class="java">   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
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L280">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>Run a string returning the result of the last expression. Strings are compiled and  live for the life of the interpreter.</p>
+   java_api.call(spreadFn, 1, 2); // Returns -1
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L310">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
 <pre><code class="java">  java_api.setGlobal("bid", 1);
   java_api.setGlobal("ask", 2);
   java_api.runStringAsInput("bid-ask"); //Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L258">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L221">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L243">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L238">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L194">view source</a></div></div><div class="public anchor" id="var-allocate-fastcall-context*"><h3>allocate-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L108">view source</a></div></div><div class="public anchor" id="var-as-jvm*"><h3>as-jvm*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L113">view source</a></div></div><div class="public anchor" id="var-check-error-throw*"><h3>check-error-throw*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L111">view source</a></div></div><div class="public anchor" id="var-compile-cache"><h3>compile-cache</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L150">view source</a></div></div><div class="public anchor" id="var-compile-string"><h3>compile-string</h3><div class="usage"><code>(compile-string strval run-type)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L161">view source</a></div></div><div class="public anchor" id="var-compiler*"><h3>compiler*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L152">view source</a></div></div><div class="public anchor" id="var-eval-code*"><h3>eval-code*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L114">view source</a></div></div><div class="public anchor" id="var-fast-dict-set-item*"><h3>fast-dict-set-item*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L132">view source</a></div></div><div class="public anchor" id="var-fastcall*"><h3>fastcall*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L107">view source</a></div></div><div class="public anchor" id="var-globals*"><h3>globals*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L119">view source</a></div></div><div class="public anchor" id="var-make-fastcallable*"><h3>make-fastcallable*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L110">view source</a></div></div><div class="public anchor" id="var-release-fastcall-context*"><h3>release-fastcall-context*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L109">view source</a></div></div><div class="public anchor" id="var-requires*"><h3>requires*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L94">view source</a></div></div><div class="public anchor" id="var-simplify-or-track*"><h3>simplify-or-track*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L112">view source</a></div></div><div class="public anchor" id="var-strcomp*"><h3>strcomp*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L126">view source</a></div></div><div class="public anchor" id="var-string-cache"><h3>string-cache</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L117">view source</a></div></div><div class="public anchor" id="var-untracked-.3Epython*"><h3>untracked-&gt;python*</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L115">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L288">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L251">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L273">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L268">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L232">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index f74df65..3ad1d84 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
@@ -12,7 +12,7 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L513">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L524">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L266">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L360">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L348">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L354">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L254">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L168">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
+</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L551">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L562">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L266">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L360">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L348">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L354">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L254">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L168">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L494">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L272">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L284">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L278">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L260">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L331">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
@@ -48,7 +48,7 @@
 2
 user&gt; c
 3
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L686">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L202">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L222">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L241">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L296">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via get-attr.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L158">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L724">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L202">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L222">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L241">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L296">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via get-attr.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L158">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
@@ -64,15 +64,46 @@
     </ul>
   </li>
 </ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L319">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L399">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L423">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L432">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L399">view source</a></div></div><div class="public anchor" id="var-make-fastcallable"><h3>make-fastcallable</h3><div class="usage"><code>(make-fastcallable item)</code></div><div class="doc"><div class="markdown"><p>Wrap a python callable such that calling it in a tight loop with purely positional  arguments is a bit (2x-3x) faster.</p>
+<p>Example:</p>
+<pre><code class="clojure">user&gt; (def test-fn (-&gt; (py/run-simple-string "def spread(bid,ask):
+	return bid-ask
+
+")
+                       (get :globals)
+                       (get "spread")))
+#'user/test-fn
+user&gt; test-fn
+&lt;function spread at 0x7f330c046040&gt;
+user&gt; (py/with-gil (time (dotimes [iter 10000]
+                           (test-fn 1 2))))
+"Elapsed time: 85.140418 msecs"
+nil
+user&gt; (py/with-gil (time (dotimes [iter 10000]
+                           (test-fn 1 2))))
+"Elapsed time: 70.894275 msecs"
+nil
+user&gt; (with-open [test-fn (py/make-fastcallable test-fn)]
+        (py/with-gil (time (dotimes [iter 10000]
+                             (test-fn 1 2)))))
+
+"Elapsed time: 39.442622 msecs"
+nil
+user&gt; (with-open [test-fn (py/make-fastcallable test-fn)]
+        (py/with-gil (time (dotimes [iter 10000]
+                             (test-fn 1 2)))))
+
+"Elapsed time: 35.492965 msecs"
+nil
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L505">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L423">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L432">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
 <p>Options:</p>
 <ul>
   <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L661">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L699">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L550">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L572">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L541">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L534">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L588">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L610">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L579">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L572">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
 <p>is equivalent to Python’s</p>
 <p>import sys sys.path.append(‘/home/user/bin’)</p>
@@ -82,8 +113,8 @@
 <p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
 <p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
 <p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L607">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L290">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
+<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L645">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L290">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
 <p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L366">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L208">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L215">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L114">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L505">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L127">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L136">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L366">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L208">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L215">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L114">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L543">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L127">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L136">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index f9e7266..8617d44 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index d5d48a8..2fa8ee0 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index f7496da..df00c98 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index d78b32d..0608d9f 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 48ad0f6..8895830 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.010</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index a864aca..41bba58 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -10,26 +10,39 @@
   appear to python as a dict-like object an implementation of java.util.List will look
   like a sequence and if the thing is iterable then it will be iterable in python.
   To receive callbacks from python you can provide an implementation of the
-  interface `clojure.lang.IFn` - see `clojure.lang.AFn` for a base class that makes this
-  easier.
+  interface [clojure.lang.IFn](https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html)
+  - see [clojure.lang.AFn](https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/AFn.java) for a base class that makes this easier.
 
 
   Performance:
 
-  * `fastcall` - For the use case of repeatedly calling a single function, for instance
-  for each row of a table or in a tight loop, use `allocateFastcallContext` before the loop,
-  use fastcall to call your function noting that it takes an additional context parameter
-  the user can pass in as the first argument, and use `releaseFastcallContext` afterwords.  This
-  pathway eliminates nearly all of the overhead of calling python from Java and uses the
-  absolutely minimal number of C api calls in order to call a python function.  This is
-  about twice as fast as using the generic architecture to call a python function.
+  There are a two logical ways to repeatedly invoking python functionality.  The first is
+  to set some globals and repeatedly [[runStringAsInput]] a script.  The second is
+  'exec'ing a script, finding an exported function in the global dict and calling
+  that.  With libpython-clj, the second pathway -- repeatedly calling a function --
+  is going to be faster than the first if the user makes a fastcallable out of the function
+  to be invoked.  Here are some sample timings for an extremely simple function with two
+  arguments:
+
+
+```console
+Python fn calls/ms 1923.2490094806021
+Python fastcallable calls/ms 3776.767751742239
+Python eval pathway calls/ms 2646.0478013509883
+```
+
+
+  * [[makeFastcallable]] - - For the use case of repeatedly calling a single function - this
+  will cache the argument tuple for repeated use as opposed to allocating the argument tuple
+  every call.  This can be a surprising amount faster -- 2x-3x -- than directly calling the
+  python callable.  Once a fastcallable object is made you can either cast it to a
+  [clojure.lang.IFn](https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html)
+  or call it via the provided `call` static method.
 
-  * `makeFastcallable` - A simplified version of fastcall to be used with try-with-resources.
-  This is a safer but equally-as-fast pathway as `fastcall`.
 
   * HAIR ON FIRE MODE - If you are certain you are correctly calling lockGIL and unlockGIL
   then you can define a variable, `-Dlibpython_clj.manual_gil=true` that will disable
-  automatic GIL lock/unlock system and correctness checking.  This is useful, for instance,
+  automatic GIL lock/unlock system and gil correctness checking.  This is useful, for instance,
   if you are going to lock libpython-clj to a thread and control all access to it yourself.
   This pathway will get at most 10% above using fastcall by itself.
 
@@ -43,16 +56,17 @@
   dims.add(3);
   Object npArray = java_api.call(ones, dims); //see fastcall notes above
 ```"
-  (:import [java.util Map Map$Entry List HashMap]
+  (:import [java.util Map Map$Entry List HashMap LinkedHashMap]
            [java.util.function Supplier]
-           [clojure.java.api Clojure])
+           [clojure.java.api Clojure]
+           [com.google.common.cache CacheBuilder RemovalListener])
   (:gen-class
    :name libpython_clj2.java_api
    :main false
    :methods [#^{:static true} [initialize [java.util.Map] Object]
+             #^{:static true} [initializeEmbedded [] Object]
              #^{:static true} [lockGIL [] long]
              #^{:static true} [unlockGIL [long] Object]
-             #^{: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]
@@ -65,7 +79,6 @@
              #^{:static true} [runStringAsFile [String] java.util.Map]
              #^{:static true} [importModule [String] Object]
              #^{:static true} [callKw [Object java.util.List java.util.Map] Object]
-             #^{:static true} [callPos [Object java.util.List] Object]
              #^{:static true} [call [Object] Object]
              #^{:static true} [call [Object Object] Object]
              #^{:static true} [call [Object Object Object] Object]
@@ -85,51 +98,66 @@
              #^{:static true} [copyToPy [Object] Object]
              #^{:static true} [copyToJVM [Object] Object]
              #^{:static true} [createArray [String Object Object] Object]
-             #^{:static true} [arrayToJVM [Object] java.util.Map]]))
+             #^{:static true} [arrayToJVM [Object] java.util.Map]
+             #^{:static true} [copyData [Object Object] Object]]
+   ))
 
 
 (set! *warn-on-reflection* true)
 
 
-(def requires* (delay
-                 (let [require (Clojure/var "clojure.core" "require")]
-                   (doseq [clj-ns ["tech.v3.datatype"
-                                   "tech.v3.tensor"
-                                   "libpython-clj2.python"
-                                   "libpython-clj2.python.fn"
-                                   "libpython-clj2.python.ffi"
-                                   "libpython-clj2.python.gc"
-                                   "libpython-clj2.python.np-array"]]
-                     (require (Clojure/read clj-ns))))))
-
-
-(def ->python* (delay (Clojure/var "libpython-clj2.python" "->python")))
-(def fastcall* (delay (Clojure/var "libpython-clj2.python.fn" "fastcall")))
-(def allocate-fastcall-context* (delay (Clojure/var "libpython-clj2.python.fn" "allocate-fastcall-context")))
-(def release-fastcall-context* (delay (Clojure/var "libpython-clj2.python.fn" "release-fastcall-context")))
-(def make-fastcallable* (delay (Clojure/var "libpython-clj2.python.fn" "make-fastcallable")))
-(def check-error-throw* (delay (Clojure/var "libpython-clj2.python.ffi" "check-error-throw")))
-(def simplify-or-track* (delay (Clojure/var "libpython-clj2.python.ffi" "simplify-or-track")))
-(def as-jvm* (delay (Clojure/var "libpython-clj2.python" "as-jvm")))
-(def eval-code* (delay (Clojure/var "libpython-clj2.python.ffi" "PyEval_EvalCode")))
-(def untracked->python* (delay (Clojure/var "libpython-clj2.python.ffi" "untracked->python")))
-
-(def ^{:tag HashMap} string-cache (HashMap.))
+(def ^:private requires* (delay
+                           (let [require (Clojure/var "clojure.core" "require")]
+                             (doseq [clj-ns ["tech.v3.datatype"
+                                             "tech.v3.tensor"
+                                             "libpython-clj2.python"
+                                             "libpython-clj2.python.fn"
+                                             "libpython-clj2.python.ffi"
+                                             "libpython-clj2.python.gc"
+                                             "libpython-clj2.python.np-array"]]
+                               (require (Clojure/read clj-ns))))))
+
+
+(def ^:private ->python* (delay (Clojure/var "libpython-clj2.python" "->python")))
+(def ^:private fastcall* (delay (Clojure/var "libpython-clj2.python.fn" "fastcall")))
+(def ^:private allocate-fastcall-context* (delay (Clojure/var "libpython-clj2.python.fn" "allocate-fastcall-context")))
+(def ^:private release-fastcall-context* (delay (Clojure/var "libpython-clj2.python.fn" "release-fastcall-context")))
+(def ^:private make-fastcallable* (delay (Clojure/var "libpython-clj2.python.fn" "make-fastcallable")))
+(def ^:private check-error-throw* (delay (Clojure/var "libpython-clj2.python.ffi" "check-error-throw")))
+(def ^:private simplify-or-track* (delay (Clojure/var "libpython-clj2.python.ffi" "simplify-or-track")))
+(def ^:private as-jvm* (delay (Clojure/var "libpython-clj2.python" "as-jvm")))
+(def ^:private eval-code* (delay (Clojure/var "libpython-clj2.python.ffi" "PyEval_EvalCode")))
+(def ^:private untracked->python* (delay (Clojure/var "libpython-clj2.python.ffi" "untracked->python")))
+(def ^:private decref* (delay (Clojure/var "libpython-clj2.python.ffi" "Py_DecRef")))
+
+
+(defn- decref-lru-cache
+  ^Map [^long max-size]
+  (let [builder (CacheBuilder/newBuilder)]
+    (.maximumSize builder max-size)
+    (.removalListener builder (reify RemovalListener
+                                (onRemoval [this notification]
+                                  (@decref* (.getValue notification)))))
+    (-> (.build builder)
+        (.asMap))))
+
+
+(def ^{:tag Map :private true} string-cache (decref-lru-cache 1024))
 (declare -lockGIL -unlockGIL)
-(def globals*
+(def ^:private globals*
   (delay
     (let [gstate (-lockGIL)
           main-mod ((Clojure/var "libpython-clj2.python.ffi" "PyImport_AddModule") "__main__")]
       (-> ((Clojure/var "libpython-clj2.python.ffi" "PyModule_GetDict") main-mod)
           (@as-jvm*)))))
 
-(def strcomp* (delay (let [->python @->python*]
-                       (reify java.util.function.Function
-                         (apply [this data]
-                           (->python data))))))
+(def ^:private strcomp* (delay (let [->python @->python*]
+                                 (reify java.util.function.Function
+                                   (apply [this data]
+                                     (->python data))))))
 
 
-(def fast-dict-set-item*
+(def ^:private fast-dict-set-item*
   (delay (let [untracked->python (Clojure/var "libpython-clj2.python.ffi"
                                               "untracked->python")
                decref (Clojure/var "libpython-clj2.python.ffi"
@@ -147,18 +175,19 @@
     (.computeIfAbsent string-cache strval @strcomp*)))
 
 
-(def ^{:tag HashMap} compile-cache (HashMap.))
-
-(def compiler* (delay
-                 (let [compile-fn (Clojure/var "libpython-clj2.python.ffi"
-                                               "Py_CompileString")]
-                   (reify java.util.function.Function
-                     (apply [this [strdata run-type]]
-                       (compile-fn strdata "unnamed.py" (case run-type
-                                                          :file 257
-                                                          :input 258)))))))
+(def ^{:tag Map :private true} compile-cache (decref-lru-cache 1024))
 
-(defn compile-string
+(def ^:private compiler*
+  (delay
+    (let [compile-fn (Clojure/var "libpython-clj2.python.ffi"
+                                  "Py_CompileString")]
+      (reify java.util.function.Function
+        (apply [this [strdata run-type]]
+          (compile-fn strdata "unnamed.py" (case run-type
+                                             :file 257
+                                             :input 258)))))))
+
+(defn- compile-string
   [strval run-type]
   (when strval
     (.computeIfAbsent compile-cache [strval run-type] @compiler*)))
@@ -178,9 +207,18 @@
                         [(keyword (.getKey entry)) (.getValue entry)])))))
 
 
+(defn -initializeEmbedded
+  "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](https://clj-python.github.io/libpython-clj/embedded.html)"
+  []
+  @requires*
+  ((Clojure/var "libpython-clj2.python.ffi" "set-library!") nil))
+
+
 (defn -lockGIL
   "Attempt to lock the gil.  This is safe to call in a reentrant manner.
-  Returns an long representing the gil state that must be passed into unlockGIL.
+  Returns a long representing the gil state that must be passed into unlockGIL.
 
   See documentation for [pyGILState_Ensure](https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure).
 
@@ -198,14 +236,6 @@
   ((Clojure/var "libpython-clj2.python.ffi" "unlock-gil") gilstate))
 
 
-(defn -inPyContext
-  "Run some code in a python context where all python objects allocated within the context
-  will be deallocated once the context is released.  The code must not return references
-  to live python objects."
-  [^Supplier fn]
-  ((Clojure/var "libpython-clj2.python" "in-py-ctx") fn))
-
-
 (defn -hasAttr
   "Returns true if this python object has this attribute."
   [pyobj attname]
@@ -257,7 +287,8 @@
 
 (defn -runStringAsInput
   "Run a string returning the result of the last expression.  Strings are compiled and
-  live for the life of the interpreter.
+  live for the life of the interpreter.  This is the equivalent to the python
+  [eval](https://docs.python.org/3/library/functions.html#eval) call.
 
   This function expects the GIL to be locked - it will not lock/unlock it for you.
 
@@ -267,8 +298,7 @@
   java_api.setGlobal(\"bid\", 1);
   java_api.setGlobal(\"ask\", 2);
   java_api.runStringAsInput(\"bid-ask\"); //Returns -1
-```
-  "
+```"
   [strdata]
   (let [pyobj (compile-string strdata :input)]
     (when-not pyobj
@@ -279,18 +309,20 @@
 
 (defn -runStringAsFile
   "Run a string returning the result of the last expression.  Strings are compiled and
-  live for the life of the interpreter.
+  live for the life of the interpreter.  This is the equivalent to the python
+  [exec](https://docs.python.org/3/library/functions.html#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:
+
 ```java
    Map globals = java_api.runStringAsFile(\"def calcSpread(bid,ask):\n\treturn bid-ask\n\n\");
    Object spreadFn = globals.get(\"calcSpread\");
-   java_api.call(spreadFn, 1 2); // Returns -1
-```
-  "
+   java_api.call(spreadFn, 1, 2); // Returns -1
+```"
   [strdata]
   (let [pyobj (compile-string strdata :file)]
     (when-not pyobj
@@ -309,7 +341,7 @@
 (defn -callKw
   "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`."
+  callable then it will implement [clojure.lang.IFn](https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html) and you can use `invoke`."
   [pyobj pos-args kw-args]
   (let [gstate (-lockGIL)]
     (try
@@ -323,18 +355,11 @@
         (-unlockGIL gstate)))))
 
 
-(defn -callPos
-  "Call a python callable with only positional arguments.  Note that you don't need this pathway
-  to call python methods - you can also cast the python object to `clojure.lang.IFn` and call
-  `invoke` directly."
-  [pyobj pos-args]
-  (apply pyobj pos-args))
-
-
 (defn -call
   "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."
+  [clojure.lang.IFn](https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html) and
+  calling `invoke` directly."
   ([item]
    (item))
   ([item arg1]
@@ -351,14 +376,14 @@
    (item item arg1 arg2 arg3 arg4 arg5 arg6)))
 
 
-(defn -allocateFastcallContext
+(defn ^:no-doc -allocateFastcallContext
   "Allocate a fastcall context.  See docs for [[-fastcall]].  The returned context must be
   release via [[-releaseFastcallContext]]."
   []
   (@allocate-fastcall-context*))
 
 
-(defn -releaseFastcallContext
+(defn ^:no-doc -releaseFastcallContext
   "Release a fastcall context.  See docs for [[-fastcall]].  This is safe to call with
   null and to call multiple times on the same context."
   [ctx]
@@ -366,7 +391,7 @@
     (@release-fastcall-context* ctx)))
 
 
-(defn -fastcall
+(defn ^:no-doc -fastcall
   "Call a python function as fast as possible using a fixed number of positional arguments.
   The caller must provide an allocated fastcall context
   via [[-allocateFastcallContext]] and furthermore the caller may choose to deallocate the
@@ -397,7 +422,7 @@
 
 ```java
   try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
-     tightloop {
+     tightloop: {
        java_api.call(fastcaller, arg1, arg2);
      }
   }
@@ -423,9 +448,9 @@
   "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 shapes.
+  * `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 datatype."
+  of the array matches the requested datatype."
   [datatype shape data]
   (let [reshape (Clojure/var "tech.v3.tensor" "reshape")
         ->python (Clojure/var "libpython-clj2" "->python")]
@@ -436,9 +461,25 @@
 
 (defn -arrayToJVM
   "Copy (efficiently) a numeric numpy array into a jvm map containing keys \"datatype\",
-  \"shape\", and \"data\"."
+  \"shape\", and a jvm array \"data\" in flattened row-major form."
   [pyobj]
   (let [tens-data ((Clojure/var "libpython-clj2.python" "as-jvm") pyobj)]
     {"datatype" (name ((Clojure/var "tech.v3.datatype" "elemwise-datatype") tens-data))
      "shape" (int-array ((Clojure/var "tech.v3.datatype" "shape") tens-data))
      "data" ((Clojure/var "tech.v3.datatype" "->array") tens-data)}))
+
+
+(def ^:private copyfn* (delay (Clojure/var "tech.v3.datatype" "copy!")))
+
+
+(defn -copyData
+  "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."
+  [from to]
+  (@copyfn* from to))
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 73294dd..d23d331 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -502,6 +502,44 @@ user> (py/call-attr inst \"addarg\" 10)
   (apply py-fn/afn item attr args))
 
 
+(defn make-fastcallable
+  "Wrap a python callable such that calling it in a tight loop with purely positional
+  arguments is a bit (2x-3x) faster.
+
+  Example:
+
+```clojure
+user> (def test-fn (-> (py/run-simple-string \"def spread(bid,ask):\n\treturn bid-ask\n\n\")
+                       (get :globals)
+                       (get \"spread\")))
+#'user/test-fn
+user> test-fn
+<function spread at 0x7f330c046040>
+user> (py/with-gil (time (dotimes [iter 10000]
+                           (test-fn 1 2))))
+\"Elapsed time: 85.140418 msecs\"
+nil
+user> (py/with-gil (time (dotimes [iter 10000]
+                           (test-fn 1 2))))
+\"Elapsed time: 70.894275 msecs\"
+nil
+user> (with-open [test-fn (py/make-fastcallable test-fn)]
+        (py/with-gil (time (dotimes [iter 10000]
+                             (test-fn 1 2)))))
+
+\"Elapsed time: 39.442622 msecs\"
+nil
+user> (with-open [test-fn (py/make-fastcallable test-fn)]
+        (py/with-gil (time (dotimes [iter 10000]
+                             (test-fn 1 2)))))
+
+\"Elapsed time: 35.492965 msecs\"
+nil
+```"
+  ^java.lang.AutoCloseable [item]
+  (py-fn/make-fastcallable item))
+
+
 (defmacro with
   "Support for the 'with' statement in python:
   (py/with [item (py/call-attr testcode-module \"WithObjClass\" true fn-list)]
diff --git a/src/libpython_clj2/python/fn.clj b/src/libpython_clj2/python/fn.clj
index 72e2193..9b6cbe0 100644
--- a/src/libpython_clj2/python/fn.clj
+++ b/src/libpython_clj2/python/fn.clj
@@ -342,9 +342,11 @@
   `(let [~'ctx-list (object-array max-fastcall-args)]
      (reify
        AutoCloseable
-       (close [this#] (dotimes [idx# (alength ~'ctx-list)]
-                        (release-fastcall-context (aget ~'ctx-list idx#))
-                        (aset ~'ctx-list idx# nil)))
+       (close [this#]
+         (py-ffi/with-gil
+           (dotimes [idx# (alength ~'ctx-list)]
+             (release-fastcall-context (aget ~'ctx-list idx#))
+             (aset ~'ctx-list idx# nil))))
        clojure.lang.IFn
        (invoke [this#] (fastcall ~item))
        ~@(->> (range 1 (inc max-fastcall-args))
diff --git a/test/libpython_clj2/java_api_test.clj b/test/libpython_clj2/java_api_test.clj
index 74558a0..2590884 100644
--- a/test/libpython_clj2/java_api_test.clj
+++ b/test/libpython_clj2/java_api_test.clj
@@ -22,10 +22,16 @@
       (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)]
+            jvm-data (japi/-arrayToJVM base-data)
+            data-ary (get jvm-data "data")]
         (is (= "int32" (get jvm-data "datatype")))
         (is (= (vec (repeat 6 1))
-               (vec (get jvm-data "data"))))))
+               (vec data-ary)))
+        (java.util.Arrays/fill ^ints data-ary 25)
+        (japi/-copyData data-ary base-data)
+        (let [jvm-data (japi/-arrayToJVM base-data)]
+          (is (= (vec (repeat 6 25))
+                 (vec (get jvm-data "data")))))))
     (try
       (let [test-fn (-> (japi/-runStringAsFile "def calcSpread(bid,ask):\n\treturn bid-ask\n\n")
                         (get "calcSpread"))

From e773928427bdedb2f9a4f4b03455b2ebf9209a51 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Jan 2022 10:13:25 -0700
Subject: [PATCH 388/456] Release 2.012.

---
 deps.edn                                 |   2 +-
 docs/Usage.html                          |   2 +-
 docs/design.html                         |   2 +-
 docs/embedded.html                       |   2 +-
 docs/environments.html                   |   2 +-
 docs/index.html                          |   2 +-
 docs/libpython-clj2.codegen.html         |   2 +-
 docs/libpython-clj2.embedded.html        |   2 +-
 docs/libpython-clj2.java-api.html        |  16 ++--
 docs/libpython-clj2.python.html          |   2 +-
 docs/libpython-clj2.python.np-array.html |   2 +-
 docs/libpython-clj2.require.html         |   2 +-
 docs/new-to-clojure.html                 |   2 +-
 docs/scopes-and-gc.html                  |   2 +-
 docs/slicing.html                        |   2 +-
 src/libpython_clj2/java_api.clj          | 102 +++++++++++++++++++++--
 src/libpython_clj2/python/ffi.clj        |  43 +++++-----
 test/libpython_clj2/java_api_test.clj    |   8 ++
 18 files changed, 151 insertions(+), 46 deletions(-)

diff --git a/deps.edn b/deps.edn
index 526748b..52da2b1 100644
--- a/deps.edn
+++ b/deps.edn
@@ -50,7 +50,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.011"
+                        :version "2.012"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 3f9e748..edfc06f 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 642ff9f..59f6894 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 40a7398..ee382b1 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index dbad6cf..888053f 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 0c7f12f..8d798a8 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.011</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.012</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index bbe9132..34ae2a1 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 8d01118..fb031d6 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 9a93b9f..4cb2755 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
 <p>Note that you can pass java objects into python. An implementation of java.util.Map will  appear to python as a dict-like object an implementation of java.util.List will look  like a sequence and if the thing is iterable then it will be iterable in python.  To receive callbacks from python you can provide an implementation of the  interface <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a>  - see <a href="https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/AFn.java">clojure.lang.AFn</a> for a base class that makes this easier.</p>
 <p>Performance:</p>
 <p>There are a two logical ways to repeatedly invoking python functionality. The first is  to set some globals and repeatedly <a href="null">runStringAsInput</a> a script. The second is  ’exec’ing a script, finding an exported function in the global dict and calling  that. With libpython-clj, the second pathway – repeatedly calling a function –  is going to be faster than the first if the user makes a fastcallable out of the function  to be invoked. Here are some sample timings for an extremely simple function with two  arguments:</p>
@@ -21,16 +21,18 @@
   dims.add(2);
   dims.add(3);
   Object npArray = java_api.call(ones, dims); //see fastcall notes above
-</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L462">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L358">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L341">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
-<p>Note this copies <em>from</em> the first argument <em>to</em> the second argument – this is reverse the normal memcpy argument order!!. Returns the destination (to) argument.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L475">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L441">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L434">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L447">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L245">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L281">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L263">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L239">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L257">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L335">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L196">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L210">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L551">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L444">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L427">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>Note this copies <em>from</em> the first argument <em>to</em> the second argument – this is reverse the normal memcpy argument order!!. Returns the destination (to) argument.</p>
+<p>Not this does <em>not</em> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L564">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L527">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L520">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L533">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L331">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L367">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L349">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L325">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L343">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L421">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L282">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L296">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L219">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L305">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <pre><code class="java">  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
      tightloop: {
        java_api.call(fastcaller, arg1, arg2);
      }
   }
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L417">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L503">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
 <p>The global context is returned as a java map.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
@@ -40,10 +42,10 @@
 ");
    Object spreadFn = globals.get("calcSpread");
    java_api.call(spreadFn, 1, 2); // Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L310">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L396">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
 <pre><code class="java">  java_api.setGlobal("bid", 1);
   java_api.setGlobal("ask", 2);
   java_api.runStringAsInput("bid-ask"); //Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L288">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L251">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L273">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L268">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L232">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L374">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L337">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L359">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L354">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L318">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 3ad1d84..a17fbf9 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 8617d44..0ea835a 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 2fa8ee0..80dcfcd 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index df00c98..d29a569 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 0608d9f..de7fddb 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index 8895830..f36dbb7 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.011</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index 41bba58..dd0ed80 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -56,7 +56,7 @@ Python eval pathway calls/ms 2646.0478013509883
   dims.add(3);
   Object npArray = java_api.call(ones, dims); //see fastcall notes above
 ```"
-  (:import [java.util Map Map$Entry List HashMap LinkedHashMap]
+  (:import [java.util Map Map$Entry List HashMap LinkedHashMap Set HashSet]
            [java.util.function Supplier]
            [clojure.java.api Clojure]
            [com.google.common.cache CacheBuilder RemovalListener])
@@ -157,18 +157,104 @@ Python eval pathway calls/ms 2646.0478013509883
                                      (->python data))))))
 
 
+(declare -createArray)
+
+
+(def ^{:tag 'Map
+       :private true}
+  primitive-arrays
+  (let [base-arrays [[(byte-array 0) {:length #(alength ^bytes %)
+                                      :datatype "int8"}]
+                     [(short-array 0) {:length #(alength ^shorts %)
+                                       :datatype "int16"}]
+                     [(int-array 0) {:length #(alength ^ints %)
+                                     :datatype "int32"}]
+                     [(long-array 0) {:length #(alength ^longs %)
+                                      :datatype "int64"}]
+                     [(float-array 0) {:length #(alength ^floats %)
+                                       :datatype "float32"}]
+                     [(double-array 0) {:length #(alength ^doubles %)
+                                        :datatype "float64"}]]
+        typeset (HashMap.)]
+    (doseq [[ary getter] base-arrays]
+      (.put typeset (type ary) getter))
+    typeset))
+
+
+(def ^{:tag 'Set
+       :private true}
+  array-types
+  (let [base-arrays [(byte-array 0)
+                     (short-array 0)
+                     (int-array 0)
+                     (long-array 0)
+                     (float-array 0)
+                     (double-array 0)]
+        array-of-arrays (->> base-arrays
+                             (map (fn [ary]
+                                    (into-array [ary]))))
+        typeset (HashSet.)]
+
+    (doseq [t array-of-arrays]
+      (.add typeset (type t)))
+    (.addAll typeset (.keySet primitive-arrays))
+    typeset))
+
+
+(defn- to-python
+  "Support for auto-converting primitive arrays and array-of-arrays into python."
+  [item]
+  (let [item-type (type item)]
+    (if (.contains array-types item-type)
+      (if-let [len-getter (get primitive-arrays item-type)]
+        (-createArray (len-getter :datatype)
+                      [((len-getter :length) item)]
+                      item)
+        ;;potential 2d array if all lengths match
+        (let [^objects item item
+              item-len (alength item)
+              [datatype shape]
+              (when-let [fitem (when-not (== 0 item-len)
+                                 (aget item 0))]
+                (let [ary-entry (get primitive-arrays (type fitem))
+                      inner-len (get ary-entry :length)
+                      ary-dt (get ary-entry :datatype)
+                      fitem-len (unchecked-long (inner-len fitem))
+                      matching?
+                      (loop [idx 1
+                             matching? true]
+                        (if (< idx item-len)
+                          (recur (unchecked-inc idx)
+                                 (and matching?
+                                      (== fitem-len
+                                          (unchecked-long
+                                           (if-let [inner-item (aget item idx)]
+                                             (inner-len inner-item)
+                                             0)))))
+                          matching?))]
+                  (when matching?
+                    [ary-dt [item-len fitem-len]])))]
+          (if shape
+            (-createArray datatype shape item)
+            ;;slower fallback for ragged arrays
+            (@->python* item))))
+      (@->python* item))))
+
+
 (def ^:private fast-dict-set-item*
   (delay (let [untracked->python (Clojure/var "libpython-clj2.python.ffi"
                                               "untracked->python")
+               ->python @->python*
                decref (Clojure/var "libpython-clj2.python.ffi"
                                    "Py_DecRef")
                pydict-setitem (Clojure/var "libpython-clj2.python.ffi"
                                            "PyDict_SetItem")]
            (fn [dict k v]
-             (let [v (untracked->python v)]
+             (let [v (untracked->python v to-python)]
                (pydict-setitem dict k v)
                (decref v))))))
 
+
 (defn- cached-string
   [strval]
   (when strval
@@ -450,10 +536,13 @@ Example:
   \"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."
+  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."
   [datatype shape data]
   (let [reshape (Clojure/var "tech.v3.tensor" "reshape")
-        ->python (Clojure/var "libpython-clj2" "->python")]
+        ->python @->python*]
     (-> ((Clojure/var "tech.v3.tensor" "->tensor") data :datatype (keyword datatype))
         (reshape shape)
         (->python))))
@@ -480,6 +569,9 @@ Example:
   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."
+  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."
   [from to]
   (@copyfn* from to))
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index 25c32ac..3aecbba 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -601,26 +601,29 @@ Each call must be matched with PyGILState_Release"}
 
 
 (defn untracked->python
-  ^Pointer [item & [conversion-fallback]]
-  (cond
-    (instance? Pointer item)
-    (-> (if (.isNil ^Pointer item)
-          (py-none)
-          item)
-        (incref))
-    (instance? Number item) (if (integer? item)
-                              (PyLong_FromLongLong (long item))
-                              (PyFloat_FromDouble (double item)))
-    (instance? Boolean item) (-> (if item (py-true) (py-false))
-                                 (incref))
-    (instance? String item) (PyUnicode_FromString item)
-    (instance? Keyword item) (PyUnicode_FromString (name item))
-    (instance? Symbol item) (PyUnicode_FromString (name item))
-    (nil? item) (incref (py-none))
-    :else
-    (if conversion-fallback
-      (incref (conversion-fallback item))
-      (throw (Exception. "Unable to convert value %s" item)))))
+  ^Pointer
+  ([item conversion-fallback]
+   (cond
+     (instance? Pointer item)
+     (-> (if (.isNil ^Pointer item)
+           (py-none)
+           item)
+         (incref))
+     (instance? Number item) (if (integer? item)
+                               (PyLong_FromLongLong (long item))
+                               (PyFloat_FromDouble (double item)))
+     (instance? Boolean item) (-> (if item (py-true) (py-false))
+                                  (incref))
+     (instance? String item) (PyUnicode_FromString item)
+     (instance? Keyword item) (PyUnicode_FromString (name item))
+     (instance? Symbol item) (PyUnicode_FromString (name item))
+     (nil? item) (incref (py-none))
+     :else
+     (if conversion-fallback
+       (incref (conversion-fallback item))
+       (throw (Exception. (format "Unable to convert value %s" item))))))
+  ([item]
+   (untracked->python item nil)))
 
 
 (defn untracked-tuple
diff --git a/test/libpython_clj2/java_api_test.clj b/test/libpython_clj2/java_api_test.clj
index 2590884..7971549 100644
--- a/test/libpython_clj2/java_api_test.clj
+++ b/test/libpython_clj2/java_api_test.clj
@@ -1,6 +1,7 @@
 (ns libpython-clj2.java-api-test
   (:require [libpython-clj2.java-api :as japi]
             [libpython-clj2.python.ffi :as py-ffi]
+            [libpython-clj2.python :as py]
             [tech.v3.datatype.jvm-map :as jvm-map]
             [clojure.test :refer [deftest is]]))
 
@@ -12,6 +13,13 @@
     (is (= 5 (japi/-getGlobal "data")))
     (japi/-setGlobal "data" 6)
     (is (= 6 (japi/-getGlobal "data")))
+    (japi/-setGlobal "bdata" (byte-array (range 100)))
+    (is (= :ndarray (py/python-type (japi/-getGlobal "bdata"))))
+    (japi/-setGlobal "bdata" (into-array (repeat 4 (byte-array (range 100)))))
+    (is (= :ndarray (py/python-type (japi/-getGlobal "bdata"))))
+    (japi/-setGlobal "bdata" (into-array (concat (repeat 4 (byte-array (range 100)))
+                                                 [(byte-array (range 10))])))
+    (is (not= :ndarray (py/python-type (japi/-getGlobal "bdata"))))
 
     (let [np (japi/-importModule "numpy")
           ones-fn (japi/-getAttr np "ones")

From a66f19b340c5339676bc640723aa11103b07d964 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Jan 2022 10:24:11 -0700
Subject: [PATCH 389/456] Documentation update.

---
 docs/libpython-clj2.java-api.html | 13 +++++++------
 src/libpython_clj2/java_api.clj   |  7 ++++++-
 2 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 4cb2755..a35b316 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -21,10 +21,10 @@
   dims.add(2);
   dims.add(3);
   Object npArray = java_api.call(ones, dims); //see fastcall notes above
-</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L551">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L444">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L427">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L556">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L449">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L432">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Note this copies <em>from</em> the first argument <em>to</em> the second argument – this is reverse the normal memcpy argument order!!. Returns the destination (to) argument.</p>
-<p>Not this does <em>not</em> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L564">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L527">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L520">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L533">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L331">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L367">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L349">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L325">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L343">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L421">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L282">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L296">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>Not this does <em>not</em> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L569">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L532">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L525">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L538">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L331">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L372">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L349">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L325">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L343">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L426">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L282">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L296">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
 <p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L305">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <pre><code class="java">  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
@@ -32,7 +32,7 @@
        java_api.call(fastcaller, arg1, arg2);
      }
   }
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L503">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L508">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
 <p>The global context is returned as a java map.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
@@ -42,10 +42,11 @@
 ");
    Object spreadFn = globals.get("calcSpread");
    java_api.call(spreadFn, 1, 2); // Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L396">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L401">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
 <pre><code class="java">  java_api.setGlobal("bid", 1);
   java_api.setGlobal("ask", 2);
   java_api.runStringAsInput("bid-ask"); //Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L374">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L337">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L359">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L354">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L318">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L379">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L337">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
+<p>In addition to numbers and strings, this method can take an implementation of <code>clojure.lang.IFn</code> that will be converted to a python callable, primitive arrays which will be converted to numpy arrays and primitive array-of-arrays which, if all inner arrays are non-nil and have matching lengths, will be converted to a numpy matrix.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L359">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L354">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L318">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index dd0ed80..2cb8417 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -358,7 +358,12 @@ Python eval pathway calls/ms 2646.0478013509883
 
 (defn -setGlobal
   "Set a value in the global dict.  This function expects the GIL to be locked - it will
-  not lock/unlock it for you."
+  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, primitive arrays which
+  will be converted to numpy arrays and primitive array-of-arrays which, if all inner
+  arrays are non-nil and have matching lengths, will be converted to a numpy matrix."
   [^String varname varval]
   (@fast-dict-set-item* @globals* (cached-string varname) varval)
   nil)

From 5ea03925d564cecec5a393e0df8d4ab565905851 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Jan 2022 15:06:16 -0700
Subject: [PATCH 390/456] Updated docs and disabled auto-numpy for setGlobal. 
 Release 2.013

---
 deps.edn                                 |  6 ++----
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        | 16 ++++++++--------
 docs/libpython-clj2.python.html          |  2 +-
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 src/libpython_clj2/java_api.clj          |  9 ++++-----
 test/libpython_clj2/java_api_test.clj    | 15 ++++++++-------
 17 files changed, 35 insertions(+), 37 deletions(-)

diff --git a/deps.edn b/deps.edn
index 52da2b1..f74e7b7 100644
--- a/deps.edn
+++ b/deps.edn
@@ -33,9 +33,7 @@
                                      libpython-clj2.python.np-array
                                      libpython-clj2.require
                                      libpython-clj2.embedded
-                                     libpython-clj2.java-api
-                                     python.builtins
-                                     python.numpy]}}
+                                     libpython-clj2.java-api]}}
            :test
            {:extra-deps {com.cognitect/test-runner
                          {:git/url "https://github.com/cognitect-labs/test-runner"
@@ -50,7 +48,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.012"
+                        :version "2.013"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index edfc06f..92c1d79 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 59f6894..5025ff1 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index ee382b1..d53d7bd 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 888053f..96e6753 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 8d798a8..f746fae 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.012</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.013</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 34ae2a1..2a8c4ad 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index fb031d6..6dc7301 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index a35b316..0765483 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
 <p>Note that you can pass java objects into python. An implementation of java.util.Map will  appear to python as a dict-like object an implementation of java.util.List will look  like a sequence and if the thing is iterable then it will be iterable in python.  To receive callbacks from python you can provide an implementation of the  interface <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a>  - see <a href="https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/AFn.java">clojure.lang.AFn</a> for a base class that makes this easier.</p>
 <p>Performance:</p>
 <p>There are a two logical ways to repeatedly invoking python functionality. The first is  to set some globals and repeatedly <a href="null">runStringAsInput</a> a script. The second is  ’exec’ing a script, finding an exported function in the global dict and calling  that. With libpython-clj, the second pathway – repeatedly calling a function –  is going to be faster than the first if the user makes a fastcallable out of the function  to be invoked. Here are some sample timings for an extremely simple function with two  arguments:</p>
@@ -21,10 +21,10 @@
   dims.add(2);
   dims.add(3);
   Object npArray = java_api.call(ones, dims); //see fastcall notes above
-</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L556">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L449">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L432">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L555">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L448">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L431">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Note this copies <em>from</em> the first argument <em>to</em> the second argument – this is reverse the normal memcpy argument order!!. Returns the destination (to) argument.</p>
-<p>Not this does <em>not</em> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L569">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L532">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L525">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L538">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L331">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L372">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L349">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L325">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L343">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L426">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L282">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L296">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>Not this does <em>not</em> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L568">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L531">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L524">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L537">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L331">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L371">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L349">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L325">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L343">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L425">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L282">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L296">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
 <p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L305">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <pre><code class="java">  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
@@ -32,7 +32,7 @@
        java_api.call(fastcaller, arg1, arg2);
      }
   }
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L508">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L507">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
 <p>The global context is returned as a java map.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
@@ -42,11 +42,11 @@
 ");
    Object spreadFn = globals.get("calcSpread");
    java_api.call(spreadFn, 1, 2); // Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L401">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L400">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
 <pre><code class="java">  java_api.setGlobal("bid", 1);
   java_api.setGlobal("ask", 2);
   java_api.runStringAsInput("bid-ask"); //Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L379">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L337">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
-<p>In addition to numbers and strings, this method can take an implementation of <code>clojure.lang.IFn</code> that will be converted to a python callable, primitive arrays which will be converted to numpy arrays and primitive array-of-arrays which, if all inner arrays are non-nil and have matching lengths, will be converted to a numpy matrix.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L359">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L354">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L318">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L378">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L337">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
+<p>In addition to numbers and strings, this method can take an implementation of <code>clojure.lang.IFn</code> that will be converted to a python callable, arrays and lists will be converted to python lists. If you would like numpy arrays use <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L359">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L354">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L318">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index a17fbf9..8553eea 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 0ea835a..871152a 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 80dcfcd..9f32e1d 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index d29a569..6b0e4af 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index de7fddb..1cee0b5 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index f36dbb7..bdfae54 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.012</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index 2cb8417..b9b84af 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -201,7 +201,7 @@ Python eval pathway calls/ms 2646.0478013509883
     typeset))
 
 
-(defn- to-python
+#_(defn- to-python
   "Support for auto-converting primitive arrays and array-of-arrays into python."
   [item]
   (let [item-type (type item)]
@@ -250,7 +250,7 @@ Python eval pathway calls/ms 2646.0478013509883
                pydict-setitem (Clojure/var "libpython-clj2.python.ffi"
                                            "PyDict_SetItem")]
            (fn [dict k v]
-             (let [v (untracked->python v to-python)]
+             (let [v (untracked->python v ->python)]
                (pydict-setitem dict k v)
                (decref v))))))
 
@@ -361,9 +361,8 @@ Python eval pathway calls/ms 2646.0478013509883
   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, primitive arrays which
-  will be converted to numpy arrays and primitive array-of-arrays which, if all inner
-  arrays are non-nil and have matching lengths, will be converted to a numpy matrix."
+  `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]]."
   [^String varname varval]
   (@fast-dict-set-item* @globals* (cached-string varname) varval)
   nil)
diff --git a/test/libpython_clj2/java_api_test.clj b/test/libpython_clj2/java_api_test.clj
index 7971549..bfcbb47 100644
--- a/test/libpython_clj2/java_api_test.clj
+++ b/test/libpython_clj2/java_api_test.clj
@@ -13,13 +13,14 @@
     (is (= 5 (japi/-getGlobal "data")))
     (japi/-setGlobal "data" 6)
     (is (= 6 (japi/-getGlobal "data")))
-    (japi/-setGlobal "bdata" (byte-array (range 100)))
-    (is (= :ndarray (py/python-type (japi/-getGlobal "bdata"))))
-    (japi/-setGlobal "bdata" (into-array (repeat 4 (byte-array (range 100)))))
-    (is (= :ndarray (py/python-type (japi/-getGlobal "bdata"))))
-    (japi/-setGlobal "bdata" (into-array (concat (repeat 4 (byte-array (range 100)))
-                                                 [(byte-array (range 10))])))
-    (is (not= :ndarray (py/python-type (japi/-getGlobal "bdata"))))
+
+    ;; (japi/-setGlobal "bdata" (byte-array (range 100)))
+    ;; (is (= :ndarray (py/python-type (japi/-getGlobal "bdata"))))
+    ;; (japi/-setGlobal "bdata" (into-array (repeat 4 (byte-array (range 100)))))
+    ;; (is (= :ndarray (py/python-type (japi/-getGlobal "bdata"))))
+    ;; (japi/-setGlobal "bdata" (into-array (concat (repeat 4 (byte-array (range 100)))
+    ;;                                              [(byte-array (range 10))])))
+    ;; (is (not= :ndarray (py/python-type (japi/-getGlobal "bdata"))))
 
     (let [np (japi/-importModule "numpy")
           ones-fn (japi/-getAttr np "ones")

From c52e7eb30f3ec5f78174e89a52284293001b9127 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Jan 2022 15:17:01 -0700
Subject: [PATCH 391/456] Updating changelog and readme.

---
 CHANGELOG.md |  5 +++++
 README.md    | 18 +++++++++++-------
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ed2abdb..0b671e5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,9 @@
 # Time for a ChangeLog!
+## 2.013
+ * Lots of changes and releases ironing out a java api with a user.  This is close but not
+   completely there yet so expect the java api to change a bit more.
+ * [make-fastcallable](https://clj-python.github.io/libpython-clj/libpython-clj2.python.html#var-make-fastcallable)
+
 ## 2.000
  * You can now create instance functions that accept both positional and keyword arguments -
    libpython-clj2.python/make-kw-instance-fn.  See test at
diff --git a/README.md b/README.md
index 6d4f8c7..c7d02b3 100644
--- a/README.md
+++ b/README.md
@@ -7,19 +7,23 @@
 
 
  ## New Versions Are HOT!  Huge New Features! You Can't Afford To Miss Out!
-
+ 
+ * [API Documentation](https://clj-python.github.io/libpython-clj/)
+ * [Java API](https://clj-python.github.io/libpython-clj/libpython-clj2.java-api.html) - you can use libpython-clj from java - no
+   Clojure required.  The class is included with the jar so just put the jar on the classpath and then `import libpython_clj2.java_api;`
+   will work.  Be sure to carefully read the namespace doc as, due to performance considerations, not all methods are 
+   protected via automatic GIL management.
+ * [make-fastcallable](https://clj-python.github.io/libpython-clj/libpython-clj2.python.html#var-make-fastcallable) so if you 
+   calling a small function repeatedly you can now call it about twice as fast.  A better optimization is to call
+   a function once with numpy array arguments but unfortunately not all use cases are amenable to this pathway.  So we
+   did what we can.
  * JDK-17 and Mac M-1 support.  To use libpython-clj2 with jdk-17 you need to enable the foreign module -
    see [deps.edn](https://github.com/clj-python/libpython-clj/blob/6e7368b44aaabddf565a5bbf3a240e60bf3dcbf8/deps.edn#L10)
    for a working alias.
  * You can now [Embed Clojure in Python](https://clj-python.github.io/libpython-clj/embedded.html) - you can launch a Clojure REPL from a Python host process.
- * Main namespace is now `libpython-clj2` -- docs have not been updated.
  * **32 bit support**!!
- * Partial support for JDK-16 - The tests pass for core Python functionality but numpy
-   failed to load - the JDK-16 dynamic library loading path is different than JNA and of
-   course this causes issues.
  * 20-30% better performance.
- * - Note - Please avoid deprecated versions such as `[cnuernber/libpython-clj "1.36"]` (***note name change***).
- * [API Documentation](https://clj-python.github.io/libpython-clj/)
+ * Please avoid deprecated versions such as `[cnuernber/libpython-clj "1.36"]` (***note name change***).
  * This library, which has received the efforts of many excellent people, is built mainly upon
    [cnuernber/dtype-next](https://github.com/cnuernber/dtype-next/) and the
    [JNA library](https://github.com/java-native-access/jna).

From 24200cbda71dadf758525796cc4c77ab05b5f5a1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Jan 2022 16:15:14 -0700
Subject: [PATCH 392/456] Fix for runStringAsInput.  Release 2.014

---
 deps.edn                                 |  2 +-
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        | 18 +++++++++---------
 docs/libpython-clj2.python.html          |  2 +-
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 src/libpython_clj2/java_api.clj          |  4 +++-
 16 files changed, 26 insertions(+), 24 deletions(-)

diff --git a/deps.edn b/deps.edn
index f74e7b7..9f623d5 100644
--- a/deps.edn
+++ b/deps.edn
@@ -48,7 +48,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.013"
+                        :version "2.014"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 92c1d79..31ea585 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 5025ff1..125b2e8 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index d53d7bd..b1f5c37 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 96e6753..9b41372 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index f746fae..1cd50b7 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.013</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.014</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 2a8c4ad..75e2369 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 6dc7301..c672492 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 0765483..8b772de 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
 <p>Note that you can pass java objects into python. An implementation of java.util.Map will  appear to python as a dict-like object an implementation of java.util.List will look  like a sequence and if the thing is iterable then it will be iterable in python.  To receive callbacks from python you can provide an implementation of the  interface <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a>  - see <a href="https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/AFn.java">clojure.lang.AFn</a> for a base class that makes this easier.</p>
 <p>Performance:</p>
 <p>There are a two logical ways to repeatedly invoking python functionality. The first is  to set some globals and repeatedly <a href="null">runStringAsInput</a> a script. The second is  ’exec’ing a script, finding an exported function in the global dict and calling  that. With libpython-clj, the second pathway – repeatedly calling a function –  is going to be faster than the first if the user makes a fastcallable out of the function  to be invoked. Here are some sample timings for an extremely simple function with two  arguments:</p>
@@ -21,18 +21,18 @@
   dims.add(2);
   dims.add(3);
   Object npArray = java_api.call(ones, dims); //see fastcall notes above
-</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L555">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L448">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L431">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L557">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L450">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L433">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Note this copies <em>from</em> the first argument <em>to</em> the second argument – this is reverse the normal memcpy argument order!!. Returns the destination (to) argument.</p>
-<p>Not this does <em>not</em> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L568">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L531">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L524">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L537">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L331">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L371">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L349">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L325">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L343">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L425">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L282">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L296">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>Not this does <em>not</em> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L570">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L533">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L526">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L539">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L332">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L372">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L350">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L326">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L344">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L427">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L283">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L297">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L305">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L306">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <pre><code class="java">  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
      tightloop: {
        java_api.call(fastcaller, arg1, arg2);
      }
   }
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L507">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L509">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
 <p>The global context is returned as a java map.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
@@ -42,11 +42,11 @@
 ");
    Object spreadFn = globals.get("calcSpread");
    java_api.call(spreadFn, 1, 2); // Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L400">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L402">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
 <pre><code class="java">  java_api.setGlobal("bid", 1);
   java_api.setGlobal("ask", 2);
   java_api.runStringAsInput("bid-ask"); //Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L378">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L337">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
-<p>In addition to numbers and strings, this method can take an implementation of <code>clojure.lang.IFn</code> that will be converted to a python callable, arrays and lists will be converted to python lists. If you would like numpy arrays use <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L359">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L354">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L318">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L379">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L338">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
+<p>In addition to numbers and strings, this method can take an implementation of <code>clojure.lang.IFn</code> that will be converted to a python callable, arrays and lists will be converted to python lists. If you would like numpy arrays use <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L360">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L355">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L319">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 8553eea..40215e1 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 871152a..0b76b84 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 9f32e1d..db81f24 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 6b0e4af..e587770 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 1cee0b5..e97dd1c 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index bdfae54..ecf549f 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.013</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index b9b84af..66917b5 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -126,6 +126,7 @@ Python eval pathway calls/ms 2646.0478013509883
 (def ^:private check-error-throw* (delay (Clojure/var "libpython-clj2.python.ffi" "check-error-throw")))
 (def ^:private simplify-or-track* (delay (Clojure/var "libpython-clj2.python.ffi" "simplify-or-track")))
 (def ^:private as-jvm* (delay (Clojure/var "libpython-clj2.python" "as-jvm")))
+(def ^:private ->jvm* (delay (Clojure/var "libpython-clj2.python" "->jvm")))
 (def ^:private eval-code* (delay (Clojure/var "libpython-clj2.python.ffi" "PyEval_EvalCode")))
 (def ^:private untracked->python* (delay (Clojure/var "libpython-clj2.python.ffi" "untracked->python")))
 (def ^:private decref* (delay (Clojure/var "libpython-clj2.python.ffi" "Py_DecRef")))
@@ -394,7 +395,8 @@ Python eval pathway calls/ms 2646.0478013509883
     (when-not pyobj
       (@check-error-throw*))
     (if-let [script-rt (@eval-code* pyobj @globals* @globals*)]
-      (@simplify-or-track* script-rt))))
+      (-> (@simplify-or-track* script-rt)
+          (@as-jvm*)))))
 
 
 (defn -runStringAsFile

From c45915bac5d3601244dad777f4a8c3d9bb269f1d Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 3 Jan 2022 08:31:35 -0700
Subject: [PATCH 393/456] editing

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c7d02b3..791036c 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,8 @@
  * [Java API](https://clj-python.github.io/libpython-clj/libpython-clj2.java-api.html) - you can use libpython-clj from java - no
    Clojure required.  The class is included with the jar so just put the jar on the classpath and then `import libpython_clj2.java_api;`
    will work.  Be sure to carefully read the namespace doc as, due to performance considerations, not all methods are 
-   protected via automatic GIL management.
+   protected via automatic GIL management.  Note this integration includes support for extremely efficient data copies to numpy objects
+   and callbacks from python to java.
  * [make-fastcallable](https://clj-python.github.io/libpython-clj/libpython-clj2.python.html#var-make-fastcallable) so if you 
    calling a small function repeatedly you can now call it about twice as fast.  A better optimization is to call
    a function once with numpy array arguments but unfortunately not all use cases are amenable to this pathway.  So we

From 6e634a1cf788ace3aed419a8325fc0378c73e16c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 4 Jan 2022 11:17:43 -0700
Subject: [PATCH 394/456] Added GILLocker.  Release 2.015

---
 CHANGELOG.md                             |  5 +++
 deps.edn                                 |  2 +-
 docs/Usage.html                          |  2 +-
 docs/design.html                         |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  2 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        | 41 +++++++++++++++---------
 docs/libpython-clj2.python.html          |  2 +-
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 src/libpython_clj2/java_api.clj          | 39 ++++++++++++++++++----
 test/libpython_clj2/java_api_test.clj    |  6 ++--
 18 files changed, 78 insertions(+), 41 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0b671e5..75c4e9f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,9 @@
 # Time for a ChangeLog!
+## 2.015
+ * java API has stabilized.
+ * [GILLocker](https://clj-python.github.io/libpython-clj/libpython-clj2.java-api.html#var--GILLocker) -
+ an auto-closeable pathway so you case use Java's try-with-resources or Clojure's with-open.
+
 ## 2.013
  * Lots of changes and releases ironing out a java api with a user.  This is close but not
    completely there yet so expect the java api to change a bit more.
diff --git a/deps.edn b/deps.edn
index 9f623d5..96a0801 100644
--- a/deps.edn
+++ b/deps.edn
@@ -48,7 +48,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.014"
+                        :version "2.015"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 31ea585..3d77789 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
 <pre><code class="python">table.loc[row_date]
diff --git a/docs/design.html b/docs/design.html
index 125b2e8..bbcdfa7 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
 <h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
 <h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
 <p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index b1f5c37..da922e1 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
 <ol>
   <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
diff --git a/docs/environments.html b/docs/environments.html
index 9b41372..ea37fac 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
 <h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
 <p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 1cd50b7..476dc58 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,3 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.014</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.015</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--GILLocker">-GILLocker</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 75e2369..8e809f3 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index c672492..22f4e82 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
 <pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
 </code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
 <p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 8b772de..3e989c2 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,9 +1,9 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
 <p>Note that you can pass java objects into python. An implementation of java.util.Map will  appear to python as a dict-like object an implementation of java.util.List will look  like a sequence and if the thing is iterable then it will be iterable in python.  To receive callbacks from python you can provide an implementation of the  interface <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a>  - see <a href="https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/AFn.java">clojure.lang.AFn</a> for a base class that makes this easier.</p>
 <p>Performance:</p>
-<p>There are a two logical ways to repeatedly invoking python functionality. The first is  to set some globals and repeatedly <a href="null">runStringAsInput</a> a script. The second is  ’exec’ing a script, finding an exported function in the global dict and calling  that. With libpython-clj, the second pathway – repeatedly calling a function –  is going to be faster than the first if the user makes a fastcallable out of the function  to be invoked. Here are some sample timings for an extremely simple function with two  arguments:</p>
+<p>There are a two logical ways to repeatedly invoke python functionality. The first is  to set some globals and repeatedly <a href="null">runStringAsInput</a> a script. The second is  ’exec’ing a script, finding an exported function in the global dict and calling  that. With libpython-clj, the second pathway – repeatedly calling a function –  is going to be faster than the first if the user makes a fastcallable out of the function  to be invoked. Here are some sample timings for an extremely simple function with two  arguments:</p>
 <pre><code class="console">Python fn calls/ms 1923.2490094806021
 Python fastcallable calls/ms 3776.767751742239
 Python eval pathway calls/ms 2646.0478013509883
@@ -14,25 +14,34 @@
   <li>
   <p>HAIR ON FIRE MODE - If you are certain you are correctly calling lockGIL and unlockGIL  then you can define a variable, <code>-Dlibpython_clj.manual_gil=true</code> that will disable  automatic GIL lock/unlock system and gil correctness checking. This is useful, for instance,  if you are going to lock libpython-clj to a thread and control all access to it yourself.  This pathway will get at most 10% above using fastcall by itself.</p></li>
 </ul>
+<p>Example:</p>
 <pre><code class="java">  java_api.initialize(null);
-  np = java_api.importModule("numpy");
-  Object ones = java_api.getAttr(np, "ones");
-  ArrayList dims = new ArrayList();
-  dims.add(2);
-  dims.add(3);
-  Object npArray = java_api.call(ones, dims); //see fastcall notes above
-</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L557">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L450">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L433">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+  try (AutoCloseable locker = java_api.GILLocker()) {
+    np = java_api.importModule("numpy");
+    Object ones = java_api.getAttr(np, "ones");
+    ArrayList dims = new ArrayList();
+    dims.add(2);
+    dims.add(3);
+    Object npArray = java_api.call(ones, dims); //see fastcall notes above
+    ...
+  }
+</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L582">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L475">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L458">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Note this copies <em>from</em> the first argument <em>to</em> the second argument – this is reverse the normal memcpy argument order!!. Returns the destination (to) argument.</p>
-<p>Not this does <em>not</em> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L570">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L533">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L526">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L539">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L332">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L372">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L350">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L326">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L344">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L427">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L283">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L297">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>Not this does <em>not</em> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L595">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L558">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L551">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L564">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L357">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L397">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L375">view source</a></div></div><div class="public anchor" id="var--GILLocker"><h3>-GILLocker</h3><div class="usage"><code>(-GILLocker)</code></div><div class="doc"><div class="markdown"><p>Lock the gil returning an AutoCloseable that will unlock the gil upon close.</p>
+<p>Example:</p>
+<pre><code class="java">  try (AutoCloseable locker = java_api.GILLocker()) {
+    ... Do your python stuff.
+  }
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L334">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L351">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L369">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L452">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L291">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L305">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L306">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L314">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <pre><code class="java">  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
      tightloop: {
        java_api.call(fastcaller, arg1, arg2);
      }
   }
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L509">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L534">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
 <p>The global context is returned as a java map.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
@@ -42,11 +51,11 @@
 ");
    Object spreadFn = globals.get("calcSpread");
    java_api.call(spreadFn, 1, 2); // Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L402">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L427">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
 <pre><code class="java">  java_api.setGlobal("bid", 1);
   java_api.setGlobal("ask", 2);
   java_api.runStringAsInput("bid-ask"); //Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L379">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L338">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
-<p>In addition to numbers and strings, this method can take an implementation of <code>clojure.lang.IFn</code> that will be converted to a python callable, arrays and lists will be converted to python lists. If you would like numpy arrays use <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L360">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L355">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L319">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L404">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L363">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
+<p>In addition to numbers and strings, this method can take an implementation of <code>clojure.lang.IFn</code> that will be converted to a python callable, arrays and lists will be converted to python lists. If you would like numpy arrays use <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L385">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L380">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L327">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 40215e1..5e704d8 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
 <p>Example:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 0b76b84..9af09e0 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,4 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
 <p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index db81f24..3b3bddd 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
 <p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python ’[math :as maaaath])</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index e587770..4889a63 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
 <h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
 <p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index e97dd1c..8bd8244 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/docs/slicing.html b/docs/slicing.html
index ecf549f..fb244a7 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.014</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
 <p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
 <pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
diff --git a/src/libpython_clj2/java_api.clj b/src/libpython_clj2/java_api.clj
index 66917b5..f388b15 100644
--- a/src/libpython_clj2/java_api.clj
+++ b/src/libpython_clj2/java_api.clj
@@ -16,7 +16,7 @@
 
   Performance:
 
-  There are a two logical ways to repeatedly invoking python functionality.  The first is
+  There are a two logical ways to repeatedly invoke python functionality.  The first is
   to set some globals and repeatedly [[runStringAsInput]] a script.  The second is
   'exec'ing a script, finding an exported function in the global dict and calling
   that.  With libpython-clj, the second pathway -- repeatedly calling a function --
@@ -47,17 +47,24 @@ Python eval pathway calls/ms 2646.0478013509883
   This pathway will get at most 10% above using fastcall by itself.
 
 
+  Example:
+
+
 ```java
   java_api.initialize(null);
-  np = java_api.importModule(\"numpy\");
-  Object ones = java_api.getAttr(np, \"ones\");
-  ArrayList dims = new ArrayList();
-  dims.add(2);
-  dims.add(3);
-  Object npArray = java_api.call(ones, dims); //see fastcall notes above
+  try (AutoCloseable locker = java_api.GILLocker()) {
+    np = java_api.importModule(\"numpy\");
+    Object ones = java_api.getAttr(np, \"ones\");
+    ArrayList dims = new ArrayList();
+    dims.add(2);
+    dims.add(3);
+    Object npArray = java_api.call(ones, dims); //see fastcall notes above
+    ...
+  }
 ```"
   (:import [java.util Map Map$Entry List HashMap LinkedHashMap Set HashSet]
            [java.util.function Supplier]
+           [java.lang AutoCloseable]
            [clojure.java.api Clojure]
            [com.google.common.cache CacheBuilder RemovalListener])
   (:gen-class
@@ -67,6 +74,7 @@ Python eval pathway calls/ms 2646.0478013509883
              #^{:static true} [initializeEmbedded [] Object]
              #^{:static true} [lockGIL [] long]
              #^{:static true} [unlockGIL [long] Object]
+             #^{:static true} [GILLocker [] java.lang.AutoCloseable]
              #^{:static true} [hasAttr [Object String] Boolean]
              #^{:static true} [getAttr [Object String] Object]
              #^{:static true} [setAttr [Object String Object] Object]
@@ -323,6 +331,23 @@ Python eval pathway calls/ms 2646.0478013509883
   ((Clojure/var "libpython-clj2.python.ffi" "unlock-gil") gilstate))
 
 
+(defn -GILLocker
+  "Lock the gil returning an AutoCloseable that will unlock the gil upon close.
+
+  Example:
+
+```java
+  try (AutoCloseable locker = java_api.GILLocker()) {
+    ... Do your python stuff.
+  }
+```"
+  ^AutoCloseable []
+  (let [gilstate (-lockGIL)]
+    (reify AutoCloseable
+      (close [this]
+        (-unlockGIL gilstate)))))
+
+
 (defn -hasAttr
   "Returns true if this python object has this attribute."
   [pyobj attname]
diff --git a/test/libpython_clj2/java_api_test.clj b/test/libpython_clj2/java_api_test.clj
index bfcbb47..3c2ddb4 100644
--- a/test/libpython_clj2/java_api_test.clj
+++ b/test/libpython_clj2/java_api_test.clj
@@ -8,7 +8,7 @@
 
 (deftest base-japi-test
   (japi/-initialize nil)
-  (let [gilstate (japi/-lockGIL)]
+  (with-open [locker (japi/-GILLocker)]
     (japi/-runStringAsFile "data = 5")
     (is (= 5 (japi/-getGlobal "data")))
     (japi/-setGlobal "data" 6)
@@ -81,9 +81,7 @@
                   (japi/-runStringAsInput "bid-ask"))
               end-ns (System/nanoTime)
               ms (/ (- end-ns start-ns) 10e6)]
-          (println "Python setglobal pathway calls/ms" (/ n-calls ms))))
-      (finally
-        (japi/-unlockGIL gilstate)))))
+          (println "Python setglobal pathway calls/ms" (/ n-calls ms)))))))
 
 
 (defn only-string-input

From c71711d93fc6d7384ddbd47ab5c50c7f57e3eee3 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 21 Jan 2022 08:27:32 -0700
Subject: [PATCH 395/456] Release 2.016

---
 CHANGELOG.md                             |   4 +
 deps.edn                                 |  10 +-
 docs/Usage.html                          | 134 ++++++++------
 docs/design.html                         | 102 +++++++---
 docs/embedded.html                       |  99 ++++++----
 docs/environments.html                   |  19 +-
 docs/index.html                          |  20 +-
 docs/libpython-clj2.codegen.html         |  27 ++-
 docs/libpython-clj2.embedded.html        |  23 ++-
 docs/libpython-clj2.java-api.html        | 139 +++++++++++---
 docs/libpython-clj2.python.html          | 225 +++++++++++++++++++----
 docs/libpython-clj2.python.np-array.html |   9 +-
 docs/libpython-clj2.require.html         |  91 ++++++---
 docs/new-to-clojure.html                 | 145 +++++++++++----
 docs/scopes-and-gc.html                  |  33 +++-
 docs/slicing.html                        |  15 +-
 16 files changed, 804 insertions(+), 291 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 75c4e9f..caf2501 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,8 @@
 # Time for a ChangeLog!
+## 2.016
+ * Upgrade dtype-next to latest version.  This version of dtype-next comes with it's own
+   java-api so you can integrate deeper into the zero-copy pathways.
+
 ## 2.015
  * java API has stabilized.
  * [GILLocker](https://clj-python.github.io/libpython-clj/libpython-clj2.java-api.html#var--GILLocker) -
diff --git a/deps.edn b/deps.edn
index 96a0801..71a3ed8 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "8.053"}
+        cnuernber/dtype-next {:mvn/version "8.062"}
         net.java.dev.jna/jna {:mvn/version "5.10.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
@@ -16,10 +16,8 @@
            {:extra-deps {codox-theme-rdash/codox-theme-rdash {:mvn/version "0.1.2"}
                          nrepl/nrepl {:mvn/version "0.8.3"}
                          cider/cider-nrepl {:mvn/version "0.25.5"}
-                         codox/codox {:mvn/version "0.10.7"
-                                      :exclusions [org.ow2.asm/asm-all]}}
-            :ns-default tech.v3.libs.lein-codox
-            :exec-fn tech.v3.libs.lein-codox/-main
+                         com.cnuernber/codox {:mvn/version "1.001"}}
+            :exec-fn codox.main/-main
             :exec-args {:arg-paths [[:aliases :depstar :exec-args]]
                         :description "Python bindings for Clojure"
                         :metadata {:doc/format :markdown}
@@ -48,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.015"
+                        :version "2.016"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 3d77789..2187315 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,23 +1,28 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#usage" name="usage"></a>Usage</h1>
-<p>Python objects are essentially two dictionaries, one for ‘attributes’ and one for ‘items’. When you use python and use the ‘.’ operator, you are referencing attributes. If you use the ‘[]’ operator, then you are referencing items. Attributes are built in, item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes. This is important to realize in that the code below doesn’t look like python because we are referencing the item and attribute systems by name and not via ‘.’ or ‘[]’.</p>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Usage</h1>
+<p>Python objects are essentially two dictionaries, one for 'attributes' and one for
+'items'.  When you use python and use the '.' operator, you are referencing attributes.
+If you use the '[]' operator, then you are referencing items.  Attributes are built in,
+item access is optional and happens via the <code>__getitem__</code> and <code>__setitem__</code> attributes.
+This is important to realize in that the code below doesn't look like python because we are
+referencing the item and attribute systems by name and not via '.' or '[]'.</p>
 <p>This would result in the following analogous code (full example <a href="#dataframe-access-full-example">further on</a>):</p>
-<pre><code class="python">table.loc[row_date]
+<pre><code class="language-python">table.loc[row_date]
 </code></pre>
-<pre><code class="clojure">(get-item (get-attr table :loc) row-date)
+<pre><code class="language-clojure">(get-item (get-attr table :loc) row-date)
 </code></pre>
-<h3><a href="#installation" name="installation"></a>Installation</h3>
-<h4><a href="#ubuntu" name="ubuntu"></a>Ubuntu</h4>
-<pre><code class="console">sudo apt install libpython3.6
+<h3>Installation</h3>
+<h4>Ubuntu</h4>
+<pre><code class="language-console">sudo apt install libpython3.6
 # numpy and pandas are required for unit tests.  Numpy is required for
 # zero copy support.
 python3.6 -m pip install numpy pandas --user
 </code></pre>
-<h4><a href="#macosx" name="macosx"></a>MacOSX</h4>
+<h4>MacOSX</h4>
 <p>Python installation instructions <a href="https://docs.python-guide.org/starting/install3/osx/">here</a>.</p>
-<h3><a href="#initialize-python" name="initialize-python"></a>Initialize python</h3>
-<pre><code class="clojure">user&gt;
+<h3>Initialize python</h3>
+<pre><code class="language-clojure">user&gt;
 
 user&gt; (require '[libpython-clj.python
                  :refer [as-python as-jvm
@@ -53,25 +58,32 @@ <h3><a href="#initialize-python" name="initialize-python"></a>Initialize python<
 ...
 :ok
 </code></pre>
-<p>This dynamically finds the python shared library and loads it using output from the python3 executable on your system. For information about how that works, please checkout the code <a href="https://github.com/cnuernber/libpython-clj/blob/master/src/libpython_clj/python/interpreter.clj#L30">here</a>.</p>
-<h3><a href="#execute-some-python" name="execute-some-python"></a>Execute Some Python</h3>
+<p>This dynamically finds the python shared library and loads it using output from
+the python3 executable on your system.  For information about how that works,
+please checkout the code
+<a href="https://github.com/cnuernber/libpython-clj/blob/master/src/libpython_clj/python/interpreter.clj#L30">here</a>.</p>
+<h3>Execute Some Python</h3>
 <p><code>*out*</code> and <code>*err*</code> capture python stdout and stderr respectively.</p>
-<pre><code class="clojure"><br />user&gt; (run-simple-string "print('hey')")
+<pre><code class="language-clojure">
+user&gt; (run-simple-string "print('hey')")
 hey
 {:globals
  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;},
  :locals
  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;}}
 </code></pre>
-<p>The results have been ‘bridged’ into java meaning they are still python objects but there are java wrappers over the top of them. For instance, <code>Object.toString</code> forwards its implementation to the python function <code>__str__</code>.</p>
-<pre><code class="clojure">(def bridged (run-simple-string "print('hey')"))
+<p>The results have been 'bridged' into java meaning they are still python objects but
+there are java wrappers over the top of them.  For instance, <code>Object.toString</code> forwards
+its implementation to the python function <code>__str__</code>.</p>
+<pre><code class="language-clojure">(def bridged (run-simple-string "print('hey')"))
 (instance? java.util.Map (:globals bridged))
 true
 user&gt; (:globals bridged)
 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;}
 </code></pre>
-<p>We can get and set global variables here. If we run another string, these are in the environment. The globals map itself is the global dict of the main module:</p>
-<pre><code class="clojure">(def main-globals (-&gt; (add-module "__main__")
+<p>We can get and set global variables here.  If we run another string, these are in the
+environment.  The globals map itself is the global dict of the main module:</p>
+<pre><code class="language-clojure">(def main-globals (-&gt; (add-module "__main__")
                             (module-dict)))
 #'user/main-globals
 
@@ -97,8 +109,9 @@ <h3><a href="#execute-some-python" name="execute-some-python"></a>Execute Some P
  :locals
  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;, 'my_var': 200}}
 </code></pre>
-<p>Running Python isn’t ever really necessary, however, although it may at times be convenient. You can call attributes from clojure easily:</p>
-<pre><code class="clojure">user&gt; (def np (import-module "numpy"))
+<p>Running Python isn't ever really necessary, however, although it may at times be
+convenient.  You can call attributes from clojure easily:</p>
+<pre><code class="language-clojure">user&gt; (def np (import-module "numpy"))
 #'user/np
 user&gt; (def ones-ary (call-attr np "ones" [2 3]))
 #'user/ones-ary
@@ -149,9 +162,9 @@ <h3><a href="#execute-some-python" name="execute-some-python"></a>Execute Some P
  "var" :builtin-function-or-method,
  "view" :builtin-function-or-method}
 </code></pre>
-<h3><a href="#att-type-map" name="att-type-map"></a>att-type-map</h3>
+<h3>att-type-map</h3>
 <p>It can be extremely helpful to print out the attribute name-&gt;attribute type map:</p>
-<pre><code class="clojure">user&gt; (att-type-map ones-ary)
+<pre><code class="language-clojure">user&gt; (att-type-map ones-ary)
 {"T" :ndarray,
  "__abs__" :method-wrapper,
  "__add__" :method-wrapper,
@@ -175,9 +188,9 @@ <h3><a href="#att-type-map" name="att-type-map"></a>att-type-map</h3>
  ...
 }
 </code></pre>
-<h3><a href="#dataframe-access-full-example" name="dataframe-access-full-example"></a>DataFrame access full example</h3>
-<p>Here’s how to create Pandas DataFrame and accessing its rows via <code>loc</code> in both Python and Clojure:</p>
-<pre><code class="python"># Python
+<h3>DataFrame access full example</h3>
+<p>Here's how to create Pandas DataFrame and accessing its rows via <code>loc</code> in both Python and Clojure:</p>
+<pre><code class="language-python"># Python
 import numpy as np
 import pandas as pan
 
@@ -186,7 +199,7 @@ <h3><a href="#dataframe-access-full-example" name="dataframe-access-full-example
 row_date = pan.date_range(start="2000-01-01", end="2000-01-01")
 table.loc[row_date]
 </code></pre>
-<pre><code class="clojure">; Clojure
+<pre><code class="language-clojure">; Clojure
 (require-python '[numpy :as np])
 (require-python '[pandas :as pan])
 
@@ -195,17 +208,18 @@ <h3><a href="#dataframe-access-full-example" name="dataframe-access-full-example
 (def row-date (pan/date_range :start "2000-01-01" :end "2000-01-01"))
 (get-item (get-attr table :loc) row-date)
 </code></pre>
-<h3><a href="#errors" name="errors"></a>Errors</h3>
-<p>Errors are caught and an exception is thrown. The error text is saved verbatim in the exception:</p>
-<pre><code class="clojure">user&gt; (run-simple-string "print('syntax errrr")
+<h3>Errors</h3>
+<p>Errors are caught and an exception is thrown.  The error text is saved verbatim
+in the exception:</p>
+<pre><code class="language-clojure">user&gt; (run-simple-string "print('syntax errrr")
 Execution error (ExceptionInfo) at libpython-clj.python.interpreter/check-error-throw (interpreter.clj:260).
   File "&lt;string&gt;", line 1
     print('syntax errrr
                       ^
 SyntaxError: EOL while scanning string literal
 </code></pre>
-<h3><a href="#some-syntax-sugar" name="some-syntax-sugar"></a>Some Syntax Sugar</h3>
-<pre><code class="clojure">user&gt; (py/from-import numpy linspace)
+<h3>Some Syntax Sugar</h3>
+<pre><code class="language-clojure">user&gt; (py/from-import numpy linspace)
 #'user/linspace
 user&gt; (linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
@@ -221,36 +235,46 @@ <h3><a href="#some-syntax-sugar" name="some-syntax-sugar"></a>Some Syntax Sugar<
 
 </code></pre>
 <ul>
-  <li><code>from-import</code> - sugar around python <code>from a import b</code>. Takes multiple b’s.</li>
-  <li><code>import-as</code> - sugar around python <code>import a as b</code>.</li>
-  <li><code>$a</code> - call an attribute using symbol att name. Keywords map to kwargs</li>
-  <li><code>$c</code> - call an object mapping keywords to kwargs</li>
+<li><code>from-import</code> - sugar around python <code>from a import b</code>.  Takes multiple b's.</li>
+<li><code>import-as</code> - sugar around python <code>import a as b</code>.</li>
+<li><code>$a</code> - call an attribute using symbol att name.  Keywords map to kwargs</li>
+<li><code>$c</code> - call an object mapping keywords to kwargs</li>
 </ul>
-<h4><a href="#experimental-sugar" name="experimental-sugar"></a>Experimental Sugar</h4>
-<p>We are trying to find the best way to handle attributes in order to shorten generic python notebook-type usage. The currently implemented direction is:</p>
+<h4>Experimental Sugar</h4>
+<p>We are trying to find the best way to handle attributes in order to shorten
+generic python notebook-type usage.  The currently implemented direction is:</p>
 <ul>
-  <li><code>$.</code> - get an attribute. Can pass in symbol, string, or keyword</li>
-  <li><code>$..</code> - get an attribute. If more args are present, get the attribute on that result.</li>
+<li><code>$.</code> - get an attribute.  Can pass in symbol, string, or keyword</li>
+<li><code>$..</code> - get an attribute.  If more args are present, get the attribute on that
+result.</li>
 </ul>
-<pre><code class="clojure">user&gt; (py/$. numpy linspace)
+<pre><code class="language-clojure">user&gt; (py/$. numpy linspace)
 &lt;function linspace at 0x7fa6642766a8&gt;
 user&gt; (py/$.. numpy random shuffle)
 &lt;built-in method shuffle of numpy.random.mtrand.RandomState object at 0x7fa66410cca8&gt;
 </code></pre>
-<h5><a href="#new-sugar-fixme-" name="new-sugar-fixme-"></a>New sugar (fixme)</h5>
-<p><code>libpython-clj</code> offers syntactic forms similar to those offered by Clojure for interacting with Python classes and objects. </p>
-<p><strong>Class/object methods</strong> Where in Clojure you would use <code>(. obj method arg1 arg2 ... argN)</code>, you can use <code>(py. pyobj method arg1 arg2 ... argN)</code>. </p>
-<p>In Python, this is equivalent to <code>pyobj.method(arg1, arg2, ..., argN)</code>. Concrete examples are shown below.</p>
-<p><strong>Class/object attributes</strong> Where in Clojure you would use <code>(.- obj attr)</code>, you can use <code>(py.- pyobj attr)</code>.</p>
-<p>In Python, this is equivalent to <code>pyobj.attr</code>. Concrete examples shown below.</p>
-<p><strong>Nested attribute access</strong> To achieve a chain of method/attribute access, use the <code>py..</code> for.</p>
-<pre><code class="clojure ">(py.. (requests/get "http://www.google.com") 
+<h5>New sugar (fixme)</h5>
+<p><code>libpython-clj</code> offers syntactic forms similar to those offered by
+Clojure for interacting with Python classes and objects.</p>
+<p><strong>Class/object methods</strong>
+Where in Clojure you would use <code>(. obj method arg1 arg2 ... argN)</code>,
+you can use <code>(py. pyobj method arg1 arg2 ... argN)</code>.</p>
+<p>In Python, this is equivalent to <code>pyobj.method(arg1, arg2, ..., argN)</code>.
+Concrete examples are shown below.</p>
+<p><strong>Class/object attributes</strong>
+Where in Clojure you would use <code>(.- obj attr)</code>, you can use
+<code>(py.- pyobj attr)</code>.</p>
+<p>In Python, this is equivalent to <code>pyobj.attr</code>.
+Concrete examples shown below.</p>
+<p><strong>Nested attribute access</strong>
+To achieve a chain of method/attribute access, use the <code>py..</code> for.</p>
+<pre><code class="language-clojure">(py.. (requests/get "http://www.google.com") 
       -content
       (decode "latin-1"))
 </code></pre>
-<p>(**Note**: requires Python <code>requests</code> module installled)</p>
+<p>(<strong>Note</strong>: requires Python <code>requests</code> module installled)</p>
 <p><strong>Examples</strong></p>
-<pre><code class="clojure ">user=&gt; (require '[libpython-clj.python :as py :refer [py. py.. py.-]])
+<pre><code class="language-clojure">user=&gt; (require '[libpython-clj.python :as py :refer [py. py.. py.-]])
 nil
 user=&gt; (require '[libpython-clj.require :refer [require-python]])
 
@@ -286,9 +310,9 @@ <h5><a href="#new-sugar-fixme-" name="new-sugar-fixme-"></a>New sugar (fixme)</h
 user=&gt; (py.. requests (get "http://www.google.com") -content (decode "latin-1"))
 "&lt;!doctype html&gt;&lt;html itemscope=\"\" ... snip ... "
 </code></pre>
-<h3><a href="#numpy" name="numpy"></a>Numpy</h3>
+<h3>Numpy</h3>
 <p>Speaking of numpy, you can move data between numpy and java easily.</p>
-<pre><code class="clojure">user&gt; (def tens-data (as-tensor ones-ary))
+<pre><code class="language-clojure">user&gt; (def tens-data (as-tensor ones-ary))
 #'user/tens-data
 user&gt; (println tens-data)
 #tech.v2.tensor&lt;float64&gt;[2 3]
@@ -317,5 +341,9 @@ <h3><a href="#numpy" name="numpy"></a>Numpy</h3>
  {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': &lt;class '_frozen_importlib.BuiltinImporter'&gt;, '__spec__': None, '__annotations__': {}, '__builtins__': &lt;module 'builtins' (built-in)&gt;, 'my_var': 200, 'ones_ary': array([[5., 5., 5.],
        [5., 5., 5.]])}}
 </code></pre>
-<p>So heavy data has a zero-copy route. Anything backed by a <code>:native-buffer</code> has a zero copy pathway to and from numpy. For more information on how this happens, please refer to the datatype library <a href="https://github.com/techascent/tech.datatype/tree/master/docs">documentation</a>.</p>
-<p>Just keep in mind, careless usage of zero copy is going to cause spooky action at a  distance.</p></div></div></div></body></html>
\ No newline at end of file
+<p>So heavy data has a zero-copy route.  Anything backed by a <code>:native-buffer</code> has a
+zero copy pathway to and from numpy.  For more information on how this happens,
+please refer to the datatype library <a href="https://github.com/techascent/tech.datatype/tree/master/docs">documentation</a>.</p>
+<p>Just keep in mind, careless usage of zero copy is going to cause spooky action at a
+distance.</p>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/design.html b/docs/design.html
index bbcdfa7..83fa1ba 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,34 +1,75 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#libpython-clj-design-notes" name="libpython-clj-design-notes"></a>LibPython-CLJ Design Notes</h1>
-<h2><a href="#key-design-points" name="key-design-points"></a>Key Design Points</h2>
-<h3><a href="#code-organization" name="code-organization"></a>Code Organization</h3>
-<p>There are 3 rough sections of code: 1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full  documentation. The docstrings on the functions match the documentation if you lookup  the 3.7 API documentation. Users must manually manage the GIL when using this API  layer.</p>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Design Notes</h1>
+<h2>Key Design Points</h2>
+<h3>Code Organization</h3>
+<p>There are 3 rough sections of code:</p>
 <ol>
-  <li>
-  <p>An API implementation layer which knows about things like interpreters and type  symbol tables. Users must know how to manipulate the GIL and how the two garbage  collectors work with each other to add to this layer.</p></li>
-  <li>
-  <p>A public API layer. Details like managing the GIL or messing with garbage collection  in general do not leak out to this layer.</p></li>
+<li>
+<p>A JNA layer which is a 1-1 mapping most of the C API with no changes and full
+documentation.  The docstrings on the functions match the documentation if you lookup
+the 3.7 API documentation.  Users must manually manage the GIL when using this API
+layer.</p>
+</li>
+<li>
+<p>An API implementation layer which knows about things like interpreters and type
+symbol tables.  Users must know how to manipulate the GIL and how the two garbage
+collectors work with each other to add to this layer.</p>
+</li>
+<li>
+<p>A public API layer.  Details like managing the GIL or messing with garbage collection
+in general do not leak out to this layer.</p>
+</li>
 </ol>
-<h3><a href="#interpreters" name="interpreters"></a>Interpreters</h3>
-<p>Interpreters are global objects. After initialize!, there is a main interpreter which is used automatically from any thread. Access to the interpreters relies on thread local variables and interpreter locking so you can do things like:</p>
-<pre><code class="clojure">(with-interpreter interpreter
+<h3>Interpreters</h3>
+<p>Interpreters are global objects.  After initialize!, there is a main interpreter which
+is used automatically from any thread.  Access to the interpreters relies on thread
+local variables and interpreter locking so you can do things like:</p>
+<pre><code class="language-clojure">(with-interpreter interpreter
   some code)
 </code></pre>
-<p>You don’t have to do this, however. If you don’t care what context you run in you can just use the public API which under the covers simple does:</p>
-<pre><code class="clojure">(with-gil
+<p>You don't have to do this, however.  If you don't care what context you run in you can
+just use the public API which under the covers simple does:</p>
+<pre><code class="language-clojure">(with-gil
   some code)
 </code></pre>
-<p>This type of thing grabs the GIL if it hasn’t already been claimed by the current thread and off you go. When the code is finished, it saves the interpreter thread state back into a global atom and thus releases the GIL. Interpreters have both shared and per-interpreter state named <code>:shared-state</code> and <code>:interpreter-state</code> respectively. Shared state would be the global type symbol table. Interpreter state contains things like a map of objects to their per-interpreter python bridging class.</p>
-<p>If the interpreter isn’t specified it uses the main interpreter. The simplest way to ensure you have the gil is <code>with-gil</code>. You may also use <code>(ensure-bound-interpreter)</code> if you wish to penalize users for using a function incorrectly. This returns the interpreter currently bound to this thread or throws.</p>
-<h3><a href="#garbage-collection" name="garbage-collection"></a>Garbage Collection</h3>
-<p>The system uses the <a href="https://github.com/techascent/tech.resource">tech.resource</a> library to attach a GC hook to appropriate java object that releases the associated python object if the java object goes out of scope. Bridges use a similar technique to unregister the bridge on destruction of their python counterpart. There should be no need for manual addref/release calls in any user code aside from potentially (and damn rarely) a <code>(System/gc)</code> call.</p>
-<h3><a href="#copying-vs-bridging" name="copying-vs-bridging"></a>Copying Vs. Bridging</h3>
-<p>Objects either in python or in java may be either copied or bridged into the other ecosystem. Bridging allows sharing complex and potentially changing datastructures while copying allows a cleaner partitioning of concerns and frees both garbage collection systems to act more independently. Numeric buffers that have a direct representation as a C-ptr (the datatype native-buffer type) have a zero-copy pathway via numpy. If you want access to object functionality that object needs to be bridged; so for example if you want to call numpy functions then you need to bridge that object. Tensors are always represented in python as numpy objects using zero-copy where possible in all cases.</p>
-<h3><a href="#bridging" name="bridging"></a>Bridging</h3>
-<p>Python Callables implement <code>clojure.lang.IFn</code> along with a python specific interface so in general you can call them like any other function but you also can use keyword arguments if you know you are dealing with a python function. Python dicts implement <code>java.util.Map</code> and <code>clojure.lang.IFn</code> and lists are <code>java.util.List</code>, <code>java.util.RandomAccess</code>, and <code>clojure.lang.IFn</code>. This allows fluid manipulation of the datastructures (even mutation) from both languages.</p>
-<p>You can create a python function from a clojure function with create-function. You can create a new bridge type by implementing the <code>libpython_clj.jna.JVMBridge</code> interface:</p>
-<pre><code class="java">public interface JVMBridge extends AutoCloseable
+<p>This type of thing grabs the GIL if it hasn't already been claimed by the current thread
+and off you go.  When the code is finished, it saves the interpreter thread state back
+into a global atom and thus releases the GIL.  Interpreters have both shared and
+per-interpreter state named <code>:shared-state</code> and <code>:interpreter-state</code> respectively.
+Shared state would be the global type symbol table.  Interpreter state contains things
+like a map of objects to their per-interpreter python bridging class.</p>
+<p>If the interpreter isn't specified it uses the main interpreter.  The simplest way to
+ensure you have the gil is <code>with-gil</code>.  You may also use <code>(ensure-bound-interpreter)</code> if
+you wish to penalize users for using a function incorrectly.  This returns the
+interpreter currently bound to this thread or throws.</p>
+<h3>Garbage Collection</h3>
+<p>The system uses the <a href="https://github.com/techascent/tech.resource">tech.resource</a>
+library to attach a GC hook to appropriate java object
+that releases the associated python object if the java object goes out of scope.
+Bridges use a similar technique to unregister the bridge on destruction of their python
+counterpart.  There should be no need for manual addref/release calls in any user code
+aside from potentially (and damn rarely) a <code>(System/gc)</code> call.</p>
+<h3>Copying Vs. Bridging</h3>
+<p>Objects either in python or in java may be either copied or bridged into the other
+ecosystem.  Bridging allows sharing complex and potentially changing datastructures
+while copying allows a cleaner partitioning of concerns and frees both garbage
+collection systems to act more independently.  Numeric buffers that have a direct
+representation as a C-ptr (the datatype native-buffer type) have a zero-copy pathway via
+numpy.  If you want access to object functionality that object needs to be bridged; so
+for example if you want to call numpy functions then you need to bridge that object.
+Tensors are always represented in python as numpy objects using zero-copy where possible
+in all cases.</p>
+<h3>Bridging</h3>
+<p>Python Callables implement <code>clojure.lang.IFn</code> along with a python specific interface so
+in general you can call them like any other function but you also can use keyword
+arguments if you know you are dealing with a python function.  Python dicts implement
+<code>java.util.Map</code> and <code>clojure.lang.IFn</code> and lists are <code>java.util.List</code>,
+<code>java.util.RandomAccess</code>, and <code>clojure.lang.IFn</code>.  This allows fluid manipulation of
+the datastructures (even mutation) from both languages.</p>
+<p>You can create a python function from a clojure function with create-function.  You can
+create a new bridge type by implementing the <code>libpython_clj.jna.JVMBridge</code> interface:</p>
+<pre><code class="language-java">public interface JVMBridge extends AutoCloseable
 {
   public Pointer getAttr(String name);
   public void setAttr(String name, Pointer val);
@@ -40,8 +81,9 @@ <h3><a href="#bridging" name="bridging"></a>Bridging</h3>
   public default void close() {}
 }
 </code></pre>
-<p>If all you want to do is override the attribute map that is simple. Here is the bridge for java.util.Map:</p>
-<pre><code class="clojure">(defn jvm-map-&gt;python
+<p>If all you want to do is override the attribute map that is simple.  Here is the bridge
+for java.util.Map:</p>
+<pre><code class="language-clojure">(defn jvm-map-&gt;python
   ^Pointer [^Map jvm-data]
   (with-gil
     (let [att-map
@@ -59,9 +101,10 @@ <h3><a href="#bridging" name="bridging"></a>Bridging</h3>
            "pop" (jvm-fn-&gt;python #(.remove jvm-data %))}]
       (create-bridge-from-att-map jvm-data att-map))))
 </code></pre>
-<h3><a href="#io" name="io"></a>IO</h3>
-<p><code>sys.stdout</code> and <code>sys.stderr</code> are redirected to <code>*out*</code> and <code>*err*</code> respectively. This rerouting is done using a bridge that is then set as <code>sys.stdout</code> or <code>sys.stderr</code>:</p>
-<pre><code class="clojure">(defn create-var-writer
+<h3>IO</h3>
+<p><code>sys.stdout</code> and <code>sys.stderr</code> are redirected to <code>*out*</code> and <code>*err*</code> respectively.
+This rerouting is done using a bridge that is then set as <code>sys.stdout</code> or <code>sys.stderr</code>:</p>
+<pre><code class="language-clojure">(defn create-var-writer
   "Returns an unregistered bridge"
   ^Pointer [writer-var]
   (with-gil
@@ -93,4 +136,5 @@ <h3><a href="#io" name="io"></a>IO</h3>
       (pyinterop/setup-std-writer #'*err* "stderr")
       (pyinterop/setup-std-writer #'*out* "stdout")))
   :ok)
-</code></pre></div></div></div></body></html>
\ No newline at end of file
+</code></pre>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/embedded.html b/docs/embedded.html
index da922e1..caec9b5 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,28 +1,50 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#embedding-clojure-in-python" name="embedding-clojure-in-python"></a>Embedding Clojure In Python</h1>
-<p>The initial development push for <code>libpython-clj</code> was simply to embed Python in Clojure allowing Clojure developers to use Python modules simply transparently. This approach relied on <code>libpython-clj</code> being able to find the Python shared library and having some capability to setup various Python system variables before loading any modules. While this works great most of the time there are several reasons for which this approach is less than ideal:</p>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+<p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
+Clojure allowing Clojure developers to use Python modules simply transparently.
+This approach relied on <code>libpython-clj</code> being able to find the Python shared library
+and having some capability to setup various Python system variables before loading
+any modules.  While this works great most of the time there are several reasons for
+which this approach is less than ideal:</p>
 <ol>
-  <li>In some cases a mainly Python team wants to use some Clojure for a small part of their work. Telling them to host Python from Clojure is for them a potentially very disruptive change.</li>
-  <li>The python ecosystem is moving away from the shared library and towards compiling a statically linked executable. This can never work with libpython-clj’s default pathway.</li>
-  <li>Embedded Python cannot use all of Python functionality available due to the fact that the host process isn’t <code>python</code>. Specifically the multithreading module relies on forking the host process and thus produces a hang if the JVM is the main underlying process.</li>
-  <li>Replicating the exact python environment is error prone especially when Python environment managers such as <code>pyenv</code> and <code>Conda</code> are taken into account.</li>
+<li>In some cases a mainly Python team wants to use some Clojure for a small part of
+their work.  Telling them to host Python from Clojure is for them a potentially
+very disruptive change.</li>
+<li>The python ecosystem is moving away from the shared library and towards
+compiling a statically linked executable.  This can never work with
+libpython-clj's default pathway.</li>
+<li>Embedded Python cannot use all of Python functionality available due to the fact
+that the host process isn't <code>python</code>.  Specifically the multithreading module
+relies on forking the host process and thus produces a hang if the JVM is the
+main underlying process.</li>
+<li>Replicating the exact python environment is error prone especially when Python
+environment managers such as <code>pyenv</code> and <code>Conda</code> are taken into account.</li>
 </ol>
-<p>Due to the above reasons there is a solid argument for, if possible, embedding Clojure into Python allowing the Python executable to be the host process.</p>
-<h2><a href="#enter-cljbridge" name="enter-cljbridge"></a>Enter: cljbridge</h2>
-<p>Python already had a nascent system for embedding Java in Python - the <a href="https://pypi.org/project/javabridge/">javabridge module</a>. </p>
+<p>Due to the above reasons there is a solid argument for, if possible, embedding
+Clojure into Python allowing the Python executable to be the host process.</p>
+<h2>Enter: cljbridge</h2>
+<p>Python already had a nascent system for embedding Java in Python - the
+<a href="https://pypi.org/project/javabridge/">javabridge module</a>.</p>
 <p>We went a step further and provide <code>cljbridge</code> python module.</p>
-<p>In order to compile <code>javabridge</code> a JDK is required and <strong>not just the JRE</strong>. <a href="https://github.com/tristanstraub/">tristanstraub</a> had found a way to use this in order to work with <a href="https://github.com/tristanstraub/blender-clj/">Blender</a>. We took a bit more time and worked out ways to smooth out these interactions and make sure they were supported throughout the system.</p>
-<h2><a href="#from-the-python-repl" name="from-the-python-repl"></a>From the Python REPL</h2>
+<p>In order to compile <code>javabridge</code>
+a JDK is required and <strong>not just the JRE</strong>.  <a href="https://github.com/tristanstraub/">tristanstraub</a>
+had found a way to use this in order to work with <a href="https://github.com/tristanstraub/blender-clj/">Blender</a>.
+We took a bit more time and worked out ways to smooth out these interactions
+and make sure they were supported throughout the system.</p>
+<h2>From the Python REPL</h2>
 <p>The next step involves starting a python repl.</p>
-<p>This requires a python library <code>cljbridge</code>, which can be installed via</p>
+<p>This requires a python library <code>cljbridge</code>,
+which can be installed via</p>
 <pre><code>export JAVA_HOME=&lt;--YOUR JAVA HOME--&gt;
 python3 -m pip install cljbridge
 </code></pre>
 <p>This will install and eventually compile <code>javabridge</code> as well.</p>
-<p>If the installation cannot find ‘jni.h’ then most likely you have the Java runtime (JRE) installed as opposed to the Java development kit (JDK).</p>
-<p>So we start by importing that script:</p>
-<pre><code class="python">Python 3.8.5 (default, Jan 27 2021, 15:41:15)
+<p>If the installation cannot find 'jni.h' then most likely you have the Java runtime
+(JRE) installed as opposed to the Java development kit (JDK).</p>
+<p>So we start by importing
+that script:</p>
+<pre><code class="language-python">Python 3.8.5 (default, Jan 27 2021, 15:41:15)
 [GCC 9.3.0] on linux
 Type "help", "copyright", "credits" or "license" for more information.
 &gt;&gt;&gt; from clojurebridge import cljbridge
@@ -31,10 +53,15 @@ <h2><a href="#from-the-python-repl" name="from-the-python-repl"></a>From the Pyt
 Mar 11, 2021 9:08:47 AM clojure.tools.logging$eval3186$fn__3189 invoke
 INFO: nREPL server started on port 40241 on host localhost - nrepl://localhost:40241
 </code></pre>
-<p>At this point we do not get control back; we have released the GIL and java is blocking this thread to allow the Clojure REPL systems access to the GIL. We have two important libraries for clojure loaded, nrepl and cider which allow a rich, interactive development experience so let’s now connect to that port with our favorite Clojure editor - emacs of course ;-).</p>
-<h2><a href="#from-the-clojure-repl" name="from-the-clojure-repl"></a>From the Clojure REPL</h2>
-<p>From emacs, I run the command ‘cider-connect’ which allows me to specify a host and port to connect to. Once connected, I get a minimal repl environment:</p>
-<pre><code class="clojure">;; M-x cider-connect ...localhost...40241
+<p>At this point we do not get control back; we have released the GIL and java
+is blocking this thread to allow the Clojure REPL systems access to the GIL.  We have
+two important libraries for clojure loaded, nrepl and cider which allow a rich,
+interactive development experience so let's now connect to that port with our favorite
+Clojure editor - emacs of course ;-).</p>
+<h2>From the Clojure REPL</h2>
+<p>From emacs, I run the command 'cider-connect' which allows me to specify a host
+and port to connect to.  Once connected, I get a minimal repl environment:</p>
+<pre><code class="language-clojure">;; M-x cider-connect ...localhost...40241
 ;; I am not sure why but to initialize the user namespace I have to eval ns user
 
 user&gt; (eval '(ns user))
@@ -68,9 +95,11 @@ <h2><a href="#from-the-clojure-repl" name="from-the-clojure-repl"></a>From the C
 nil
 user&gt; (embedded/stop-repl!)
 </code></pre>
-<h2><a href="#and-back-to-python-" name="and-back-to-python-"></a>And Back to Python!!</h2>
-<p>Shutting down the repl always gives us an exception; something perhaps to work on. But the important thing is that we can access variables and data that we set in the main module -</p>
-<pre><code class="python">&gt;&gt;&gt; Exception in thread "nREPL-session-d684061e-f21c-4265-a9a2-828b99dcaf42" java.net.SocketException: Socket closed
+<h2>And Back to Python!!</h2>
+<p>Shutting down the repl always gives us an exception; something perhaps to work on.
+But the important thing is that we can access variables and data that we set
+in the main module -</p>
+<pre><code class="language-python">&gt;&gt;&gt; Exception in thread "nREPL-session-d684061e-f21c-4265-a9a2-828b99dcaf42" java.net.SocketException: Socket closed
 	at java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:118)
 	at java.net.SocketOutputStream.write(SocketOutputStream.java:155)
 	at java.io.BufferedOutputStream.flushBuffer(BufferedOutputStream.java:82)
@@ -101,15 +130,21 @@ <h2><a href="#and-back-to-python-" name="and-back-to-python-"></a>And Back to Py
 Printing from Clojure:  [1 2 3 4 Embedded Clojure FTW!!]
 &gt;&gt;&gt;
 </code></pre>
-<h2><a href="#loading-and-running-a-clojure-file-in-embedded-mode" name="loading-and-running-a-clojure-file-in-embedded-mode"></a>Loading and running a Clojure file in embedded mode</h2>
-<p>We can runs as well a .clj file in embedded mode. The following does this without an interactive pytho shell, it just runs the provided clj file with <code>clojure.core/load-file</code></p>
-<pre><code class="bash">python3 -c 'import cljbridge;cljbridge.load_clojure_file(clj_file="my-file.clj")'
+<h2>Loading and running a Clojure file in embedded mode</h2>
+<p>We can runs as well a .clj file in embedded mode.
+The following does this without an interactive pytho shell, it just runs the provided clj file with
+<code>clojure.core/load-file</code></p>
+<pre><code class="language-bash">python3 -c 'import cljbridge;cljbridge.load_clojure_file(clj_file="my-file.clj")'
 </code></pre>
-<h2><a href="#are-you-not-entertained-" name="are-you-not-entertained-"></a>Are You Not Entertained???</h2>
-<p>So there you have it, embedding a Clojure repl in a Python process and passing data in between these two systems. This sidesteps a <em>ton</em> of issues with embedding Python and provides another interesting set of possibilities, essentially extending existing Python systems with some of the greatest tech the JVM has to offer :-).</p>
+<h2>Are You Not Entertained???</h2>
+<p>So there you have it, embedding a Clojure repl in a Python process and passing data
+in between these two systems.  This sidesteps a <em>ton</em> of issues with embedding Python
+and provides another interesting set of possibilities, essentially extending existing
+Python systems with some of the greatest tech the JVM has to offer :-).</p>
 <ul>
-  <li><a href="https://github.com/LeeKamentsky/python-javabridge">javabridge github</a></li>
-  <li><a href="https://github.com/clj-python/libpython-clj/blob/94c72ca0ac94b210a9b126805cd4112024ad0b96/cljbridge.py">libpython-clj cljbridge.py</a></li>
-  <li><a href="https://clj-python.github.io/libpython-clj/libpython-clj2.embedded.html">libpython-clj embedded docs</a></li>
-  <li><a href="https://github.com/tristanstraub/blender-clj/">blender-clj - the inspiration</a></li>
-</ul></div></div></div></body></html>
\ No newline at end of file
+<li><a href="https://github.com/LeeKamentsky/python-javabridge">javabridge github</a></li>
+<li><a href="https://github.com/clj-python/libpython-clj/blob/94c72ca0ac94b210a9b126805cd4112024ad0b96/cljbridge.py">libpython-clj cljbridge.py</a></li>
+<li><a href="https://clj-python.github.io/libpython-clj/libpython-clj2.embedded.html">libpython-clj embedded docs</a></li>
+<li><a href="https://github.com/tristanstraub/blender-clj/">blender-clj - the inspiration</a></li>
+</ul>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/environments.html b/docs/environments.html
index ea37fac..0115214 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,15 +1,16 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#python-environments" name="python-environments"></a>Python Environments</h1>
-<h2><a href="#pyenv" name="pyenv"></a>pyenv</h2>
-<p>pyenv requires that you build the shared library. This is a separate configuration option than a lot of pyenv users have used before.</p>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+<h2>pyenv</h2>
+<p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
-  <li><a href="https://github.com/pyenv/pyenv/issues/392">pyenv shared library issue</a></li>
-  <li><a href="https://github.com/clj-python/libpython-clj/issues/123">libpython-clj related issue</a></li>
+<li><a href="https://github.com/pyenv/pyenv/issues/392">pyenv shared library issue</a></li>
+<li><a href="https://github.com/clj-python/libpython-clj/issues/123">libpython-clj related issue</a></li>
 </ul>
-<h2><a href="#conda" name="conda"></a>Conda</h2>
+<h2>Conda</h2>
 <p>Conda requires that we set the LD_LIBRARY_PATH to the conda install.</p>
 <ul>
-  <li><a href="https://github.com/clj-python/libpython-clj/blob/master/scripts/conda-repl">example conda repl launcher</a></li>
-  <li><a href="https://github.com/clj-python/libpython-clj/issues/18">libpython-clj issue for Conda</a></li>
-</ul></div></div></div></body></html>
\ No newline at end of file
+<li><a href="https://github.com/clj-python/libpython-clj/blob/master/scripts/conda-repl">example conda repl launcher</a></li>
+<li><a href="https://github.com/clj-python/libpython-clj/issues/18">libpython-clj issue for Conda</a></li>
+</ul>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/index.html b/docs/index.html
index 476dc58..9e9b4f1 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,3 +1,21 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.015</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--GILLocker">-GILLocker</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title> 2.016</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+</div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+See jbridge.py for python details.  This namespace relies on
+the classpath having nrepl and cider-nrepl on it.  For example:</p>
+</div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.embedded.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.embedded.html#var-start-repl.21">start-repl!</a> </li><li> <a href="libpython-clj2.embedded.html#var-stop-repl.21">stop-repl!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.java-api.html">libpython-clj2.java-api</a></h3><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+without the leading '-'.  Note that returned python objects implement the respective
+java interfaces so a python dict will implement java.util.Map, etc.  There is some
+startup time as Clojure dynamically compiles the source code but this binding should
+have great runtime characteristics in comparison to any other java python engine.</p>
+</div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--GILLocker">-GILLocker</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+python, loads the shared library and allows Clojure users to use Python modules
+as if they were Clojure namespaces.</p>
+</div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+allows seamless usage of numpy arrays in datatype and tensor functionality such as
+enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
+zero copying when possible.</p>
+</div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name">datatype-&gt;ptr-type-name</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy">descriptor-&gt;numpy</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map">dtype-&gt;py-dtype-map</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc">numpy-&gt;desc</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype">obj-dtype-&gt;dtype</a> </li><li> <a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map">py-dtype-&gt;dtype-map</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.require.html">libpython-clj2.require</a></h3><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+scanning the module for metadata and dynamically building the Clojure namespace.</p>
+</div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.require.html#var-import-python">import-python</a> </li><li> <a href="libpython-clj2.require.html#var-require-python">require-python</a> </li></ul></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 8e809f3..c76503d 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,19 +1,25 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p></div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+</div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>Once generated this namespace is safe to be used for AOT,</p>
 <p>Options:</p>
 <ul>
-  <li><code>:output-fname</code> - override the autogenerated file path.</li>
-  <li><code>:output-dir</code> - Defaults “src”. Set the output directory. The final filename, if <code>:output-fname</code> is not provided, is built up from <code>:ns-prefix and
-</code>py-mod-or-cls`.</li>
-  <li><code>:ns-symbol</code> - The fully qualified namespace symbol. If not provided is built from <code>:ns-prefix</code> and <code>py-mod-or-cls</code>.</li>
-  <li><code>:ns-prefix</code> - The prefix used for all python namespaces. Defaults to “python”.</li>
-  <li><code>:symbol-name-remaps</code> - A list of remaps used to avoid name clashes with  clojure.core or builtin java symbols.</li>
-  <li><code>:exclude</code> - List of symbols used like <code>(:refer-clojure :exclude %s)</code>. You can see the default list as <code>codegen/default-exclude</code>.</li>
+<li><code>:output-fname</code> - override the autogenerated file path.</li>
+<li><code>:output-dir</code> - Defaults "src".  Set the output directory.  The final filename,
+if <code>:output-fname</code> is not provided, is built up from <code>:ns-prefix and</code>py-mod-or-cls`.</li>
+<li><code>:ns-symbol</code> - The fully qualified namespace symbol.  If not provided is built
+from <code>:ns-prefix</code> and <code>py-mod-or-cls</code>.</li>
+<li><code>:ns-prefix</code> - The prefix used for all python namespaces.  Defaults to "python".</li>
+<li><code>:symbol-name-remaps</code> - A list of remaps used to avoid name clashes with
+clojure.core or builtin java symbols.</li>
+<li><code>:exclude</code> - List of symbols used like <code>(:refer-clojure :exclude %s)</code>.  You can
+see the default list as <code>codegen/default-exclude</code>.</li>
 </ul>
 <p>Example:</p>
-<pre><code class="clojure">user&gt; (require '[libpython-clj2.codegen :as codegen])
+<pre><code class="language-clojure">user&gt; (require '[libpython-clj2.codegen :as codegen])
 nil
 user&gt; (codegen/write-namespace!
        "builtins" {:symbol-name-remaps {"AssertionError" "PyAssertionError"
@@ -34,4 +40,5 @@
         (.add 1)
         (.add 2))
 [1, 2]
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/codegen.clj#L102">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/codegen.clj#L102">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 22f4e82..1b47156 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,8 +1,21 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.  See jbridge.py for python details. This namespace relies on  the classpath having nrepl and cider-nrepl on it. For example:</p>
-<pre><code class="console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
-</code></pre></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case, unless libpath is explicitly provided the system will look for the python symbols in the current executable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread. This function does not return control to the calling thread until another thread calls `stop-repl!; this design is explicit to ensure the python GIL is released and thus when connected to the REPL you can use Python.</p>
-<p>If an existing repl server has been started this returns the port of the previous server else it returns the port of the new server.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+See jbridge.py for python details.  This namespace relies on
+the classpath having nrepl and cider-nrepl on it.  For example:</p>
+<pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
+</code></pre>
+</div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize!)</code><code>(initialize! libpath)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program.  In
+that case, unless libpath is explicitly provided the system will look for the
+python symbols in the current executable.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L15">view source</a></div></div><div class="public anchor" id="var-start-repl.21"><h3>start-repl!</h3><div class="usage"><code>(start-repl! options)</code><code>(start-repl!)</code></div><div class="doc"><div class="markdown"><p>This is called to start a clojure repl and block the thread.  This function does not return
+control to the calling thread until another thread calls `stop-repl!; this design is
+explicit to ensure the python GIL is released and thus when connected to the REPL you can
+use Python.</p>
+<p>If an existing repl server has been started this returns the port of the previous
+server else it returns the port of the new server.</p>
 <p>To return control to the calling thread call <code>stop-repl!</code>.</p>
-<p>Options are the same as the command line options found in nrepl.cmdline.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L43">view source</a></div></div><div class="public anchor" id="var-stop-repl.21"><h3>stop-repl!</h3><div class="usage"><code>(stop-repl!)</code></div><div class="doc"><div class="markdown"><p>If an existing repl has been started, stop it. This returns control to the thread that called <code>start-repl!</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L26">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>Options are the same as the command line options found in nrepl.cmdline.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L43">view source</a></div></div><div class="public anchor" id="var-stop-repl.21"><h3>stop-repl!</h3><div class="usage"><code>(stop-repl!)</code></div><div class="doc"><div class="markdown"><p>If an existing repl has been started, stop it.  This returns control to the
+thread that called <code>start-repl!</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/embedded.clj#L26">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 3e989c2..d55f122 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,21 +1,49 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2. The methods below are statically callable  without the leading ‘-’. Note that returned python objects implement the respective  java interfaces so a python dict will implement java.util.Map, etc. There is some  startup time as Clojure dynamically compiles the source code but this binding should  have great runtime characteristics in comparison to any other java python engine.</p>
-<p>Note that you can pass java objects into python. An implementation of java.util.Map will  appear to python as a dict-like object an implementation of java.util.List will look  like a sequence and if the thing is iterable then it will be iterable in python.  To receive callbacks from python you can provide an implementation of the  interface <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a>  - see <a href="https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/AFn.java">clojure.lang.AFn</a> for a base class that makes this easier.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+without the leading '-'.  Note that returned python objects implement the respective
+java interfaces so a python dict will implement java.util.Map, etc.  There is some
+startup time as Clojure dynamically compiles the source code but this binding should
+have great runtime characteristics in comparison to any other java python engine.</p>
+<p>Note that you can pass java objects into python.  An implementation of java.util.Map will
+appear to python as a dict-like object an implementation of java.util.List will look
+like a sequence and if the thing is iterable then it will be iterable in python.
+To receive callbacks from python you can provide an implementation of the
+interface <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a></p>
+<ul>
+<li>see <a href="https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/AFn.java">clojure.lang.AFn</a> for a base class that makes this easier.</li>
+</ul>
 <p>Performance:</p>
-<p>There are a two logical ways to repeatedly invoke python functionality. The first is  to set some globals and repeatedly <a href="null">runStringAsInput</a> a script. The second is  ’exec’ing a script, finding an exported function in the global dict and calling  that. With libpython-clj, the second pathway – repeatedly calling a function –  is going to be faster than the first if the user makes a fastcallable out of the function  to be invoked. Here are some sample timings for an extremely simple function with two  arguments:</p>
-<pre><code class="console">Python fn calls/ms 1923.2490094806021
+<p>There are a two logical ways to repeatedly invoke python functionality.  The first is
+to set some globals and repeatedly <a href="runStringAsInput">runStringAsInput</a> a script.  The second is
+'exec'ing a script, finding an exported function in the global dict and calling
+that.  With libpython-clj, the second pathway -- repeatedly calling a function --
+is going to be faster than the first if the user makes a fastcallable out of the function
+to be invoked.  Here are some sample timings for an extremely simple function with two
+arguments:</p>
+<pre><code class="language-console">Python fn calls/ms 1923.2490094806021
 Python fastcallable calls/ms 3776.767751742239
 Python eval pathway calls/ms 2646.0478013509883
 </code></pre>
 <ul>
-  <li>
-  <p><a href="null">makeFastcallable</a> - - For the use case of repeatedly calling a single function - this  will cache the argument tuple for repeated use as opposed to allocating the argument tuple  every call. This can be a surprising amount faster – 2x-3x – than directly calling the  python callable. Once a fastcallable object is made you can either cast it to a  <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a>  or call it via the provided <code>call</code> static method.</p></li>
-  <li>
-  <p>HAIR ON FIRE MODE - If you are certain you are correctly calling lockGIL and unlockGIL  then you can define a variable, <code>-Dlibpython_clj.manual_gil=true</code> that will disable  automatic GIL lock/unlock system and gil correctness checking. This is useful, for instance,  if you are going to lock libpython-clj to a thread and control all access to it yourself.  This pathway will get at most 10% above using fastcall by itself.</p></li>
+<li>
+<p><a href="makeFastcallable">makeFastcallable</a> - - For the use case of repeatedly calling a single function - this
+will cache the argument tuple for repeated use as opposed to allocating the argument tuple
+every call.  This can be a surprising amount faster -- 2x-3x -- than directly calling the
+python callable.  Once a fastcallable object is made you can either cast it to a
+<a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a>
+or call it via the provided <code>call</code> static method.</p>
+</li>
+<li>
+<p>HAIR ON FIRE MODE - If you are certain you are correctly calling lockGIL and unlockGIL
+then you can define a variable, <code>-Dlibpython_clj.manual_gil=true</code> that will disable
+automatic GIL lock/unlock system and gil correctness checking.  This is useful, for instance,
+if you are going to lock libpython-clj to a thread and control all access to it yourself.
+This pathway will get at most 10% above using fastcall by itself.</p>
+</li>
 </ul>
 <p>Example:</p>
-<pre><code class="java">  java_api.initialize(null);
+<pre><code class="language-java">  java_api.initialize(null);
   try (AutoCloseable locker = java_api.GILLocker()) {
     np = java_api.importModule("numpy");
     Object ones = java_api.getAttr(np, "ones");
@@ -25,37 +53,102 @@
     Object npArray = java_api.call(ones, dims); //see fastcall notes above
     ...
   }
-</code></pre></div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys “datatype”, “shape”, and a jvm array “data” in flattened row-major form.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L582">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object. Python callables implement this interface so this works for python objects. This is a convenience method around casting implementation of <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and calling <code>invoke</code> directly.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L475">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L458">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
-<p>Note this copies <em>from</em> the first argument <em>to</em> the second argument – this is reverse the normal memcpy argument order!!. Returns the destination (to) argument.</p>
-<p>Not this does <em>not</em> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L595">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L558">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to a python object.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L551">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data. * <code>datatype</code> - One of “int8” “uint8” “int16” “uint16” “int32” “uint32” “int64” “uint64” “float32” “float64”. * <code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>. * <code>data</code> - list or array of data. This will of course be fastest if the datatype of the array matches the requested datatype.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L564">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute. This corresponds to the python ‘.’ operator.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L357">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L397">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L375">view source</a></div></div><div class="public anchor" id="var--GILLocker"><h3>-GILLocker</h3><div class="usage"><code>(-GILLocker)</code></div><div class="doc"><div class="markdown"><p>Lock the gil returning an AutoCloseable that will unlock the gil upon close.</p>
+</code></pre>
+</div></div><div class="public anchor" id="var--arrayToJVM"><h3>-arrayToJVM</h3><div class="usage"><code>(-arrayToJVM pyobj)</code></div><div class="doc"><div class="markdown"><p>Copy (efficiently) a numeric numpy array into a jvm map containing keys "datatype",
+"shape", and a jvm array "data" in flattened row-major form.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L582">view source</a></div></div><div class="public anchor" id="var--call"><h3>-call</h3><div class="usage"><code>(-call item)</code><code>(-call item arg1)</code><code>(-call item arg1 arg2)</code><code>(-call item arg1 arg2 arg3)</code><code>(-call item arg1 arg2 arg3 arg4)</code><code>(-call item arg1 arg2 arg3 arg4 arg5)</code><code>(-call item arg1 arg2 arg3 arg4 arg5 arg6)</code></div><div class="doc"><div class="markdown"><p>Call a clojure <code>IFn</code> object.  Python callables implement this interface so this works for
+python objects.  This is a convenience method around casting implementation of
+<a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and
+calling <code>invoke</code> directly.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L475">view source</a></div></div><div class="public anchor" id="var--callKw"><h3>-callKw</h3><div class="usage"><code>(-callKw pyobj pos-args kw-args)</code></div><div class="doc"><div class="markdown"><p>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 <a href="https://clojure.github.io/clojure/javadoc/clojure/lang/IFn.html">clojure.lang.IFn</a> and you can use <code>invoke</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L458">view source</a></div></div><div class="public anchor" id="var--copyData"><h3>-copyData</h3><div class="usage"><code>(-copyData from to)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<p>Note this copies <em>from</em> the first argument <em>to</em> the second argument -- this is reverse the
+normal memcpy argument order!!.  Returns the destination (to) argument.</p>
+<p>Not this does <em>not</em> work with array-of-arrays.  It will work with, for instance,
+a numpy matrix of shape <a href="2, 2">2, 2</a> and an double array of length 4.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L595">view source</a></div></div><div class="public anchor" id="var--copyToJVM"><h3>-copyToJVM</h3><div class="usage"><code>(-copyToJVM object)</code></div><div class="doc"><div class="markdown"><p>Copy a python object such as a dict or a list into a comparable JVM object.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L558">view source</a></div></div><div class="public anchor" id="var--copyToPy"><h3>-copyToPy</h3><div class="usage"><code>(-copyToPy object)</code></div><div class="doc"><div class="markdown"><p>Copy a basic jvm object, such as an implementation of java.util.Map or java.util.List to
+a python object.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L551">view source</a></div></div><div class="public anchor" id="var--createArray"><h3>-createArray</h3><div class="usage"><code>(-createArray datatype shape data)</code></div><div class="doc"><div class="markdown"><p>Create a numpy array from a tuple of string datatype, shape and data.</p>
+<ul>
+<li><code>datatype</code> - One of "int8" "uint8" "int16" "uint16" "int32" "uint32"
+"int64" "uint64" "float32" "float64".</li>
+<li><code>shape</code> - integer array of dimension e.g. <code>[2,3]</code>.</li>
+<li><code>data</code> - list or array of data.  This will of course be fastest if the datatype
+of the array matches the requested datatype.</li>
+</ul>
+<p>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.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L564">view source</a></div></div><div class="public anchor" id="var--getAttr"><h3>-getAttr</h3><div class="usage"><code>(-getAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get a python attribute.  This corresponds to the python '.' operator.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L357">view source</a></div></div><div class="public anchor" id="var--getGlobal"><h3>-getGlobal</h3><div class="usage"><code>(-getGlobal varname)</code></div><div class="doc"><div class="markdown"><p>Get a value from the global dict.  This function expects the GIL to be locked - it will
+not lock/unlock it for you.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L397">view source</a></div></div><div class="public anchor" id="var--getItem"><h3>-getItem</h3><div class="usage"><code>(-getItem pyobj itemName)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L375">view source</a></div></div><div class="public anchor" id="var--GILLocker"><h3>-GILLocker</h3><div class="usage"><code>(-GILLocker)</code></div><div class="doc"><div class="markdown"><p>Lock the gil returning an AutoCloseable that will unlock the gil upon close.</p>
 <p>Example:</p>
-<pre><code class="java">  try (AutoCloseable locker = java_api.GILLocker()) {
+<pre><code class="language-java">  try (AutoCloseable locker = java_api.GILLocker()) {
     ... Do your python stuff.
   }
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L334">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L351">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L369">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via <code>getAttr</code>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L452">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>. Note that the keyword option arguments can be provided by using strings so <code>:library-path</code> 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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L291">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program. In that case the system will look for the python symbols in the current executable. See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L305">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+</code></pre>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L334">view source</a></div></div><div class="public anchor" id="var--hasAttr"><h3>-hasAttr</h3><div class="usage"><code>(-hasAttr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Returns true if this python object has this attribute.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L351">view source</a></div></div><div class="public anchor" id="var--hasItem"><h3>-hasItem</h3><div class="usage"><code>(-hasItem pyobj itemName)</code></div><div class="doc"><div class="markdown"><p>Return true if this pyobj has this item</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L369">view source</a></div></div><div class="public anchor" id="var--importModule"><h3>-importModule</h3><div class="usage"><code>(-importModule modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module.  Module entries can be accessed via <code>getAttr</code>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L452">view source</a></div></div><div class="public anchor" id="var--initialize"><h3>-initialize</h3><div class="usage"><code>(-initialize options)</code></div><div class="doc"><div class="markdown"><p>See options for <a href="libpython-clj2.python.html#var-initialize.21">libpython-clj2.python/initialize!</a>.  Note that the keyword
+option arguments can be provided by using strings so <code>:library-path</code> 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.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L291">view source</a></div></div><div class="public anchor" id="var--initializeEmbedded"><h3>-initializeEmbedded</h3><div class="usage"><code>(-initializeEmbedded)</code></div><div class="doc"><div class="markdown"><p>Initialize python when this library is being called <em>from</em> a python program.  In
+that case the system will look for the python symbols in the current executable.
+See the <a href="https://clj-python.github.io/libpython-clj/embedded.html">embedded topic</a></p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L305">view source</a></div></div><div class="public anchor" id="var--lockGIL"><h3>-lockGIL</h3><div class="usage"><code>(-lockGIL)</code></div><div class="doc"><div class="markdown"><p>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.</p>
 <p>See documentation for <a href="https://docs.python.org/3/c-api/init.html#c.PyGILState_Ensure">pyGILState_Ensure</a>.</p>
-<p>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.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L314">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
-<pre><code class="java">  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
+<p>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.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L314">view source</a></div></div><div class="public anchor" id="var--makeFastcallable"><h3>-makeFastcallable</h3><div class="usage"><code>(-makeFastcallable item)</code></div><div class="doc"><div class="markdown"><p>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.</p>
+<pre><code class="language-java">  try (AutoCloseable fastcaller = java_api.makeFastcallable(pycallable)) {
      tightloop: {
        java_api.call(fastcaller, arg1, arg2);
      }
   }
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L534">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
+</code></pre>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L534">view source</a></div></div><div class="public anchor" id="var--runStringAsFile"><h3>-runStringAsFile</h3><div class="usage"><code>(-runStringAsFile strdata)</code></div><div class="doc"><div class="markdown"><p>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
+<a href="https://docs.python.org/3/library/functions.html#exec">exec</a> all.</p>
 <p>The global context is returned as a java map.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
-<pre><code class="java">   Map globals = java_api.runStringAsFile("def calcSpread(bid,ask):
+<pre><code class="language-java">   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
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L427">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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  <a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
+</code></pre>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L427">view source</a></div></div><div class="public anchor" id="var--runStringAsInput"><h3>-runStringAsInput</h3><div class="usage"><code>(-runStringAsInput strdata)</code></div><div class="doc"><div class="markdown"><p>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
+<a href="https://docs.python.org/3/library/functions.html#eval">eval</a> call.</p>
 <p>This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
 <p>Example:</p>
-<pre><code class="java">  java_api.setGlobal("bid", 1);
+<pre><code class="language-java">  java_api.setGlobal("bid", 1);
   java_api.setGlobal("ask", 2);
   java_api.runStringAsInput("bid-ask"); //Returns -1
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L404">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. This corresponds to the <code>__setattr</code> python call.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L363">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict. This function expects the GIL to be locked - it will not lock/unlock it for you.</p>
-<p>In addition to numbers and strings, this method can take an implementation of <code>clojure.lang.IFn</code> that will be converted to a python callable, arrays and lists will be converted to python lists. If you would like numpy arrays use <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L385">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L380">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL. Each call to lockGIL must be paired to a call to unlockGIL.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L327">view source</a></div></div></div></body></html>
\ No newline at end of file
+</code></pre>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L404">view source</a></div></div><div class="public anchor" id="var--setAttr"><h3>-setAttr</h3><div class="usage"><code>(-setAttr pyobj attname objval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object.  This corresponds to the <code>__setattr</code> python call.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L363">view source</a></div></div><div class="public anchor" id="var--setGlobal"><h3>-setGlobal</h3><div class="usage"><code>(-setGlobal varname varval)</code></div><div class="doc"><div class="markdown"><p>Set a value in the global dict.  This function expects the GIL to be locked - it will
+not lock/unlock it for you.</p>
+<p>In addition to numbers and strings, this method can take an implementation of
+<code>clojure.lang.IFn</code> that will be converted to a python callable, arrays and lists
+will be converted to python lists.  If you would like numpy arrays use <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L385">view source</a></div></div><div class="public anchor" id="var--setItem"><h3>-setItem</h3><div class="usage"><code>(-setItem pyobj itemName itemVal)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L380">view source</a></div></div><div class="public anchor" id="var--unlockGIL"><h3>-unlockGIL</h3><div class="usage"><code>(-unlockGIL gilstate)</code></div><div class="doc"><div class="markdown"><p>Unlock the gil passing in the gilstate returned from lockGIL.  Each call to lockGIL must
+be paired to a call to unlockGIL.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/java_api.clj#L327">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 5e704d8..c8b3297 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,8 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure. This library dynamically finds the installed  python, loads the shared library and allows Clojure users to use Python modules  as if they were Clojure namespaces.</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+python, loads the shared library and allows Clojure users to use Python modules
+as if they were Clojure namespaces.</p>
 <p>Example:</p>
-<pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
+<pre><code class="language-clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
 user&gt; (py/initialize!)
 ;;  ... (logging)
@@ -12,11 +14,43 @@
 user&gt; (py/py. np linspace 2 3 :num 10)
 [2.         2.11111111 2.22222222 2.33333333 2.44444444 2.55555556
  2.66666667 2.77777778 2.88888889 3.        ]
-</code></pre></div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime. The attr name can be a symbol.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L551">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs. Keywords must be compile time constants. So this won’t work with ‘apply’. On the other hand, building the positional and kw argmaps happens at compile time as opposed to at runtime.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L562">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L266">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L360">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L348">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L354">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L254">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module. This can create a module if it doesn’t exist.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L168">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L494">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L272">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L284">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it’s items</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L278">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L260">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L331">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object. Arguments are passed in positionally. Any keyword arguments are paired with the next arg, gathered, and passed into the system as *kwargs.</p>
-<p>Not having an argument after a keyword argument is an error.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object. Any callable values in the cls-hashmap  will be presented as instance methods. If you want access to the  ‘this’ object then you must use <code>make-instance-fn</code>.</p>
+</code></pre>
+</div></div><div class="public anchor" id="var-.24a"><h3>$a</h3><h4 class="type">macro</h4><div class="usage"><code>($a item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object using automatic detection of the python kwargs.
+Keywords must be compile time constants.  So this won't work with 'apply'.  On the
+other hand, building the positional and kw argmaps happens at compile time as
+opposed to at runtime.  The attr name can be a symbol.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L551">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs.
+Keywords must be compile time constants.  So this won't work with 'apply'.  On the
+other hand, building the positional and kw argmaps happens at compile time as
+opposed to at runtime.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L562">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L266">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L360">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L348">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L354">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L254">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module.  This can create a module if it doesn't exist.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L168">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object.
+Arguments are passed in positionally.  Any keyword
+arguments are paired with the next arg, gathered, and passed into the
+system as *kwargs.</p>
+<p>Not having an argument after a keyword is an error.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L494">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L272">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L284">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it's items</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L278">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L260">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L331">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object.
+Arguments are passed in positionally.  Any keyword
+arguments are paired with the next arg, gathered, and passed into the
+system as *kwargs.</p>
+<p>Not having an argument after a keyword argument is an error.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
+will be presented as instance methods.  If you want access to the
+'this' object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
-<pre><code class="clojure">user&gt; (require '[libpython-clj2.python :as py])
+<pre><code class="language-clojure">user&gt; (require '[libpython-clj2.python :as py])
 nil
 user&gt; (def cls-obj (py/create-class
                     "myfancyclass"
@@ -38,9 +72,11 @@
 #'user/inst
 user&gt; (py/call-attr inst "addarg" 10)
 20
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L448">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs. Useful when trying to match Python  idioms - this is definitely not idiomatic Clojure.</p>
+</code></pre>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L448">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs.  Useful when trying to match Python
+idioms - this is definitely not idiomatic Clojure.</p>
 <p>Example:</p>
-<pre><code class="clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
+<pre><code class="language-clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
 #'user/c
 user&gt; a
 1
@@ -48,25 +84,58 @@
 2
 user&gt; c
 3
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L724">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L202">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>getitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L222">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item. Calls <strong>hasitem</strong>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L241">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var. Documentation is included.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L296">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module. Module entries can be accessed via get-attr.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L158">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library. If library path is not provided, then the system attempts to execute a simple python program and have python return system info.</p>
-<p>Returns either <code>:ok</code> in which case the initialization completed successfully or <code>:already-initialized</code> in which case we detected that python has already been initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
+</code></pre>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L724">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python.
+Documentation is included.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L202">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using  <strong>getitem</strong></p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L222">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item.  Calls <strong>hasitem</strong>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L241">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var.  Documentation is included.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L296">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module.  Module entries can be accessed via get-attr.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L158">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library.  If library path is not provided, then the system
+attempts to execute a simple python program and have python return system info.</p>
+<p>Returns either <code>:ok</code> in which case the initialization completed successfully or
+<code>:already-initialized</code> in which case we detected that python has already been
+initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
 <p>Options:</p>
 <ul>
-  <li><code>:library-path</code> - Library path of the python library to use.</li>
-  <li><code>:program-name</code> - Optional – will show up in error messages from python.</li>
-  <li><code>:no-io-redirect?</code> - True if you don’t want python stdout and stderr redirection  to <em>out</em> and <em>err</em>.</li>
-  <li><code>:python-executable</code> - The python executable to use to find system information.</li>
-  <li><code>:python-home</code> - Python home directory. The system first uses this variable, then  the environment variable PYTHON_HOME, and finally information returned from  python system info.</li>
-  <li><code>:signals?</code> - defaults to false - true if you want python to initialized signals.  Be aware that the JVM itself uses quite a few signals - SIGSEGV, for instance -  during it’s normal course of operation. For more information see:
-    <ul>
-      <li><a href="https://docs.oracle.com/javase/10/troubleshoot/handle-signals-and-exceptions.htm#JSTGD356">used signals</a></li>
-      <li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
-    </ul>
-  </li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls. Note that arguments are reversed as compared to <code>instance?</code></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L319">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function. This is called for you  if you use <code>as-python</code> on an implementation of IFn.</p>
-<p>Options:  * <code>:arg-converter</code> - Function called for each function argument before your ifn  gets access to it. Defaults to <code>-&gt;jvm</code>.  * <code>:result-converter</code> - Function called on return value before it gets returned to  python. Must return a python object. Defaults to <code>-&gt;python</code>; the result will  get an extra incref before being returned to Python to account for the implied  tracking of <code>as-python</code> or <code>-&gt;python</code>.  * <code>:name</code> - Name of the python method. This will appear in stack traces.  * <code>:doc</code> - documentation for method.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L399">view source</a></div></div><div class="public anchor" id="var-make-fastcallable"><h3>make-fastcallable</h3><div class="usage"><code>(make-fastcallable item)</code></div><div class="doc"><div class="markdown"><p>Wrap a python callable such that calling it in a tight loop with purely positional  arguments is a bit (2x-3x) faster.</p>
+<li><code>:library-path</code> - Library path of the python library to use.</li>
+<li><code>:program-name</code> - Optional -- will show up in error messages from python.</li>
+<li><code>:no-io-redirect?</code> - True if you don't want python stdout and stderr redirection
+to <em>out</em> and <em>err</em>.</li>
+<li><code>:python-executable</code> - The python executable to use to find system information.</li>
+<li><code>:python-home</code> - Python home directory.  The system first uses this variable, then
+the environment variable PYTHON_HOME, and finally information returned from
+python system info.</li>
+<li><code>:signals?</code> - defaults to false - true if you want python to initialized signals.
+Be aware that the JVM itself uses quite a few signals - SIGSEGV, for instance -
+during it's normal course of operation.  For more information see:
+<ul>
+<li><a href="https://docs.oracle.com/javase/10/troubleshoot/handle-signals-and-exceptions.htm#JSTGD356">used signals</a></li>
+<li><a href="https://docs.oracle.com/javase/8/docs/technotes/guides/vm/signal-chaining.html">signal-chaining</a></li>
+</ul>
+</li>
+</ul>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls.  Note that arguments
+are reversed as compared to <code>instance?</code></p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L319">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function.  This is called for you
+if you use <code>as-python</code> on an implementation of IFn.</p>
+<p>Options:</p>
+<ul>
+<li><code>:arg-converter</code> - Function called for each function argument before your ifn
+gets access to it.  Defaults to <code>-&gt;jvm</code>.</li>
+<li><code>:result-converter</code> - Function called on return value before it gets returned to
+python.  Must return a python object.  Defaults to <code>-&gt;python</code>; the result will
+get an extra incref before being returned to Python to account for the implied
+tracking of <code>as-python</code> or <code>-&gt;python</code>.</li>
+<li><code>:name</code> - Name of the python method.  This will appear in stack traces.</li>
+<li><code>:doc</code> - documentation for method.</li>
+</ul>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L399">view source</a></div></div><div class="public anchor" id="var-make-fastcallable"><h3>make-fastcallable</h3><div class="usage"><code>(make-fastcallable item)</code></div><div class="doc"><div class="markdown"><p>Wrap a python callable such that calling it in a tight loop with purely positional
+arguments is a bit (2x-3x) faster.</p>
 <p>Example:</p>
-<pre><code class="clojure">user&gt; (def test-fn (-&gt; (py/run-simple-string "def spread(bid,ask):
+<pre><code class="language-clojure">user&gt; (def test-fn (-&gt; (py/run-simple-string "def spread(bid,ask):
 	return bid-ask
 
 ")
@@ -95,26 +164,104 @@
 
 "Elapsed time: 35.492965 msecs"
 nil
-</code></pre></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L505">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the ‘this’ object as it’s first argument. In addition, this function calls <code>make-callable</code> with a <code>arg-converter</code> defaulted to <code>as-jvm</code>. See documentation for [[libpython-clj2.python.class/make-instance-fn.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L423">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments, the positional argument vector and a map of keyword arguments. Results are marshalled back to python using <a href="null">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also used when bridging an object into python. See documentation for <a href="null">libpython-clj2.python.class/make-kw-instance-fn</a>.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L432">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as “builtins” or “builtins.list”, load the module or the class object in the module.</p>
+</code></pre>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L505">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the 'this'
+object as it's first argument.  In addition, this function calls <code>make-callable</code>
+with a <code>arg-converter</code> defaulted to <code>as-jvm</code>.  See documentation for
+[[libpython-clj2.python.class/make-instance-fn.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L423">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments,
+the positional argument vector and a map of keyword arguments.  Results are marshalled
+back to python using <a href="libpython-clj2.python.fn-bridged-fn-arg--python">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also
+used when bridging an object into python.  See documentation for
+<a href="libpython-clj2.python.class-make-kw-instance-fn">libpython-clj2.python.class/make-kw-instance-fn</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L432">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as "builtins" or "builtins.list", load the module or
+the class object in the module.</p>
 <p>Options:</p>
 <ul>
-  <li><code>:reload</code> - Reload the module.</li>
-</ul></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L699">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments to methods.</p>
+<li><code>:reload</code> - Reload the module.</li>
+</ul>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L699">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments
+to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
 <p>Example:</p>
-<p>(def d (python/dict)) d ;;=&gt; {} (def iterable <a href="null">:a 1] [:b 2</a>) (def kwargs {:cat “dog” :name “taco”}) (py* d update [iterable] kwargs) d ;;=&gt; {“a”: 1, “b”: 2, “cat”: “dog”, “name”: “taco”}</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L588">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L610">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax. (py. obj method arg1 arg2 … argN) is equivalent to Python’s obj.method(arg1, arg2, …, argN) syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L579">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax. (py.- obj attr) is equivalent to Python’s obj.attr syntax.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L572">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
-<p>(require-python ’sys) (py.. sys -path (append “/home/user/bin”))</p>
-<p>is equivalent to Python’s</p>
-<p>import sys sys.path.append(‘/home/user/bin’)</p>
+<p>(def d (python/dict))
+d ;;=&gt; {}
+(def iterable [<a href=":a 1">:a 1</a> <a href=":b 2">:b 2</a>])
+(def kwargs {:cat "dog" :name "taco"})
+(py* d  update <a href="iterable">iterable</a> kwargs)
+d ;;=&gt; {"a": 1, "b": 2, "cat": "dog", "name": "taco"}</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L588">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L610">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
+is equivalent to Python's obj.method(arg1, arg2, ..., argN) syntax.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L579">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax.  (py.- obj attr) is equivalent to
+Python's obj.attr syntax.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L572">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+<p>(require-python 'sys)
+(py.. sys -path (append "/home/user/bin"))</p>
+<p>is equivalent to Python's</p>
+<p>import sys
+sys.path.append('/home/user/bin')</p>
 <p>SPECIAL SYNTAX for programmatic *args and **kwargs</p>
-<p>Special syntax is provided to meet the needs required by Python’s *args and **kwargs syntax programmatically.</p>
-<p>(= (py.. obj (*method args))  (py* obj methods args))</p>
-<p>(= (py.. obj (*method args kwargs))  (py* obj method args kwargs))</p>
-<p>(= (py.. obj (**method kwargs))  (py** obj method kwargs))</p>
-<p>(= (py.. obj (**method arg1 arg2 arg3 … argN kwargs))  (py** obj method arg1 arg2 arg3 … argN kwargs)  (py* obj method [arg1 arg2 arg3 … argN] kwargs))</p>
-<p>These forms exist for when you need to pass in a map of options in the same way you would use the f(*args, **kwargs) forms in Python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L645">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L290">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of {:globals :locals}. This uses the global <strong>main</strong> dict under the covers so it matches the behavior of the cpython implementation with the exception of returning the various maps used.</p>
-<p>Note this will never return the result of the expression: <a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
+<p>Special syntax is provided to meet the needs required by
+Python's *args and **kwargs syntax programmatically.</p>
+<p>(= (py.. obj (<em>method args))
+(py</em> obj methods args))</p>
+<p>(= (py.. obj (<em>method args kwargs))
+(py</em> obj method args kwargs))</p>
+<p>(= (py.. obj (<strong>method kwargs))
+(py</strong> obj method kwargs))</p>
+<p>(= (py.. obj (<strong>method arg1 arg2 arg3 ... argN kwargs))
+(py</strong> obj method arg1 arg2 arg3 ... argN kwargs)
+(py*  obj method <a href="arg1 arg2 arg3 ... argN">arg1 arg2 arg3 ... argN</a> kwargs))</p>
+<p>These forms exist for when you need to pass in a map of options
+in the same way you would use the f(*args, **kwargs) forms in
+Python.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L645">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L290">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of
+{:globals :locals}.
+This uses the global <strong>main</strong> dict under the covers so it matches the behavior
+of the cpython implementation with the exception of returning the various maps
+used.</p>
+<p>Note this will never return the result of the expression:
+<a href="https://mail.python.org/pipermail/python-list/1999-April/018011.html">https://mail.python.org/pipermail/python-list/1999-April/018011.html</a></p>
 <p>Globals, locals may be provided but are not necessary.</p>
 <p>Implemented in cpython as:</p>
-<p>PyObject *m, *d, *v;  m = PyImport_AddModule(“<strong>main</strong>”);  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;</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L366">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L208">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value] attributes. Returns pyobj.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L215">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using <strong>setitem</strong></p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of [name value]. Returns pyobj</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context. All python objects allocated within this context will be released at the termination of this context. !!This means that no python objects can escape from this context!! You must use copy semantics (-&gt;jvm) for anything escaping this context. Furthermore, if you are returning generic python objects you may need to call (into {}) or something like that just to ensure that absolutely everything is copied into the jvm.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L114">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the ‘with’ statement in python: (py/with [item (py/call-attr testcode-module “WithObjClass” true fn-list)]  (py/call-attr item “doit_err”))</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L543">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time. This can greatly speed up operations as the mutex is captured and held once as opposed to find grained grabbing/releasing of the mutex.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L127">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context. The resource context is released before the gil is leading to much faster resource collection. See documentation on <code>stack-resource-context</code> for multiple warnings; the most important one being that if a python object escapes this context your program will eventually, at some undefined point in the future crash. That being said, this is the recommended pathway to use in production contexts where you want defined behavior and timings related to use of python.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L136">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>PyObject *m, *d, *v;
+m = PyImport_AddModule("<strong>main</strong>");
+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;</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L366">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object.  Returns pyobj.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L208">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a> attributes.  Returns pyobj.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L215">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using  <strong>setitem</strong></p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a>. Returns pyobj</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context.  All python objects allocated within this
+context will be released at the termination of this context.
+!!This means that no python objects can escape from this context!!
+You must use copy semantics (-&gt;jvm) for anything escaping this context.
+Furthermore, if you are returning generic python objects you may need
+to call (into {}) or something like that just to ensure that absolutely
+everything is copied into the jvm.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L114">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the 'with' statement in python:
+(py/with <a href="item (py/call-attr testcode-module &quot;WithObjClass&quot; true fn-list)">item (py/call-attr testcode-module "WithObjClass" true fn-list)</a>
+(py/call-attr item "doit_err"))</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L543">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time.  This can greatly speed up
+operations as the mutex is captured and held once as opposed to find grained
+grabbing/releasing of the mutex.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L127">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context.  The resource context is released
+before the gil is leading to much faster resource collection.  See documentation
+on <code>stack-resource-context</code> for multiple warnings; the most important one being
+that if a python object escapes this context your program will eventually, at
+some undefined point in the future crash.  That being said, this is the recommended
+pathway to use in production contexts where you want defined behavior and timings
+related to use of python.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L136">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 9af09e0..654904e 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,4 +1,9 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system. This allows seamless usage of numpy arrays in datatype and tensor functionality such as enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays – using zero copying when possible.</p>
-<p>All users need to do is call require this namespace; then as-jvm will convert a numpy array into a tech tensor in-place.</p></div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+allows seamless usage of numpy arrays in datatype and tensor functionality such as
+enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
+zero copying when possible.</p>
+<p>All users need to do is call require this namespace; then as-jvm will convert a numpy
+array into a tech tensor in-place.</p>
+</div></div><div class="public anchor" id="var-datatype-.3Eptr-type-name"><h3>datatype-&gt;ptr-type-name</h3><div class="usage"><code>(datatype-&gt;ptr-type-name dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L135">view source</a></div></div><div class="public anchor" id="var-descriptor-.3Enumpy"><h3>descriptor-&gt;numpy</h3><div class="usage"><code>(descriptor-&gt;numpy {:keys [ptr shape strides elemwise-datatype], :as buffer-desc})</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L150">view source</a></div></div><div class="public anchor" id="var-dtype-.3Epy-dtype-map"><h3>dtype-&gt;py-dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L37">view source</a></div></div><div class="public anchor" id="var-numpy-.3Edesc"><h3>numpy-&gt;desc</h3><div class="usage"><code>(numpy-&gt;desc np-obj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L55">view source</a></div></div><div class="public anchor" id="var-obj-dtype-.3Edtype"><h3>obj-dtype-&gt;dtype</h3><div class="usage"><code>(obj-dtype-&gt;dtype py-dtype)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L41">view source</a></div></div><div class="public anchor" id="var-py-dtype-.3Edtype-map"><h3>py-dtype-&gt;dtype-map</h3><div class="usage"></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/np_array.clj#L25">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 3b3bddd..3bc1ba6 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,32 +1,67 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces. This works via scanning the module for metadata and dynamically building the Clojure namespace.</p></div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple, and python.frozenset.</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2><a href="#basic-usage" name="basic-usage"></a>Basic usage</h2>
-<p>(require-python ’math) (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
-<p>(require-python ’[math :as maaaath])</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+scanning the module for metadata and dynamically building the Clojure namespace.</p>
+</div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
+and python.frozenset.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2>Basic usage</h2>
+<p>(require-python 'math)
+(math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
+<p>(require-python '<a href="math :as maaaath">math :as maaaath</a>)</p>
 <p>(maaaath/sin 1.0) ;;=&gt; 0.8414709848078965</p>
-<p>(require-python ‘math ‘csv) (require-python ’[math :as pymath] ‘csv)) (require-python ’[math :as pymath] ’[csv :as py-csv]) (require-python ‘concurrent.futures) (require-python ’[concurrent.futures :as fs]) (require-python ’(concurrent [futures :as fs]))</p>
-<p>(require-python ’[requests :refer [get post]])</p>
-<p>(requests/get “https//www.google.com”) ;;=&gt; &lt;Response [200]&gt; (get “https//www.google.com”) ;;=&gt; &lt;Response [200]&gt;</p>
-<p>In some cases we may generate invalid arglists metadata for the clojure compiler. In those cases we have a flag, :no-arglists that will disable adding arglists to the generated metadata for the vars. Use the reload flag below if you need to force reload a namespace where invalid arglists have been generated.</p>
-<p>(require-python ’[numpy :refer [linspace] :no-arglists :as np])</p>
-<p>If you would like to bind the Python module to the namespace, use the :bind-ns flag.</p>
-<p>(require-python ‘[requests :bind-ns true]) or (require-python ’[requests :bind-ns])</p>
-<h2><a href="#use-with-custom-modules" name="use-with-custom-modules"></a>Use with custom modules</h2>
-<p>For use with a custom namespace foo.py while developing, you can use:</p>
-<p>(require-python ’[foo :reload])</p>
-<p>NOTE: unless you specify the :reload flag,  ..: the module will NOT reload. If the :reload flag is set,  ..: the behavior mimics importlib.reload</p>
-<h2><a href="#setting-up-classpath-for-custom-modules" name="setting-up-classpath-for-custom-modules"></a>Setting up classpath for custom modules</h2>
-<p>Note: you may need to setup your PYTHONPATH correctly. One technique to do this is, if your foo.py lives at /path/to/foodir/foo.py:</p>
-<p>(require-python ’sys) (py/call-attr (py/get-attr sys “path”)  “append”  “/path/to/foodir”)</p>
+<p>(require-python 'math 'csv)
+(require-python '<a href="math :as pymath">math :as pymath</a> 'csv))
+(require-python '<a href="math :as pymath">math :as pymath</a> '<a href="csv :as py-csv">csv :as py-csv</a>)
+(require-python 'concurrent.futures)
+(require-python '<a href="concurrent.futures :as fs">concurrent.futures :as fs</a>)
+(require-python '(concurrent <a href="futures :as fs">futures :as fs</a>))</p>
+<p>(require-python '[requests :refer <a href="get post">get post</a>])</p>
+<p>(requests/get "https//<a href="http://www.google.com">www.google.com</a>") ;;=&gt;  &lt;Response <a href="200">200</a>&gt;
+(get "https//<a href="http://www.google.com">www.google.com</a>") ;;=&gt;  &lt;Response <a href="200">200</a>&gt;</p>
+<p>In some cases we may generate invalid arglists metadata for the clojure compiler.
+In those cases we have a flag, :no-arglists that will disable adding arglists to
+the generated metadata for the vars.  Use the reload flag below if you need to
+force reload a namespace where invalid arglists have been generated.</p>
+<p>(require-python '[numpy :refer <a href="linspace">linspace</a> :no-arglists :as np])</p>
+<p>If you would like to bind the Python module to the namespace, use
+the :bind-ns flag.</p>
+<p>(require-python '<a href="requests :bind-ns true">requests :bind-ns true</a>) or
+(require-python '<a href="requests :bind-ns">requests :bind-ns</a>)</p>
+<h2>Use with custom modules</h2>
+<p>For use with a custom namespace foo.py while developing, you can
+use:</p>
+<p>(require-python '<a href="foo :reload">foo :reload</a>)</p>
+<p>NOTE: unless you specify the :reload flag,
+..: the module will NOT reload.  If the :reload flag is set,
+..: the behavior mimics importlib.reload</p>
+<h2>Setting up classpath for custom modules</h2>
+<p>Note: you may need to setup your PYTHONPATH correctly.
+One technique to do this is, if your foo.py lives at
+/path/to/foodir/foo.py:</p>
+<p>(require-python 'sys)
+(py/call-attr (py/get-attr sys "path")
+"append"
+"/path/to/foodir")</p>
 <p>Another option is</p>
-<p>(require-python ’os) (os/chdir “/path/to/foodir”)</p>
-<h2><a href="#prefix-lists" name="prefix-lists"></a>prefix lists</h2>
-<p>For convenience, if you are loading multiple Python modules with the same prefix, you can use the following notation:</p>
-<p>(require-python ’(a b c)) is equivalent to (require-python ’a.b ’a.c)</p>
-<p>(require-python ‘(foo [bar :as baz :refer [qux]])) is equivalent to (require-python ’[foo.bar :as baz :refer [qux]])</p>
-<p>(require-python ‘(foo [bar :as baz :refer [qux]] buster)) (require-python ’[foo.bar :as baz :refer [qux]] ’foo.buster))</p>
-<h2><a href="#for-library-developers" name="for-library-developers"></a>For library developers</h2>
-<p>If you want to intern all symbols to your current namespace, you can do the following –</p>
-<p>(require-python ’[math :refer :all])</p>
-<p>However, if you only want to use those things designated by the module under the <strong>all</strong> attribute, you can do</p>
-<p>(require-python ’[operators :refer :*])</p></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L173">view source</a></div></div></div></body></html>
\ No newline at end of file
+<p>(require-python 'os)
+(os/chdir "/path/to/foodir")</p>
+<h2>prefix lists</h2>
+<p>For convenience, if you are loading multiple Python modules
+with the same prefix, you can use the following notation:</p>
+<p>(require-python '(a b c))
+is equivalent to
+(require-python 'a.b 'a.c)</p>
+<p>(require-python '(foo [bar :as baz :refer <a href="qux">qux</a>]))
+is equivalent to
+(require-python '[foo.bar :as baz :refer <a href="qux">qux</a>])</p>
+<p>(require-python '(foo [bar :as baz :refer <a href="qux">qux</a>] buster))
+(require-python '[foo.bar :as baz :refer <a href="qux">qux</a>] 'foo.buster))</p>
+<h2>For library developers</h2>
+<p>If you want to intern all symbols to your current namespace,
+you can do the following --</p>
+<p>(require-python '<a href="math :refer :all">math :refer :all</a>)</p>
+<p>However, if you only want to use
+those things designated by the module under the <strong>all</strong> attribute,
+you can do</p>
+<p>(require-python '<a href="operators :refer :*">operators :refer :*</a>)</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L173">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 4889a63..d96d169 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,49 +1,116 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#so-many-parenthesis-" name="so-many-parenthesis-"></a>So Many Parenthesis!</h1>
-<h2><a href="#about-clojure" name="about-clojure"></a>About Clojure</h2>
-<p>LISP stands for List Processing and it was originally designed by John McCarthy around 1958. It was the first language with a garbage collector making it the first truly high level language assuming you don’t consider Fortran a high level language. Here is Dr. McCarthy’s <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a> and for a much better intro than I can give please see <a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
-<p>Time passed and along came a man named Rich Hickey. Making a long story short, Rich was working in a variety of languages such as C++, Java, and C# when he did a project in Common Lisp and was hooked. There are many YouTube videos and documents that Rich has produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a> is one I found very compelling. If you enjoy that video, don’t stop there; Rich has many interesting, profound, and sometimes provocative things to add to the conversation. For more about his reasoning behind Clojure, please check out his <a href="https://clojure.org/about/rationale">rationale</a>. </p>
-<p>My perspective is closer to <a href="http://blog.cleancoder.com/uncle-bob/2019/08/22/WhyClojure.html">Uncle Bob’s</a>. </p>
-<p>To address the parenthesis, we need to talk about <a href="https://en.wikipedia.org/wiki/Homoiconicity">homoiconicity</a>. LISPs are part of a subset of languages that build themselves out of their own data structures so that when you type symbols into a file or repl, you get back a data structure of the language itself. This means that several parts of the programmers toolbox can be simpler and you can load a file as data, transform it, and then execute some portion of it all without leaving the language. This isn’t something you will really need to understand today, but the point is that the look and structure of the language is a sweet spot to make it more of middle ground between what a human and a machine can understand.</p>
-<p>The fallout from having a language that is both a language and a data structure is that you can extend the language without needing to change the compiler. For example, the very first standardized ‘object oriented programming’ system was <a href="https://en.wikipedia.org/wiki/Common_Lisp_Object_System">CLOS</a>, or Common Lisp Object System. This was implemented on top of Common Lisp with no updates to the compiler whatsoever. In Clojure, we have been able to add things like an <a href="https://github.com/clojure/core.async">async library</a> or <a href="https://clojure.org/reference/refs">software transactional memory</a> without changing the compiler itself because we can extend or change the language quite substantially at compile time.</p>
-<p>Clojure is a deeply functional language with pragmatic pathways built for mutation. All of the basic data structures of Clojure are immutable. Learning to program in a functional manner will mean learning things like <code>map</code> and <code>reduce</code> and basically re-wiring how you think about problems. I believe it is this re-wiring that is most beneficial in the long term regardless of whether you become some functional programming God or just dabble for a while.</p>
-<p>Many systems, regardless of language, are designed in a functional manner because properties like <a href="https://en.wikipedia.org/wiki/Idempotence">idempotency</a> and <a href="https://en.wikipedia.org/wiki/Referential_transparency">referential transparency</a> make it easier to reason about code that you didn’t write. That being said, Clojure doesn’t force you to write functional code all the time as it is mainly a pragmatic language. You can easily write mutable code if you like.</p>
-<p>For the web, Clojure has a <a href="https://clojurescript.org/">version</a> that compiles to JavaScript so that you can write one language both server and front end side. Many Clojure projects are just one repository and one artifact that when run produces both the server and client side of the equation. Another important usage of the Clojurescript is mobile application development using frameworks like <a href="https://www.upwork.com/blog/2018/11/developing-react-native-applications-in-clojurescript/">React Native</a>. Clojurescript is truly one of Clojure’s greatest strengths and one that the Clojure community has strongly embraced.</p>
-<p>No talk about Clojure would be complete without giving major credit to its excellent REPL support. One important aspect of the Clojure REPL is that you can see all of complex nested datastructures easily without needing to write <code>toString</code> or <code>__str__</code> methods. Because of this visibility advantage a common way to use Clojure is to model your problem as a transformation from datastructure to datastructure, testing each stage of this transformation in the repl and just letting the REPL printing show you the next move. Programming with data is often just easier than programming with objects and debugging data transformations is far, far easier than debugging a complex object graph.</p>
-<h2><a href="#learning-clojure" name="learning-clojure"></a>Learning Clojure</h2>
-<p>There are in fact many resources to learn Clojure and here are some the community recommends:</p>
-<h3><a href="#books-courses" name="books-courses"></a>Books/Courses</h3>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+<h2>About Clojure</h2>
+<p>LISP stands for List Processing and it was originally designed by John McCarthy
+around 1958.  It was the first language with a garbage collector making it the first
+truly high level language assuming you don't consider Fortran a high level language.
+Here is Dr. McCarthy's <a href="http://www-formal.stanford.edu/jmc/recursive.pdf">seminal paper</a>
+and for a much better intro than I can give please see
+<a href="http://www.paulgraham.com/rootsoflisp.html">here</a>.</p>
+<p>Time passed and along came a man named Rich Hickey.  Making a long story short, Rich was
+working in a variety of languages such as C++, Java, and C# when he did a project in
+Common Lisp and was hooked.  There are many YouTube videos and documents that Rich has
+produced but <a href="https://www.infoq.com/presentations/Simple-Made-Easy/">simple made easy</a>
+is one I found very compelling.  If you enjoy that video, don't stop there; Rich has
+many interesting, profound, and sometimes provocative things to add to the conversation.
+For more about his reasoning behind Clojure, please check out his
+<a href="https://clojure.org/about/rationale">rationale</a>.</p>
+<p>My perspective is closer to <a href="http://blog.cleancoder.com/uncle-bob/2019/08/22/WhyClojure.html">Uncle Bob's</a>.</p>
+<p>To address the parenthesis, we need to talk about
+<a href="https://en.wikipedia.org/wiki/Homoiconicity">homoiconicity</a>.  LISPs are part of a
+subset of languages that build themselves out of their own data structures so that when
+you type symbols into a file or repl, you get back a data structure of the language
+itself.  This means that several parts of the programmers toolbox can be simpler and you
+can load a file as data, transform it, and then execute some portion of it all without
+leaving the language.  This isn't something you will really need to understand today,
+but the point is that the look and structure of the language is a sweet spot to make it
+more of middle ground between what a human and a machine can understand.</p>
+<p>The fallout from having a language that is both a language and a data structure is that
+you can extend the language without needing to change the compiler.  For example, the
+very first standardized 'object oriented programming' system was
+<a href="https://en.wikipedia.org/wiki/Common_Lisp_Object_System">CLOS</a>, or Common Lisp Object
+System.  This was implemented on top of Common Lisp with no updates to the compiler
+whatsoever.  In Clojure, we have been able to add things like an
+<a href="https://github.com/clojure/core.async">async library</a> or
+<a href="https://clojure.org/reference/refs">software transactional memory</a> without changing the
+compiler itself because we can extend or change the language quite substantially at compile
+time.</p>
+<p>Clojure is a deeply functional language with pragmatic pathways built for mutation.  All
+of the basic data structures of Clojure are immutable.  Learning to program in a
+functional manner will mean learning things like <code>map</code> and <code>reduce</code> and basically
+re-wiring how you think about problems.  I believe it is this re-wiring that is most
+beneficial in the long term regardless of whether you become some functional programming
+God or just dabble for a while.</p>
+<p>Many systems, regardless of language, are designed in a functional manner because
+properties like <a href="https://en.wikipedia.org/wiki/Idempotence">idempotency</a> and
+<a href="https://en.wikipedia.org/wiki/Referential_transparency">referential transparency</a> make
+it easier to reason about code that you didn't write.  That being said, Clojure doesn't
+force you to write functional code all the time as it is mainly a pragmatic language.
+You can easily write mutable code if you like.</p>
+<p>For the web, Clojure has a <a href="https://clojurescript.org/">version</a> that compiles to
+JavaScript so that you can write one language both server and front end side.  Many
+Clojure projects are just one repository and one artifact that when run produces both
+the server and client side of the equation.  Another important usage of the
+Clojurescript is mobile application development using frameworks like
+<a href="https://www.upwork.com/blog/2018/11/developing-react-native-applications-in-clojurescript/">React Native</a>.
+Clojurescript is truly one of Clojure's greatest strengths and one that the Clojure
+community has strongly embraced.</p>
+<p>No talk about Clojure would be complete without giving major credit to its excellent
+REPL support.  One important aspect of the Clojure REPL is that you can see all of
+complex nested datastructures easily without needing to write <code>toString</code> or <code>__str__</code>
+methods.  Because of this visibility advantage a common way to use Clojure is to model
+your problem as a transformation from datastructure to datastructure, testing each stage
+of this transformation in the repl and just letting the REPL printing show you the next
+move.  Programming with data is often just easier than programming with objects and
+debugging data transformations is far, far easier than debugging a complex object graph.</p>
+<h2>Learning Clojure</h2>
+<p>There are in fact many resources to learn Clojure and here are some the community
+recommends:</p>
+<h3>Books/Courses</h3>
 <ol>
-  <li><a href="https://www.braveclojure.com/clojure-for-the-brave-and-true/">Clojure for the Brave and True</a></li>
-  <li><a href="https://practicalli.github.io/clojure/">Practicalli</a></li>
-  <li><a href="https://www.amazon.it/dp/B00YSILGWG/ref=dp-kindle-redirect?_encoding=UTF8&amp;btkr=1">Clojure for Data Science</a></li>
-  <li><a href="https://www.amazon.it/dp/B00HUEG8KK/ref=dp-kindle-redirect?_encoding=UTF8&amp;btkr=1">Functional Programming in Scala and Clojure</a></li>
+<li><a href="https://www.braveclojure.com/clojure-for-the-brave-and-true/">Clojure for the Brave and True</a></li>
+<li><a href="https://practicalli.github.io/clojure/">Practicalli</a></li>
+<li><a href="https://www.amazon.it/dp/B00YSILGWG/ref=dp-kindle-redirect?_encoding=UTF8&amp;btkr=1">Clojure for Data Science</a></li>
+<li><a href="https://www.amazon.it/dp/B00HUEG8KK/ref=dp-kindle-redirect?_encoding=UTF8&amp;btkr=1">Functional Programming in Scala and Clojure</a></li>
 </ol>
-<p>Practicalli has a page devoted purely to resources on learning Clojure at whatever level you are so if these recommendations do not speak to you please review their <a href="https://practicalli.github.io/clojure/reference/books.html">books page</a>.</p>
-<h3><a href="#learn-by-writing-code" name="learn-by-writing-code"></a>Learn by Writing Code</h3>
+<p>Practicalli has a page devoted purely to resources on learning Clojure at whatever level
+you are so if these recommendations do not speak to you please review their
+<a href="https://practicalli.github.io/clojure/reference/books.html">books page</a>.</p>
+<h3>Learn by Writing Code</h3>
 <ol>
-  <li><a href="https://github.com/functional-koans/clojure-koans">Clojure Koans</a></li>
-  <li><a href="https://github.com/lspector/clojinc">clojinc</a></li>
-  <li><a href="http://clojurescriptkoans.com/">Clojurescript Koans</a></li>
-  <li><a href="http://www.4clojure.com/">4Clojure</a></li>
+<li><a href="https://github.com/functional-koans/clojure-koans">Clojure Koans</a></li>
+<li><a href="https://github.com/lspector/clojinc">clojinc</a></li>
+<li><a href="http://clojurescriptkoans.com/">Clojurescript Koans</a></li>
+<li><a href="http://www.4clojure.com/">4Clojure</a></li>
 </ol>
-<h3><a href="#ides-editors" name="ides-editors"></a>IDEs/Editors</h3>
+<h3>IDEs/Editors</h3>
 <p>There are many more IDEs available than listed here; these ones are just very popular:</p>
 <ol>
-  <li><a href="https://marketplace.visualstudio.com/items?itemName=betterthantomorrow.calva">Calva</a></li>
-  <li><a href="https://cursive-ide.com/">Cursive</a></li>
-  <li><a href="https://medium.com/@jacekschae/slick-clojure-editor-setup-with-atom-a3c1b528b722">Atom</a></li>
-  <li><a href="https://cider.mx/">emacs + cider</a></li>
-  <li><a href="https://www.vim.org/scripts/script.php?script_id=4978">vim + fireplace</a></li>
+<li><a href="https://marketplace.visualstudio.com/items?itemName=betterthantomorrow.calva">Calva</a></li>
+<li><a href="https://cursive-ide.com/">Cursive</a></li>
+<li><a href="https://medium.com/@jacekschae/slick-clojure-editor-setup-with-atom-a3c1b528b722">Atom</a></li>
+<li><a href="https://cider.mx/">emacs + cider</a></li>
+<li><a href="https://www.vim.org/scripts/script.php?script_id=4978">vim + fireplace</a></li>
 </ol>
-<p>One thing to be sure of, regardless of IDE, is to use some form of <a href="https://shaunlebron.github.io/parinfer/">structural editing</a>. All the better IDEs have it; all the IDEs listed here have it, and I personally really struggle without it. When I have a form of <a href="https://wikemacs.org/wiki/Paredit-mode">structure editing</a>, however, I can move code around much faster than I can in Java, Python, or C++. This is another benefit of the homoiconicity that we spoke earlier in that we can transform the program easily because it is just a data structure and this includes editor level transformations and analysis.</p>
-<h2><a href="#off-we-go-" name="off-we-go-"></a>Off We Go!</h2>
-<p>Clojure is an amazing language. It is really rewarding on a personal level because it is tailored towards extremely high individual and small group productivity. But this power comes with some caveats and one of those is that learning Clojure takes time and patience. The community is here to support you, however, so check us out:</p>
+<p>One thing to be sure of, regardless of IDE, is to use some form of
+<a href="https://shaunlebron.github.io/parinfer/">structural editing</a>.  All the better IDEs
+have it; all the IDEs listed here have it, and I personally really struggle without it.
+When I have a form of <a href="https://wikemacs.org/wiki/Paredit-mode">structure editing</a>, however,
+I can move code around much faster than I can in Java, Python, or C++. This is another
+benefit of the homoiconicity that we spoke earlier in that we can transform the program easily
+because it is just a data structure and this includes editor level transformations and
+analysis.</p>
+<h2>Off We Go!</h2>
+<p>Clojure is an amazing language.  It is really rewarding on a personal level because it
+is tailored towards extremely high individual and small group productivity.  But this
+power comes with some caveats and one of those is that learning Clojure takes time and
+patience.  The community is here to support you, however, so check us out:</p>
 <ul>
-  <li><a href="https://clojurians.slack.com">Clojurians Slack</a></li>
-  <li><a href="https://clojurians.zulipchat.com/">Clojurians Zulip</a></li>
-  <li><a href="https://www.reddit.com/r/Clojure/">r/Clojure reddit</a></li>
-  <li><a href="https://www.reddit.com/r/Clojurescript/">r/Clojurescript reddit</a></li>
-  <li><a href="https://clojureverse.org/">Clojureverse</a></li>
-</ul></div></div></div></body></html>
\ No newline at end of file
+<li><a href="https://clojurians.slack.com">Clojurians Slack</a></li>
+<li><a href="https://clojurians.zulipchat.com/">Clojurians Zulip</a></li>
+<li><a href="https://www.reddit.com/r/Clojure/">r/Clojure reddit</a></li>
+<li><a href="https://www.reddit.com/r/Clojurescript/">r/Clojurescript reddit</a></li>
+<li><a href="https://clojureverse.org/">Clojureverse</a></li>
+</ul>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 8bd8244..bdb5bc4 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,9 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#scopes-and-garbage-collection" name="scopes-and-garbage-collection"></a>Scopes And Garbage Collection</h1>
-<p>libpython-clj now supports stack-based scoping rules so you can guarantee all python objects created during a section of code will be released by a certain point.</p>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+<p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
+objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
-<pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
+<pre><code class="language-clojure">user&gt; (require '[libpython-clj.python :as py])
 nil
 user&gt; (py/initialize!)
 ... (logging elided)
@@ -15,8 +16,9 @@
 {"a" 1, "b" 2}
 </code></pre>
 <p>You must either call -&gt;jvm or return a keyword at the end of your scope.</p>
-<p>In the case where you are processing a batch of items (which we recommend for perf reasons), you can also grab the GIL at the top of your thing:</p>
-<pre><code class="clojure">user&gt; (def dict-seq (py/as-jvm (py/-&gt;py-list (repeat 1000 (py/-&gt;py-dict {:a 1 :b 2})))))
+<p>In the case where you are processing a batch of items (which we recommend for perf
+reasons), you can also grab the GIL at the top of your thing:</p>
+<pre><code class="language-clojure">user&gt; (def dict-seq (py/as-jvm (py/-&gt;py-list (repeat 1000 (py/-&gt;py-dict {:a 1 :b 2})))))
 #'user/dict-seq
 
 
@@ -27,9 +29,15 @@
 "Elapsed time: 2095.815518 msecs"
 #'user/ignored
 </code></pre>
-<p>The hidden thing above, regardless of if you grab the gil or not is that you are actually holding onto a lot of python objects that could be released. Hence if you aren’t disciplined about calling System/gc or if the jvm gc just decides not to run you could be allocating a lot of native-heap objects. Plus what you don’t see is that if you call System/gc the resource thread dedicated to releasing things will have a lot of work to do.</p>
-<p>For production use cases where you need a bit more assurance that things get released, please consider both grabbing the gil <em>and</em> opening a resource context:</p>
-<pre><code class="clojure">user&gt; (def ignored (time (py/with-gil-stack-rc-context
+<p>The hidden thing above, regardless of if you grab the gil or not is that you are
+actually holding onto a lot of python objects that could be released.  Hence if you
+aren't disciplined about calling System/gc or if the jvm gc just decides not to run
+you could be allocating a lot of native-heap objects.  Plus what you don't see is
+that if you call System/gc the resource thread dedicated to releasing things will
+have a lot of work to do.</p>
+<p>For production use cases where you need a bit more assurance that things get released,
+please consider both grabbing the gil <em>and</em> opening a resource context:</p>
+<pre><code class="language-clojure">user&gt; (def ignored (time (py/with-gil-stack-rc-context
                            (-&gt;&gt; (repeatedly 1000 #(py/-&gt;py-dict {:a 1 :b 2}))
                                 (py/-&gt;py-list)
                                 (py/as-jvm)
@@ -38,5 +46,10 @@
 "Elapsed time: 3246.847595 msecs"
 #'user/ignored
 </code></pre>
-<p>This took a second longer! But, you <em>know</em> that all python objects allocated within that scope are released. Before, you would be in essence hoping that things would be released soon enough.</p>
-<p>Again, for production contexts we recommend batch processing objects <em>and</em> using the <code>with-gil-stack-rc-context</code> function call that correctly grabs the gil, opens a resource context and then releases anything allocated within that context.</p></div></div></div></body></html>
\ No newline at end of file
+<p>This took a second longer!  But, you <em>know</em> that all python objects allocated within
+that scope are released.  Before, you would be in essence hoping that things would be
+released soon enough.</p>
+<p>Again, for production contexts we recommend batch processing objects <em>and</em> using
+the <code>with-gil-stack-rc-context</code> function call that correctly grabs the gil, opens
+a resource context and then releases anything allocated within that context.</p>
+</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/slicing.html b/docs/slicing.html
index fb244a7..ba12a2f 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,9 +1,13 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.015</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1><a href="#slicing-and-slices" name="slicing-and-slices"></a>Slicing And Slices</h1>
-<p>The way Python implements slicing is via overloading the <code>get-item</code> function call. This is the call the Python interpreter makes under the covers whenever you use the square bracket <code>[]</code> syntax.</p>
-<p>For quite a few objects, that function call take a tuple of arguments. The trick to numpy slicing is to create builtin slice objects with the appropriate arguments and pass them into the <code>get-item</code> call in a tuple.</p>
-<pre><code class="clojure">user&gt; (require '[libpython-clj.python :as py])
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+<p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
+This is the call the Python interpreter makes under the covers whenever you use the
+square bracket <code>[]</code> syntax.</p>
+<p>For quite a few objects, that function call take a tuple of arguments. The trick to
+numpy slicing is to create builtin slice objects with the appropriate arguments and
+pass them into the <code>get-item</code> call in a tuple.</p>
+<pre><code class="language-clojure">user&gt; (require '[libpython-clj.python :as py])
 nil
 user&gt; (require '[libpython-clj.require :refer [require-python]])
 ... lotta logs ...
@@ -55,4 +59,5 @@
 [[1 2]
  [4 5]
  [7 8]]
-</code></pre></div></div></div></body></html>
\ No newline at end of file
+</code></pre>
+</div></div></div></body></html>
\ No newline at end of file

From e6ec1aca703fdf736ea971be22f0624190fac381 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 3 Feb 2022 15:41:42 -0700
Subject: [PATCH 396/456] Release 2.017 - fixing codegen

---
 CHANGELOG.md                                |     4 +
 codegen-test/README.md                      |    19 +
 codegen-test/deps.edn                       |     2 +
 codegen-test/src/code/codegen.clj           |     9 +
 codegen-test/src/code/main.clj              |    21 +
 codegen-test/src/python/numpy.clj           | 29449 ++++++++++++++++++
 deps.edn                                    |     7 +-
 docs/Usage.html                             |     2 +-
 docs/design.html                            |     2 +-
 docs/embedded.html                          |     2 +-
 docs/environments.html                      |     2 +-
 docs/index.html                             |     2 +-
 docs/libpython-clj2.codegen.html            |     4 +-
 docs/libpython-clj2.embedded.html           |     2 +-
 docs/libpython-clj2.java-api.html           |     2 +-
 docs/libpython-clj2.python.html             |     2 +-
 docs/libpython-clj2.python.np-array.html    |     2 +-
 docs/libpython-clj2.require.html            |     2 +-
 docs/new-to-clojure.html                    |     2 +-
 docs/scopes-and-gc.html                     |     2 +-
 docs/slicing.html                           |     2 +-
 scripts/install                             |     6 +
 src/libpython_clj2/codegen.clj              |     9 +-
 src/libpython_clj2/python/bridge_as_jvm.clj |   200 +-
 24 files changed, 29634 insertions(+), 122 deletions(-)
 create mode 100644 codegen-test/README.md
 create mode 100644 codegen-test/deps.edn
 create mode 100644 codegen-test/src/code/codegen.clj
 create mode 100644 codegen-test/src/code/main.clj
 create mode 100644 codegen-test/src/python/numpy.clj
 create mode 100755 scripts/install

diff --git a/CHANGELOG.md b/CHANGELOG.md
index caf2501..dd517dd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,8 @@
 # Time for a ChangeLog!
+## 2.017
+ * Tested AOT and codegen of numpy namespace to ensure it is loadable and works as expected.
+ * This fixed an issue with the codegen system.
+
 ## 2.016
  * Upgrade dtype-next to latest version.  This version of dtype-next comes with it's own
    java-api so you can integrate deeper into the zero-copy pathways.
diff --git a/codegen-test/README.md b/codegen-test/README.md
new file mode 100644
index 0000000..76ff4b0
--- /dev/null
+++ b/codegen-test/README.md
@@ -0,0 +1,19 @@
+# Codegen Sample
+
+A quick sample testing intended codegen usage.
+
+
+## Usage
+
+We first generate the numpy namespace with a compile step.
+
+```console
+scripts/compile
+```
+
+Next we run the compiled code from an AOT'd main.
+
+
+```console
+scripts/run
+```
diff --git a/codegen-test/deps.edn b/codegen-test/deps.edn
new file mode 100644
index 0000000..d6099f7
--- /dev/null
+++ b/codegen-test/deps.edn
@@ -0,0 +1,2 @@
+{:paths ["src"]
+ :deps {clj-python/libpython-clj {:mvn/version "2.017"}}}
diff --git a/codegen-test/src/code/codegen.clj b/codegen-test/src/code/codegen.clj
new file mode 100644
index 0000000..d9a476f
--- /dev/null
+++ b/codegen-test/src/code/codegen.clj
@@ -0,0 +1,9 @@
+(ns code.codegen
+  (:require [libpython-clj2.python :as py]
+            [libpython-clj2.codegen :as cgen]))
+
+
+(defn codegen
+  []
+  (py/initialize!)
+  (cgen/write-namespace! "numpy"))
diff --git a/codegen-test/src/code/main.clj b/codegen-test/src/code/main.clj
new file mode 100644
index 0000000..080d888
--- /dev/null
+++ b/codegen-test/src/code/main.clj
@@ -0,0 +1,21 @@
+(ns code.main
+  (:require [python.numpy :as np]
+            [libpython-clj2.python :as py])
+  (:gen-class))
+
+
+(defn setup!
+  []
+  (py/initialize!))
+
+
+(defn lspace
+  []
+  (np/linspace 2 3))
+
+
+(defn -main
+  []
+  (setup!)
+  (println (lspace))
+  (shutdown-agents))
diff --git a/codegen-test/src/python/numpy.clj b/codegen-test/src/python/numpy.clj
new file mode 100644
index 0000000..9923893
--- /dev/null
+++ b/codegen-test/src/python/numpy.clj
@@ -0,0 +1,29449 @@
+(ns python.numpy
+"No documentation provided"
+(: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 [+ - * / 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]))
+
+(defonce ^:private src-obj* (py-global-delay (py/path->py-obj "numpy")))
+
+(def ^{:doc "
+    result_type(*arrays_and_dtypes)
+
+    Returns the type that results from applying the NumPy
+    type promotion rules to the arguments.
+
+    Type promotion in NumPy works similarly to the rules in languages
+    like C++, with some slight differences.  When both scalars and
+    arrays are used, the array's type takes precedence and the actual value
+    of the scalar is taken into account.
+
+    For example, calculating 3*a, where a is an array of 32-bit floats,
+    intuitively should result in a 32-bit float output.  If the 3 is a
+    32-bit integer, the NumPy rules indicate it can't convert losslessly
+    into a 32-bit float, so a 64-bit float should be the result type.
+    By examining the value of the constant, '3', we see that it fits in
+    an 8-bit integer, which can be cast losslessly into the 32-bit float.
+
+    Parameters
+    ----------
+    arrays_and_dtypes : list of arrays and dtypes
+        The operands of some operation whose result type is needed.
+
+    Returns
+    -------
+    out : dtype
+        The result type.
+
+    See also
+    --------
+    dtype, promote_types, min_scalar_type, can_cast
+
+    Notes
+    -----
+    .. versionadded:: 1.6.0
+
+    The specific algorithm used is as follows.
+
+    Categories are determined by first checking which of boolean,
+    integer (int/uint), or floating point (float/complex) the maximum
+    kind of all the arrays and the scalars are.
+
+    If there are only scalars or the maximum category of the scalars
+    is higher than the maximum category of the arrays,
+    the data types are combined with :func:`promote_types`
+    to produce the return value.
+
+    Otherwise, `min_scalar_type` is called on each array, and
+    the resulting data types are all combined with :func:`promote_types`
+    to produce the return value.
+
+    The set of int values is not a subset of the uint values for types
+    with the same number of bits, something not reflected in
+    :func:`min_scalar_type`, but handled as a special case in `result_type`.
+
+    Examples
+    --------
+    >>> np.result_type(3, np.arange(7, dtype='i1'))
+    dtype('int8')
+
+    >>> np.result_type('i4', 'c8')
+    dtype('complex128')
+
+    >>> np.result_type(3.0, -2)
+    dtype('float64')
+
+    " :arglists '[[& [args {:as kwargs}]]]} result_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "result_type"))))
+
+(def ^{:doc "
+    ravel_multi_index(multi_index, dims, mode='raise', order='C')
+
+    Converts a tuple of index arrays into an array of flat
+    indices, applying boundary modes to the multi-index.
+
+    Parameters
+    ----------
+    multi_index : tuple of array_like
+        A tuple of integer arrays, one array for each dimension.
+    dims : tuple of ints
+        The shape of array into which the indices from ``multi_index`` apply.
+    mode : {'raise', 'wrap', 'clip'}, optional
+        Specifies how out-of-bounds indices are handled.  Can specify
+        either one mode or a tuple of modes, one mode per index.
+
+        * 'raise' -- raise an error (default)
+        * 'wrap' -- wrap around
+        * 'clip' -- clip to the range
+
+        In 'clip' mode, a negative index which would normally
+        wrap will clip to 0 instead.
+    order : {'C', 'F'}, optional
+        Determines whether the multi-index should be viewed as
+        indexing in row-major (C-style) or column-major
+        (Fortran-style) order.
+
+    Returns
+    -------
+    raveled_indices : ndarray
+        An array of indices into the flattened version of an array
+        of dimensions ``dims``.
+
+    See Also
+    --------
+    unravel_index
+
+    Notes
+    -----
+    .. versionadded:: 1.6.0
+
+    Examples
+    --------
+    >>> arr = np.array([[3,6,6],[4,5,1]])
+    >>> np.ravel_multi_index(arr, (7,6))
+    array([22, 41, 37])
+    >>> np.ravel_multi_index(arr, (7,6), order='F')
+    array([31, 41, 13])
+    >>> np.ravel_multi_index(arr, (4,6), mode='clip')
+    array([22, 23, 19])
+    >>> np.ravel_multi_index(arr, (4,4), mode=('clip','wrap'))
+    array([12, 13, 13])
+
+    >>> np.ravel_multi_index((3,1,4,1), (6,7,8,9))
+    1621
+    " :arglists '[[& [args {:as kwargs}]]]} ravel_multi_index (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ravel_multi_index"))))
+
+(def ^{:doc "
+    vdot(a, b)
+
+    Return the dot product of two vectors.
+
+    The vdot(`a`, `b`) function handles complex numbers differently than
+    dot(`a`, `b`).  If the first argument is complex the complex conjugate
+    of the first argument is used for the calculation of the dot product.
+
+    Note that `vdot` handles multidimensional arrays differently than `dot`:
+    it does *not* perform a matrix product, but flattens input arguments
+    to 1-D vectors first. Consequently, it should only be used for vectors.
+
+    Parameters
+    ----------
+    a : array_like
+        If `a` is complex the complex conjugate is taken before calculation
+        of the dot product.
+    b : array_like
+        Second argument to the dot product.
+
+    Returns
+    -------
+    output : ndarray
+        Dot product of `a` and `b`.  Can be an int, float, or
+        complex depending on the types of `a` and `b`.
+
+    See Also
+    --------
+    dot : Return the dot product without using the complex conjugate of the
+          first argument.
+
+    Examples
+    --------
+    >>> a = np.array([1+2j,3+4j])
+    >>> b = np.array([5+6j,7+8j])
+    >>> np.vdot(a, b)
+    (70-8j)
+    >>> np.vdot(b, a)
+    (70+8j)
+
+    Note that higher-dimensional arrays are flattened!
+
+    >>> a = np.array([[1, 4], [5, 6]])
+    >>> b = np.array([[4, 1], [2, 2]])
+    >>> np.vdot(a, b)
+    30
+    >>> np.vdot(b, a)
+    30
+    >>> 1*4 + 4*1 + 5*2 + 6*2
+    30
+
+    " :arglists '[[& [args {:as kwargs}]]]} vdot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vdot"))))
+
+(def ^{:doc "Signed integer type, compatible with C ``short``.
+
+    :Character code: ``'h'``
+    :Canonical name: `numpy.short`
+    :Alias on this platform: `numpy.int16`: 16-bit signed integer (``-32_768`` to ``32_767``)." :arglists '[[self & [args {:as kwargs}]]]} int16 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int16"))))
+
+(def ^{:doc ""} NaN ##NaN)
+
+(def ^{:doc "
+    Diagnosing machine parameters.
+
+    Attributes
+    ----------
+    ibeta : int
+        Radix in which numbers are represented.
+    it : int
+        Number of base-`ibeta` digits in the floating point mantissa M.
+    machep : int
+        Exponent of the smallest (most negative) power of `ibeta` that,
+        added to 1.0, gives something different from 1.0
+    eps : float
+        Floating-point number ``beta**machep`` (floating point precision)
+    negep : int
+        Exponent of the smallest power of `ibeta` that, subtracted
+        from 1.0, gives something different from 1.0.
+    epsneg : float
+        Floating-point number ``beta**negep``.
+    iexp : int
+        Number of bits in the exponent (including its sign and bias).
+    minexp : int
+        Smallest (most negative) power of `ibeta` consistent with there
+        being no leading zeros in the mantissa.
+    xmin : float
+        Floating-point number ``beta**minexp`` (the smallest [in
+        magnitude] positive floating point number with full precision).
+    maxexp : int
+        Smallest (positive) power of `ibeta` that causes overflow.
+    xmax : float
+        ``(1-epsneg) * beta**maxexp`` (the largest [in magnitude]
+        usable floating value).
+    irnd : int
+        In ``range(6)``, information on what kind of rounding is done
+        in addition, and on how underflow is handled.
+    ngrd : int
+        Number of 'guard digits' used when truncating the product
+        of two mantissas to fit the representation.
+    epsilon : float
+        Same as `eps`.
+    tiny : float
+        Same as `xmin`.
+    huge : float
+        Same as `xmax`.
+    precision : float
+        ``- int(-log10(eps))``
+    resolution : float
+        ``- 10**(-precision)``
+
+    Parameters
+    ----------
+    float_conv : function, optional
+        Function that converts an integer or integer array to a float
+        or float array. Default is `float`.
+    int_conv : function, optional
+        Function that converts a float or float array to an integer or
+        integer array. Default is `int`.
+    float_to_float : function, optional
+        Function that converts a float array to float. Default is `float`.
+        Note that this does not seem to do anything useful in the current
+        implementation.
+    float_to_str : function, optional
+        Function that converts a single float to a string. Default is
+        ``lambda v:'%24.16e' %v``.
+    title : str, optional
+        Title that is printed in the string representation of `MachAr`.
+
+    See Also
+    --------
+    finfo : Machine limits for floating point types.
+    iinfo : Machine limits for integer types.
+
+    References
+    ----------
+    .. [1] Press, Teukolsky, Vetterling and Flannery,
+           \"Numerical Recipes in C++,\" 2nd ed,
+           Cambridge University Press, 2002, p. 31.
+
+    " :arglists '[[self & [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float, float_to_str :float_to_str, title :title}]] [self & [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float, float_to_str :float_to_str}]] [self & [{float_conv :float_conv, int_conv :int_conv, float_to_float :float_to_float}]] [self & [{float_conv :float_conv, int_conv :int_conv}]] [self & [{float_conv :float_conv}]] [self]]} MachAr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "MachAr"))))
+
+(def ^{:doc "
+    Kronecker product of two arrays.
+
+    Computes the Kronecker product, a composite array made of blocks of the
+    second array scaled by the first.
+
+    Parameters
+    ----------
+    a, b : array_like
+
+    Returns
+    -------
+    out : ndarray
+
+    See Also
+    --------
+    outer : The outer product
+
+    Notes
+    -----
+    The function assumes that the number of dimensions of `a` and `b`
+    are the same, if necessary prepending the smallest with ones.
+    If `a.shape = (r0,r1,..,rN)` and `b.shape = (s0,s1,...,sN)`,
+    the Kronecker product has shape `(r0*s0, r1*s1, ..., rN*SN)`.
+    The elements are products of elements from `a` and `b`, organized
+    explicitly by::
+
+        kron(a,b)[k0,k1,...,kN] = a[i0,i1,...,iN] * b[j0,j1,...,jN]
+
+    where::
+
+        kt = it * st + jt,  t = 0,...,N
+
+    In the common 2-D case (N=1), the block structure can be visualized::
+
+        [[ a[0,0]*b,   a[0,1]*b,  ... , a[0,-1]*b  ],
+         [  ...                              ...   ],
+         [ a[-1,0]*b,  a[-1,1]*b, ... , a[-1,-1]*b ]]
+
+
+    Examples
+    --------
+    >>> np.kron([1,10,100], [5,6,7])
+    array([  5,   6,   7, ..., 500, 600, 700])
+    >>> np.kron([5,6,7], [1,10,100])
+    array([  5,  50, 500, ...,   7,  70, 700])
+
+    >>> np.kron(np.eye(2), np.ones((2,2)))
+    array([[1.,  1.,  0.,  0.],
+           [1.,  1.,  0.,  0.],
+           [0.,  0.,  1.,  1.],
+           [0.,  0.,  1.,  1.]])
+
+    >>> a = np.arange(100).reshape((2,5,2,5))
+    >>> b = np.arange(24).reshape((2,3,4))
+    >>> c = np.kron(a,b)
+    >>> c.shape
+    (2, 10, 6, 20)
+    >>> I = (1,3,0,2)
+    >>> J = (0,2,1)
+    >>> J1 = (0,) + J             # extend to ndim=4
+    >>> S1 = (1,) + b.shape
+    >>> K = tuple(np.array(I) * np.array(S1) + np.array(J1))
+    >>> c[K] == a[I]*b[J]
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]]} kron (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "kron"))))
+
+(def ^{:doc "Abstract base class of all scalar types without predefined length.
+    The actual size of these types depends on the specific `np.dtype`
+    instantiation." :arglists '[[self & [args {:as kwargs}]]]} flexible (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flexible"))))
+
+(def ^{:doc "
+    Load ASCII data stored in a comma-separated file.
+
+    The returned array is a record array (if ``usemask=False``, see
+    `recarray`) or a masked record array (if ``usemask=True``,
+    see `ma.mrecords.MaskedRecords`).
+
+    Parameters
+    ----------
+    fname, kwargs : For a description of input parameters, see `genfromtxt`.
+
+    See Also
+    --------
+    numpy.genfromtxt : generic function to load ASCII data.
+
+    Notes
+    -----
+    By default, `dtype` is None, which means that the data-type of the output
+    array will be determined from the data.
+
+    " :arglists '[[fname & [{:as kwargs}]]]} recfromcsv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "recfromcsv"))))
+
+(def ^{:doc "Abstract base class of all numeric scalar types with a (potentially)
+    inexact representation of the values in its range, such as
+    floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} inexact (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "inexact"))))
+
+(def ^{:doc "floor(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the floor of the input, element-wise.
+
+The floor of the scalar `x` is the largest integer `i`, such that
+`i <= x`.  It is often denoted as :math:`\\lfloor x \\rfloor`.
+
+Parameters
+----------
+x : array_like
+    Input data.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The floor of each element in `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+ceil, trunc, rint
+
+Notes
+-----
+Some spreadsheet programs calculate the \"floor-towards-zero\", in other
+words ``floor(-2.5) == -2``.  NumPy instead uses the definition of
+`floor` where `floor(-2.5) == -3`.
+
+Examples
+--------
+>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
+>>> np.floor(a)
+array([-2., -2., -1.,  0.,  1.,  1.,  2.])" :arglists '[[self & [args {:as kwargs}]]]} floor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "floor"))))
+
+(def ^{:doc ""} tracemalloc_domain 389047)
+
+(def ^{:doc "
+    Return selected slices of an array along given axis.
+
+    When working along a given axis, a slice along that axis is returned in
+    `output` for each index where `condition` evaluates to True. When
+    working on a 1-D array, `compress` is equivalent to `extract`.
+
+    Parameters
+    ----------
+    condition : 1-D array of bools
+        Array that selects which entries to return. If len(condition)
+        is less than the size of `a` along the given axis, then output is
+        truncated to the length of the condition array.
+    a : array_like
+        Array from which to extract a part.
+    axis : int, optional
+        Axis along which to take slices. If None (default), work on the
+        flattened array.
+    out : ndarray, optional
+        Output array.  Its type is preserved and it must be of the right
+        shape to hold the output.
+
+    Returns
+    -------
+    compressed_array : ndarray
+        A copy of `a` without the slices along axis for which `condition`
+        is false.
+
+    See Also
+    --------
+    take, choose, diag, diagonal, select
+    ndarray.compress : Equivalent method in ndarray
+    extract: Equivalent method when working on 1-D arrays
+    :ref:`ufuncs-output-type`
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4], [5, 6]])
+    >>> a
+    array([[1, 2],
+           [3, 4],
+           [5, 6]])
+    >>> np.compress([0, 1], a, axis=0)
+    array([[3, 4]])
+    >>> np.compress([False, True, True], a, axis=0)
+    array([[3, 4],
+           [5, 6]])
+    >>> np.compress([False, True], a, axis=1)
+    array([[2],
+           [4],
+           [6]])
+
+    Working on the flattened array does not return slices along an axis but
+    selects elements.
+
+    >>> np.compress([False, True], a)
+    array([2])
+
+    " :arglists '[[& [args {:as kwargs}]]]} compress (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "compress"))))
+
+(def ^{:doc "Extended-precision floating-point number type, compatible with C
+    ``long double`` but not necessarily with IEEE 754 quadruple-precision.
+
+    :Character code: ``'g'``
+    :Canonical name: `numpy.longdouble`
+    :Alias: `numpy.longfloat`
+    :Alias on this platform: `numpy.float128`: 128-bit extended-precision floating-point number type." :arglists '[[self & [args {:as kwargs}]]]} longfloat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longfloat"))))
+
+(def ^{:doc "log1p(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the natural logarithm of one plus the input array, element-wise.
+
+Calculates ``log(1 + x)``.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    Natural logarithm of `1 + x`, element-wise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+expm1 : ``exp(x) - 1``, the inverse of `log1p`.
+
+Notes
+-----
+For real-valued input, `log1p` is accurate also for `x` so small
+that `1 + x == 1` in floating-point accuracy.
+
+Logarithm is a multivalued function: for each `x` there is an infinite
+number of `z` such that `exp(z) = 1 + x`. The convention is to return
+the `z` whose imaginary part lies in `[-pi, pi]`.
+
+For real-valued input data types, `log1p` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `log1p` is a complex analytical function that
+has a branch cut `[-inf, -1]` and is continuous from above on it.
+`log1p` handles the floating-point negative zero as an infinitesimal
+negative number, conforming to the C99 standard.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm
+
+Examples
+--------
+>>> np.log1p(1e-99)
+1e-99
+>>> np.log(1 + 1e-99)
+0.0" :arglists '[[self & [args {:as kwargs}]]]} log1p (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log1p"))))
+
+(def ^{:doc "arctan2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Element-wise arc tangent of ``x1/x2`` choosing the quadrant correctly.
+
+The quadrant (i.e., branch) is chosen so that ``arctan2(x1, x2)`` is
+the signed angle in radians between the ray ending at the origin and
+passing through the point (1,0), and the ray ending at the origin and
+passing through the point (`x2`, `x1`).  (Note the role reversal: the
+\"`y`-coordinate\" is the first function parameter, the \"`x`-coordinate\"
+is the second.)  By IEEE convention, this function is defined for
+`x2` = +/-0 and for either or both of `x1` and `x2` = +/-inf (see
+Notes for specific values).
+
+This function is not defined for complex-valued arguments; for the
+so-called argument of complex values, use `angle`.
+
+Parameters
+----------
+x1 : array_like, real-valued
+    `y`-coordinates.
+x2 : array_like, real-valued
+    `x`-coordinates.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+angle : ndarray
+    Array of angles in radians, in the range ``[-pi, pi]``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+arctan, tan, angle
+
+Notes
+-----
+*arctan2* is identical to the `atan2` function of the underlying
+C library.  The following special values are defined in the C
+standard: [1]_
+
+====== ====== ================
+`x1`   `x2`   `arctan2(x1,x2)`
+====== ====== ================
++/- 0  +0     +/- 0
++/- 0  -0     +/- pi
+ > 0   +/-inf +0 / +pi
+ < 0   +/-inf -0 / -pi
++/-inf +inf   +/- (pi/4)
++/-inf -inf   +/- (3*pi/4)
+====== ====== ================
+
+Note that +0 and -0 are distinct floating point numbers, as are +inf
+and -inf.
+
+References
+----------
+.. [1] ISO/IEC standard 9899:1999, \"Programming language C.\"
+
+Examples
+--------
+Consider four points in different quadrants:
+
+>>> x = np.array([-1, +1, +1, -1])
+>>> y = np.array([-1, -1, +1, +1])
+>>> np.arctan2(y, x) * 180 / np.pi
+array([-135.,  -45.,   45.,  135.])
+
+Note the order of the parameters. `arctan2` is defined also when `x2` = 0
+and at several other special points, obtaining values in
+the range ``[-pi, pi]``:
+
+>>> np.arctan2([1., -1.], [0., 0.])
+array([ 1.57079633, -1.57079633])
+>>> np.arctan2([0., 0., np.inf], [+0., -0., np.inf])
+array([ 0.        ,  3.14159265,  0.78539816])" :arglists '[[self & [args {:as kwargs}]]]} arctan2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arctan2"))))
+
+(def ^{:doc "ceil(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the ceiling of the input, element-wise.
+
+The ceil of the scalar `x` is the smallest integer `i`, such that
+`i >= x`.  It is often denoted as :math:`\\lceil x \\rceil`.
+
+Parameters
+----------
+x : array_like
+    Input data.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The ceiling of each element in `x`, with `float` dtype.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+floor, trunc, rint
+
+Examples
+--------
+>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
+>>> np.ceil(a)
+array([-1., -1., -0.,  1.,  2.,  2.,  2.])" :arglists '[[self & [args {:as kwargs}]]]} ceil (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ceil"))))
+
+(def ^{:doc "
+    Return an array (ndim >= 1) laid out in Fortran order in memory.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    dtype : str or dtype object, optional
+        By default, the data-type is inferred from the input data.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        The input `a` in Fortran, or column-major, order.
+
+    See Also
+    --------
+    ascontiguousarray : Convert input to a contiguous (C order) array.
+    asanyarray : Convert input to an ndarray with either row or
+        column-major memory order.
+    require : Return an ndarray that satisfies requirements.
+    ndarray.flags : Information about the memory layout of the array.
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2,3)
+    >>> y = np.asfortranarray(x)
+    >>> x.flags['F_CONTIGUOUS']
+    False
+    >>> y.flags['F_CONTIGUOUS']
+    True
+
+    Note: This function returns an array with at least one-dimension (1-d) 
+    so it will not preserve 0-d arrays.  
+
+    " :arglists '[[a & [{dtype :dtype, like :like}]] [a & [{like :like}]]]} asfortranarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asfortranarray"))))
+
+(def ^{:doc "logical_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the truth value of x1 AND x2 element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or bool
+    Boolean result of the logical AND operation applied to the elements
+    of `x1` and `x2`; the shape is determined by broadcasting.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_or, logical_not, logical_xor
+bitwise_and
+
+Examples
+--------
+>>> np.logical_and(True, False)
+False
+>>> np.logical_and([True, False], [False, False])
+array([False, False])
+
+>>> x = np.arange(5)
+>>> np.logical_and(x>1, x<4)
+array([False, False,  True,  True, False])
+
+
+The ``&`` operator can be used as a shorthand for ``np.logical_and`` on
+boolean ndarrays.
+
+>>> a = np.array([True, False])
+>>> b = np.array([False, False])
+>>> a & b
+array([False, False])" :arglists '[[self & [args {:as kwargs}]]]} logical_and (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_and"))))
+
+(def ^{:doc "
+    Return indices that are non-zero in the flattened version of a.
+
+    This is equivalent to np.nonzero(np.ravel(a))[0].
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+
+    Returns
+    -------
+    res : ndarray
+        Output array, containing the indices of the elements of `a.ravel()`
+        that are non-zero.
+
+    See Also
+    --------
+    nonzero : Return the indices of the non-zero elements of the input array.
+    ravel : Return a 1-D array containing the elements of the input array.
+
+    Examples
+    --------
+    >>> x = np.arange(-2, 3)
+    >>> x
+    array([-2, -1,  0,  1,  2])
+    >>> np.flatnonzero(x)
+    array([0, 1, 3, 4])
+
+    Use the indices of the non-zero elements as an index array to extract
+    these elements:
+
+    >>> x.ravel()[np.flatnonzero(x)]
+    array([-2, -1,  1,  2])
+
+    " :arglists '[[& [args {:as kwargs}]]]} flatnonzero (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flatnonzero"))))
+
+(def ^{:doc "
+    Returns True if the type of `element` is a scalar type.
+
+    Parameters
+    ----------
+    element : any
+        Input argument, can be of any type and shape.
+
+    Returns
+    -------
+    val : bool
+        True if `element` is a scalar type, False if it is not.
+
+    See Also
+    --------
+    ndim : Get the number of dimensions of an array
+
+    Notes
+    -----
+    If you need a stricter way to identify a *numerical* scalar, use
+    ``isinstance(x, numbers.Number)``, as that returns ``False`` for most
+    non-numerical elements such as strings.
+
+    In most cases ``np.ndim(x) == 0`` should be used instead of this function,
+    as that will also return true for 0d arrays. This is how numpy overloads
+    functions in the style of the ``dx`` arguments to `gradient` and the ``bins``
+    argument to `histogram`. Some key differences:
+
+    +--------------------------------------+---------------+-------------------+
+    | x                                    |``isscalar(x)``|``np.ndim(x) == 0``|
+    +======================================+===============+===================+
+    | PEP 3141 numeric objects (including  | ``True``      | ``True``          |
+    | builtins)                            |               |                   |
+    +--------------------------------------+---------------+-------------------+
+    | builtin string and buffer objects    | ``True``      | ``True``          |
+    +--------------------------------------+---------------+-------------------+
+    | other builtin objects, like          | ``False``     | ``True``          |
+    | `pathlib.Path`, `Exception`,         |               |                   |
+    | the result of `re.compile`           |               |                   |
+    +--------------------------------------+---------------+-------------------+
+    | third-party objects like             | ``False``     | ``True``          |
+    | `matplotlib.figure.Figure`           |               |                   |
+    +--------------------------------------+---------------+-------------------+
+    | zero-dimensional numpy arrays        | ``False``     | ``True``          |
+    +--------------------------------------+---------------+-------------------+
+    | other numpy arrays                   | ``False``     | ``False``         |
+    +--------------------------------------+---------------+-------------------+
+    | `list`, `tuple`, and other sequence  | ``False``     | ``False``         |
+    | objects                              |               |                   |
+    +--------------------------------------+---------------+-------------------+
+
+    Examples
+    --------
+    >>> np.isscalar(3.1)
+    True
+    >>> np.isscalar(np.array(3.1))
+    False
+    >>> np.isscalar([3.1])
+    False
+    >>> np.isscalar(False)
+    True
+    >>> np.isscalar('numpy')
+    True
+
+    NumPy supports PEP 3141 numbers:
+
+    >>> from fractions import Fraction
+    >>> np.isscalar(Fraction(5, 17))
+    True
+    >>> from numbers import Number
+    >>> np.isscalar(Number())
+    True
+
+    " :arglists '[[element]]} isscalar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isscalar"))))
+
+(def ^{:doc "
+    Return a scalar type which is common to the input arrays.
+
+    The return type will always be an inexact (i.e. floating point) scalar
+    type, even if all the arrays are integer arrays. If one of the inputs is
+    an integer array, the minimum precision type that is returned is a
+    64-bit floating point dtype.
+
+    All input arrays except int64 and uint64 can be safely cast to the
+    returned dtype without loss of information.
+
+    Parameters
+    ----------
+    array1, array2, ... : ndarrays
+        Input arrays.
+
+    Returns
+    -------
+    out : data type code
+        Data type code.
+
+    See Also
+    --------
+    dtype, mintypecode
+
+    Examples
+    --------
+    >>> np.common_type(np.arange(2, dtype=np.float32))
+    <class 'numpy.float32'>
+    >>> np.common_type(np.arange(2, dtype=np.float32), np.arange(2))
+    <class 'numpy.float64'>
+    >>> np.common_type(np.arange(4), np.array([45, 6.j]), np.array([45.0]))
+    <class 'numpy.complex128'>
+
+    " :arglists '[[& [args {:as kwargs}]]]} common_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "common_type"))))
+
+(def ^{:doc "Complex number type composed of two extended-precision floating-point
+    numbers.
+
+    :Character code: ``'G'``
+    :Canonical name: `numpy.clongdouble`
+    :Alias: `numpy.clongfloat`
+    :Alias: `numpy.longcomplex`
+    :Alias on this platform: `numpy.complex256`: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} clongdouble (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "clongdouble"))))
+
+(def ^{:doc "
+    Extract a diagonal or construct a diagonal array.
+
+    See the more detailed documentation for ``numpy.diagonal`` if you use this
+    function to extract a diagonal and wish to write to the resulting array;
+    whether it returns a copy or a view depends on what version of numpy you
+    are using.
+
+    Parameters
+    ----------
+    v : array_like
+        If `v` is a 2-D array, return a copy of its `k`-th diagonal.
+        If `v` is a 1-D array, return a 2-D array with `v` on the `k`-th
+        diagonal.
+    k : int, optional
+        Diagonal in question. The default is 0. Use `k>0` for diagonals
+        above the main diagonal, and `k<0` for diagonals below the main
+        diagonal.
+
+    Returns
+    -------
+    out : ndarray
+        The extracted diagonal or constructed diagonal array.
+
+    See Also
+    --------
+    diagonal : Return specified diagonals.
+    diagflat : Create a 2-D array with the flattened input as a diagonal.
+    trace : Sum along diagonals.
+    triu : Upper triangle of an array.
+    tril : Lower triangle of an array.
+
+    Examples
+    --------
+    >>> x = np.arange(9).reshape((3,3))
+    >>> x
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+
+    >>> np.diag(x)
+    array([0, 4, 8])
+    >>> np.diag(x, k=1)
+    array([1, 5])
+    >>> np.diag(x, k=-1)
+    array([3, 7])
+
+    >>> np.diag(np.diag(x))
+    array([[0, 0, 0],
+           [0, 4, 0],
+           [0, 0, 8]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} diag (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diag"))))
+
+(def ^{:doc "
+    Return the maximum of an array or maximum along an axis, ignoring any
+    NaNs.  When all-NaN slices are encountered a ``RuntimeWarning`` is
+    raised and NaN is returned for that slice.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose maximum is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the maximum is computed. The default is to compute
+        the maximum of the flattened array.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary. See
+        :ref:`ufuncs-output-type` for more details.
+
+        .. versionadded:: 1.8.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `max` method
+        of sub-classes of `ndarray`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+        .. versionadded:: 1.8.0
+
+    Returns
+    -------
+    nanmax : ndarray
+        An array with the same shape as `a`, with the specified axis removed.
+        If `a` is a 0-d array, or if axis is None, an ndarray scalar is
+        returned.  The same dtype as `a` is returned.
+
+    See Also
+    --------
+    nanmin :
+        The minimum value of an array along a given axis, ignoring any NaNs.
+    amax :
+        The maximum value of an array along a given axis, propagating any NaNs.
+    fmax :
+        Element-wise maximum of two arrays, ignoring any NaNs.
+    maximum :
+        Element-wise maximum of two arrays, propagating any NaNs.
+    isnan :
+        Shows which elements are Not a Number (NaN).
+    isfinite:
+        Shows which elements are neither NaN nor infinity.
+
+    amin, fmin, minimum
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+    Positive infinity is treated as a very large number and negative
+    infinity is treated as a very small (i.e. negative) number.
+
+    If the input has a integer type the function is equivalent to np.max.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nanmax(a)
+    3.0
+    >>> np.nanmax(a, axis=0)
+    array([3.,  2.])
+    >>> np.nanmax(a, axis=1)
+    array([2.,  3.])
+
+    When positive infinity and negative infinity are present:
+
+    >>> np.nanmax([1, 2, np.nan, np.NINF])
+    2.0
+    >>> np.nanmax([1, 2, np.nan, np.inf])
+    inf
+
+    " :arglists '[[& [args {:as kwargs}]]]} nanmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmax"))))
+
+(def ^{:doc "Base class for numpy scalar types.
+
+    Class from which most (all?) numpy scalar types are derived.  For
+    consistency, exposes the same API as `ndarray`, despite many
+    consequent attributes being either \"get-only,\" or completely irrelevant.
+    This is the class from which it is strongly suggested users should derive
+    custom scalar types." :arglists '[[self & [args {:as kwargs}]]]} generic (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "generic"))))
+
+(def ^{:doc "
+    Return the indices of the bins to which each value in input array belongs.
+
+    =========  =============  ============================
+    `right`    order of bins  returned index `i` satisfies
+    =========  =============  ============================
+    ``False``  increasing     ``bins[i-1] <= x < bins[i]``
+    ``True``   increasing     ``bins[i-1] < x <= bins[i]``
+    ``False``  decreasing     ``bins[i-1] > x >= bins[i]``
+    ``True``   decreasing     ``bins[i-1] >= x > bins[i]``
+    =========  =============  ============================
+
+    If values in `x` are beyond the bounds of `bins`, 0 or ``len(bins)`` is
+    returned as appropriate.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array to be binned. Prior to NumPy 1.10.0, this array had to
+        be 1-dimensional, but can now have any shape.
+    bins : array_like
+        Array of bins. It has to be 1-dimensional and monotonic.
+    right : bool, optional
+        Indicating whether the intervals include the right or the left bin
+        edge. Default behavior is (right==False) indicating that the interval
+        does not include the right edge. The left bin end is open in this
+        case, i.e., bins[i-1] <= x < bins[i] is the default behavior for
+        monotonically increasing bins.
+
+    Returns
+    -------
+    indices : ndarray of ints
+        Output array of indices, of same shape as `x`.
+
+    Raises
+    ------
+    ValueError
+        If `bins` is not monotonic.
+    TypeError
+        If the type of the input is complex.
+
+    See Also
+    --------
+    bincount, histogram, unique, searchsorted
+
+    Notes
+    -----
+    If values in `x` are such that they fall outside the bin range,
+    attempting to index `bins` with the indices that `digitize` returns
+    will result in an IndexError.
+
+    .. versionadded:: 1.10.0
+
+    `np.digitize` is  implemented in terms of `np.searchsorted`. This means
+    that a binary search is used to bin the values, which scales much better
+    for larger number of bins than the previous linear search. It also removes
+    the requirement for the input array to be 1-dimensional.
+
+    For monotonically _increasing_ `bins`, the following are equivalent::
+
+        np.digitize(x, bins, right=True)
+        np.searchsorted(bins, x, side='left')
+
+    Note that as the order of the arguments are reversed, the side must be too.
+    The `searchsorted` call is marginally faster, as it does not do any
+    monotonicity checks. Perhaps more importantly, it supports all dtypes.
+
+    Examples
+    --------
+    >>> x = np.array([0.2, 6.4, 3.0, 1.6])
+    >>> bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])
+    >>> inds = np.digitize(x, bins)
+    >>> inds
+    array([1, 4, 3, 2])
+    >>> for n in range(x.size):
+    ...   print(bins[inds[n]-1], \"<=\", x[n], \"<\", bins[inds[n]])
+    ...
+    0.0 <= 0.2 < 1.0
+    4.0 <= 6.4 < 10.0
+    2.5 <= 3.0 < 4.0
+    1.0 <= 1.6 < 2.5
+
+    >>> x = np.array([1.2, 10.0, 12.4, 15.5, 20.])
+    >>> bins = np.array([0, 5, 10, 15, 20])
+    >>> np.digitize(x,bins,right=True)
+    array([1, 2, 3, 4, 4])
+    >>> np.digitize(x,bins,right=False)
+    array([1, 3, 3, 4, 5])
+    " :arglists '[[& [args {:as kwargs}]]]} digitize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "digitize"))))
+
+(def ^{:doc "
+    Split an array into multiple sub-arrays.
+
+    Please refer to the ``split`` documentation.  The only difference
+    between these functions is that ``array_split`` allows
+    `indices_or_sections` to be an integer that does *not* equally
+    divide the axis. For an array of length l that should be split
+    into n sections, it returns l % n sub-arrays of size l//n + 1
+    and the rest of size l//n.
+
+    See Also
+    --------
+    split : Split array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> x = np.arange(8.0)
+    >>> np.array_split(x, 3)
+    [array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.])]
+
+    >>> x = np.arange(9)
+    >>> np.array_split(x, 4)
+    [array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]
+
+    " :arglists '[[& [args {:as kwargs}]]]} array_split (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_split"))))
+
+(def ^{:doc "
+========================
+Random Number Generation
+========================
+
+Use ``default_rng()`` to create a `Generator` and call its methods.
+
+=============== =========================================================
+Generator
+--------------- ---------------------------------------------------------
+Generator       Class implementing all of the random number distributions
+default_rng     Default constructor for ``Generator``
+=============== =========================================================
+
+============================================= ===
+BitGenerator Streams that work with Generator
+--------------------------------------------- ---
+MT19937
+PCG64
+Philox
+SFC64
+============================================= ===
+
+============================================= ===
+Getting entropy to initialize a BitGenerator
+--------------------------------------------- ---
+SeedSequence
+============================================= ===
+
+
+Legacy
+------
+
+For backwards compatibility with previous versions of numpy before 1.17, the
+various aliases to the global `RandomState` methods are left alone and do not
+use the new `Generator` API.
+
+==================== =========================================================
+Utility functions
+-------------------- ---------------------------------------------------------
+random               Uniformly distributed floats over ``[0, 1)``
+bytes                Uniformly distributed random bytes.
+permutation          Randomly permute a sequence / generate a random sequence.
+shuffle              Randomly permute a sequence in place.
+choice               Random sample from 1-D array.
+==================== =========================================================
+
+==================== =========================================================
+Compatibility
+functions - removed
+in the new API
+-------------------- ---------------------------------------------------------
+rand                 Uniformly distributed values.
+randn                Normally distributed values.
+ranf                 Uniformly distributed floating point numbers.
+random_integers      Uniformly distributed integers in a given range.
+                     (deprecated, use ``integers(..., closed=True)`` instead)
+random_sample        Alias for `random_sample`
+randint              Uniformly distributed integers in a given range
+seed                 Seed the legacy random number generator.
+==================== =========================================================
+
+==================== =========================================================
+Univariate
+distributions
+-------------------- ---------------------------------------------------------
+beta                 Beta distribution over ``[0, 1]``.
+binomial             Binomial distribution.
+chisquare            :math:`\\chi^2` distribution.
+exponential          Exponential distribution.
+f                    F (Fisher-Snedecor) distribution.
+gamma                Gamma distribution.
+geometric            Geometric distribution.
+gumbel               Gumbel distribution.
+hypergeometric       Hypergeometric distribution.
+laplace              Laplace distribution.
+logistic             Logistic distribution.
+lognormal            Log-normal distribution.
+logseries            Logarithmic series distribution.
+negative_binomial    Negative binomial distribution.
+noncentral_chisquare Non-central chi-square distribution.
+noncentral_f         Non-central F distribution.
+normal               Normal / Gaussian distribution.
+pareto               Pareto distribution.
+poisson              Poisson distribution.
+power                Power distribution.
+rayleigh             Rayleigh distribution.
+triangular           Triangular distribution.
+uniform              Uniform distribution.
+vonmises             Von Mises circular distribution.
+wald                 Wald (inverse Gaussian) distribution.
+weibull              Weibull distribution.
+zipf                 Zipf's distribution over ranked data.
+==================== =========================================================
+
+==================== ==========================================================
+Multivariate
+distributions
+-------------------- ----------------------------------------------------------
+dirichlet            Multivariate generalization of Beta distribution.
+multinomial          Multivariate generalization of the binomial distribution.
+multivariate_normal  Multivariate generalization of the normal distribution.
+==================== ==========================================================
+
+==================== =========================================================
+Standard
+distributions
+-------------------- ---------------------------------------------------------
+standard_cauchy      Standard Cauchy-Lorentz distribution.
+standard_exponential Standard exponential distribution.
+standard_gamma       Standard Gamma distribution.
+standard_normal      Standard normal distribution.
+standard_t           Standard Student's t-distribution.
+==================== =========================================================
+
+==================== =========================================================
+Internal functions
+-------------------- ---------------------------------------------------------
+get_state            Get tuple representing internal state of generator.
+set_state            Set state of generator.
+==================== =========================================================
+
+
+"} random (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "random"))))
+
+(def ^{:doc "
+    Return the directory that contains the NumPy \\*.h header files.
+
+    Extension modules that need to compile against NumPy should use this
+    function to locate the appropriate include directory.
+
+    Notes
+    -----
+    When using ``distutils``, for example in ``setup.py``.
+    ::
+
+        import numpy as np
+        ...
+        Extension('extension_name', ...
+                include_dirs=[np.get_include()])
+        ...
+
+    " :arglists '[[]]} get_include (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "get_include"))))
+
+(def ^{:doc ""} MAY_SHARE_BOUNDS 0)
+
+(def ^{:doc ""} UFUNC_BUFSIZE_DEFAULT 8192)
+
+(def ^{:doc ""} __config__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__config__"))))
+
+(def ^{:doc "
+    Return the length of the first dimension of the input array.
+
+    .. deprecated:: 1.18
+       `numpy.alen` is deprecated, use `len` instead.
+
+    Parameters
+    ----------
+    a : array_like
+       Input array.
+
+    Returns
+    -------
+    alen : int
+       Length of the first dimension of `a`.
+
+    See Also
+    --------
+    shape, size
+
+    Examples
+    --------
+    >>> a = np.zeros((7,4,5))
+    >>> a.shape[0]
+    7
+    >>> np.alen(a)
+    7
+
+    " :arglists '[[& [args {:as kwargs}]]]} alen (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "alen"))))
+
+(def ^{:doc "
+    Save an array to a binary file in NumPy ``.npy`` format.
+
+    Parameters
+    ----------
+    file : file, str, or pathlib.Path
+        File or filename to which the data is saved.  If file is a file-object,
+        then the filename is unchanged.  If file is a string or Path, a ``.npy``
+        extension will be appended to the filename if it does not already
+        have one.
+    arr : array_like
+        Array data to be saved.
+    allow_pickle : bool, optional
+        Allow saving object arrays using Python pickles. Reasons for disallowing
+        pickles include security (loading pickled data can execute arbitrary
+        code) and portability (pickled objects may not be loadable on different
+        Python installations, for example if the stored objects require libraries
+        that are not available, and not all pickled data is compatible between
+        Python 2 and Python 3).
+        Default: True
+    fix_imports : bool, optional
+        Only useful in forcing objects in object arrays on Python 3 to be
+        pickled in a Python 2 compatible way. If `fix_imports` is True, pickle
+        will try to map the new Python 3 names to the old module names used in
+        Python 2, so that the pickle data stream is readable with Python 2.
+
+    See Also
+    --------
+    savez : Save several arrays into a ``.npz`` archive
+    savetxt, load
+
+    Notes
+    -----
+    For a description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.
+
+    Any data saved to the file is appended to the end of the file.
+
+    Examples
+    --------
+    >>> from tempfile import TemporaryFile
+    >>> outfile = TemporaryFile()
+
+    >>> x = np.arange(10)
+    >>> np.save(outfile, x)
+
+    >>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file
+    >>> np.load(outfile)
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+
+    >>> with open('test.npy', 'wb') as f:
+    ...     np.save(f, np.array([1, 2]))
+    ...     np.save(f, np.array([1, 3]))
+    >>> with open('test.npy', 'rb') as f:
+    ...     a = np.load(f)
+    ...     b = np.load(f)
+    >>> print(a, b)
+    # [1 2] [1 3]
+    " :arglists '[[& [args {:as kwargs}]]]} save (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "save"))))
+
+(def ^{:doc "cosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Hyperbolic cosine, element-wise.
+
+Equivalent to ``1/2 * (np.exp(x) + np.exp(-x))`` and ``np.cos(1j*x)``.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array of same shape as `x`.
+    This is a scalar if `x` is a scalar.
+
+Examples
+--------
+>>> np.cosh(0)
+1.0
+
+The hyperbolic cosine describes the shape of a hanging cable:
+
+>>> import matplotlib.pyplot as plt
+>>> x = np.linspace(-4, 4, 1000)
+>>> plt.plot(x, np.cosh(x))
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]]} cosh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cosh"))))
+
+(def ^{:doc "
+    Construct an open mesh from multiple sequences.
+
+    This function takes N 1-D sequences and returns N outputs with N
+    dimensions each, such that the shape is 1 in all but one dimension
+    and the dimension with the non-unit shape value cycles through all
+    N dimensions.
+
+    Using `ix_` one can quickly construct index arrays that will index
+    the cross product. ``a[np.ix_([1,3],[2,5])]`` returns the array
+    ``[[a[1,2] a[1,5]], [a[3,2] a[3,5]]]``.
+
+    Parameters
+    ----------
+    args : 1-D sequences
+        Each sequence should be of integer or boolean type.
+        Boolean sequences will be interpreted as boolean masks for the
+        corresponding dimension (equivalent to passing in
+        ``np.nonzero(boolean_sequence)``).
+
+    Returns
+    -------
+    out : tuple of ndarrays
+        N arrays with N dimensions each, with N the number of input
+        sequences. Together these arrays form an open mesh.
+
+    See Also
+    --------
+    ogrid, mgrid, meshgrid
+
+    Examples
+    --------
+    >>> a = np.arange(10).reshape(2, 5)
+    >>> a
+    array([[0, 1, 2, 3, 4],
+           [5, 6, 7, 8, 9]])
+    >>> ixgrid = np.ix_([0, 1], [2, 4])
+    >>> ixgrid
+    (array([[0],
+           [1]]), array([[2, 4]]))
+    >>> ixgrid[0].shape, ixgrid[1].shape
+    ((2, 1), (1, 2))
+    >>> a[ixgrid]
+    array([[2, 4],
+           [7, 9]])
+
+    >>> ixgrid = np.ix_([True, True], [2, 4])
+    >>> a[ixgrid]
+    array([[2, 4],
+           [7, 9]])
+    >>> ixgrid = np.ix_([True, True], [False, False, True, False, True])
+    >>> a[ixgrid]
+    array([[2, 4],
+           [7, 9]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} ix_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ix_"))))
+
+(def ^{:doc ""} NINF ##-Inf)
+
+(def ^{:doc "Functions that operate element by element on whole arrays.
+
+    To see the documentation for a specific ufunc, use `info`.  For
+    example, ``np.info(np.sin)``.  Because ufuncs are written in C
+    (for speed) and linked into Python with NumPy's ufunc facility,
+    Python's help() function finds this page whenever help() is called
+    on a ufunc.
+
+    A detailed explanation of ufuncs can be found in the docs for :ref:`ufuncs`.
+
+    **Calling ufuncs:** ``op(*x[, out], where=True, **kwargs)``
+
+    Apply `op` to the arguments `*x` elementwise, broadcasting the arguments.
+
+    The broadcasting rules are:
+
+    * Dimensions of length 1 may be prepended to either array.
+    * Arrays may be repeated along dimensions of length 1.
+
+    Parameters
+    ----------
+    *x : array_like
+        Input arrays.
+    out : ndarray, None, or tuple of ndarray and None, optional
+        Alternate array object(s) in which to put the result; if provided, it
+        must have a shape that the inputs broadcast to. A tuple of arrays
+        (possible only as a keyword argument) must have length equal to the
+        number of outputs; use None for uninitialized outputs to be
+        allocated by the ufunc.
+    where : array_like, optional
+        This condition is broadcast over the input. At locations where the
+        condition is True, the `out` array will be set to the ufunc result.
+        Elsewhere, the `out` array will retain its original value.
+        Note that if an uninitialized `out` array is created via the default
+        ``out=None``, locations within it where the condition is False will
+        remain uninitialized.
+    **kwargs
+        For other keyword-only arguments, see the :ref:`ufunc docs <ufuncs.kwargs>`.
+
+    Returns
+    -------
+    r : ndarray or tuple of ndarray
+        `r` will have the shape that the arrays in `x` broadcast to; if `out` is
+        provided, it will be returned. If not, `r` will be allocated and
+        may contain uninitialized values. If the function has more than one
+        output, then the result will be a tuple of arrays." :arglists '[[self & [args {:as kwargs}]]]} ufunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ufunc"))))
+
+(def ^{:doc "" :arglists '[[self & [args {:as kwargs}]]]} TooHardError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "TooHardError"))))
+
+(def ^{:doc "
+    Return the string representation of a scalar dtype.
+
+    Parameters
+    ----------
+    sctype : scalar dtype or object
+        If a scalar dtype, the corresponding string character is
+        returned. If an object, `sctype2char` tries to infer its scalar type
+        and then return the corresponding string character.
+
+    Returns
+    -------
+    typechar : str
+        The string character corresponding to the scalar type.
+
+    Raises
+    ------
+    ValueError
+        If `sctype` is an object for which the type can not be inferred.
+
+    See Also
+    --------
+    obj2sctype, issctype, issubsctype, mintypecode
+
+    Examples
+    --------
+    >>> for sctype in [np.int32, np.double, np.complex_, np.string_, np.ndarray]:
+    ...     print(np.sctype2char(sctype))
+    l # may vary
+    d
+    D
+    S
+    O
+
+    >>> x = np.array([1., 2-1.j])
+    >>> np.sctype2char(x)
+    'D'
+    >>> np.sctype2char(list)
+    'O'
+
+    " :arglists '[[sctype]]} sctype2char (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sctype2char"))))
+
+(def ^{:doc "
+    Find the unique elements of an array.
+
+    Returns the sorted unique elements of an array. There are three optional
+    outputs in addition to the unique elements:
+
+    * the indices of the input array that give the unique values
+    * the indices of the unique array that reconstruct the input array
+    * the number of times each unique value comes up in the input array
+
+    Parameters
+    ----------
+    ar : array_like
+        Input array. Unless `axis` is specified, this will be flattened if it
+        is not already 1-D.
+    return_index : bool, optional
+        If True, also return the indices of `ar` (along the specified axis,
+        if provided, or in the flattened array) that result in the unique array.
+    return_inverse : bool, optional
+        If True, also return the indices of the unique array (for the specified
+        axis, if provided) that can be used to reconstruct `ar`.
+    return_counts : bool, optional
+        If True, also return the number of times each unique item appears
+        in `ar`.
+
+        .. versionadded:: 1.9.0
+
+    axis : int or None, optional
+        The axis to operate on. If None, `ar` will be flattened. If an integer,
+        the subarrays indexed by the given axis will be flattened and treated
+        as the elements of a 1-D array with the dimension of the given axis,
+        see the notes for more details.  Object arrays or structured arrays
+        that contain objects are not supported if the `axis` kwarg is used. The
+        default is None.
+
+        .. versionadded:: 1.13.0
+
+    Returns
+    -------
+    unique : ndarray
+        The sorted unique values.
+    unique_indices : ndarray, optional
+        The indices of the first occurrences of the unique values in the
+        original array. Only provided if `return_index` is True.
+    unique_inverse : ndarray, optional
+        The indices to reconstruct the original array from the
+        unique array. Only provided if `return_inverse` is True.
+    unique_counts : ndarray, optional
+        The number of times each of the unique values comes up in the
+        original array. Only provided if `return_counts` is True.
+
+        .. versionadded:: 1.9.0
+
+    See Also
+    --------
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+    repeat : Repeat elements of an array.
+
+    Notes
+    -----
+    When an axis is specified the subarrays indexed by the axis are sorted.
+    This is done by making the specified axis the first dimension of the array
+    (move the axis to the first dimension to keep the order of the other axes)
+    and then flattening the subarrays in C order. The flattened subarrays are
+    then viewed as a structured type with each element given a label, with the
+    effect that we end up with a 1-D array of structured types that can be
+    treated in the same way as any other 1-D array. The result is that the
+    flattened subarrays are sorted in lexicographic order starting with the
+    first element.
+
+    Examples
+    --------
+    >>> np.unique([1, 1, 2, 2, 3, 3])
+    array([1, 2, 3])
+    >>> a = np.array([[1, 1], [2, 3]])
+    >>> np.unique(a)
+    array([1, 2, 3])
+
+    Return the unique rows of a 2D array
+
+    >>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
+    >>> np.unique(a, axis=0)
+    array([[1, 0, 0], [2, 3, 4]])
+
+    Return the indices of the original array that give the unique values:
+
+    >>> a = np.array(['a', 'b', 'b', 'c', 'a'])
+    >>> u, indices = np.unique(a, return_index=True)
+    >>> u
+    array(['a', 'b', 'c'], dtype='<U1')
+    >>> indices
+    array([0, 1, 3])
+    >>> a[indices]
+    array(['a', 'b', 'c'], dtype='<U1')
+
+    Reconstruct the input array from the unique values and inverse:
+
+    >>> a = np.array([1, 2, 6, 4, 2, 3, 2])
+    >>> u, indices = np.unique(a, return_inverse=True)
+    >>> u
+    array([1, 2, 3, 4, 6])
+    >>> indices
+    array([0, 1, 4, 3, 1, 2, 1])
+    >>> u[indices]
+    array([1, 2, 6, 4, 2, 3, 2])
+
+    Reconstruct the input values from the unique values and counts:
+
+    >>> a = np.array([1, 2, 6, 4, 2, 3, 2])
+    >>> values, counts = np.unique(a, return_counts=True)
+    >>> values
+    array([1, 2, 3, 4, 6])
+    >>> counts
+    array([1, 3, 1, 1, 1])
+    >>> np.repeat(values, counts)
+    array([1, 2, 2, 2, 3, 4, 6])    # original order not preserved
+
+    " :arglists '[[& [args {:as kwargs}]]]} unique (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unique"))))
+
+(def ^{:doc "
+    Return the minimum of an array or minimum along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to operate.  By default, flattened input is
+        used.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, the minimum is selected over multiple axes,
+        instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternative output array in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+        See :ref:`ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `amin` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    initial : scalar, optional
+        The maximum value of an output element. Must be present to allow
+        computation on empty slice. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to compare for the minimum. See `~numpy.ufunc.reduce`
+        for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    amin : ndarray or scalar
+        Minimum of `a`. If `axis` is None, the result is a scalar value.
+        If `axis` is given, the result is an array of dimension
+        ``a.ndim - 1``.
+
+    See Also
+    --------
+    amax :
+        The maximum value of an array along a given axis, propagating any NaNs.
+    nanmin :
+        The minimum value of an array along a given axis, ignoring any NaNs.
+    minimum :
+        Element-wise minimum of two arrays, propagating any NaNs.
+    fmin :
+        Element-wise minimum of two arrays, ignoring any NaNs.
+    argmin :
+        Return the indices of the minimum values.
+
+    nanmax, maximum, fmax
+
+    Notes
+    -----
+    NaN values are propagated, that is if at least one item is NaN, the
+    corresponding min value will be NaN as well. To ignore NaN values
+    (MATLAB behavior), please use nanmin.
+
+    Don't use `amin` for element-wise comparison of 2 arrays; when
+    ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than
+    ``amin(a, axis=0)``.
+
+    Examples
+    --------
+    >>> a = np.arange(4).reshape((2,2))
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> np.amin(a)           # Minimum of the flattened array
+    0
+    >>> np.amin(a, axis=0)   # Minima along the first axis
+    array([0, 1])
+    >>> np.amin(a, axis=1)   # Minima along the second axis
+    array([0, 2])
+    >>> np.amin(a, where=[False, True], initial=10, axis=0)
+    array([10,  1])
+
+    >>> b = np.arange(5, dtype=float)
+    >>> b[2] = np.NaN
+    >>> np.amin(b)
+    nan
+    >>> np.amin(b, where=~np.isnan(b), initial=10)
+    0.0
+    >>> np.nanmin(b)
+    0.0
+
+    >>> np.min([[-50], [10]], axis=-1, initial=0)
+    array([-50,   0])
+
+    Notice that the initial value is used as one of the elements for which the
+    minimum is determined, unlike for the default argument Python's max
+    function, which is only used for empty iterables.
+
+    Notice that this isn't the same as Python's ``default`` argument.
+
+    >>> np.min([6], initial=5)
+    5
+    >>> min([6], default=5)
+    6
+    " :arglists '[[& [args {:as kwargs}]]]} min (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "min"))))
+
+(def ^{:doc "
+    Compute the bi-dimensional histogram of two data samples.
+
+    Parameters
+    ----------
+    x : array_like, shape (N,)
+        An array containing the x coordinates of the points to be
+        histogrammed.
+    y : array_like, shape (N,)
+        An array containing the y coordinates of the points to be
+        histogrammed.
+    bins : int or array_like or [int, int] or [array, array], optional
+        The bin specification:
+
+          * If int, the number of bins for the two dimensions (nx=ny=bins).
+          * If array_like, the bin edges for the two dimensions
+            (x_edges=y_edges=bins).
+          * If [int, int], the number of bins in each dimension
+            (nx, ny = bins).
+          * If [array, array], the bin edges in each dimension
+            (x_edges, y_edges = bins).
+          * A combination [int, array] or [array, int], where int
+            is the number of bins and array is the bin edges.
+
+    range : array_like, shape(2,2), optional
+        The leftmost and rightmost edges of the bins along each dimension
+        (if not specified explicitly in the `bins` parameters):
+        ``[[xmin, xmax], [ymin, ymax]]``. All values outside of this range
+        will be considered outliers and not tallied in the histogram.
+    density : bool, optional
+        If False, the default, returns the number of samples in each bin.
+        If True, returns the probability *density* function at the bin,
+        ``bin_count / sample_count / bin_area``.
+    normed : bool, optional
+        An alias for the density argument that behaves identically. To avoid
+        confusion with the broken normed argument to `histogram`, `density`
+        should be preferred.
+    weights : array_like, shape(N,), optional
+        An array of values ``w_i`` weighing each sample ``(x_i, y_i)``.
+        Weights are normalized to 1 if `normed` is True. If `normed` is
+        False, the values of the returned histogram are equal to the sum of
+        the weights belonging to the samples falling into each bin.
+
+    Returns
+    -------
+    H : ndarray, shape(nx, ny)
+        The bi-dimensional histogram of samples `x` and `y`. Values in `x`
+        are histogrammed along the first dimension and values in `y` are
+        histogrammed along the second dimension.
+    xedges : ndarray, shape(nx+1,)
+        The bin edges along the first dimension.
+    yedges : ndarray, shape(ny+1,)
+        The bin edges along the second dimension.
+
+    See Also
+    --------
+    histogram : 1D histogram
+    histogramdd : Multidimensional histogram
+
+    Notes
+    -----
+    When `normed` is True, then the returned histogram is the sample
+    density, defined such that the sum over bins of the product
+    ``bin_value * bin_area`` is 1.
+
+    Please note that the histogram does not follow the Cartesian convention
+    where `x` values are on the abscissa and `y` values on the ordinate
+    axis.  Rather, `x` is histogrammed along the first dimension of the
+    array (vertical), and `y` along the second dimension of the array
+    (horizontal).  This ensures compatibility with `histogramdd`.
+
+    Examples
+    --------
+    >>> from matplotlib.image import NonUniformImage
+    >>> import matplotlib.pyplot as plt
+
+    Construct a 2-D histogram with variable bin width. First define the bin
+    edges:
+
+    >>> xedges = [0, 1, 3, 5]
+    >>> yedges = [0, 2, 3, 4, 6]
+
+    Next we create a histogram H with random bin content:
+
+    >>> x = np.random.normal(2, 1, 100)
+    >>> y = np.random.normal(1, 1, 100)
+    >>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges))
+    >>> H = H.T  # Let each row list bins with common y range.
+
+    :func:`imshow <matplotlib.pyplot.imshow>` can only display square bins:
+
+    >>> fig = plt.figure(figsize=(7, 3))
+    >>> ax = fig.add_subplot(131, title='imshow: square bins')
+    >>> plt.imshow(H, interpolation='nearest', origin='lower',
+    ...         extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])
+    <matplotlib.image.AxesImage object at 0x...>
+
+    :func:`pcolormesh <matplotlib.pyplot.pcolormesh>` can display actual edges:
+
+    >>> ax = fig.add_subplot(132, title='pcolormesh: actual edges',
+    ...         aspect='equal')
+    >>> X, Y = np.meshgrid(xedges, yedges)
+    >>> ax.pcolormesh(X, Y, H)
+    <matplotlib.collections.QuadMesh object at 0x...>
+
+    :class:`NonUniformImage <matplotlib.image.NonUniformImage>` can be used to
+    display actual bin edges with interpolation:
+
+    >>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated',
+    ...         aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])
+    >>> im = NonUniformImage(ax, interpolation='bilinear')
+    >>> xcenters = (xedges[:-1] + xedges[1:]) / 2
+    >>> ycenters = (yedges[:-1] + yedges[1:]) / 2
+    >>> im.set_data(xcenters, ycenters, H)
+    >>> ax.images.append(im)
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]]} histogram2d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogram2d"))))
+
+(def ^{:doc "
+    Return a string representation of the data in an array.
+
+    The data in the array is returned as a single string.  This function is
+    similar to `array_repr`, the difference being that `array_repr` also
+    returns information on the kind of array and its data type.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input array.
+    max_line_width : int, optional
+        Inserts newlines if text is longer than `max_line_width`.
+        Defaults to ``numpy.get_printoptions()['linewidth']``.
+    precision : int, optional
+        Floating point precision.
+        Defaults to ``numpy.get_printoptions()['precision']``.
+    suppress_small : bool, optional
+        Represent numbers \"very close\" to zero as zero; default is False.
+        Very close is defined by precision: if the precision is 8, e.g.,
+        numbers smaller (in absolute value) than 5e-9 are represented as
+        zero.
+        Defaults to ``numpy.get_printoptions()['suppress']``.
+
+    See Also
+    --------
+    array2string, array_repr, set_printoptions
+
+    Examples
+    --------
+    >>> np.array_str(np.arange(3))
+    '[0 1 2]'
+
+    " :arglists '[[& [args {:as kwargs}]]]} array_str (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_str"))))
+
+(def ^{:doc ""} SHIFT_INVALID 9)
+
+(def ^{:doc "zeros(shape, dtype=float, order='C', *, like=None)
+
+    Return a new array of given shape and type, filled with zeros.
+
+    Parameters
+    ----------
+    shape : int or tuple of ints
+        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
+    dtype : data-type, optional
+        The desired data-type for the array, e.g., `numpy.int8`.  Default is
+        `numpy.float64`.
+    order : {'C', 'F'}, optional, default: 'C'
+        Whether to store multi-dimensional data in row-major
+        (C-style) or column-major (Fortran-style) order in
+        memory.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of zeros with the given shape, dtype, and order.
+
+    See Also
+    --------
+    zeros_like : Return an array of zeros with shape and type of input.
+    empty : Return a new uninitialized array.
+    ones : Return a new array setting values to one.
+    full : Return a new array of given shape filled with value.
+
+    Examples
+    --------
+    >>> np.zeros(5)
+    array([ 0.,  0.,  0.,  0.,  0.])
+
+    >>> np.zeros((5,), dtype=int)
+    array([0, 0, 0, 0, 0])
+
+    >>> np.zeros((2, 1))
+    array([[ 0.],
+           [ 0.]])
+
+    >>> s = (2,2)
+    >>> np.zeros(s)
+    array([[ 0.,  0.],
+           [ 0.,  0.]])
+
+    >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
+    array([(0, 0), (0, 0)],
+          dtype=[('x', '<i4'), ('y', '<i4')])" :arglists '[[self & [args {:as kwargs}]]]} zeros (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "zeros"))))
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} sctypes (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "sctypes")))) 
+
+(def ^{:doc "invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute bit-wise inversion, or bit-wise NOT, element-wise.
+
+Computes the bit-wise NOT of the underlying binary representation of
+the integers in the input arrays. This ufunc implements the C/Python
+operator ``~``.
+
+For signed integer inputs, the two's complement is returned.  In a
+two's-complement system negative numbers are represented by the two's
+complement of the absolute value. This is the most common method of
+representing signed integers on computers [1]_. A N-bit
+two's-complement system can represent every integer in the range
+:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
+
+Parameters
+----------
+x : array_like
+    Only integer and boolean types are handled.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Result.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+bitwise_and, bitwise_or, bitwise_xor
+logical_not
+binary_repr :
+    Return the binary representation of the input number as a string.
+
+Notes
+-----
+`bitwise_not` is an alias for `invert`:
+
+>>> np.bitwise_not is np.invert
+True
+
+References
+----------
+.. [1] Wikipedia, \"Two's complement\",
+    https://en.wikipedia.org/wiki/Two's_complement
+
+Examples
+--------
+We've seen that 13 is represented by ``00001101``.
+The invert or bit-wise NOT of 13 is then:
+
+>>> x = np.invert(np.array(13, dtype=np.uint8))
+>>> x
+242
+>>> np.binary_repr(x, width=8)
+'11110010'
+
+The result depends on the bit-width:
+
+>>> x = np.invert(np.array(13, dtype=np.uint16))
+>>> x
+65522
+>>> np.binary_repr(x, width=16)
+'1111111111110010'
+
+When using signed integer types the result is the two's complement of
+the result for the unsigned type:
+
+>>> np.invert(np.array([13], dtype=np.int8))
+array([-14], dtype=int8)
+>>> np.binary_repr(-14, width=8)
+'11110010'
+
+Booleans are accepted as well:
+
+>>> np.invert(np.array([True, False]))
+array([False,  True])
+
+The ``~`` operator can be used as a shorthand for ``np.invert`` on
+ndarrays.
+
+>>> x1 = np.array([True, False])
+>>> ~x1
+array([False,  True])" :arglists '[[self & [args {:as kwargs}]]]} invert (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "invert"))))
+
+(def ^{:doc "floor_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the largest integer smaller or equal to the division of the inputs.
+It is equivalent to the Python ``//`` operator and pairs with the
+Python ``%`` (`remainder`), function so that ``a = a % b + b * (a // b)``
+up to roundoff.
+
+Parameters
+----------
+x1 : array_like
+    Numerator.
+x2 : array_like
+    Denominator.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    y = floor(`x1`/`x2`)
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+remainder : Remainder complementary to floor_divide.
+divmod : Simultaneous floor division and remainder.
+divide : Standard division.
+floor : Round a number to the nearest integer toward minus infinity.
+ceil : Round a number to the nearest integer toward infinity.
+
+Examples
+--------
+>>> np.floor_divide(7,3)
+2
+>>> np.floor_divide([1., 2., 3., 4.], 2.5)
+array([ 0.,  0.,  1.,  1.])
+
+The ``//`` operator can be used as a shorthand for ``np.floor_divide``
+on ndarrays.
+
+>>> x1 = np.array([1., 2., 3., 4.])
+>>> x1 // 2.5
+array([0., 0., 1., 1.])" :arglists '[[self & [args {:as kwargs}]]]} floor_divide (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "floor_divide"))))
+
+(def ^{:doc "Unsigned integer type, compatible with C ``unsigned long``.
+
+    :Character code: ``'L'``
+    :Canonical name: `numpy.uint`
+    :Alias on this platform: `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``).
+    :Alias on this platform: `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]]} uint0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint0"))))
+
+(def ^{:doc "
+============================
+``ctypes`` Utility Functions
+============================
+
+See Also
+---------
+load_library : Load a C library.
+ndpointer : Array restype/argtype with verification.
+as_ctypes : Create a ctypes array from an ndarray.
+as_array : Create an ndarray from a ctypes array.
+
+References
+----------
+.. [1] \"SciPy Cookbook: ctypes\", https://scipy-cookbook.readthedocs.io/items/Ctypes.html
+
+Examples
+--------
+Load the C library:
+
+>>> _lib = np.ctypeslib.load_library('libmystuff', '.')     #doctest: +SKIP
+
+Our result type, an ndarray that must be of type double, be 1-dimensional
+and is C-contiguous in memory:
+
+>>> array_1d_double = np.ctypeslib.ndpointer(
+...                          dtype=np.double,
+...                          ndim=1, flags='CONTIGUOUS')    #doctest: +SKIP
+
+Our C-function typically takes an array and updates its values
+in-place.  For example::
+
+    void foo_func(double* x, int length)
+    {
+        int i;
+        for (i = 0; i < length; i++) {
+            x[i] = i*i;
+        }
+    }
+
+We wrap it using:
+
+>>> _lib.foo_func.restype = None                      #doctest: +SKIP
+>>> _lib.foo_func.argtypes = [array_1d_double, c_int] #doctest: +SKIP
+
+Then, we're ready to call ``foo_func``:
+
+>>> out = np.empty(15, dtype=np.double)
+>>> _lib.foo_func(out, len(out))                #doctest: +SKIP
+
+"} ctypeslib (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ctypeslib"))))
+
+(def ^{:doc "Boolean type (True or False), stored as a byte.
+
+    .. warning::
+
+       The :class:`bool_` type is not a subclass of the :class:`int_` type
+       (the :class:`bool_` is not even a number type). This is different
+       than Python's default implementation of :class:`bool` as a
+       sub-class of :class:`int`.
+
+    :Character code: ``'?'``
+    :Alias: `numpy.bool8`" :arglists '[[self & [args {:as kwargs}]]]} bool_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bool_"))))
+
+(def ^{:doc "Either an opaque sequence of bytes, or a structure.
+    
+    >>> np.void(b'abcd')
+    void(b'\\x61\\x62\\x63\\x64')
+    
+    Structured `void` scalars can only be constructed via extraction from :ref:`structured_arrays`:
+    
+    >>> arr = np.array((1, 2), dtype=[('x', np.int8), ('y', np.int8)])
+    >>> arr[()]
+    (1, 2)  # looks like a tuple, but is `np.void`
+
+    :Character code: ``'V'``" :arglists '[[self & [args {:as kwargs}]]]} void0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "void0"))))
+
+(def ^{:doc "A byte string.
+
+    When used in arrays, this type strips trailing null bytes.
+
+    :Character code: ``'S'``
+    :Alias: `numpy.string_`" :arglists '[[self & [args {:as kwargs}]]]} bytes_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bytes_"))))
+
+(def ^{:doc "
+    Set how floating-point errors are handled.
+
+    Note that operations on integer scalar types (such as `int16`) are
+    handled like floating point, and are affected by these settings.
+
+    Parameters
+    ----------
+    all : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
+        Set treatment for all types of floating-point errors at once:
+
+        - ignore: Take no action when the exception occurs.
+        - warn: Print a `RuntimeWarning` (via the Python `warnings` module).
+        - raise: Raise a `FloatingPointError`.
+        - call: Call a function specified using the `seterrcall` function.
+        - print: Print a warning directly to ``stdout``.
+        - log: Record error in a Log object specified by `seterrcall`.
+
+        The default is not to change the current behavior.
+    divide : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
+        Treatment for division by zero.
+    over : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
+        Treatment for floating-point overflow.
+    under : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
+        Treatment for floating-point underflow.
+    invalid : {'ignore', 'warn', 'raise', 'call', 'print', 'log'}, optional
+        Treatment for invalid floating-point operation.
+
+    Returns
+    -------
+    old_settings : dict
+        Dictionary containing the old settings.
+
+    See also
+    --------
+    seterrcall : Set a callback function for the 'call' mode.
+    geterr, geterrcall, errstate
+
+    Notes
+    -----
+    The floating-point exceptions are defined in the IEEE 754 standard [1]_:
+
+    - Division by zero: infinite result obtained from finite numbers.
+    - Overflow: result too large to be expressed.
+    - Underflow: result so close to zero that some precision
+      was lost.
+    - Invalid operation: result is not an expressible number, typically
+      indicates that a NaN was produced.
+
+    .. [1] https://en.wikipedia.org/wiki/IEEE_754
+
+    Examples
+    --------
+    >>> old_settings = np.seterr(all='ignore')  #seterr to known value
+    >>> np.seterr(over='raise')
+    {'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}
+    >>> np.seterr(**old_settings)  # reset to default
+    {'divide': 'ignore', 'over': 'raise', 'under': 'ignore', 'invalid': 'ignore'}
+
+    >>> np.int16(32000) * np.int16(3)
+    30464
+    >>> old_settings = np.seterr(all='warn', over='raise')
+    >>> np.int16(32000) * np.int16(3)
+    Traceback (most recent call last):
+      File \"<stdin>\", line 1, in <module>
+    FloatingPointError: overflow encountered in short_scalars
+
+    >>> from collections import OrderedDict
+    >>> old_settings = np.seterr(all='print')
+    >>> OrderedDict(np.geterr())
+    OrderedDict([('divide', 'print'), ('over', 'print'), ('under', 'print'), ('invalid', 'print')])
+    >>> np.int16(32000) * np.int16(3)
+    30464
+
+    " :arglists '[[& [{all :all, divide :divide, over :over, under :under, invalid :invalid}]] [& [{all :all, divide :divide, over :over, under :under}]] [& [{all :all, divide :divide, over :over}]] [& [{all :all, divide :divide}]] [& [{all :all}]] []]} seterr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "seterr"))))
+
+(def ^{:doc ""} ERR_CALL 3)
+
+(def ^{:doc "isinf(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Test element-wise for positive or negative infinity.
+
+Returns a boolean array of the same shape as `x`, True where ``x ==
++/-inf``, otherwise False.
+
+Parameters
+----------
+x : array_like
+    Input values
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : bool (scalar) or boolean ndarray
+    True where ``x`` is positive or negative infinity, false otherwise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+isneginf, isposinf, isnan, isfinite
+
+Notes
+-----
+NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+(IEEE 754).
+
+Errors result if the second argument is supplied when the first
+argument is a scalar, or if the first and second arguments have
+different shapes.
+
+Examples
+--------
+>>> np.isinf(np.inf)
+True
+>>> np.isinf(np.nan)
+False
+>>> np.isinf(np.NINF)
+True
+>>> np.isinf([np.inf, -np.inf, 1.0, np.nan])
+array([ True,  True, False, False])
+
+>>> x = np.array([-np.inf, 0., np.inf])
+>>> y = np.array([2, 2, 2])
+>>> np.isinf(x, y)
+array([1, 0, 1])
+>>> y
+array([1, 0, 1])" :arglists '[[self & [args {:as kwargs}]]]} isinf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isinf"))))
+(def ^{:doc "Built-in immutable sequence.
+
+If no argument is given, the constructor returns an empty tuple.
+If iterable is specified the tuple is initialized from iterable's items.
+
+If the argument is a tuple, the return value is the same object."} kernel_version (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* "kernel_version")))) 
+
+(def ^{:doc "spacing(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the distance between x and the nearest adjacent number.
+
+Parameters
+----------
+x : array_like
+    Values to find the spacing of.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    The spacing of values of `x`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+It can be considered as a generalization of EPS:
+``spacing(np.float64(1)) == np.finfo(np.float64).eps``, and there
+should not be any representable number between ``x + spacing(x)`` and
+x for any finite x.
+
+Spacing of +- inf and NaN is NaN.
+
+Examples
+--------
+>>> np.spacing(1) == np.finfo(np.float64).eps
+True" :arglists '[[self & [args {:as kwargs}]]]} spacing (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "spacing"))))
+
+(def ^{:doc "Double-precision floating-point number type, compatible with Python `float`
+    and C ``double``.
+
+    :Character code: ``'d'``
+    :Canonical name: `numpy.double`
+    :Alias: `numpy.float_`
+    :Alias on this platform: `numpy.float64`: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa." :arglists '[[self & [args {:as kwargs}]]]} float_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float_"))))
+
+(def ^{:doc "
+    Issued by `polyfit` when the Vandermonde matrix is rank deficient.
+
+    For more information, a way to suppress the warning, and an example of
+    `RankWarning` being issued, see `polyfit`.
+
+    " :arglists '[[self & [args {:as kwargs}]]]} RankWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "RankWarning"))))
+
+(def ^{:doc "
+    Evaluate a polynomial at specific values.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide </reference/routines.polynomials>`.
+
+    If `p` is of length N, this function returns the value:
+
+        ``p[0]*x**(N-1) + p[1]*x**(N-2) + ... + p[N-2]*x + p[N-1]``
+
+    If `x` is a sequence, then `p(x)` is returned for each element of `x`.
+    If `x` is another polynomial then the composite polynomial `p(x(t))`
+    is returned.
+
+    Parameters
+    ----------
+    p : array_like or poly1d object
+       1D array of polynomial coefficients (including coefficients equal
+       to zero) from highest degree to the constant term, or an
+       instance of poly1d.
+    x : array_like or poly1d object
+       A number, an array of numbers, or an instance of poly1d, at
+       which to evaluate `p`.
+
+    Returns
+    -------
+    values : ndarray or poly1d
+       If `x` is a poly1d instance, the result is the composition of the two
+       polynomials, i.e., `x` is \"substituted\" in `p` and the simplified
+       result is returned. In addition, the type of `x` - array_like or
+       poly1d - governs the type of the output: `x` array_like => `values`
+       array_like, `x` a poly1d object => `values` is also.
+
+    See Also
+    --------
+    poly1d: A polynomial class.
+
+    Notes
+    -----
+    Horner's scheme [1]_ is used to evaluate the polynomial. Even so,
+    for polynomials of high degree the values may be inaccurate due to
+    rounding errors. Use carefully.
+
+    If `x` is a subtype of `ndarray` the return value will be of the same type.
+
+    References
+    ----------
+    .. [1] I. N. Bronshtein, K. A. Semendyayev, and K. A. Hirsch (Eng.
+       trans. Ed.), *Handbook of Mathematics*, New York, Van Nostrand
+       Reinhold Co., 1985, pg. 720.
+
+    Examples
+    --------
+    >>> np.polyval([3,0,1], 5)  # 3 * 5**2 + 0 * 5**1 + 1
+    76
+    >>> np.polyval([3,0,1], np.poly1d(5))
+    poly1d([76])
+    >>> np.polyval(np.poly1d([3,0,1]), 5)
+    76
+    >>> np.polyval(np.poly1d([3,0,1]), np.poly1d(5))
+    poly1d([76])
+
+    " :arglists '[[& [args {:as kwargs}]]]} polyval (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyval"))))
+
+(def ^{:doc "
+    Translates slice objects to concatenation along the first axis.
+
+    This is a simple way to build up arrays quickly. There are two use cases.
+
+    1. If the index expression contains comma separated arrays, then stack
+       them along their first axis.
+    2. If the index expression contains slice notation or scalars then create
+       a 1-D array with a range indicated by the slice notation.
+
+    If slice notation is used, the syntax ``start:stop:step`` is equivalent
+    to ``np.arange(start, stop, step)`` inside of the brackets. However, if
+    ``step`` is an imaginary number (i.e. 100j) then its integer portion is
+    interpreted as a number-of-points desired and the start and stop are
+    inclusive. In other words ``start:stop:stepj`` is interpreted as
+    ``np.linspace(start, stop, step, endpoint=1)`` inside of the brackets.
+    After expansion of slice notation, all comma separated sequences are
+    concatenated together.
+
+    Optional character strings placed as the first element of the index
+    expression can be used to change the output. The strings 'r' or 'c' result
+    in matrix output. If the result is 1-D and 'r' is specified a 1 x N (row)
+    matrix is produced. If the result is 1-D and 'c' is specified, then a N x 1
+    (column) matrix is produced. If the result is 2-D then both provide the
+    same matrix result.
+
+    A string integer specifies which axis to stack multiple comma separated
+    arrays along. A string of two comma-separated integers allows indication
+    of the minimum number of dimensions to force each entry into as the
+    second integer (the axis to concatenate along is still the first integer).
+
+    A string with three comma-separated integers allows specification of the
+    axis to concatenate along, the minimum number of dimensions to force the
+    entries to, and which axis should contain the start of the arrays which
+    are less than the specified number of dimensions. In other words the third
+    integer allows you to specify where the 1's should be placed in the shape
+    of the arrays that have their shapes upgraded. By default, they are placed
+    in the front of the shape tuple. The third argument allows you to specify
+    where the start of the array should be instead. Thus, a third argument of
+    '0' would place the 1's at the end of the array shape. Negative integers
+    specify where in the new shape tuple the last dimension of upgraded arrays
+    should be placed, so the default is '-1'.
+
+    Parameters
+    ----------
+    Not a function, so takes no parameters
+
+
+    Returns
+    -------
+    A concatenated ndarray or matrix.
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays along an existing axis.
+    c_ : Translates slice objects to concatenation along the second axis.
+
+    Examples
+    --------
+    >>> np.r_[np.array([1,2,3]), 0, 0, np.array([4,5,6])]
+    array([1, 2, 3, ..., 4, 5, 6])
+    >>> np.r_[-1:1:6j, [0]*3, 5, 6]
+    array([-1. , -0.6, -0.2,  0.2,  0.6,  1. ,  0. ,  0. ,  0. ,  5. ,  6. ])
+
+    String integers specify the axis to concatenate along or the minimum
+    number of dimensions to force entries into.
+
+    >>> a = np.array([[0, 1, 2], [3, 4, 5]])
+    >>> np.r_['-1', a, a] # concatenate along last axis
+    array([[0, 1, 2, 0, 1, 2],
+           [3, 4, 5, 3, 4, 5]])
+    >>> np.r_['0,2', [1,2,3], [4,5,6]] # concatenate along first axis, dim>=2
+    array([[1, 2, 3],
+           [4, 5, 6]])
+
+    >>> np.r_['0,2,0', [1,2,3], [4,5,6]]
+    array([[1],
+           [2],
+           [3],
+           [4],
+           [5],
+           [6]])
+    >>> np.r_['1,2,0', [1,2,3], [4,5,6]]
+    array([[1, 4],
+           [2, 5],
+           [3, 6]])
+
+    Using 'r' or 'c' as a first string argument creates a matrix.
+
+    >>> np.r_['r',[1,2,3], [4,5,6]]
+    matrix([[1, 2, 3, 4, 5, 6]])
+
+    "} r_ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "r_"))))
+
+(def ^{:doc "
+    An N-dimensional iterator object to index arrays.
+
+    Given the shape of an array, an `ndindex` instance iterates over
+    the N-dimensional index of the array. At each iteration a tuple
+    of indices is returned, the last dimension is iterated over first.
+
+    Parameters
+    ----------
+    shape : ints, or a single tuple of ints
+        The size of each dimension of the array can be passed as 
+        individual parameters or as the elements of a tuple.
+
+    See Also
+    --------
+    ndenumerate, flatiter
+
+    Examples
+    --------
+    # dimensions as individual arguments
+    >>> for index in np.ndindex(3, 2, 1):
+    ...     print(index)
+    (0, 0, 0)
+    (0, 1, 0)
+    (1, 0, 0)
+    (1, 1, 0)
+    (2, 0, 0)
+    (2, 1, 0)
+
+    # same dimensions - but in a tuple (3, 2, 1)
+    >>> for index in np.ndindex((3, 2, 1)):
+    ...     print(index)
+    (0, 0, 0)
+    (0, 1, 0)
+    (1, 0, 0)
+    (1, 1, 0)
+    (2, 0, 0)
+    (2, 1, 0)
+
+    " :arglists '[[self & [shape]]]} ndindex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndindex"))))
+
+(def ^{:doc ""} infty ##Inf)
+
+(def ^{:doc "
+    Issues a DeprecationWarning, adds warning to `old_name`'s
+    docstring, rebinds ``old_name.__name__`` and returns the new
+    function object.
+
+    This function may also be used as a decorator.
+
+    Parameters
+    ----------
+    func : function
+        The function to be deprecated.
+    old_name : str, optional
+        The name of the function to be deprecated. Default is None, in
+        which case the name of `func` is used.
+    new_name : str, optional
+        The new name for the function. Default is None, in which case the
+        deprecation message is that `old_name` is deprecated. If given, the
+        deprecation message is that `old_name` is deprecated and `new_name`
+        should be used instead.
+    message : str, optional
+        Additional explanation of the deprecation.  Displayed in the
+        docstring after the warning.
+
+    Returns
+    -------
+    old_func : function
+        The deprecated function.
+
+    Examples
+    --------
+    Note that ``olduint`` returns a value after printing Deprecation
+    Warning:
+
+    >>> olduint = np.deprecate(np.uint)
+    DeprecationWarning: `uint64` is deprecated! # may vary
+    >>> olduint(6)
+    6
+
+    " :arglists '[[& [args {:as kwargs}]]]} deprecate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "deprecate"))))
+
+(def ^{:doc "
+    Set printing options.
+
+    These options determine the way floating point numbers, arrays and
+    other NumPy objects are displayed.
+
+    Parameters
+    ----------
+    precision : int or None, optional
+        Number of digits of precision for floating point output (default 8).
+        May be None if `floatmode` is not `fixed`, to print as many digits as
+        necessary to uniquely specify the value.
+    threshold : int, optional
+        Total number of array elements which trigger summarization
+        rather than full repr (default 1000).
+        To always use the full repr without summarization, pass `sys.maxsize`.
+    edgeitems : int, optional
+        Number of array items in summary at beginning and end of
+        each dimension (default 3).
+    linewidth : int, optional
+        The number of characters per line for the purpose of inserting
+        line breaks (default 75).
+    suppress : bool, optional
+        If True, always print floating point numbers using fixed point
+        notation, in which case numbers equal to zero in the current precision
+        will print as zero.  If False, then scientific notation is used when
+        absolute value of the smallest number is < 1e-4 or the ratio of the
+        maximum absolute value to the minimum is > 1e3. The default is False.
+    nanstr : str, optional
+        String representation of floating point not-a-number (default nan).
+    infstr : str, optional
+        String representation of floating point infinity (default inf).
+    sign : string, either '-', '+', or ' ', optional
+        Controls printing of the sign of floating-point types. If '+', always
+        print the sign of positive values. If ' ', always prints a space
+        (whitespace character) in the sign position of positive values.  If
+        '-', omit the sign character of positive values. (default '-')
+    formatter : dict of callables, optional
+        If not None, the keys should indicate the type(s) that the respective
+        formatting function applies to.  Callables should return a string.
+        Types that are not specified (by their corresponding keys) are handled
+        by the default formatters.  Individual types for which a formatter
+        can be set are:
+
+        - 'bool'
+        - 'int'
+        - 'timedelta' : a `numpy.timedelta64`
+        - 'datetime' : a `numpy.datetime64`
+        - 'float'
+        - 'longfloat' : 128-bit floats
+        - 'complexfloat'
+        - 'longcomplexfloat' : composed of two 128-bit floats
+        - 'numpystr' : types `numpy.string_` and `numpy.unicode_`
+        - 'object' : `np.object_` arrays
+        - 'str' : all other strings
+
+        Other keys that can be used to set a group of types at once are:
+
+        - 'all' : sets all types
+        - 'int_kind' : sets 'int'
+        - 'float_kind' : sets 'float' and 'longfloat'
+        - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
+        - 'str_kind' : sets 'str' and 'numpystr'
+    floatmode : str, optional
+        Controls the interpretation of the `precision` option for
+        floating-point types. Can take the following values
+        (default maxprec_equal):
+
+        * 'fixed': Always print exactly `precision` fractional digits,
+                even if this would print more or fewer digits than
+                necessary to specify the value uniquely.
+        * 'unique': Print the minimum number of fractional digits necessary
+                to represent each value uniquely. Different elements may
+                have a different number of digits. The value of the
+                `precision` option is ignored.
+        * 'maxprec': Print at most `precision` fractional digits, but if
+                an element can be uniquely represented with fewer digits
+                only print it with that many.
+        * 'maxprec_equal': Print at most `precision` fractional digits,
+                but if every element in the array can be uniquely
+                represented with an equal number of fewer digits, use that
+                many digits for all elements.
+    legacy : string or `False`, optional
+        If set to the string `'1.13'` enables 1.13 legacy printing mode. This
+        approximates numpy 1.13 print output by including a space in the sign
+        position of floats and different behavior for 0d arrays. If set to
+        `False`, disables legacy mode. Unrecognized strings will be ignored
+        with a warning for forward compatibility.
+
+        .. versionadded:: 1.14.0
+
+    See Also
+    --------
+    get_printoptions, printoptions, set_string_function, array2string
+
+    Notes
+    -----
+    `formatter` is always reset with a call to `set_printoptions`.
+
+    Use `printoptions` as a context manager to set the values temporarily.
+
+    Examples
+    --------
+    Floating point precision can be set:
+
+    >>> np.set_printoptions(precision=4)
+    >>> np.array([1.123456789])
+    [1.1235]
+
+    Long arrays can be summarised:
+
+    >>> np.set_printoptions(threshold=5)
+    >>> np.arange(10)
+    array([0, 1, 2, ..., 7, 8, 9])
+
+    Small results can be suppressed:
+
+    >>> eps = np.finfo(float).eps
+    >>> x = np.arange(4.)
+    >>> x**2 - (x + eps)**2
+    array([-4.9304e-32, -4.4409e-16,  0.0000e+00,  0.0000e+00])
+    >>> np.set_printoptions(suppress=True)
+    >>> x**2 - (x + eps)**2
+    array([-0., -0.,  0.,  0.])
+
+    A custom formatter can be used to display array elements as desired:
+
+    >>> np.set_printoptions(formatter={'all':lambda x: 'int: '+str(-x)})
+    >>> x = np.arange(3)
+    >>> x
+    array([int: 0, int: -1, int: -2])
+    >>> np.set_printoptions()  # formatter gets reset
+    >>> x
+    array([0, 1, 2])
+
+    To put back the default options, you can use:
+
+    >>> np.set_printoptions(edgeitems=3, infstr='inf',
+    ... linewidth=75, nanstr='nan', precision=8,
+    ... suppress=False, threshold=1000, formatter=None)
+
+    Also to temporarily override options, use `printoptions` as a context manager:
+
+    >>> with np.printoptions(precision=2, suppress=True, threshold=5):
+    ...     np.linspace(0, 10, 10)
+    array([ 0.  ,  1.11,  2.22, ...,  7.78,  8.89, 10.  ])
+
+    " :arglists '[[& [{legacy :legacy, infstr :infstr, linewidth :linewidth, suppress :suppress, sign :sign, formatter :formatter, precision :precision, floatmode :floatmode, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}]] [& [{legacy :legacy, infstr :infstr, linewidth :linewidth, suppress :suppress, sign :sign, formatter :formatter, precision :precision, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}]] [& [{legacy :legacy, infstr :infstr, linewidth :linewidth, suppress :suppress, formatter :formatter, precision :precision, edgeitems :edgeitems, threshold :threshold, nanstr :nanstr}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, nanstr :nanstr, infstr :infstr, legacy :legacy}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, nanstr :nanstr, legacy :legacy}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, suppress :suppress, legacy :legacy}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, linewidth :linewidth, legacy :legacy}]] [& [{precision :precision, threshold :threshold, edgeitems :edgeitems, legacy :legacy}]] [& [{precision :precision, threshold :threshold, legacy :legacy}]] [& [{precision :precision, legacy :legacy}]] [& [{legacy :legacy}]]]} set_printoptions (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "set_printoptions"))))
+
+(def ^{:doc "
+    Pad an array.
+
+    Parameters
+    ----------
+    array : array_like of rank N
+        The array to pad.
+    pad_width : {sequence, array_like, int}
+        Number of values padded to the edges of each axis.
+        ((before_1, after_1), ... (before_N, after_N)) unique pad widths
+        for each axis.
+        ((before, after),) yields same before and after pad for each axis.
+        (pad,) or int is a shortcut for before = after = pad width for all
+        axes.
+    mode : str or function, optional
+        One of the following string values or a user supplied function.
+
+        'constant' (default)
+            Pads with a constant value.
+        'edge'
+            Pads with the edge values of array.
+        'linear_ramp'
+            Pads with the linear ramp between end_value and the
+            array edge value.
+        'maximum'
+            Pads with the maximum value of all or part of the
+            vector along each axis.
+        'mean'
+            Pads with the mean value of all or part of the
+            vector along each axis.
+        'median'
+            Pads with the median value of all or part of the
+            vector along each axis.
+        'minimum'
+            Pads with the minimum value of all or part of the
+            vector along each axis.
+        'reflect'
+            Pads with the reflection of the vector mirrored on
+            the first and last values of the vector along each
+            axis.
+        'symmetric'
+            Pads with the reflection of the vector mirrored
+            along the edge of the array.
+        'wrap'
+            Pads with the wrap of the vector along the axis.
+            The first values are used to pad the end and the
+            end values are used to pad the beginning.
+        'empty'
+            Pads with undefined values.
+
+            .. versionadded:: 1.17
+
+        <function>
+            Padding function, see Notes.
+    stat_length : sequence or int, optional
+        Used in 'maximum', 'mean', 'median', and 'minimum'.  Number of
+        values at edge of each axis used to calculate the statistic value.
+
+        ((before_1, after_1), ... (before_N, after_N)) unique statistic
+        lengths for each axis.
+
+        ((before, after),) yields same before and after statistic lengths
+        for each axis.
+
+        (stat_length,) or int is a shortcut for before = after = statistic
+        length for all axes.
+
+        Default is ``None``, to use the entire axis.
+    constant_values : sequence or scalar, optional
+        Used in 'constant'.  The values to set the padded values for each
+        axis.
+
+        ``((before_1, after_1), ... (before_N, after_N))`` unique pad constants
+        for each axis.
+
+        ``((before, after),)`` yields same before and after constants for each
+        axis.
+
+        ``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
+        all axes.
+
+        Default is 0.
+    end_values : sequence or scalar, optional
+        Used in 'linear_ramp'.  The values used for the ending value of the
+        linear_ramp and that will form the edge of the padded array.
+
+        ``((before_1, after_1), ... (before_N, after_N))`` unique end values
+        for each axis.
+
+        ``((before, after),)`` yields same before and after end values for each
+        axis.
+
+        ``(constant,)`` or ``constant`` is a shortcut for ``before = after = constant`` for
+        all axes.
+
+        Default is 0.
+    reflect_type : {'even', 'odd'}, optional
+        Used in 'reflect', and 'symmetric'.  The 'even' style is the
+        default with an unaltered reflection around the edge value.  For
+        the 'odd' style, the extended part of the array is created by
+        subtracting the reflected values from two times the edge value.
+
+    Returns
+    -------
+    pad : ndarray
+        Padded array of rank equal to `array` with shape increased
+        according to `pad_width`.
+
+    Notes
+    -----
+    .. versionadded:: 1.7.0
+
+    For an array with rank greater than 1, some of the padding of later
+    axes is calculated from padding of previous axes.  This is easiest to
+    think about with a rank 2 array where the corners of the padded array
+    are calculated by using padded values from the first axis.
+
+    The padding function, if used, should modify a rank 1 array in-place. It
+    has the following signature::
+
+        padding_func(vector, iaxis_pad_width, iaxis, kwargs)
+
+    where
+
+        vector : ndarray
+            A rank 1 array already padded with zeros.  Padded values are
+            vector[:iaxis_pad_width[0]] and vector[-iaxis_pad_width[1]:].
+        iaxis_pad_width : tuple
+            A 2-tuple of ints, iaxis_pad_width[0] represents the number of
+            values padded at the beginning of vector where
+            iaxis_pad_width[1] represents the number of values padded at
+            the end of vector.
+        iaxis : int
+            The axis currently being calculated.
+        kwargs : dict
+            Any keyword arguments the function requires.
+
+    Examples
+    --------
+    >>> a = [1, 2, 3, 4, 5]
+    >>> np.pad(a, (2, 3), 'constant', constant_values=(4, 6))
+    array([4, 4, 1, ..., 6, 6, 6])
+
+    >>> np.pad(a, (2, 3), 'edge')
+    array([1, 1, 1, ..., 5, 5, 5])
+
+    >>> np.pad(a, (2, 3), 'linear_ramp', end_values=(5, -4))
+    array([ 5,  3,  1,  2,  3,  4,  5,  2, -1, -4])
+
+    >>> np.pad(a, (2,), 'maximum')
+    array([5, 5, 1, 2, 3, 4, 5, 5, 5])
+
+    >>> np.pad(a, (2,), 'mean')
+    array([3, 3, 1, 2, 3, 4, 5, 3, 3])
+
+    >>> np.pad(a, (2,), 'median')
+    array([3, 3, 1, 2, 3, 4, 5, 3, 3])
+
+    >>> a = [[1, 2], [3, 4]]
+    >>> np.pad(a, ((3, 2), (2, 3)), 'minimum')
+    array([[1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1],
+           [3, 3, 3, 4, 3, 3, 3],
+           [1, 1, 1, 2, 1, 1, 1],
+           [1, 1, 1, 2, 1, 1, 1]])
+
+    >>> a = [1, 2, 3, 4, 5]
+    >>> np.pad(a, (2, 3), 'reflect')
+    array([3, 2, 1, 2, 3, 4, 5, 4, 3, 2])
+
+    >>> np.pad(a, (2, 3), 'reflect', reflect_type='odd')
+    array([-1,  0,  1,  2,  3,  4,  5,  6,  7,  8])
+
+    >>> np.pad(a, (2, 3), 'symmetric')
+    array([2, 1, 1, 2, 3, 4, 5, 5, 4, 3])
+
+    >>> np.pad(a, (2, 3), 'symmetric', reflect_type='odd')
+    array([0, 1, 1, 2, 3, 4, 5, 5, 6, 7])
+
+    >>> np.pad(a, (2, 3), 'wrap')
+    array([4, 5, 1, 2, 3, 4, 5, 1, 2, 3])
+
+    >>> def pad_with(vector, pad_width, iaxis, kwargs):
+    ...     pad_value = kwargs.get('padder', 10)
+    ...     vector[:pad_width[0]] = pad_value
+    ...     vector[-pad_width[1]:] = pad_value
+    >>> a = np.arange(6)
+    >>> a = a.reshape((2, 3))
+    >>> np.pad(a, 2, pad_with)
+    array([[10, 10, 10, 10, 10, 10, 10],
+           [10, 10, 10, 10, 10, 10, 10],
+           [10, 10,  0,  1,  2, 10, 10],
+           [10, 10,  3,  4,  5, 10, 10],
+           [10, 10, 10, 10, 10, 10, 10],
+           [10, 10, 10, 10, 10, 10, 10]])
+    >>> np.pad(a, 2, pad_with, padder=100)
+    array([[100, 100, 100, 100, 100, 100, 100],
+           [100, 100, 100, 100, 100, 100, 100],
+           [100, 100,   0,   1,   2, 100, 100],
+           [100, 100,   3,   4,   5, 100, 100],
+           [100, 100, 100, 100, 100, 100, 100],
+           [100, 100, 100, 100, 100, 100, 100]])
+    " :arglists '[[& [args {:as kwargs}]]]} pad (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "pad"))))
+
+(def ^{:doc "Unsigned integer type, compatible with C ``unsigned long``.
+
+    :Character code: ``'L'``
+    :Canonical name: `numpy.uint`
+    :Alias on this platform: `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``).
+    :Alias on this platform: `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]]} Uint64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "Uint64"))))
+
+(def ^{:doc "
+    Print the NumPy arrays in the given dictionary.
+
+    If there is no dictionary passed in or `vardict` is None then returns
+    NumPy arrays in the globals() dictionary (all NumPy arrays in the
+    namespace).
+
+    Parameters
+    ----------
+    vardict : dict, optional
+        A dictionary possibly containing ndarrays.  Default is globals().
+
+    Returns
+    -------
+    out : None
+        Returns 'None'.
+
+    Notes
+    -----
+    Prints out the name, shape, bytes and type of all of the ndarrays
+    present in `vardict`.
+
+    Examples
+    --------
+    >>> a = np.arange(10)
+    >>> b = np.ones(20)
+    >>> np.who()
+    Name            Shape            Bytes            Type
+    ===========================================================
+    a               10               80               int64
+    b               20               160              float64
+    Upper bound on total bytes  =       240
+
+    >>> d = {'x': np.arange(2.0), 'y': np.arange(3.0), 'txt': 'Some str',
+    ... 'idx':5}
+    >>> np.who(d)
+    Name            Shape            Bytes            Type
+    ===========================================================
+    x               2                16               float64
+    y               3                24               float64
+    Upper bound on total bytes  =       40
+
+    " :arglists '[[& [{vardict :vardict}]] []]} who (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "who"))))
+
+(def ^{:doc "
+    Function to calculate only the edges of the bins used by the `histogram`
+    function.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data. The histogram is computed over the flattened array.
+    bins : int or sequence of scalars or str, optional
+        If `bins` is an int, it defines the number of equal-width
+        bins in the given range (10, by default). If `bins` is a
+        sequence, it defines the bin edges, including the rightmost
+        edge, allowing for non-uniform bin widths.
+
+        If `bins` is a string from the list below, `histogram_bin_edges` will use
+        the method chosen to calculate the optimal bin width and
+        consequently the number of bins (see `Notes` for more detail on
+        the estimators) from the data that falls within the requested
+        range. While the bin width will be optimal for the actual data
+        in the range, the number of bins will be computed to fill the
+        entire range, including the empty portions. For visualisation,
+        using the 'auto' option is suggested. Weighted data is not
+        supported for automated bin size selection.
+
+        'auto'
+            Maximum of the 'sturges' and 'fd' estimators. Provides good
+            all around performance.
+
+        'fd' (Freedman Diaconis Estimator)
+            Robust (resilient to outliers) estimator that takes into
+            account data variability and data size.
+
+        'doane'
+            An improved version of Sturges' estimator that works better
+            with non-normal datasets.
+
+        'scott'
+            Less robust estimator that that takes into account data
+            variability and data size.
+
+        'stone'
+            Estimator based on leave-one-out cross-validation estimate of
+            the integrated squared error. Can be regarded as a generalization
+            of Scott's rule.
+
+        'rice'
+            Estimator does not take variability into account, only data
+            size. Commonly overestimates number of bins required.
+
+        'sturges'
+            R's default method, only accounts for data size. Only
+            optimal for gaussian data and underestimates number of bins
+            for large non-gaussian datasets.
+
+        'sqrt'
+            Square root (of data size) estimator, used by Excel and
+            other programs for its speed and simplicity.
+
+    range : (float, float), optional
+        The lower and upper range of the bins.  If not provided, range
+        is simply ``(a.min(), a.max())``.  Values outside the range are
+        ignored. The first element of the range must be less than or
+        equal to the second. `range` affects the automatic bin
+        computation as well. While bin width is computed to be optimal
+        based on the actual data within `range`, the bin count will fill
+        the entire range including portions containing no data.
+
+    weights : array_like, optional
+        An array of weights, of the same shape as `a`.  Each value in
+        `a` only contributes its associated weight towards the bin count
+        (instead of 1). This is currently not used by any of the bin estimators,
+        but may be in the future.
+
+    Returns
+    -------
+    bin_edges : array of dtype float
+        The edges to pass into `histogram`
+
+    See Also
+    --------
+    histogram
+
+    Notes
+    -----
+    The methods to estimate the optimal number of bins are well founded
+    in literature, and are inspired by the choices R provides for
+    histogram visualisation. Note that having the number of bins
+    proportional to :math:`n^{1/3}` is asymptotically optimal, which is
+    why it appears in most estimators. These are simply plug-in methods
+    that give good starting points for number of bins. In the equations
+    below, :math:`h` is the binwidth and :math:`n_h` is the number of
+    bins. All estimators that compute bin counts are recast to bin width
+    using the `ptp` of the data. The final bin count is obtained from
+    ``np.round(np.ceil(range / h))``.
+
+    'auto' (maximum of the 'sturges' and 'fd' estimators)
+        A compromise to get a good value. For small datasets the Sturges
+        value will usually be chosen, while larger datasets will usually
+        default to FD.  Avoids the overly conservative behaviour of FD
+        and Sturges for small and large datasets respectively.
+        Switchover point is usually :math:`a.size \\approx 1000`.
+
+    'fd' (Freedman Diaconis Estimator)
+        .. math:: h = 2 \\frac{IQR}{n^{1/3}}
+
+        The binwidth is proportional to the interquartile range (IQR)
+        and inversely proportional to cube root of a.size. Can be too
+        conservative for small datasets, but is quite good for large
+        datasets. The IQR is very robust to outliers.
+
+    'scott'
+        .. math:: h = \\sigma \\sqrt[3]{\\frac{24 * \\sqrt{\\pi}}{n}}
+
+        The binwidth is proportional to the standard deviation of the
+        data and inversely proportional to cube root of ``x.size``. Can
+        be too conservative for small datasets, but is quite good for
+        large datasets. The standard deviation is not very robust to
+        outliers. Values are very similar to the Freedman-Diaconis
+        estimator in the absence of outliers.
+
+    'rice'
+        .. math:: n_h = 2n^{1/3}
+
+        The number of bins is only proportional to cube root of
+        ``a.size``. It tends to overestimate the number of bins and it
+        does not take into account data variability.
+
+    'sturges'
+        .. math:: n_h = \\log _{2}n+1
+
+        The number of bins is the base 2 log of ``a.size``.  This
+        estimator assumes normality of data and is too conservative for
+        larger, non-normal datasets. This is the default method in R's
+        ``hist`` method.
+
+    'doane'
+        .. math:: n_h = 1 + \\log_{2}(n) +
+                        \\log_{2}(1 + \\frac{|g_1|}{\\sigma_{g_1}})
+
+            g_1 = mean[(\\frac{x - \\mu}{\\sigma})^3]
+
+            \\sigma_{g_1} = \\sqrt{\\frac{6(n - 2)}{(n + 1)(n + 3)}}
+
+        An improved version of Sturges' formula that produces better
+        estimates for non-normal datasets. This estimator attempts to
+        account for the skew of the data.
+
+    'sqrt'
+        .. math:: n_h = \\sqrt n
+
+        The simplest and fastest estimator. Only takes into account the
+        data size.
+
+    Examples
+    --------
+    >>> arr = np.array([0, 0, 0, 1, 2, 3, 3, 4, 5])
+    >>> np.histogram_bin_edges(arr, bins='auto', range=(0, 1))
+    array([0.  , 0.25, 0.5 , 0.75, 1.  ])
+    >>> np.histogram_bin_edges(arr, bins=2)
+    array([0. , 2.5, 5. ])
+
+    For consistency with histogram, an array of pre-computed bins is
+    passed through unmodified:
+
+    >>> np.histogram_bin_edges(arr, [1, 2])
+    array([1, 2])
+
+    This function allows one set of bins to be computed, and reused across
+    multiple histograms:
+
+    >>> shared_bins = np.histogram_bin_edges(arr, bins='auto')
+    >>> shared_bins
+    array([0., 1., 2., 3., 4., 5.])
+
+    >>> group_id = np.array([0, 1, 1, 0, 1, 1, 0, 1, 1])
+    >>> hist_0, _ = np.histogram(arr[group_id == 0], bins=shared_bins)
+    >>> hist_1, _ = np.histogram(arr[group_id == 1], bins=shared_bins)
+
+    >>> hist_0; hist_1
+    array([1, 1, 0, 1, 0])
+    array([2, 0, 1, 1, 2])
+
+    Which gives more easily comparable results than using separate bins for
+    each histogram:
+
+    >>> hist_0, bins_0 = np.histogram(arr[group_id == 0], bins='auto')
+    >>> hist_1, bins_1 = np.histogram(arr[group_id == 1], bins='auto')
+    >>> hist_0; hist_1
+    array([1, 1, 1])
+    array([2, 1, 1, 2])
+    >>> bins_0; bins_1
+    array([0., 1., 2., 3.])
+    array([0.  , 1.25, 2.5 , 3.75, 5.  ])
+
+    " :arglists '[[& [args {:as kwargs}]]]} histogram_bin_edges (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogram_bin_edges"))))
+
+(def ^{:doc "
+    Compute the standard deviation along the specified axis.
+
+    Returns the standard deviation, a measure of the spread of a distribution,
+    of the array elements. The standard deviation is computed for the
+    flattened array by default, otherwise over the specified axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Calculate the standard deviation of these values.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which the standard deviation is computed. The
+        default is to compute the standard deviation of the flattened array.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a standard deviation is performed over
+        multiple axes, instead of a single axis or all the axes as before.
+    dtype : dtype, optional
+        Type to use in computing the standard deviation. For arrays of
+        integer type the default is float64, for arrays of float types it is
+        the same as the array type.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type (of the calculated
+        values) will be cast if necessary.
+    ddof : int, optional
+        Means Delta Degrees of Freedom.  The divisor used in calculations
+        is ``N - ddof``, where ``N`` represents the number of elements.
+        By default `ddof` is zero.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `std` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    where : array_like of bool, optional
+        Elements to include in the standard deviation.
+        See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    standard_deviation : ndarray, see dtype parameter above.
+        If `out` is None, return a new array containing the standard deviation,
+        otherwise return a reference to the output array.
+
+    See Also
+    --------
+    var, mean, nanmean, nanstd, nanvar
+    :ref:`ufuncs-output-type`
+
+    Notes
+    -----
+    The standard deviation is the square root of the average of the squared
+    deviations from the mean, i.e., ``std = sqrt(mean(x))``, where
+    ``x = abs(a - a.mean())**2``.
+
+    The average squared deviation is typically calculated as ``x.sum() / N``,
+    where ``N = len(x)``. If, however, `ddof` is specified, the divisor
+    ``N - ddof`` is used instead. In standard statistical practice, ``ddof=1``
+    provides an unbiased estimator of the variance of the infinite population.
+    ``ddof=0`` provides a maximum likelihood estimate of the variance for
+    normally distributed variables. The standard deviation computed in this
+    function is the square root of the estimated variance, so even with
+    ``ddof=1``, it will not be an unbiased estimate of the standard deviation
+    per se.
+
+    Note that, for complex numbers, `std` takes the absolute
+    value before squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the *std* is computed using the same
+    precision the input has. Depending on the input data, this can cause
+    the results to be inaccurate, especially for float32 (see example below).
+    Specifying a higher-accuracy accumulator using the `dtype` keyword can
+    alleviate this issue.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> np.std(a)
+    1.1180339887498949 # may vary
+    >>> np.std(a, axis=0)
+    array([1.,  1.])
+    >>> np.std(a, axis=1)
+    array([0.5,  0.5])
+
+    In single precision, std() can be inaccurate:
+
+    >>> a = np.zeros((2, 512*512), dtype=np.float32)
+    >>> a[0, :] = 1.0
+    >>> a[1, :] = 0.1
+    >>> np.std(a)
+    0.45000005
+
+    Computing the standard deviation in float64 is more accurate:
+
+    >>> np.std(a, dtype=np.float64)
+    0.44999999925494177 # may vary
+
+    Specifying a where argument:
+
+    >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
+    >>> np.std(a)
+    2.614064523559687 # may vary
+    >>> np.std(a, where=[[True], [True], [False]])
+    2.0
+
+    " :arglists '[[& [args {:as kwargs}]]]} std (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "std"))))
+
+(def ^{:doc "
+    Test element-wise for negative infinity, return result as bool array.
+
+    Parameters
+    ----------
+    x : array_like
+        The input array.
+    out : array_like, optional
+        A location into which the result is stored. If provided, it must have a
+        shape that the input broadcasts to. If not provided or None, a
+        freshly-allocated boolean array is returned.
+
+    Returns
+    -------
+    out : ndarray
+        A boolean array with the same dimensions as the input.
+        If second argument is not supplied then a numpy boolean array is
+        returned with values True where the corresponding element of the
+        input is negative infinity and values False where the element of
+        the input is not negative infinity.
+
+        If a second argument is supplied the result is stored there. If the
+        type of that array is a numeric type the result is represented as
+        zeros and ones, if the type is boolean then as False and True. The
+        return value `out` is then a reference to that array.
+
+    See Also
+    --------
+    isinf, isposinf, isnan, isfinite
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754).
+
+    Errors result if the second argument is also supplied when x is a scalar
+    input, if first and second arguments have different shapes, or if the
+    first argument has complex values.
+
+    Examples
+    --------
+    >>> np.isneginf(np.NINF)
+    True
+    >>> np.isneginf(np.inf)
+    False
+    >>> np.isneginf(np.PINF)
+    False
+    >>> np.isneginf([-np.inf, 0., np.inf])
+    array([ True, False, False])
+
+    >>> x = np.array([-np.inf, 0., np.inf])
+    >>> y = np.array([2, 2, 2])
+    >>> np.isneginf(x, y)
+    array([1, 0, 0])
+    >>> y
+    array([1, 0, 0])
+
+    " :arglists '[[& [args {:as kwargs}]]]} isneginf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isneginf"))))
+
+(def ^{:doc "
+    Round to nearest integer towards zero.
+
+    Round an array of floats element-wise to nearest integer towards zero.
+    The rounded values are returned as floats.
+
+    Parameters
+    ----------
+    x : array_like
+        An array of floats to be rounded
+    out : ndarray, optional
+        A location into which the result is stored. If provided, it must have
+        a shape that the input broadcasts to. If not provided or None, a
+        freshly-allocated array is returned.
+
+    Returns
+    -------
+    out : ndarray of floats
+        A float array with the same dimensions as the input.
+        If second argument is not supplied then a float array is returned
+        with the rounded values.
+
+        If a second argument is supplied the result is stored there.
+        The return value `out` is then a reference to that array.
+
+    See Also
+    --------
+    trunc, floor, ceil
+    around : Round to given number of decimals
+
+    Examples
+    --------
+    >>> np.fix(3.14)
+    3.0
+    >>> np.fix(3)
+    3.0
+    >>> np.fix([2.1, 2.9, -2.1, -2.9])
+    array([ 2.,  2., -2., -2.])
+
+    " :arglists '[[& [args {:as kwargs}]]]} fix (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fix"))))
+
+(def ^{:doc "
+    Return a new array of given shape and type, filled with ones.
+
+    Parameters
+    ----------
+    shape : int or sequence of ints
+        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
+    dtype : data-type, optional
+        The desired data-type for the array, e.g., `numpy.int8`.  Default is
+        `numpy.float64`.
+    order : {'C', 'F'}, optional, default: C
+        Whether to store multi-dimensional data in row-major
+        (C-style) or column-major (Fortran-style) order in
+        memory.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of ones with the given shape, dtype, and order.
+
+    See Also
+    --------
+    ones_like : Return an array of ones with shape and type of input.
+    empty : Return a new uninitialized array.
+    zeros : Return a new array setting values to zero.
+    full : Return a new array of given shape filled with value.
+
+
+    Examples
+    --------
+    >>> np.ones(5)
+    array([1., 1., 1., 1., 1.])
+
+    >>> np.ones((5,), dtype=int)
+    array([1, 1, 1, 1, 1])
+
+    >>> np.ones((2, 1))
+    array([[1.],
+           [1.]])
+
+    >>> s = (2,2)
+    >>> np.ones(s)
+    array([[1.,  1.],
+           [1.,  1.]])
+
+    " :arglists '[[shape & [{dtype :dtype, order :order, like :like}]] [shape & [{dtype :dtype, like :like}]] [shape & [{like :like}]]]} ones (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ones"))))
+
+(def ^{:doc "
+    Remove axes of length one from `a`.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        .. versionadded:: 1.7.0
+
+        Selects a subset of the entries of length one in the
+        shape. If an axis is selected with shape entry greater than
+        one, an error is raised.
+
+    Returns
+    -------
+    squeezed : ndarray
+        The input array, but with all or a subset of the
+        dimensions of length 1 removed. This is always `a` itself
+        or a view into `a`. Note that if all axes are squeezed,
+        the result is a 0d array and not a scalar.
+
+    Raises
+    ------
+    ValueError
+        If `axis` is not None, and an axis being squeezed is not of length 1
+
+    See Also
+    --------
+    expand_dims : The inverse operation, adding entries of length one
+    reshape : Insert, remove, and combine dimensions, and resize existing ones
+
+    Examples
+    --------
+    >>> x = np.array([[[0], [1], [2]]])
+    >>> x.shape
+    (1, 3, 1)
+    >>> np.squeeze(x).shape
+    (3,)
+    >>> np.squeeze(x, axis=0).shape
+    (3, 1)
+    >>> np.squeeze(x, axis=1).shape
+    Traceback (most recent call last):
+    ...
+    ValueError: cannot select an axis to squeeze out which has size not equal to one
+    >>> np.squeeze(x, axis=2).shape
+    (1, 3)
+    >>> x = np.array([[1234]])
+    >>> x.shape
+    (1, 1)
+    >>> np.squeeze(x)
+    array(1234)  # 0d array
+    >>> np.squeeze(x).shape
+    ()
+    >>> np.squeeze(x)[()]
+    1234
+
+    " :arglists '[[& [args {:as kwargs}]]]} squeeze (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "squeeze"))))
+
+(def ^{:doc "
+    Class to convert formats, names, titles description to a dtype.
+
+    After constructing the format_parser object, the dtype attribute is
+    the converted data-type:
+    ``dtype = format_parser(formats, names, titles).dtype``
+
+    Attributes
+    ----------
+    dtype : dtype
+        The converted data-type.
+
+    Parameters
+    ----------
+    formats : str or list of str
+        The format description, either specified as a string with
+        comma-separated format descriptions in the form ``'f8, i4, a5'``, or
+        a list of format description strings  in the form
+        ``['f8', 'i4', 'a5']``.
+    names : str or list/tuple of str
+        The field names, either specified as a comma-separated string in the
+        form ``'col1, col2, col3'``, or as a list or tuple of strings in the
+        form ``['col1', 'col2', 'col3']``.
+        An empty list can be used, in that case default field names
+        ('f0', 'f1', ...) are used.
+    titles : sequence
+        Sequence of title strings. An empty list can be used to leave titles
+        out.
+    aligned : bool, optional
+        If True, align the fields by padding as the C-compiler would.
+        Default is False.
+    byteorder : str, optional
+        If specified, all the fields will be changed to the
+        provided byte-order.  Otherwise, the default byte-order is
+        used. For all available string specifiers, see `dtype.newbyteorder`.
+
+    See Also
+    --------
+    dtype, typename, sctype2char
+
+    Examples
+    --------
+    >>> np.format_parser(['<f8', '<i4', '<a5'], ['col1', 'col2', 'col3'],
+    ...                  ['T1', 'T2', 'T3']).dtype
+    dtype([(('T1', 'col1'), '<f8'), (('T2', 'col2'), '<i4'), (('T3', 'col3'), 'S5')])
+
+    `names` and/or `titles` can be empty lists. If `titles` is an empty list,
+    titles will simply not appear. If `names` is empty, default field names
+    will be used.
+
+    >>> np.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'],
+    ...                  []).dtype
+    dtype([('col1', '<f8'), ('col2', '<i4'), ('col3', '<S5')])
+    >>> np.format_parser(['<f8', '<i4', '<a5'], [], []).dtype
+    dtype([('f0', '<f8'), ('f1', '<i4'), ('f2', 'S5')])
+
+    " :arglists '[[self formats names titles & [{aligned :aligned, byteorder :byteorder}]] [self formats names titles & [{aligned :aligned}]] [self formats names titles]]} format_parser (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "format_parser"))))
+
+(def ^{:doc "
+    Add documentation to an existing object, typically one defined in C
+
+    The purpose is to allow easier editing of the docstrings without requiring
+    a re-compile. This exists primarily for internal use within numpy itself.
+
+    Parameters
+    ----------
+    place : str
+        The absolute name of the module to import from
+    obj : str
+        The name of the object to add documentation to, typically a class or
+        function name
+    doc : {str, Tuple[str, str], List[Tuple[str, str]]}
+        If a string, the documentation to apply to `obj`
+
+        If a tuple, then the first element is interpreted as an attribute of
+        `obj` and the second as the docstring to apply - ``(method, docstring)``
+
+        If a list, then each element of the list should be a tuple of length
+        two - ``[(method1, docstring1), (method2, docstring2), ...]``
+    warn_on_python : bool
+        If True, the default, emit `UserWarning` if this is used to attach
+        documentation to a pure-python object.
+
+    Notes
+    -----
+    This routine never raises an error if the docstring can't be written, but
+    will raise an error if the object being documented does not exist.
+
+    This routine cannot modify read-only docstrings, as appear
+    in new-style classes or built-in functions. Because this
+    routine never raises an error the caller must check manually
+    that the docstrings were changed.
+
+    Since this function grabs the ``char *`` from a c-level str object and puts
+    it into the ``tp_doc`` slot of the type of `obj`, it violates a number of
+    C-API best-practices, by:
+
+    - modifying a `PyTypeObject` after calling `PyType_Ready`
+    - calling `Py_INCREF` on the str and losing the reference, so the str
+      will never be released
+
+    If possible it should be avoided.
+    " :arglists '[[place obj doc & [{warn_on_python :warn_on_python}]] [place obj doc]]} add_newdoc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add_newdoc"))))
+
+(def ^{:doc "Sub-package containing the matrix class and related functions.
+
+"} _mat (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_mat"))))
+
+(def ^{:doc "Single-precision floating-point number type, compatible with C ``float``.
+
+    :Character code: ``'f'``
+    :Canonical name: `numpy.single`
+    :Alias on this platform: `numpy.float32`: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa." :arglists '[[self & [args {:as kwargs}]]]} float32 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float32"))))
+
+(def ^{:doc "
+    Return the gradient of an N-dimensional array.
+
+    The gradient is computed using second order accurate central differences
+    in the interior points and either first or second order accurate one-sides
+    (forward or backwards) differences at the boundaries.
+    The returned gradient hence has the same shape as the input array.
+
+    Parameters
+    ----------
+    f : array_like
+        An N-dimensional array containing samples of a scalar function.
+    varargs : list of scalar or array, optional
+        Spacing between f values. Default unitary spacing for all dimensions.
+        Spacing can be specified using:
+
+        1. single scalar to specify a sample distance for all dimensions.
+        2. N scalars to specify a constant sample distance for each dimension.
+           i.e. `dx`, `dy`, `dz`, ...
+        3. N arrays to specify the coordinates of the values along each
+           dimension of F. The length of the array must match the size of
+           the corresponding dimension
+        4. Any combination of N scalars/arrays with the meaning of 2. and 3.
+
+        If `axis` is given, the number of varargs must equal the number of axes.
+        Default: 1.
+
+    edge_order : {1, 2}, optional
+        Gradient is calculated using N-th order accurate differences
+        at the boundaries. Default: 1.
+
+        .. versionadded:: 1.9.1
+
+    axis : None or int or tuple of ints, optional
+        Gradient is calculated only along the given axis or axes
+        The default (axis = None) is to calculate the gradient for all the axes
+        of the input array. axis may be negative, in which case it counts from
+        the last to the first axis.
+
+        .. versionadded:: 1.11.0
+
+    Returns
+    -------
+    gradient : ndarray or list of ndarray
+        A set of ndarrays (or a single ndarray if there is only one dimension)
+        corresponding to the derivatives of f with respect to each dimension.
+        Each derivative has the same shape as f.
+
+    Examples
+    --------
+    >>> f = np.array([1, 2, 4, 7, 11, 16], dtype=float)
+    >>> np.gradient(f)
+    array([1. , 1.5, 2.5, 3.5, 4.5, 5. ])
+    >>> np.gradient(f, 2)
+    array([0.5 ,  0.75,  1.25,  1.75,  2.25,  2.5 ])
+
+    Spacing can be also specified with an array that represents the coordinates
+    of the values F along the dimensions.
+    For instance a uniform spacing:
+
+    >>> x = np.arange(f.size)
+    >>> np.gradient(f, x)
+    array([1. ,  1.5,  2.5,  3.5,  4.5,  5. ])
+
+    Or a non uniform one:
+
+    >>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float)
+    >>> np.gradient(f, x)
+    array([1. ,  3. ,  3.5,  6.7,  6.9,  2.5])
+
+    For two dimensional arrays, the return will be two arrays ordered by
+    axis. In this example the first array stands for the gradient in
+    rows and the second one in columns direction:
+
+    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float))
+    [array([[ 2.,  2., -1.],
+           [ 2.,  2., -1.]]), array([[1. , 2.5, 4. ],
+           [1. , 1. , 1. ]])]
+
+    In this example the spacing is also specified:
+    uniform for axis=0 and non uniform for axis=1
+
+    >>> dx = 2.
+    >>> y = [1., 1.5, 3.5]
+    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y)
+    [array([[ 1. ,  1. , -0.5],
+           [ 1. ,  1. , -0.5]]), array([[2. , 2. , 2. ],
+           [2. , 1.7, 0.5]])]
+
+    It is possible to specify how boundaries are treated using `edge_order`
+
+    >>> x = np.array([0, 1, 2, 3, 4])
+    >>> f = x**2
+    >>> np.gradient(f, edge_order=1)
+    array([1.,  2.,  4.,  6.,  7.])
+    >>> np.gradient(f, edge_order=2)
+    array([0., 2., 4., 6., 8.])
+
+    The `axis` keyword can be used to specify a subset of axes of which the
+    gradient is calculated
+
+    >>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0)
+    array([[ 2.,  2., -1.],
+           [ 2.,  2., -1.]])
+
+    Notes
+    -----
+    Assuming that :math:`f\\in C^{3}` (i.e., :math:`f` has at least 3 continuous
+    derivatives) and let :math:`h_{*}` be a non-homogeneous stepsize, we
+    minimize the \"consistency error\" :math:`\\eta_{i}` between the true gradient
+    and its estimate from a linear combination of the neighboring grid-points:
+
+    .. math::
+
+        \\eta_{i} = f_{i}^{\\left(1\\right)} -
+                    \\left[ \\alpha f\\left(x_{i}\\right) +
+                            \\beta f\\left(x_{i} + h_{d}\\right) +
+                            \\gamma f\\left(x_{i}-h_{s}\\right)
+                    \\right]
+
+    By substituting :math:`f(x_{i} + h_{d})` and :math:`f(x_{i} - h_{s})`
+    with their Taylor series expansion, this translates into solving
+    the following the linear system:
+
+    .. math::
+
+        \\left\\{
+            \\begin{array}{r}
+                \\alpha+\\beta+\\gamma=0 \\\\
+                \\beta h_{d}-\\gamma h_{s}=1 \\\\
+                \\beta h_{d}^{2}+\\gamma h_{s}^{2}=0
+            \\end{array}
+        \\right.
+
+    The resulting approximation of :math:`f_{i}^{(1)}` is the following:
+
+    .. math::
+
+        \\hat f_{i}^{(1)} =
+            \\frac{
+                h_{s}^{2}f\\left(x_{i} + h_{d}\\right)
+                + \\left(h_{d}^{2} - h_{s}^{2}\\right)f\\left(x_{i}\\right)
+                - h_{d}^{2}f\\left(x_{i}-h_{s}\\right)}
+                { h_{s}h_{d}\\left(h_{d} + h_{s}\\right)}
+            + \\mathcal{O}\\left(\\frac{h_{d}h_{s}^{2}
+                                + h_{s}h_{d}^{2}}{h_{d}
+                                + h_{s}}\\right)
+
+    It is worth noting that if :math:`h_{s}=h_{d}`
+    (i.e., data are evenly spaced)
+    we find the standard second order approximation:
+
+    .. math::
+
+        \\hat f_{i}^{(1)}=
+            \\frac{f\\left(x_{i+1}\\right) - f\\left(x_{i-1}\\right)}{2h}
+            + \\mathcal{O}\\left(h^{2}\\right)
+
+    With a similar procedure the forward/backward approximations used for
+    boundaries can be derived.
+
+    References
+    ----------
+    .. [1]  Quarteroni A., Sacco R., Saleri F. (2007) Numerical Mathematics
+            (Texts in Applied Mathematics). New York: Springer.
+    .. [2]  Durran D. R. (1999) Numerical Methods for Wave Equations
+            in Geophysical Fluid Dynamics. New York: Springer.
+    .. [3]  Fornberg B. (1988) Generation of Finite Difference Formulas on
+            Arbitrarily Spaced Grids,
+            Mathematics of Computation 51, no. 184 : 699-706.
+            `PDF <http://www.ams.org/journals/mcom/1988-51-184/
+            S0025-5718-1988-0935077-0/S0025-5718-1988-0935077-0.pdf>`_.
+    " :arglists '[[& [args {:as kwargs}]]]} gradient (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "gradient"))))
+
+(def ^{:doc "
+    Return the scalar dtype or NumPy equivalent of Python type of an object.
+
+    Parameters
+    ----------
+    rep : any
+        The object of which the type is returned.
+    default : any, optional
+        If given, this is returned for objects whose types can not be
+        determined. If not given, None is returned for those objects.
+
+    Returns
+    -------
+    dtype : dtype or Python type
+        The data type of `rep`.
+
+    See Also
+    --------
+    sctype2char, issctype, issubsctype, issubdtype, maximum_sctype
+
+    Examples
+    --------
+    >>> np.obj2sctype(np.int32)
+    <class 'numpy.int32'>
+    >>> np.obj2sctype(np.array([1., 2.]))
+    <class 'numpy.float64'>
+    >>> np.obj2sctype(np.array([1.j]))
+    <class 'numpy.complex128'>
+
+    >>> np.obj2sctype(dict)
+    <class 'numpy.object_'>
+    >>> np.obj2sctype('string')
+
+    >>> np.obj2sctype(1, default=list)
+    <class 'list'>
+
+    " :arglists '[[rep & [{default :default}]] [rep]]} obj2sctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "obj2sctype"))))
+
+(def ^{:doc "
+    Base object for a dictionary for look-up with any alias for an array dtype.
+
+    Instances of `_typedict` can not be used as dictionaries directly,
+    first they have to be populated.
+
+    "} cast (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "cast"))))
+
+(def ^{:doc "
+    Determine common type following standard coercion rules.
+
+    Parameters
+    ----------
+    array_types : sequence
+        A list of dtypes or dtype convertible objects representing arrays.
+    scalar_types : sequence
+        A list of dtypes or dtype convertible objects representing scalars.
+
+    Returns
+    -------
+    datatype : dtype
+        The common data type, which is the maximum of `array_types` ignoring
+        `scalar_types`, unless the maximum of `scalar_types` is of a
+        different kind (`dtype.kind`). If the kind is not understood, then
+        None is returned.
+
+    See Also
+    --------
+    dtype, common_type, can_cast, mintypecode
+
+    Examples
+    --------
+    >>> np.find_common_type([], [np.int64, np.float32, complex])
+    dtype('complex128')
+    >>> np.find_common_type([np.int64, np.float32], [])
+    dtype('float64')
+
+    The standard casting rules ensure that a scalar cannot up-cast an
+    array unless the scalar is of a fundamentally different kind of data
+    (i.e. under a different hierarchy in the data type hierarchy) then
+    the array:
+
+    >>> np.find_common_type([np.float32], [np.int64, np.float64])
+    dtype('float32')
+
+    Complex is of a different type, so it up-casts the float in the
+    `array_types` argument:
+
+    >>> np.find_common_type([np.float32], [complex])
+    dtype('complex128')
+
+    Type specifier strings are convertible to dtypes and can therefore
+    be used instead of dtypes:
+
+    >>> np.find_common_type(['f4', 'f4', 'i4'], ['c8'])
+    dtype('complex128')
+
+    " :arglists '[[array_types scalar_types]]} find_common_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "find_common_type"))))
+
+(def ^{:doc "Signed integer type, compatible with Python `int` and C ``long``.
+
+    :Character code: ``'l'``
+    :Canonical name: `numpy.int_`
+    :Alias on this platform: `numpy.int64`: 64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``).
+    :Alias on this platform: `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]]} intp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "intp"))))
+
+(def ^{:doc "
+    Find the coefficients of a polynomial with the given sequence of roots.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide </reference/routines.polynomials>`.
+
+    Returns the coefficients of the polynomial whose leading coefficient
+    is one for the given sequence of zeros (multiple roots must be included
+    in the sequence as many times as their multiplicity; see Examples).
+    A square matrix (or array, which will be treated as a matrix) can also
+    be given, in which case the coefficients of the characteristic polynomial
+    of the matrix are returned.
+
+    Parameters
+    ----------
+    seq_of_zeros : array_like, shape (N,) or (N, N)
+        A sequence of polynomial roots, or a square array or matrix object.
+
+    Returns
+    -------
+    c : ndarray
+        1D array of polynomial coefficients from highest to lowest degree:
+
+        ``c[0] * x**(N) + c[1] * x**(N-1) + ... + c[N-1] * x + c[N]``
+        where c[0] always equals 1.
+
+    Raises
+    ------
+    ValueError
+        If input is the wrong shape (the input must be a 1-D or square
+        2-D array).
+
+    See Also
+    --------
+    polyval : Compute polynomial values.
+    roots : Return the roots of a polynomial.
+    polyfit : Least squares polynomial fit.
+    poly1d : A one-dimensional polynomial class.
+
+    Notes
+    -----
+    Specifying the roots of a polynomial still leaves one degree of
+    freedom, typically represented by an undetermined leading
+    coefficient. [1]_ In the case of this function, that coefficient -
+    the first one in the returned array - is always taken as one. (If
+    for some reason you have one other point, the only automatic way
+    presently to leverage that information is to use ``polyfit``.)
+
+    The characteristic polynomial, :math:`p_a(t)`, of an `n`-by-`n`
+    matrix **A** is given by
+
+        :math:`p_a(t) = \\mathrm{det}(t\\, \\mathbf{I} - \\mathbf{A})`,
+
+    where **I** is the `n`-by-`n` identity matrix. [2]_
+
+    References
+    ----------
+    .. [1] M. Sullivan and M. Sullivan, III, \"Algebra and Trignometry,
+       Enhanced With Graphing Utilities,\" Prentice-Hall, pg. 318, 1996.
+
+    .. [2] G. Strang, \"Linear Algebra and Its Applications, 2nd Edition,\"
+       Academic Press, pg. 182, 1980.
+
+    Examples
+    --------
+    Given a sequence of a polynomial's zeros:
+
+    >>> np.poly((0, 0, 0)) # Multiple root example
+    array([1., 0., 0., 0.])
+
+    The line above represents z**3 + 0*z**2 + 0*z + 0.
+
+    >>> np.poly((-1./2, 0, 1./2))
+    array([ 1.  ,  0.  , -0.25,  0.  ])
+
+    The line above represents z**3 - z/4
+
+    >>> np.poly((np.random.random(1)[0], 0, np.random.random(1)[0]))
+    array([ 1.        , -0.77086955,  0.08618131,  0.        ]) # random
+
+    Given a square array object:
+
+    >>> P = np.array([[0, 1./3], [-1./2, 0]])
+    >>> np.poly(P)
+    array([1.        , 0.        , 0.16666667])
+
+    Note how in all cases the leading coefficient is always 1.
+
+    " :arglists '[[& [args {:as kwargs}]]]} poly (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "poly"))))
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} __deprecated_attrs__ (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "__deprecated_attrs__")))) 
+
+(def ^{:doc "
+    Return the scalar type of highest precision of the same kind as the input.
+
+    Parameters
+    ----------
+    t : dtype or dtype specifier
+        The input data type. This can be a `dtype` object or an object that
+        is convertible to a `dtype`.
+
+    Returns
+    -------
+    out : dtype
+        The highest precision data type of the same kind (`dtype.kind`) as `t`.
+
+    See Also
+    --------
+    obj2sctype, mintypecode, sctype2char
+    dtype
+
+    Examples
+    --------
+    >>> np.maximum_sctype(int)
+    <class 'numpy.int64'>
+    >>> np.maximum_sctype(np.uint8)
+    <class 'numpy.uint64'>
+    >>> np.maximum_sctype(complex)
+    <class 'numpy.complex256'> # may vary
+
+    >>> np.maximum_sctype(str)
+    <class 'numpy.str_'>
+
+    >>> np.maximum_sctype('i2')
+    <class 'numpy.int64'>
+    >>> np.maximum_sctype('f4')
+    <class 'numpy.float128'> # may vary
+
+    " :arglists '[[t]]} maximum_sctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "maximum_sctype"))))
+
+(def ^{:doc "
+    Build a matrix object from a string, nested sequence, or array.
+
+    Parameters
+    ----------
+    obj : str or array_like
+        Input data. If a string, variables in the current scope may be
+        referenced by name.
+    ldict : dict, optional
+        A dictionary that replaces local operands in current frame.
+        Ignored if `obj` is not a string or `gdict` is None.
+    gdict : dict, optional
+        A dictionary that replaces global operands in current frame.
+        Ignored if `obj` is not a string.
+
+    Returns
+    -------
+    out : matrix
+        Returns a matrix object, which is a specialized 2-D array.
+
+    See Also
+    --------
+    block :
+        A generalization of this function for N-d arrays, that returns normal
+        ndarrays.
+
+    Examples
+    --------
+    >>> A = np.mat('1 1; 1 1')
+    >>> B = np.mat('2 2; 2 2')
+    >>> C = np.mat('3 4; 5 6')
+    >>> D = np.mat('7 8; 9 0')
+
+    All the following expressions construct the same block matrix:
+
+    >>> np.bmat([[A, B], [C, D]])
+    matrix([[1, 1, 2, 2],
+            [1, 1, 2, 2],
+            [3, 4, 7, 8],
+            [5, 6, 9, 0]])
+    >>> np.bmat(np.r_[np.c_[A, B], np.c_[C, D]])
+    matrix([[1, 1, 2, 2],
+            [1, 1, 2, 2],
+            [3, 4, 7, 8],
+            [5, 6, 9, 0]])
+    >>> np.bmat('A,B; C,D')
+    matrix([[1, 1, 2, 2],
+            [1, 1, 2, 2],
+            [3, 4, 7, 8],
+            [5, 6, 9, 0]])
+
+    " :arglists '[[obj & [{ldict :ldict, gdict :gdict}]] [obj & [{ldict :ldict}]] [obj]]} bmat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bmat"))))
+
+(def ^{:doc "
+    Put values into the destination array by matching 1d index and data slices.
+
+    This iterates over matching 1d slices oriented along the specified axis in
+    the index and data arrays, and uses the former to place values into the
+    latter. These slices can be different lengths.
+
+    Functions returning an index along an axis, like `argsort` and
+    `argpartition`, produce suitable indices for this function.
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    arr: ndarray (Ni..., M, Nk...)
+        Destination array.
+    indices: ndarray (Ni..., J, Nk...)
+        Indices to change along each 1d slice of `arr`. This must match the
+        dimension of arr, but dimensions in Ni and Nj may be 1 to broadcast
+        against `arr`.
+    values: array_like (Ni..., J, Nk...)
+        values to insert at those indices. Its shape and dimension are
+        broadcast to match that of `indices`.
+    axis: int
+        The axis to take 1d slices along. If axis is None, the destination
+        array is treated as if a flattened 1d view had been created of it.
+
+    Notes
+    -----
+    This is equivalent to (but faster than) the following use of `ndindex` and
+    `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::
+
+        Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
+        J = indices.shape[axis]  # Need not equal M
+
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                a_1d       = a      [ii + s_[:,] + kk]
+                indices_1d = indices[ii + s_[:,] + kk]
+                values_1d  = values [ii + s_[:,] + kk]
+                for j in range(J):
+                    a_1d[indices_1d[j]] = values_1d[j]
+
+    Equivalently, eliminating the inner loop, the last two lines would be::
+
+                a_1d[indices_1d] = values_1d
+
+    See Also
+    --------
+    take_along_axis :
+        Take values from the input array by matching 1d index and data slices
+
+    Examples
+    --------
+
+    For this sample array
+
+    >>> a = np.array([[10, 30, 20], [60, 40, 50]])
+
+    We can replace the maximum values with:
+
+    >>> ai = np.expand_dims(np.argmax(a, axis=1), axis=1)
+    >>> ai
+    array([[1],
+           [0]])
+    >>> np.put_along_axis(a, ai, 99, axis=1)
+    >>> a
+    array([[10, 99, 20],
+           [99, 40, 50]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} put_along_axis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "put_along_axis"))))
+
+(def ^{:doc "logical_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the truth value of x1 OR x2 element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Logical OR is applied to the elements of `x1` and `x2`.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or bool
+    Boolean result of the logical OR operation applied to the elements
+    of `x1` and `x2`; the shape is determined by broadcasting.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_and, logical_not, logical_xor
+bitwise_or
+
+Examples
+--------
+>>> np.logical_or(True, False)
+True
+>>> np.logical_or([True, False], [False, False])
+array([ True, False])
+
+>>> x = np.arange(5)
+>>> np.logical_or(x < 1, x > 3)
+array([ True, False, False, False,  True])
+
+The ``|`` operator can be used as a shorthand for ``np.logical_or`` on
+boolean ndarrays.
+
+>>> a = np.array([True, False])
+>>> b = np.array([False, False])
+>>> a | b
+array([ True, False])" :arglists '[[self & [args {:as kwargs}]]]} logical_or (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_or"))))
+
+(def ^{:doc "Either an opaque sequence of bytes, or a structure.
+    
+    >>> np.void(b'abcd')
+    void(b'\\x61\\x62\\x63\\x64')
+    
+    Structured `void` scalars can only be constructed via extraction from :ref:`structured_arrays`:
+    
+    >>> arr = np.array((1, 2), dtype=[('x', np.int8), ('y', np.int8)])
+    >>> arr[()]
+    (1, 2)  # looks like a tuple, but is `np.void`
+
+    :Character code: ``'V'``" :arglists '[[self & [args {:as kwargs}]]]} void (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "void"))))
+
+(def ^{:doc ""} e 2.718281828459045)
+
+(def ^{:doc "positive(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Numerical positive, element-wise.
+
+.. versionadded:: 1.13.0
+
+Parameters
+----------
+x : array_like or scalar
+    Input array.
+
+Returns
+-------
+y : ndarray or scalar
+    Returned array or scalar: `y = +x`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+Equivalent to `x.copy()`, but only defined for types that support
+arithmetic.
+
+Examples
+--------
+
+>>> x1 = np.array(([1., -1.]))
+>>> np.positive(x1)
+array([ 1., -1.])
+
+The unary ``+`` operator can be used as a shorthand for ``np.positive`` on
+ndarrays.
+
+>>> x1 = np.array(([1., -1.]))
+>>> +x1
+array([ 1., -1.])" :arglists '[[self & [args {:as kwargs}]]]} positive (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "positive"))))
+
+(def ^{:doc ""} inf ##Inf)
+
+(def ^{:doc "nditer(op, flags=None, op_flags=None, op_dtypes=None, order='K', casting='safe', op_axes=None, itershape=None, buffersize=0)
+
+    Efficient multi-dimensional iterator object to iterate over arrays.
+    To get started using this object, see the
+    :ref:`introductory guide to array iteration <arrays.nditer>`.
+
+    Parameters
+    ----------
+    op : ndarray or sequence of array_like
+        The array(s) to iterate over.
+
+    flags : sequence of str, optional
+          Flags to control the behavior of the iterator.
+
+          * ``buffered`` enables buffering when required.
+          * ``c_index`` causes a C-order index to be tracked.
+          * ``f_index`` causes a Fortran-order index to be tracked.
+          * ``multi_index`` causes a multi-index, or a tuple of indices
+            with one per iteration dimension, to be tracked.
+          * ``common_dtype`` causes all the operands to be converted to
+            a common data type, with copying or buffering as necessary.
+          * ``copy_if_overlap`` causes the iterator to determine if read
+            operands have overlap with write operands, and make temporary
+            copies as necessary to avoid overlap. False positives (needless
+            copying) are possible in some cases.
+          * ``delay_bufalloc`` delays allocation of the buffers until
+            a reset() call is made. Allows ``allocate`` operands to
+            be initialized before their values are copied into the buffers.
+          * ``external_loop`` causes the ``values`` given to be
+            one-dimensional arrays with multiple values instead of
+            zero-dimensional arrays.
+          * ``grow_inner`` allows the ``value`` array sizes to be made
+            larger than the buffer size when both ``buffered`` and
+            ``external_loop`` is used.
+          * ``ranged`` allows the iterator to be restricted to a sub-range
+            of the iterindex values.
+          * ``refs_ok`` enables iteration of reference types, such as
+            object arrays.
+          * ``reduce_ok`` enables iteration of ``readwrite`` operands
+            which are broadcasted, also known as reduction operands.
+          * ``zerosize_ok`` allows `itersize` to be zero.
+    op_flags : list of list of str, optional
+          This is a list of flags for each operand. At minimum, one of
+          ``readonly``, ``readwrite``, or ``writeonly`` must be specified.
+
+          * ``readonly`` indicates the operand will only be read from.
+          * ``readwrite`` indicates the operand will be read from and written to.
+          * ``writeonly`` indicates the operand will only be written to.
+          * ``no_broadcast`` prevents the operand from being broadcasted.
+          * ``contig`` forces the operand data to be contiguous.
+          * ``aligned`` forces the operand data to be aligned.
+          * ``nbo`` forces the operand data to be in native byte order.
+          * ``copy`` allows a temporary read-only copy if required.
+          * ``updateifcopy`` allows a temporary read-write copy if required.
+          * ``allocate`` causes the array to be allocated if it is None
+            in the ``op`` parameter.
+          * ``no_subtype`` prevents an ``allocate`` operand from using a subtype.
+          * ``arraymask`` indicates that this operand is the mask to use
+            for selecting elements when writing to operands with the
+            'writemasked' flag set. The iterator does not enforce this,
+            but when writing from a buffer back to the array, it only
+            copies those elements indicated by this mask.
+          * ``writemasked`` indicates that only elements where the chosen
+            ``arraymask`` operand is True will be written to.
+          * ``overlap_assume_elementwise`` can be used to mark operands that are
+            accessed only in the iterator order, to allow less conservative
+            copying when ``copy_if_overlap`` is present.
+    op_dtypes : dtype or tuple of dtype(s), optional
+        The required data type(s) of the operands. If copying or buffering
+        is enabled, the data will be converted to/from their original types.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Controls the iteration order. 'C' means C order, 'F' means
+        Fortran order, 'A' means 'F' order if all the arrays are Fortran
+        contiguous, 'C' order otherwise, and 'K' means as close to the
+        order the array elements appear in memory as possible. This also
+        affects the element memory order of ``allocate`` operands, as they
+        are allocated to be compatible with iteration order.
+        Default is 'K'.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur when making a copy
+        or buffering.  Setting this to 'unsafe' is not recommended,
+        as it can adversely affect accumulations.
+
+        * 'no' means the data types should not be cast at all.
+        * 'equiv' means only byte-order changes are allowed.
+        * 'safe' means only casts which can preserve values are allowed.
+        * 'same_kind' means only safe casts or casts within a kind,
+          like float64 to float32, are allowed.
+        * 'unsafe' means any data conversions may be done.
+    op_axes : list of list of ints, optional
+        If provided, is a list of ints or None for each operands.
+        The list of axes for an operand is a mapping from the dimensions
+        of the iterator to the dimensions of the operand. A value of
+        -1 can be placed for entries, causing that dimension to be
+        treated as `newaxis`.
+    itershape : tuple of ints, optional
+        The desired shape of the iterator. This allows ``allocate`` operands
+        with a dimension mapped by op_axes not corresponding to a dimension
+        of a different operand to get a value not equal to 1 for that
+        dimension.
+    buffersize : int, optional
+        When buffering is enabled, controls the size of the temporary
+        buffers. Set to 0 for the default value.
+
+    Attributes
+    ----------
+    dtypes : tuple of dtype(s)
+        The data types of the values provided in `value`. This may be
+        different from the operand data types if buffering is enabled.
+        Valid only before the iterator is closed.
+    finished : bool
+        Whether the iteration over the operands is finished or not.
+    has_delayed_bufalloc : bool
+        If True, the iterator was created with the ``delay_bufalloc`` flag,
+        and no reset() function was called on it yet.
+    has_index : bool
+        If True, the iterator was created with either the ``c_index`` or
+        the ``f_index`` flag, and the property `index` can be used to
+        retrieve it.
+    has_multi_index : bool
+        If True, the iterator was created with the ``multi_index`` flag,
+        and the property `multi_index` can be used to retrieve it.
+    index
+        When the ``c_index`` or ``f_index`` flag was used, this property
+        provides access to the index. Raises a ValueError if accessed
+        and ``has_index`` is False.
+    iterationneedsapi : bool
+        Whether iteration requires access to the Python API, for example
+        if one of the operands is an object array.
+    iterindex : int
+        An index which matches the order of iteration.
+    itersize : int
+        Size of the iterator.
+    itviews
+        Structured view(s) of `operands` in memory, matching the reordered
+        and optimized iterator access pattern. Valid only before the iterator
+        is closed.
+    multi_index
+        When the ``multi_index`` flag was used, this property
+        provides access to the index. Raises a ValueError if accessed
+        accessed and ``has_multi_index`` is False.
+    ndim : int
+        The dimensions of the iterator.
+    nop : int
+        The number of iterator operands.
+    operands : tuple of operand(s)
+        The array(s) to be iterated over. Valid only before the iterator is
+        closed.
+    shape : tuple of ints
+        Shape tuple, the shape of the iterator.
+    value
+        Value of ``operands`` at current iteration. Normally, this is a
+        tuple of array scalars, but if the flag ``external_loop`` is used,
+        it is a tuple of one dimensional arrays.
+
+    Notes
+    -----
+    `nditer` supersedes `flatiter`.  The iterator implementation behind
+    `nditer` is also exposed by the NumPy C API.
+
+    The Python exposure supplies two iteration interfaces, one which follows
+    the Python iterator protocol, and another which mirrors the C-style
+    do-while pattern.  The native Python approach is better in most cases, but
+    if you need the coordinates or index of an iterator, use the C-style pattern.
+
+    Examples
+    --------
+    Here is how we might write an ``iter_add`` function, using the
+    Python iterator protocol:
+
+    >>> def iter_add_py(x, y, out=None):
+    ...     addop = np.add
+    ...     it = np.nditer([x, y, out], [],
+    ...                 [['readonly'], ['readonly'], ['writeonly','allocate']])
+    ...     with it:
+    ...         for (a, b, c) in it:
+    ...             addop(a, b, out=c)
+    ...     return it.operands[2]
+
+    Here is the same function, but following the C-style pattern:
+
+    >>> def iter_add(x, y, out=None):
+    ...    addop = np.add
+    ...    it = np.nditer([x, y, out], [],
+    ...                [['readonly'], ['readonly'], ['writeonly','allocate']])
+    ...    with it:
+    ...        while not it.finished:
+    ...            addop(it[0], it[1], out=it[2])
+    ...            it.iternext()
+    ...        return it.operands[2]
+
+    Here is an example outer product function:
+
+    >>> def outer_it(x, y, out=None):
+    ...     mulop = np.multiply
+    ...     it = np.nditer([x, y, out], ['external_loop'],
+    ...             [['readonly'], ['readonly'], ['writeonly', 'allocate']],
+    ...             op_axes=[list(range(x.ndim)) + [-1] * y.ndim,
+    ...                      [-1] * x.ndim + list(range(y.ndim)),
+    ...                      None])
+    ...     with it:
+    ...         for (a, b, c) in it:
+    ...             mulop(a, b, out=c)
+    ...         return it.operands[2]
+
+    >>> a = np.arange(2)+1
+    >>> b = np.arange(3)+1
+    >>> outer_it(a,b)
+    array([[1, 2, 3],
+           [2, 4, 6]])
+
+    Here is an example function which operates like a \"lambda\" ufunc:
+
+    >>> def luf(lamdaexpr, *args, **kwargs):
+    ...    '''luf(lambdaexpr, op1, ..., opn, out=None, order='K', casting='safe', buffersize=0)'''
+    ...    nargs = len(args)
+    ...    op = (kwargs.get('out',None),) + args
+    ...    it = np.nditer(op, ['buffered','external_loop'],
+    ...            [['writeonly','allocate','no_broadcast']] +
+    ...                            [['readonly','nbo','aligned']]*nargs,
+    ...            order=kwargs.get('order','K'),
+    ...            casting=kwargs.get('casting','safe'),
+    ...            buffersize=kwargs.get('buffersize',0))
+    ...    while not it.finished:
+    ...        it[0] = lamdaexpr(*it[1:])
+    ...        it.iternext()
+    ...        return it.operands[0]
+
+    >>> a = np.arange(5)
+    >>> b = np.ones(5)
+    >>> luf(lambda i,j:i*i + j/2, a, b)
+    array([  0.5,   1.5,   4.5,   9.5,  16.5])
+
+    If operand flags `\"writeonly\"` or `\"readwrite\"` are used the
+    operands may be views into the original data with the
+    `WRITEBACKIFCOPY` flag. In this case `nditer` must be used as a
+    context manager or the `nditer.close` method must be called before
+    using the result. The temporary data will be written back to the
+    original data when the `__exit__` function is called but not before:
+
+    >>> a = np.arange(6, dtype='i4')[::-2]
+    >>> with np.nditer(a, [],
+    ...        [['writeonly', 'updateifcopy']],
+    ...        casting='unsafe',
+    ...        op_dtypes=[np.dtype('f4')]) as i:
+    ...    x = i.operands[0]
+    ...    x[:] = [-1, -2, -3]
+    ...    # a still unchanged here
+    >>> a, x
+    (array([-1, -2, -3], dtype=int32), array([-1., -2., -3.], dtype=float32))
+
+    It is important to note that once the iterator is exited, dangling
+    references (like `x` in the example) may or may not share data with
+    the original data `a`. If writeback semantics were active, i.e. if
+    `x.base.flags.writebackifcopy` is `True`, then exiting the iterator
+    will sever the connection between `x` and `a`, writing to `x` will
+    no longer write to `a`. If writeback semantics are not active, then
+    `x.data` will still point at some part of `a.data`, and writing to
+    one will affect the other.
+
+    Context management and the `close` method appeared in version 1.15.0." :arglists '[[self & [args {:as kwargs}]]]} nditer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nditer"))))
+
+(def ^{:doc "
+    Return the sum of array elements over a given axis treating Not a
+    Numbers (NaNs) as zero.
+
+    In NumPy versions <= 1.9.0 Nan is returned for slices that are all-NaN or
+    empty. In later versions zero is returned.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose sum is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the sum is computed. The default is to compute the
+        sum of the flattened array.
+    dtype : data-type, optional
+        The type of the returned array and of the accumulator in which the
+        elements are summed.  By default, the dtype of `a` is used.  An
+        exception is when `a` has an integer type with less precision than
+        the platform (u)intp. In that case, the default will be either
+        (u)int32 or (u)int64 depending on whether the platform is 32 or 64
+        bits. For inexact inputs, dtype must be inexact.
+
+        .. versionadded:: 1.8.0
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``. If provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary.  See
+        :ref:`ufuncs-output-type` for more details. The casting of NaN to integer
+        can yield unexpected results.
+
+        .. versionadded:: 1.8.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `mean` or `sum` methods
+        of sub-classes of `ndarray`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+        .. versionadded:: 1.8.0
+
+    Returns
+    -------
+    nansum : ndarray.
+        A new array holding the result is returned unless `out` is
+        specified, in which it is returned. The result has the same
+        size as `a`, and the same shape as `a` if `axis` is not None
+        or `a` is a 1-d array.
+
+    See Also
+    --------
+    numpy.sum : Sum across array propagating NaNs.
+    isnan : Show which elements are NaN.
+    isfinite: Show which elements are not NaN or +/-inf.
+
+    Notes
+    -----
+    If both positive and negative infinity are present, the sum will be Not
+    A Number (NaN).
+
+    Examples
+    --------
+    >>> np.nansum(1)
+    1
+    >>> np.nansum([1])
+    1
+    >>> np.nansum([1, np.nan])
+    1.0
+    >>> a = np.array([[1, 1], [1, np.nan]])
+    >>> np.nansum(a)
+    3.0
+    >>> np.nansum(a, axis=0)
+    array([2.,  1.])
+    >>> np.nansum([1, np.nan, np.inf])
+    inf
+    >>> np.nansum([1, np.nan, np.NINF])
+    -inf
+    >>> from numpy.testing import suppress_warnings
+    >>> with suppress_warnings() as sup:
+    ...     sup.filter(RuntimeWarning)
+    ...     np.nansum([1, np.nan, np.inf, -np.inf]) # both +/- infinity present
+    nan
+
+    " :arglists '[[& [args {:as kwargs}]]]} nansum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nansum"))))
+
+(def ^{:doc "
+    Return the product of array elements over a given axis treating Not a
+    Numbers (NaNs) as ones.
+
+    One is returned for slices that are all-NaN or empty.
+
+    .. versionadded:: 1.10.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose product is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the product is computed. The default is to compute
+        the product of the flattened array.
+    dtype : data-type, optional
+        The type of the returned array and of the accumulator in which the
+        elements are summed.  By default, the dtype of `a` is used.  An
+        exception is when `a` has an integer type with less precision than
+        the platform (u)intp. In that case, the default will be either
+        (u)int32 or (u)int64 depending on whether the platform is 32 or 64
+        bits. For inexact inputs, dtype must be inexact.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``. If provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary. See
+        :ref:`ufuncs-output-type` for more details. The casting of NaN to integer
+        can yield unexpected results.
+    keepdims : bool, optional
+        If True, the axes which are reduced are left in the result as
+        dimensions with size one. With this option, the result will
+        broadcast correctly against the original `arr`.
+
+    Returns
+    -------
+    nanprod : ndarray
+        A new array holding the result is returned unless `out` is
+        specified, in which case it is returned.
+
+    See Also
+    --------
+    numpy.prod : Product across array propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> np.nanprod(1)
+    1
+    >>> np.nanprod([1])
+    1
+    >>> np.nanprod([1, np.nan])
+    1.0
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nanprod(a)
+    6.0
+    >>> np.nanprod(a, axis=0)
+    array([3., 2.])
+
+    " :arglists '[[& [args {:as kwargs}]]]} nanprod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanprod"))))
+
+(def ^{:doc "
+    Find the set exclusive-or of two arrays.
+
+    Return the sorted, unique values that are in only one (not both) of the
+    input arrays.
+
+    Parameters
+    ----------
+    ar1, ar2 : array_like
+        Input arrays.
+    assume_unique : bool
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+
+    Returns
+    -------
+    setxor1d : ndarray
+        Sorted 1D array of unique values that are in only one of the input
+        arrays.
+
+    Examples
+    --------
+    >>> a = np.array([1, 2, 3, 2, 4])
+    >>> b = np.array([2, 3, 5, 7, 5])
+    >>> np.setxor1d(a,b)
+    array([1, 4, 5, 7])
+
+    " :arglists '[[& [args {:as kwargs}]]]} setxor1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "setxor1d"))))
+
+(def ^{:doc "
+    Return an array copy of the given object.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Controls the memory layout of the copy. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible. (Note that this function and :meth:`ndarray.copy` are very
+        similar, but have different default values for their order=
+        arguments.)
+    subok : bool, optional
+        If True, then sub-classes will be passed-through, otherwise the
+        returned array will be forced to be a base-class array (defaults to False).
+
+        .. versionadded:: 1.19.0
+
+    Returns
+    -------
+    arr : ndarray
+        Array interpretation of `a`.
+
+    See Also
+    --------
+    ndarray.copy : Preferred method for creating an array copy
+
+    Notes
+    -----
+    This is equivalent to:
+
+    >>> np.array(a, copy=True)  #doctest: +SKIP
+
+    Examples
+    --------
+    Create an array x, with a reference y and a copy z:
+
+    >>> x = np.array([1, 2, 3])
+    >>> y = x
+    >>> z = np.copy(x)
+
+    Note that, when we modify x, y changes, but not z:
+
+    >>> x[0] = 10
+    >>> x[0] == y[0]
+    True
+    >>> x[0] == z[0]
+    False
+
+    Note that np.copy is a shallow copy and will not copy object
+    elements within arrays. This is mainly important for arrays
+    containing Python objects. The new array will contain the
+    same object which may lead to surprises if that object can
+    be modified (is mutable):
+
+    >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
+    >>> b = np.copy(a)
+    >>> b[2][0] = 10
+    >>> a
+    array([1, 'm', list([10, 3, 4])], dtype=object)
+
+    To ensure all elements within an ``object`` array are copied,
+    use `copy.deepcopy`:
+
+    >>> import copy
+    >>> a = np.array([1, 'm', [2, 3, 4]], dtype=object)
+    >>> c = copy.deepcopy(a)
+    >>> c[2][0] = 10
+    >>> c
+    array([1, 'm', list([10, 3, 4])], dtype=object)
+    >>> a
+    array([1, 'm', list([2, 3, 4])], dtype=object)
+
+    " :arglists '[[& [args {:as kwargs}]]]} copy (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "copy"))))
+
+(def ^{:doc "
+    Test whether each element of a 1-D array is also present in a second array.
+
+    Returns a boolean array the same length as `ar1` that is True
+    where an element of `ar1` is in `ar2` and False otherwise.
+
+    We recommend using :func:`isin` instead of `in1d` for new code.
+
+    Parameters
+    ----------
+    ar1 : (M,) array_like
+        Input array.
+    ar2 : array_like
+        The values against which to test each value of `ar1`.
+    assume_unique : bool, optional
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+    invert : bool, optional
+        If True, the values in the returned array are inverted (that is,
+        False where an element of `ar1` is in `ar2` and True otherwise).
+        Default is False. ``np.in1d(a, b, invert=True)`` is equivalent
+        to (but is faster than) ``np.invert(in1d(a, b))``.
+
+        .. versionadded:: 1.8.0
+
+    Returns
+    -------
+    in1d : (M,) ndarray, bool
+        The values `ar1[in1d]` are in `ar2`.
+
+    See Also
+    --------
+    isin                  : Version of this function that preserves the
+                            shape of ar1.
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Notes
+    -----
+    `in1d` can be considered as an element-wise function version of the
+    python keyword `in`, for 1-D sequences. ``in1d(a, b)`` is roughly
+    equivalent to ``np.array([item in b for item in a])``.
+    However, this idea fails if `ar2` is a set, or similar (non-sequence)
+    container:  As ``ar2`` is converted to an array, in those cases
+    ``asarray(ar2)`` is an object array rather than the expected array of
+    contained values.
+
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    >>> test = np.array([0, 1, 2, 5, 0])
+    >>> states = [0, 2]
+    >>> mask = np.in1d(test, states)
+    >>> mask
+    array([ True, False,  True, False,  True])
+    >>> test[mask]
+    array([0, 2, 0])
+    >>> mask = np.in1d(test, states, invert=True)
+    >>> mask
+    array([False,  True, False,  True, False])
+    >>> test[mask]
+    array([1, 5])
+    " :arglists '[[& [args {:as kwargs}]]]} in1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "in1d"))))
+
+(def ^{:doc "Complex number type composed of two double-precision floating-point
+    numbers, compatible with Python `complex`.
+
+    :Character code: ``'D'``
+    :Canonical name: `numpy.cdouble`
+    :Alias: `numpy.cfloat`
+    :Alias: `numpy.complex_`
+    :Alias on this platform: `numpy.complex128`: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} complex_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex_"))))
+
+(def ^{:doc "
+    Translates slice objects to concatenation along the second axis.
+
+    This is short-hand for ``np.r_['-1,2,0', index expression]``, which is
+    useful because of its common occurrence. In particular, arrays will be
+    stacked along their last axis after being upgraded to at least 2-D with
+    1's post-pended to the shape (column vectors made out of 1-D arrays).
+    
+    See Also
+    --------
+    column_stack : Stack 1-D arrays as columns into a 2-D array.
+    r_ : For more detailed documentation.
+
+    Examples
+    --------
+    >>> np.c_[np.array([1,2,3]), np.array([4,5,6])]
+    array([[1, 4],
+           [2, 5],
+           [3, 6]])
+    >>> np.c_[np.array([[1,2,3]]), 0, 0, np.array([[4,5,6]])]
+    array([[1, 2, 3, ..., 4, 5, 6]])
+
+    "} c_ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "c_"))))
+
+(def ^{:doc "
+    `nd_grid` instance which returns a dense multi-dimensional \"meshgrid\".
+
+    An instance of `numpy.lib.index_tricks.nd_grid` which returns an dense
+    (or fleshed out) mesh-grid when indexed, so that each returned argument
+    has the same shape.  The dimensions and number of the output arrays are
+    equal to the number of indexing dimensions.  If the step length is not a
+    complex number, then the stop is not inclusive.
+
+    However, if the step length is a **complex number** (e.g. 5j), then
+    the integer part of its magnitude is interpreted as specifying the
+    number of points to create between the start and stop values, where
+    the stop value **is inclusive**.
+
+    Returns
+    -------
+    mesh-grid `ndarrays` all of the same dimensions
+
+    See Also
+    --------
+    numpy.lib.index_tricks.nd_grid : class of `ogrid` and `mgrid` objects
+    ogrid : like mgrid but returns open (not fleshed out) mesh grids
+    r_ : array concatenator
+
+    Examples
+    --------
+    >>> np.mgrid[0:5,0:5]
+    array([[[0, 0, 0, 0, 0],
+            [1, 1, 1, 1, 1],
+            [2, 2, 2, 2, 2],
+            [3, 3, 3, 3, 3],
+            [4, 4, 4, 4, 4]],
+           [[0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4],
+            [0, 1, 2, 3, 4]]])
+    >>> np.mgrid[-1:1:5j]
+    array([-1. , -0.5,  0. ,  0.5,  1. ])
+
+    "} mgrid (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "mgrid"))))
+
+(def ^{:doc "
+    Integrate along the given axis using the composite trapezoidal rule.
+
+    Integrate `y` (`x`) along given axis.
+
+    Parameters
+    ----------
+    y : array_like
+        Input array to integrate.
+    x : array_like, optional
+        The sample points corresponding to the `y` values. If `x` is None,
+        the sample points are assumed to be evenly spaced `dx` apart. The
+        default is None.
+    dx : scalar, optional
+        The spacing between sample points when `x` is None. The default is 1.
+    axis : int, optional
+        The axis along which to integrate.
+
+    Returns
+    -------
+    trapz : float
+        Definite integral as approximated by trapezoidal rule.
+
+    See Also
+    --------
+    sum, cumsum
+
+    Notes
+    -----
+    Image [2]_ illustrates trapezoidal rule -- y-axis locations of points
+    will be taken from `y` array, by default x-axis distances between
+    points will be 1.0, alternatively they can be provided with `x` array
+    or with `dx` scalar.  Return value will be equal to combined area under
+    the red lines.
+
+
+    References
+    ----------
+    .. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule
+
+    .. [2] Illustration image:
+           https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png
+
+    Examples
+    --------
+    >>> np.trapz([1,2,3])
+    4.0
+    >>> np.trapz([1,2,3], x=[4,6,8])
+    8.0
+    >>> np.trapz([1,2,3], dx=2)
+    8.0
+    >>> a = np.arange(6).reshape(2, 3)
+    >>> a
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.trapz(a, axis=0)
+    array([1.5, 2.5, 3.5])
+    >>> np.trapz(a, axis=1)
+    array([2.,  8.])
+
+    " :arglists '[[& [args {:as kwargs}]]]} trapz (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trapz"))))
+
+(def ^{:doc "Double-precision floating-point number type, compatible with Python `float`
+    and C ``double``.
+
+    :Character code: ``'d'``
+    :Canonical name: `numpy.double`
+    :Alias: `numpy.float_`
+    :Alias on this platform: `numpy.float64`: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa." :arglists '[[self & [args {:as kwargs}]]]} float64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float64"))))
+
+(def ^{:doc "
+    Compute the multidimensional histogram of some data.
+
+    Parameters
+    ----------
+    sample : (N, D) array, or (D, N) array_like
+        The data to be histogrammed.
+
+        Note the unusual interpretation of sample when an array_like:
+
+        * When an array, each row is a coordinate in a D-dimensional space -
+          such as ``histogramdd(np.array([p1, p2, p3]))``.
+        * When an array_like, each element is the list of values for single
+          coordinate - such as ``histogramdd((X, Y, Z))``.
+
+        The first form should be preferred.
+
+    bins : sequence or int, optional
+        The bin specification:
+
+        * A sequence of arrays describing the monotonically increasing bin
+          edges along each dimension.
+        * The number of bins for each dimension (nx, ny, ... =bins)
+        * The number of bins for all dimensions (nx=ny=...=bins).
+
+    range : sequence, optional
+        A sequence of length D, each an optional (lower, upper) tuple giving
+        the outer bin edges to be used if the edges are not given explicitly in
+        `bins`.
+        An entry of None in the sequence results in the minimum and maximum
+        values being used for the corresponding dimension.
+        The default, None, is equivalent to passing a tuple of D None values.
+    density : bool, optional
+        If False, the default, returns the number of samples in each bin.
+        If True, returns the probability *density* function at the bin,
+        ``bin_count / sample_count / bin_volume``.
+    normed : bool, optional
+        An alias for the density argument that behaves identically. To avoid
+        confusion with the broken normed argument to `histogram`, `density`
+        should be preferred.
+    weights : (N,) array_like, optional
+        An array of values `w_i` weighing each sample `(x_i, y_i, z_i, ...)`.
+        Weights are normalized to 1 if normed is True. If normed is False,
+        the values of the returned histogram are equal to the sum of the
+        weights belonging to the samples falling into each bin.
+
+    Returns
+    -------
+    H : ndarray
+        The multidimensional histogram of sample x. See normed and weights
+        for the different possible semantics.
+    edges : list
+        A list of D arrays describing the bin edges for each dimension.
+
+    See Also
+    --------
+    histogram: 1-D histogram
+    histogram2d: 2-D histogram
+
+    Examples
+    --------
+    >>> r = np.random.randn(100,3)
+    >>> H, edges = np.histogramdd(r, bins = (5, 8, 4))
+    >>> H.shape, edges[0].size, edges[1].size, edges[2].size
+    ((5, 8, 4), 6, 9, 5)
+
+    " :arglists '[[& [args {:as kwargs}]]]} histogramdd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogramdd"))))
+
+(def ^{:doc "
+    Compute the weighted average along the specified axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing data to be averaged. If `a` is not an array, a
+        conversion is attempted.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to average `a`.  The default,
+        axis=None, will average over all of the elements of the input array.
+        If axis is negative it counts from the last to the first axis.
+
+        .. versionadded:: 1.7.0
+
+        If axis is a tuple of ints, averaging is performed on all of the axes
+        specified in the tuple instead of a single axis or all the axes as
+        before.
+    weights : array_like, optional
+        An array of weights associated with the values in `a`. Each value in
+        `a` contributes to the average according to its associated weight.
+        The weights array can either be 1-D (in which case its length must be
+        the size of `a` along the given axis) or of the same shape as `a`.
+        If `weights=None`, then all data in `a` are assumed to have a
+        weight equal to one.  The 1-D calculation is::
+
+            avg = sum(a * weights) / sum(weights)
+
+        The only constraint on `weights` is that `sum(weights)` must not be 0.
+    returned : bool, optional
+        Default is `False`. If `True`, the tuple (`average`, `sum_of_weights`)
+        is returned, otherwise only the average is returned.
+        If `weights=None`, `sum_of_weights` is equivalent to the number of
+        elements over which the average is taken.
+
+    Returns
+    -------
+    retval, [sum_of_weights] : array_type or double
+        Return the average along the specified axis. When `returned` is `True`,
+        return a tuple with the average as the first element and the sum
+        of the weights as the second element. `sum_of_weights` is of the
+        same type as `retval`. The result dtype follows a genereal pattern.
+        If `weights` is None, the result dtype will be that of `a` , or ``float64``
+        if `a` is integral. Otherwise, if `weights` is not None and `a` is non-
+        integral, the result type will be the type of lowest precision capable of
+        representing values of both `a` and `weights`. If `a` happens to be
+        integral, the previous rules still applies but the result dtype will
+        at least be ``float64``.
+
+    Raises
+    ------
+    ZeroDivisionError
+        When all weights along axis are zero. See `numpy.ma.average` for a
+        version robust to this type of error.
+    TypeError
+        When the length of 1D `weights` is not the same as the shape of `a`
+        along axis.
+
+    See Also
+    --------
+    mean
+
+    ma.average : average for masked arrays -- useful if your data contains
+                 \"missing\" values
+    numpy.result_type : Returns the type that results from applying the
+                        numpy type promotion rules to the arguments.
+
+    Examples
+    --------
+    >>> data = np.arange(1, 5)
+    >>> data
+    array([1, 2, 3, 4])
+    >>> np.average(data)
+    2.5
+    >>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1))
+    4.0
+
+    >>> data = np.arange(6).reshape((3,2))
+    >>> data
+    array([[0, 1],
+           [2, 3],
+           [4, 5]])
+    >>> np.average(data, axis=1, weights=[1./4, 3./4])
+    array([0.75, 2.75, 4.75])
+    >>> np.average(data, weights=[1./4, 3./4])
+    Traceback (most recent call last):
+        ...
+    TypeError: Axis must be specified when shapes of a and weights differ.
+
+    >>> a = np.ones(5, dtype=np.float128)
+    >>> w = np.ones(5, dtype=np.complex64)
+    >>> avg = np.average(a, weights=w)
+    >>> print(avg.dtype)
+    complex256
+    " :arglists '[[& [args {:as kwargs}]]]} average (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "average"))))
+
+(def ^{:doc "
+    Check for a complex type or an array of complex numbers.
+
+    The type of the input is checked, not the value. Even if the input
+    has an imaginary part equal to zero, `iscomplexobj` evaluates to True.
+
+    Parameters
+    ----------
+    x : any
+        The input can be of any type and shape.
+
+    Returns
+    -------
+    iscomplexobj : bool
+        The return value, True if `x` is of a complex type or has at least
+        one complex element.
+
+    See Also
+    --------
+    isrealobj, iscomplex
+
+    Examples
+    --------
+    >>> np.iscomplexobj(1)
+    False
+    >>> np.iscomplexobj(1+0j)
+    True
+    >>> np.iscomplexobj([3, 1+0j, True])
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]]} iscomplexobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iscomplexobj"))))
+
+(def ^{:doc "logaddexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Logarithm of the sum of exponentiations of the inputs.
+
+Calculates ``log(exp(x1) + exp(x2))``. This function is useful in
+statistics where the calculated probabilities of events may be so small
+as to exceed the range of normal floating point numbers.  In such cases
+the logarithm of the calculated probability is stored. This function
+allows adding probabilities stored in such a fashion.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input values.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+result : ndarray
+    Logarithm of ``exp(x1) + exp(x2)``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logaddexp2: Logarithm of the sum of exponentiations of inputs in base 2.
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+Examples
+--------
+>>> prob1 = np.log(1e-50)
+>>> prob2 = np.log(2.5e-50)
+>>> prob12 = np.logaddexp(prob1, prob2)
+>>> prob12
+-113.87649168120691
+>>> np.exp(prob12)
+3.5000000000000057e-50" :arglists '[[self & [args {:as kwargs}]]]} logaddexp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logaddexp"))))
+
+(def ^{:doc "multiply(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Multiply arguments element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays to be multiplied.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The product of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+Equivalent to `x1` * `x2` in terms of array broadcasting.
+
+Examples
+--------
+>>> np.multiply(2.0, 4.0)
+8.0
+
+>>> x1 = np.arange(9.0).reshape((3, 3))
+>>> x2 = np.arange(3.0)
+>>> np.multiply(x1, x2)
+array([[  0.,   1.,   4.],
+       [  0.,   4.,  10.],
+       [  0.,   7.,  16.]])
+
+The ``*`` operator can be used as a shorthand for ``np.multiply`` on
+ndarrays.
+
+>>> x1 = np.arange(9.0).reshape((3, 3))
+>>> x2 = np.arange(3.0)
+>>> x1 * x2
+array([[  0.,   1.,   4.],
+       [  0.,   4.,  10.],
+       [  0.,   7.,  16.]])" :arglists '[[self & [args {:as kwargs}]]]} multiply (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "multiply"))))
+
+(def ^{:doc "Unsigned integer type, compatible with C ``unsigned long``.
+
+    :Character code: ``'L'``
+    :Canonical name: `numpy.uint`
+    :Alias on this platform: `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``).
+    :Alias on this platform: `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]]} uint (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint"))))
+
+(def ^{:doc "
+    Compute the qth percentile of the data along the specified axis,
+    while ignoring nan values.
+
+    Returns the qth percentile(s) of the array elements.
+
+    .. versionadded:: 1.9.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array, containing
+        nan values to be ignored.
+    q : array_like of float
+        Percentile or sequence of percentiles to compute, which must be between
+        0 and 100 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the percentiles are computed. The
+        default is to compute the percentile(s) along a flattened
+        version of the array.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by intermediate
+        calculations, to save memory. In this case, the contents of the input
+        `a` after this function completes is undefined.
+    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
+        This optional parameter specifies the interpolation method to
+        use when the desired percentile lies between two data points
+        ``i < j``:
+
+        * 'linear': ``i + (j - i) * fraction``, where ``fraction``
+          is the fractional part of the index surrounded by ``i``
+          and ``j``.
+        * 'lower': ``i``.
+        * 'higher': ``j``.
+        * 'nearest': ``i`` or ``j``, whichever is nearest.
+        * 'midpoint': ``(i + j) / 2``.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+        If this is anything but the default value it will be passed
+        through (in the special case of an empty array) to the
+        `mean` function of the underlying array.  If the array is
+        a sub-class and `mean` does not have the kwarg `keepdims` this
+        will raise a RuntimeError.
+
+    Returns
+    -------
+    percentile : scalar or ndarray
+        If `q` is a single percentile and `axis=None`, then the result
+        is a scalar. If multiple percentiles are given, first axis of
+        the result corresponds to the percentiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    nanmean
+    nanmedian : equivalent to ``nanpercentile(..., 50)``
+    percentile, median, mean
+    nanquantile : equivalent to nanpercentile, but with q in the range [0, 1].
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the ``q``-th percentile of
+    ``V`` is the value ``q/100`` of the way from the minimum to the
+    maximum in a sorted copy of ``V``. The values and distances of
+    the two nearest neighbors as well as the `interpolation` parameter
+    will determine the percentile if the normalized ranking does not
+    match the location of ``q`` exactly. This function is the same as
+    the median if ``q=50``, the same as the minimum if ``q=0`` and the
+    same as the maximum if ``q=100``.
+
+    Examples
+    --------
+    >>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
+    >>> a[0][1] = np.nan
+    >>> a
+    array([[10.,  nan,   4.],
+          [ 3.,   2.,   1.]])
+    >>> np.percentile(a, 50)
+    nan
+    >>> np.nanpercentile(a, 50)
+    3.0
+    >>> np.nanpercentile(a, 50, axis=0)
+    array([6.5, 2. , 2.5])
+    >>> np.nanpercentile(a, 50, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+    >>> m = np.nanpercentile(a, 50, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.nanpercentile(a, 50, axis=0, out=out)
+    array([6.5, 2. , 2.5])
+    >>> m
+    array([6.5,  2. ,  2.5])
+
+    >>> b = a.copy()
+    >>> np.nanpercentile(b, 50, axis=1, overwrite_input=True)
+    array([7., 2.])
+    >>> assert not np.all(a==b)
+
+    " :arglists '[[& [args {:as kwargs}]]]} nanpercentile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanpercentile"))))
+
+(def ^{:doc "Signed integer type, compatible with C ``int``.
+
+    :Character code: ``'i'``
+    :Canonical name: `numpy.intc`
+    :Alias on this platform: `numpy.int32`: 32-bit signed integer (``-2_147_483_648`` to ``2_147_483_647``)." :arglists '[[self & [args {:as kwargs}]]]} intc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "intc"))))
+
+(def ^{:doc "Signed integer type, compatible with C ``int``.
+
+    :Character code: ``'i'``
+    :Canonical name: `numpy.intc`
+    :Alias on this platform: `numpy.int32`: 32-bit signed integer (``-2_147_483_648`` to ``2_147_483_647``)." :arglists '[[self & [args {:as kwargs}]]]} int32 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int32"))))
+
+(def ^{:doc "
+    Change elements of an array based on conditional and input values.
+
+    Similar to ``np.copyto(arr, vals, where=mask)``, the difference is that
+    `place` uses the first N elements of `vals`, where N is the number of
+    True values in `mask`, while `copyto` uses the elements where `mask`
+    is True.
+
+    Note that `extract` does the exact opposite of `place`.
+
+    Parameters
+    ----------
+    arr : ndarray
+        Array to put data into.
+    mask : array_like
+        Boolean mask array. Must have the same size as `a`.
+    vals : 1-D sequence
+        Values to put into `a`. Only the first N elements are used, where
+        N is the number of True values in `mask`. If `vals` is smaller
+        than N, it will be repeated, and if elements of `a` are to be masked,
+        this sequence must be non-empty.
+
+    See Also
+    --------
+    copyto, put, take, extract
+
+    Examples
+    --------
+    >>> arr = np.arange(6).reshape(2, 3)
+    >>> np.place(arr, arr>2, [44, 55])
+    >>> arr
+    array([[ 0,  1,  2],
+           [44, 55, 44]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} place (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "place"))))
+
+(def ^{:doc "
+    Return the shape of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+
+    Returns
+    -------
+    shape : tuple of ints
+        The elements of the shape tuple give the lengths of the
+        corresponding array dimensions.
+
+    See Also
+    --------
+    len
+    ndarray.shape : Equivalent array method.
+
+    Examples
+    --------
+    >>> np.shape(np.eye(3))
+    (3, 3)
+    >>> np.shape([[1, 2]])
+    (1, 2)
+    >>> np.shape([0])
+    (1,)
+    >>> np.shape(0)
+    ()
+
+    >>> a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])
+    >>> np.shape(a)
+    (2,)
+    >>> a.shape
+    (2,)
+
+    " :arglists '[[& [args {:as kwargs}]]]} shape (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "shape"))))
+
+(def ^{:doc "Sub-package containing the matrix class and related functions.
+
+"} matrixlib (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "matrixlib"))))
+
+(def ^{:doc "lcm(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns the lowest common multiple of ``|x1|`` and ``|x2|``
+
+Parameters
+----------
+x1, x2 : array_like, int
+    Arrays of values.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+
+Returns
+-------
+y : ndarray or scalar
+    The lowest common multiple of the absolute value of the inputs
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+gcd : The greatest common divisor
+
+Examples
+--------
+>>> np.lcm(12, 20)
+60
+>>> np.lcm.reduce([3, 12, 20])
+60
+>>> np.lcm.reduce([40, 12, 20])
+120
+>>> np.lcm(np.arange(6), 20)
+array([ 0, 20, 20, 60, 20, 20])" :arglists '[[self & [args {:as kwargs}]]]} lcm (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "lcm"))))
+
+(def ^{:doc "copysign(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Change the sign of x1 to that of x2, element-wise.
+
+If `x2` is a scalar, its sign will be copied to all elements of `x1`.
+
+Parameters
+----------
+x1 : array_like
+    Values to change the sign of.
+x2 : array_like
+    The sign of `x2` is copied to `x1`.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    The values of `x1` with the sign of `x2`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Examples
+--------
+>>> np.copysign(1.3, -1)
+-1.3
+>>> 1/np.copysign(0, 1)
+inf
+>>> 1/np.copysign(0, -1)
+-inf
+
+>>> np.copysign([-1, 0, 1], -1.1)
+array([-1., -0., -1.])
+>>> np.copysign([-1, 0, 1], np.arange(3)-1)
+array([-1.,  0.,  1.])" :arglists '[[self & [args {:as kwargs}]]]} copysign (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "copysign"))))
+
+(def ^{:doc "Unsigned integer type, compatible with C ``unsigned short``.
+
+    :Character code: ``'H'``
+    :Canonical name: `numpy.ushort`
+    :Alias on this platform: `numpy.uint16`: 16-bit unsigned integer (``0`` to ``65_535``)." :arglists '[[self & [args {:as kwargs}]]]} uint16 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint16"))))
+
+(def ^{:doc "
+    Return a new array with sub-arrays along an axis deleted. For a one
+    dimensional array, this returns those entries not returned by
+    `arr[obj]`.
+
+    Parameters
+    ----------
+    arr : array_like
+        Input array.
+    obj : slice, int or array of ints
+        Indicate indices of sub-arrays to remove along the specified axis.
+
+        .. versionchanged:: 1.19.0
+            Boolean indices are now treated as a mask of elements to remove,
+            rather than being cast to the integers 0 and 1.
+
+    axis : int, optional
+        The axis along which to delete the subarray defined by `obj`.
+        If `axis` is None, `obj` is applied to the flattened array.
+
+    Returns
+    -------
+    out : ndarray
+        A copy of `arr` with the elements specified by `obj` removed. Note
+        that `delete` does not occur in-place. If `axis` is None, `out` is
+        a flattened array.
+
+    See Also
+    --------
+    insert : Insert elements into an array.
+    append : Append elements at the end of an array.
+
+    Notes
+    -----
+    Often it is preferable to use a boolean mask. For example:
+
+    >>> arr = np.arange(12) + 1
+    >>> mask = np.ones(len(arr), dtype=bool)
+    >>> mask[[0,2,4]] = False
+    >>> result = arr[mask,...]
+
+    Is equivalent to `np.delete(arr, [0,2,4], axis=0)`, but allows further
+    use of `mask`.
+
+    Examples
+    --------
+    >>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
+    >>> arr
+    array([[ 1,  2,  3,  4],
+           [ 5,  6,  7,  8],
+           [ 9, 10, 11, 12]])
+    >>> np.delete(arr, 1, 0)
+    array([[ 1,  2,  3,  4],
+           [ 9, 10, 11, 12]])
+
+    >>> np.delete(arr, np.s_[::2], 1)
+    array([[ 2,  4],
+           [ 6,  8],
+           [10, 12]])
+    >>> np.delete(arr, [1,3,5], None)
+    array([ 1,  3,  5,  7,  8,  9, 10, 11, 12])
+
+    " :arglists '[[& [args {:as kwargs}]]]} delete (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "delete"))))
+
+(def ^{:doc "
+    is_busday(dates, weekmask='1111100', holidays=None, busdaycal=None, out=None)
+
+    Calculates which of the given dates are valid days, and which are not.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    dates : array_like of datetime64[D]
+        The array of dates to process.
+    weekmask : str or array_like of bool, optional
+        A seven-element array indicating which of Monday through Sunday are
+        valid days. May be specified as a length-seven list or array, like
+        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
+        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
+        weekdays, optionally separated by white space. Valid abbreviations
+        are: Mon Tue Wed Thu Fri Sat Sun
+    holidays : array_like of datetime64[D], optional
+        An array of dates to consider as invalid dates.  They may be
+        specified in any order, and NaT (not-a-time) dates are ignored.
+        This list is saved in a normalized form that is suited for
+        fast calculations of valid days.
+    busdaycal : busdaycalendar, optional
+        A `busdaycalendar` object which specifies the valid days. If this
+        parameter is provided, neither weekmask nor holidays may be
+        provided.
+    out : array of bool, optional
+        If provided, this array is filled with the result.
+
+    Returns
+    -------
+    out : array of bool
+        An array with the same shape as ``dates``, containing True for
+        each valid day, and False for each invalid day.
+
+    See Also
+    --------
+    busdaycalendar: An object that specifies a custom set of valid days.
+    busday_offset : Applies an offset counted in valid days.
+    busday_count : Counts how many valid days are in a half-open date range.
+
+    Examples
+    --------
+    >>> # The weekdays are Friday, Saturday, and Monday
+    ... np.is_busday(['2011-07-01', '2011-07-02', '2011-07-18'],
+    ...                 holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
+    array([False, False,  True])
+    " :arglists '[[& [args {:as kwargs}]]]} is_busday (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "is_busday"))))
+
+(def ^{:doc "
+    Save several arrays into a single file in compressed ``.npz`` format.
+
+    If keyword arguments are given, then filenames are taken from the keywords.
+    If arguments are passed in with no keywords, then stored filenames are
+    arr_0, arr_1, etc.
+
+    Parameters
+    ----------
+    file : str or file
+        Either the filename (string) or an open file (file-like object)
+        where the data will be saved. If file is a string or a Path, the
+        ``.npz`` extension will be appended to the filename if it is not
+        already there.
+    args : Arguments, optional
+        Arrays to save to the file. Since it is not possible for Python to
+        know the names of the arrays outside `savez`, the arrays will be saved
+        with names \"arr_0\", \"arr_1\", and so on. These arguments can be any
+        expression.
+    kwds : Keyword arguments, optional
+        Arrays to save to the file. Arrays will be saved in the file with the
+        keyword names.
+
+    Returns
+    -------
+    None
+
+    See Also
+    --------
+    numpy.save : Save a single array to a binary file in NumPy format.
+    numpy.savetxt : Save an array to a file as plain text.
+    numpy.savez : Save several arrays into an uncompressed ``.npz`` file format
+    numpy.load : Load the files created by savez_compressed.
+
+    Notes
+    -----
+    The ``.npz`` file format is a zipped archive of files named after the
+    variables they contain.  The archive is compressed with
+    ``zipfile.ZIP_DEFLATED`` and each file in the archive contains one variable
+    in ``.npy`` format. For a description of the ``.npy`` format, see
+    :py:mod:`numpy.lib.format`.
+
+
+    When opening the saved ``.npz`` file with `load` a `NpzFile` object is
+    returned. This is a dictionary-like object which can be queried for
+    its list of arrays (with the ``.files`` attribute), and for the arrays
+    themselves.
+
+    Examples
+    --------
+    >>> test_array = np.random.rand(3, 2)
+    >>> test_vector = np.random.rand(4)
+    >>> np.savez_compressed('/tmp/123', a=test_array, b=test_vector)
+    >>> loaded = np.load('/tmp/123.npz')
+    >>> print(np.array_equal(test_array, loaded['a']))
+    True
+    >>> print(np.array_equal(test_vector, loaded['b']))
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]]} savez_compressed (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "savez_compressed"))))
+
+(def ^{:doc "
+    The differences between consecutive elements of an array.
+
+    Parameters
+    ----------
+    ary : array_like
+        If necessary, will be flattened before the differences are taken.
+    to_end : array_like, optional
+        Number(s) to append at the end of the returned differences.
+    to_begin : array_like, optional
+        Number(s) to prepend at the beginning of the returned differences.
+
+    Returns
+    -------
+    ediff1d : ndarray
+        The differences. Loosely, this is ``ary.flat[1:] - ary.flat[:-1]``.
+
+    See Also
+    --------
+    diff, gradient
+
+    Notes
+    -----
+    When applied to masked arrays, this function drops the mask information
+    if the `to_begin` and/or `to_end` parameters are used.
+
+    Examples
+    --------
+    >>> x = np.array([1, 2, 4, 7, 0])
+    >>> np.ediff1d(x)
+    array([ 1,  2,  3, -7])
+
+    >>> np.ediff1d(x, to_begin=-99, to_end=np.array([88, 99]))
+    array([-99,   1,   2, ...,  -7,  88,  99])
+
+    The returned array is always 1D.
+
+    >>> y = [[1, 2, 4], [1, 6, 24]]
+    >>> np.ediff1d(y)
+    array([ 1,  2, -3,  5, 18])
+
+    " :arglists '[[& [args {:as kwargs}]]]} ediff1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ediff1d"))))
+
+(def ^{:doc "fromfile(file, dtype=float, count=-1, sep='', offset=0, *, like=None)
+
+    Construct an array from data in a text or binary file.
+
+    A highly efficient way of reading binary data with a known data-type,
+    as well as parsing simply formatted text files.  Data written using the
+    `tofile` method can be read using this function.
+
+    Parameters
+    ----------
+    file : file or str or Path
+        Open file object or filename.
+
+        .. versionchanged:: 1.17.0
+            `pathlib.Path` objects are now accepted.
+
+    dtype : data-type
+        Data type of the returned array.
+        For binary files, it is used to determine the size and byte-order
+        of the items in the file.
+        Most builtin numeric types are supported and extension types may be supported.
+
+        .. versionadded:: 1.18.0
+            Complex dtypes.
+
+    count : int
+        Number of items to read. ``-1`` means all items (i.e., the complete
+        file).
+    sep : str
+        Separator between items if file is a text file.
+        Empty (\"\") separator means the file should be treated as binary.
+        Spaces (\" \") in the separator match zero or more whitespace characters.
+        A separator consisting only of spaces must match at least one
+        whitespace.
+    offset : int
+        The offset (in bytes) from the file's current position. Defaults to 0.
+        Only permitted for binary files.
+
+        .. versionadded:: 1.17.0
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    See also
+    --------
+    load, save
+    ndarray.tofile
+    loadtxt : More flexible way of loading data from a text file.
+
+    Notes
+    -----
+    Do not rely on the combination of `tofile` and `fromfile` for
+    data storage, as the binary files generated are not platform
+    independent.  In particular, no byte-order or data-type information is
+    saved.  Data can be stored in the platform independent ``.npy`` format
+    using `save` and `load` instead.
+
+    Examples
+    --------
+    Construct an ndarray:
+
+    >>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]),
+    ...                ('temp', float)])
+    >>> x = np.zeros((1,), dtype=dt)
+    >>> x['time']['min'] = 10; x['temp'] = 98.25
+    >>> x
+    array([((10, 0), 98.25)],
+          dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])
+
+    Save the raw data to disk:
+
+    >>> import tempfile
+    >>> fname = tempfile.mkstemp()[1]
+    >>> x.tofile(fname)
+
+    Read the raw data from disk:
+
+    >>> np.fromfile(fname, dtype=dt)
+    array([((10, 0), 98.25)],
+          dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])
+
+    The recommended way to store and load data:
+
+    >>> np.save(fname, x)
+    >>> np.load(fname + '.npy')
+    array([((10, 0), 98.25)],
+          dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])" :arglists '[[self & [args {:as kwargs}]]]} fromfile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromfile"))))
+
+(def ^{:doc "
+    Replaces specified elements of an array with given values.
+
+    The indexing works on the flattened target array. `put` is roughly
+    equivalent to:
+
+    ::
+
+        a.flat[ind] = v
+
+    Parameters
+    ----------
+    a : ndarray
+        Target array.
+    ind : array_like
+        Target indices, interpreted as integers.
+    v : array_like
+        Values to place in `a` at target indices. If `v` is shorter than
+        `ind` it will be repeated as necessary.
+    mode : {'raise', 'wrap', 'clip'}, optional
+        Specifies how out-of-bounds indices will behave.
+
+        * 'raise' -- raise an error (default)
+        * 'wrap' -- wrap around
+        * 'clip' -- clip to the range
+
+        'clip' mode means that all indices that are too large are replaced
+        by the index that addresses the last element along that axis. Note
+        that this disables indexing with negative numbers. In 'raise' mode,
+        if an exception occurs the target array may still be modified.
+
+    See Also
+    --------
+    putmask, place
+    put_along_axis : Put elements by matching the array and the index arrays
+
+    Examples
+    --------
+    >>> a = np.arange(5)
+    >>> np.put(a, [0, 2], [-44, -55])
+    >>> a
+    array([-44,   1, -55,   3,   4])
+
+    >>> a = np.arange(5)
+    >>> np.put(a, 22, -5, mode='clip')
+    >>> a
+    array([ 0,  1,  2,  3, -5])
+
+    " :arglists '[[& [args {:as kwargs}]]]} put (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "put"))))
+
+(def ^{:doc "not_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return (x1 != x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+equal, greater, greater_equal, less, less_equal
+
+Examples
+--------
+>>> np.not_equal([1.,2.], [1., 3.])
+array([False,  True])
+>>> np.not_equal([1, 2], [[1, 3],[1, 4]])
+array([[False,  True],
+       [False,  True]])
+
+The ``!=`` operator can be used as a shorthand for ``np.not_equal`` on
+ndarrays.
+
+>>> a = np.array([1., 2.])
+>>> b = np.array([1., 3.])
+>>> a != b
+array([False,  True])" :arglists '[[self & [args {:as kwargs}]]]} not_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "not_equal"))))
+
+(def ^{:doc "
+    Return Pearson product-moment correlation coefficients.
+
+    Please refer to the documentation for `cov` for more detail.  The
+    relationship between the correlation coefficient matrix, `R`, and the
+    covariance matrix, `C`, is
+
+    .. math:: R_{ij} = \\frac{ C_{ij} } { \\sqrt{ C_{ii} * C_{jj} } }
+
+    The values of `R` are between -1 and 1, inclusive.
+
+    Parameters
+    ----------
+    x : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `x` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same
+        shape as `x`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+    bias : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.10.0
+    ddof : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.10.0
+    dtype : data-type, optional
+        Data-type of the result. By default, the return data-type will have
+        at least `numpy.float64` precision.
+
+        .. versionadded:: 1.20
+
+    Returns
+    -------
+    R : ndarray
+        The correlation coefficient matrix of the variables.
+
+    See Also
+    --------
+    cov : Covariance matrix
+
+    Notes
+    -----
+    Due to floating point rounding the resulting array may not be Hermitian,
+    the diagonal elements may not be 1, and the elements may not satisfy the
+    inequality abs(a) <= 1. The real and imaginary parts are clipped to the
+    interval [-1,  1] in an attempt to improve on that situation but is not
+    much help in the complex case.
+
+    This function accepts but discards arguments `bias` and `ddof`.  This is
+    for backwards compatibility with previous versions of this function.  These
+    arguments had no effect on the return values of the function and can be
+    safely ignored in this and previous versions of numpy.
+
+    Examples
+    --------
+    In this example we generate two random arrays, ``xarr`` and ``yarr``, and
+    compute the row-wise and column-wise Pearson correlation coefficients,
+    ``R``. Since ``rowvar`` is  true by  default, we first find the row-wise
+    Pearson correlation coefficients between the variables of ``xarr``.
+
+    >>> import numpy as np
+    >>> rng = np.random.default_rng(seed=42)
+    >>> xarr = rng.random((3, 3))
+    >>> xarr
+    array([[0.77395605, 0.43887844, 0.85859792],
+           [0.69736803, 0.09417735, 0.97562235],
+           [0.7611397 , 0.78606431, 0.12811363]])
+    >>> R1 = np.corrcoef(xarr)
+    >>> R1
+    array([[ 1.        ,  0.99256089, -0.68080986],
+           [ 0.99256089,  1.        , -0.76492172],
+           [-0.68080986, -0.76492172,  1.        ]])
+
+    If we add another set of variables and observations ``yarr``, we can
+    compute the row-wise Pearson correlation coefficients between the
+    variables in ``xarr`` and ``yarr``.
+
+    >>> yarr = rng.random((3, 3))
+    >>> yarr
+    array([[0.45038594, 0.37079802, 0.92676499],
+           [0.64386512, 0.82276161, 0.4434142 ],
+           [0.22723872, 0.55458479, 0.06381726]])
+    >>> R2 = np.corrcoef(xarr, yarr)
+    >>> R2
+    array([[ 1.        ,  0.99256089, -0.68080986,  0.75008178, -0.934284  ,
+            -0.99004057],
+           [ 0.99256089,  1.        , -0.76492172,  0.82502011, -0.97074098,
+            -0.99981569],
+           [-0.68080986, -0.76492172,  1.        , -0.99507202,  0.89721355,
+             0.77714685],
+           [ 0.75008178,  0.82502011, -0.99507202,  1.        , -0.93657855,
+            -0.83571711],
+           [-0.934284  , -0.97074098,  0.89721355, -0.93657855,  1.        ,
+             0.97517215],
+           [-0.99004057, -0.99981569,  0.77714685, -0.83571711,  0.97517215,
+             1.        ]])
+
+    Finally if we use the option ``rowvar=False``, the columns are now
+    being treated as the variables and we will find the column-wise Pearson
+    correlation coefficients between variables in ``xarr`` and ``yarr``.
+
+    >>> R3 = np.corrcoef(xarr, yarr, rowvar=False)
+    >>> R3
+    array([[ 1.        ,  0.77598074, -0.47458546, -0.75078643, -0.9665554 ,
+             0.22423734],
+           [ 0.77598074,  1.        , -0.92346708, -0.99923895, -0.58826587,
+            -0.44069024],
+           [-0.47458546, -0.92346708,  1.        ,  0.93773029,  0.23297648,
+             0.75137473],
+           [-0.75078643, -0.99923895,  0.93773029,  1.        ,  0.55627469,
+             0.47536961],
+           [-0.9665554 , -0.58826587,  0.23297648,  0.55627469,  1.        ,
+            -0.46666491],
+           [ 0.22423734, -0.44069024,  0.75137473,  0.47536961, -0.46666491,
+             1.        ]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} corrcoef (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "corrcoef"))))
+
+(def ^{:doc "
+    Return a copy of an array sorted along the first axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Array to be sorted.
+
+    Returns
+    -------
+    sorted_array : ndarray
+        Array of the same type and shape as `a`.
+
+    See Also
+    --------
+    sort
+
+    Notes
+    -----
+    ``np.msort(a)`` is equivalent to  ``np.sort(a, axis=0)``.
+
+    " :arglists '[[& [args {:as kwargs}]]]} msort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "msort"))))
+
+(def ^{:doc "Complex number type composed of two single-precision floating-point
+    numbers.
+
+    :Character code: ``'F'``
+    :Canonical name: `numpy.csingle`
+    :Alias: `numpy.singlecomplex`
+    :Alias on this platform: `numpy.complex64`: Complex number type composed of 2 32-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} csingle (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "csingle"))))
+
+(def ^{:doc "bitwise_or(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the bit-wise OR of two arrays element-wise.
+
+Computes the bit-wise OR of the underlying binary representation of
+the integers in the input arrays. This ufunc implements the C/Python
+operator ``|``.
+
+Parameters
+----------
+x1, x2 : array_like
+    Only integer and boolean types are handled.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Result.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_or
+bitwise_and
+bitwise_xor
+binary_repr :
+    Return the binary representation of the input number as a string.
+
+Examples
+--------
+The number 13 has the binaray representation ``00001101``. Likewise,
+16 is represented by ``00010000``.  The bit-wise OR of 13 and 16 is
+then ``000111011``, or 29:
+
+>>> np.bitwise_or(13, 16)
+29
+>>> np.binary_repr(29)
+'11101'
+
+>>> np.bitwise_or(32, 2)
+34
+>>> np.bitwise_or([33, 4], 1)
+array([33,  5])
+>>> np.bitwise_or([33, 4], [1, 2])
+array([33,  6])
+
+>>> np.bitwise_or(np.array([2, 5, 255]), np.array([4, 4, 4]))
+array([  6,   5, 255])
+>>> np.array([2, 5, 255]) | np.array([4, 4, 4])
+array([  6,   5, 255])
+>>> np.bitwise_or(np.array([2, 5, 255, 2147483647], dtype=np.int32),
+...               np.array([4, 4, 4, 2147483647], dtype=np.int32))
+array([         6,          5,        255, 2147483647])
+>>> np.bitwise_or([True, True], [False, True])
+array([ True,  True])
+
+The ``|`` operator can be used as a shorthand for ``np.bitwise_or`` on
+ndarrays.
+
+>>> x1 = np.array([2, 5, 255])
+>>> x2 = np.array([4, 4, 4])
+>>> x1 | x2
+array([  6,   5, 255])" :arglists '[[self & [args {:as kwargs}]]]} bitwise_or (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_or"))))
+
+(def ^{:doc "rad2deg(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Convert angles from radians to degrees.
+
+Parameters
+----------
+x : array_like
+    Angle in radians.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding angle in degrees.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+deg2rad : Convert angles from degrees to radians.
+unwrap : Remove large jumps in angle by wrapping.
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+rad2deg(x) is ``180 * x / pi``.
+
+Examples
+--------
+>>> np.rad2deg(np.pi/2)
+90.0" :arglists '[[self & [args {:as kwargs}]]]} rad2deg (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rad2deg"))))
+
+(def ^{:doc "" :arglists '[[msg]]} deprecate_with_doc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "deprecate_with_doc"))))
+
+(def ^{:doc "
+    If input is complex with all imaginary parts close to zero, return 
+    real parts.
+
+    \"Close to zero\" is defined as `tol` * (machine epsilon of the type for
+    `a`).
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    tol : float
+        Tolerance in machine epsilons for the complex part of the elements
+        in the array.
+
+    Returns
+    -------
+    out : ndarray
+        If `a` is real, the type of `a` is used for the output.  If `a`
+        has complex elements, the returned type is float.
+
+    See Also
+    --------
+    real, imag, angle
+
+    Notes
+    -----
+    Machine epsilon varies from machine to machine and between data types
+    but Python floats on most platforms have a machine epsilon equal to
+    2.2204460492503131e-16.  You can use 'np.finfo(float).eps' to print
+    out the machine epsilon for floats.
+
+    Examples
+    --------
+    >>> np.finfo(float).eps
+    2.2204460492503131e-16 # may vary
+
+    >>> np.real_if_close([2.1 + 4e-14j, 5.2 + 3e-15j], tol=1000)
+    array([2.1, 5.2])
+    >>> np.real_if_close([2.1 + 4e-13j, 5.2 + 3e-15j], tol=1000)
+    array([2.1+4.e-13j, 5.2 + 3e-15j])
+
+    " :arglists '[[& [args {:as kwargs}]]]} real_if_close (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "real_if_close"))))
+
+(def ^{:doc "
+    Construct an array from a text file, using regular expression parsing.
+
+    The returned array is always a structured array, and is constructed from
+    all matches of the regular expression in the file. Groups in the regular
+    expression are converted to fields of the structured array.
+
+    Parameters
+    ----------
+    file : str or file
+        Filename or file object to read.
+    regexp : str or regexp
+        Regular expression used to parse the file.
+        Groups in the regular expression correspond to fields in the dtype.
+    dtype : dtype or list of dtypes
+        Dtype for the structured array.
+    encoding : str, optional
+        Encoding used to decode the inputfile. Does not apply to input streams.
+
+        .. versionadded:: 1.14.0
+
+    Returns
+    -------
+    output : ndarray
+        The output array, containing the part of the content of `file` that
+        was matched by `regexp`. `output` is always a structured array.
+
+    Raises
+    ------
+    TypeError
+        When `dtype` is not a valid dtype for a structured array.
+
+    See Also
+    --------
+    fromstring, loadtxt
+
+    Notes
+    -----
+    Dtypes for structured arrays can be specified in several forms, but all
+    forms specify at least the data type and field name. For details see
+    `basics.rec`.
+
+    Examples
+    --------
+    >>> f = open('test.dat', 'w')
+    >>> _ = f.write(\"1312 foo\\n1534  bar\\n444   qux\")
+    >>> f.close()
+
+    >>> regexp = r\"(\\d+)\\s+(...)\"  # match [digits, whitespace, anything]
+    >>> output = np.fromregex('test.dat', regexp,
+    ...                       [('num', np.int64), ('key', 'S3')])
+    >>> output
+    array([(1312, b'foo'), (1534, b'bar'), ( 444, b'qux')],
+          dtype=[('num', '<i8'), ('key', 'S3')])
+    >>> output['num']
+    array([1312, 1534,  444])
+
+    " :arglists '[[file regexp dtype & [{encoding :encoding}]] [file regexp dtype]]} fromregex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromregex"))))
+
+(def ^{:doc ""} FLOATING_POINT_SUPPORT 1)
+
+(def ^{:doc "
+    Clip (limit) the values in an array.
+
+    Given an interval, values outside the interval are clipped to
+    the interval edges.  For example, if an interval of ``[0, 1]``
+    is specified, values smaller than 0 become 0, and values larger
+    than 1 become 1.
+
+    Equivalent to but faster than ``np.minimum(a_max, np.maximum(a, a_min))``.
+
+    No check is performed to ensure ``a_min < a_max``.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing elements to clip.
+    a_min, a_max : array_like or None
+        Minimum and maximum value. If ``None``, clipping is not performed on
+        the corresponding edge. Only one of `a_min` and `a_max` may be
+        ``None``. Both are broadcast against `a`.
+    out : ndarray, optional
+        The results will be placed in this array. It may be the input
+        array for in-place clipping.  `out` must be of the right shape
+        to hold the output.  Its type is preserved.
+    **kwargs
+        For other keyword-only arguments, see the
+        :ref:`ufunc docs <ufuncs.kwargs>`.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    clipped_array : ndarray
+        An array with the elements of `a`, but where values
+        < `a_min` are replaced with `a_min`, and those > `a_max`
+        with `a_max`.
+
+    See Also
+    --------
+    :ref:`ufuncs-output-type`
+
+    Examples
+    --------
+    >>> a = np.arange(10)
+    >>> np.clip(a, 1, 8)
+    array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
+    >>> a
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> np.clip(a, 3, 6, out=a)
+    array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
+    >>> a = np.arange(10)
+    >>> a
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
+    array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])
+
+    " :arglists '[[& [args {:as kwargs}]]]} clip (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "clip"))))
+
+(def ^{:doc "Extended-precision floating-point number type, compatible with C
+    ``long double`` but not necessarily with IEEE 754 quadruple-precision.
+
+    :Character code: ``'g'``
+    :Canonical name: `numpy.longdouble`
+    :Alias: `numpy.longfloat`
+    :Alias on this platform: `numpy.float128`: 128-bit extended-precision floating-point number type." :arglists '[[self & [args {:as kwargs}]]]} longdouble (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longdouble"))))
+
+(def ^{:doc "A data-type scalar that allows field access as attribute lookup.
+    " :arglists '[[self & [args {:as kwargs}]]]} record (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "record"))))
+
+(def ^{:doc "
+    Returns the indices of the maximum values along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        By default, the index is into the flattened array, otherwise
+        along the specified axis.
+    out : array, optional
+        If provided, the result will be inserted into this array. It should
+        be of the appropriate shape and dtype.
+
+    Returns
+    -------
+    index_array : ndarray of ints
+        Array of indices into the array. It has the same shape as `a.shape`
+        with the dimension along `axis` removed.
+
+    See Also
+    --------
+    ndarray.argmax, argmin
+    amax : The maximum value along a given axis.
+    unravel_index : Convert a flat index into an index tuple.
+    take_along_axis : Apply ``np.expand_dims(index_array, axis)``
+                      from argmax to an array as if by calling max.
+
+    Notes
+    -----
+    In case of multiple occurrences of the maximum values, the indices
+    corresponding to the first occurrence are returned.
+
+    Examples
+    --------
+    >>> a = np.arange(6).reshape(2,3) + 10
+    >>> a
+    array([[10, 11, 12],
+           [13, 14, 15]])
+    >>> np.argmax(a)
+    5
+    >>> np.argmax(a, axis=0)
+    array([1, 1, 1])
+    >>> np.argmax(a, axis=1)
+    array([2, 2])
+
+    Indexes of the maximal elements of a N-dimensional array:
+
+    >>> ind = np.unravel_index(np.argmax(a, axis=None), a.shape)
+    >>> ind
+    (1, 2)
+    >>> a[ind]
+    15
+
+    >>> b = np.arange(6)
+    >>> b[1] = 5
+    >>> b
+    array([0, 5, 2, 3, 4, 5])
+    >>> np.argmax(b)  # Only the first occurrence is returned.
+    1
+
+    >>> x = np.array([[4,2,3], [1,0,3]])
+    >>> index_array = np.argmax(x, axis=-1)
+    >>> # Same as np.max(x, axis=-1, keepdims=True)
+    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
+    array([[4],
+           [3]])
+    >>> # Same as np.max(x, axis=-1)
+    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1)
+    array([4, 3])
+
+    " :arglists '[[& [args {:as kwargs}]]]} argmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argmax"))))
+
+(def ^{:doc "frexp(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Decompose the elements of x into mantissa and twos exponent.
+
+Returns (`mantissa`, `exponent`), where `x = mantissa * 2**exponent``.
+The mantissa is lies in the open interval(-1, 1), while the twos
+exponent is a signed integer.
+
+Parameters
+----------
+x : array_like
+    Array of numbers to be decomposed.
+out1 : ndarray, optional
+    Output array for the mantissa. Must have the same shape as `x`.
+out2 : ndarray, optional
+    Output array for the exponent. Must have the same shape as `x`.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+mantissa : ndarray
+    Floating values between -1 and 1.
+    This is a scalar if `x` is a scalar.
+exponent : ndarray
+    Integer exponents of 2.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+ldexp : Compute ``y = x1 * 2**x2``, the inverse of `frexp`.
+
+Notes
+-----
+Complex dtypes are not supported, they will raise a TypeError.
+
+Examples
+--------
+>>> x = np.arange(9)
+>>> y1, y2 = np.frexp(x)
+>>> y1
+array([ 0.   ,  0.5  ,  0.5  ,  0.75 ,  0.5  ,  0.625,  0.75 ,  0.875,
+        0.5  ])
+>>> y2
+array([0, 1, 2, 2, 3, 3, 3, 3, 4])
+>>> y1 * 2**y2
+array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])" :arglists '[[self & [args {:as kwargs}]]]} frexp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "frexp"))))
+
+(def ^{:doc "
+    Interpret the input as a matrix.
+
+    Unlike `matrix`, `asmatrix` does not make a copy if the input is already
+    a matrix or an ndarray.  Equivalent to ``matrix(data, copy=False)``.
+
+    Parameters
+    ----------
+    data : array_like
+        Input data.
+    dtype : data-type
+       Data-type of the output matrix.
+
+    Returns
+    -------
+    mat : matrix
+        `data` interpreted as a matrix.
+
+    Examples
+    --------
+    >>> x = np.array([[1, 2], [3, 4]])
+
+    >>> m = np.asmatrix(x)
+
+    >>> x[0,0] = 5
+
+    >>> m
+    matrix([[5, 2],
+            [3, 4]])
+
+    " :arglists '[[data & [{dtype :dtype}]] [data]]} asmatrix (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asmatrix"))))
+
+(def ^{:doc "matmul(x1, x2, /, out=None, *, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Matrix product of two arrays.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays, scalars not allowed.
+out : ndarray, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that matches the signature `(n,k),(k,m)->(n,m)`. If not
+    provided or None, a freshly-allocated array is returned.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+    .. versionadded:: 1.16
+       Now handles ufunc kwargs
+
+Returns
+-------
+y : ndarray
+    The matrix product of the inputs.
+    This is a scalar only when both x1, x2 are 1-d vectors.
+
+Raises
+------
+ValueError
+    If the last dimension of `x1` is not the same size as
+    the second-to-last dimension of `x2`.
+
+    If a scalar value is passed in.
+
+See Also
+--------
+vdot : Complex-conjugating dot product.
+tensordot : Sum products over arbitrary axes.
+einsum : Einstein summation convention.
+dot : alternative matrix product with different broadcasting rules.
+
+Notes
+-----
+
+The behavior depends on the arguments in the following way.
+
+- If both arguments are 2-D they are multiplied like conventional
+  matrices.
+- If either argument is N-D, N > 2, it is treated as a stack of
+  matrices residing in the last two indexes and broadcast accordingly.
+- If the first argument is 1-D, it is promoted to a matrix by
+  prepending a 1 to its dimensions. After matrix multiplication
+  the prepended 1 is removed.
+- If the second argument is 1-D, it is promoted to a matrix by
+  appending a 1 to its dimensions. After matrix multiplication
+  the appended 1 is removed.
+
+``matmul`` differs from ``dot`` in two important ways:
+
+- Multiplication by scalars is not allowed, use ``*`` instead.
+- Stacks of matrices are broadcast together as if the matrices
+  were elements, respecting the signature ``(n,k),(k,m)->(n,m)``:
+
+  >>> a = np.ones([9, 5, 7, 4])
+  >>> c = np.ones([9, 5, 4, 3])
+  >>> np.dot(a, c).shape
+  (9, 5, 7, 9, 5, 3)
+  >>> np.matmul(a, c).shape
+  (9, 5, 7, 3)
+  >>> # n is 7, k is 4, m is 3
+
+The matmul function implements the semantics of the `@` operator introduced
+in Python 3.5 following PEP465.
+
+Examples
+--------
+For 2-D arrays it is the matrix product:
+
+>>> a = np.array([[1, 0],
+...               [0, 1]])
+>>> b = np.array([[4, 1],
+...               [2, 2]])
+>>> np.matmul(a, b)
+array([[4, 1],
+       [2, 2]])
+
+For 2-D mixed with 1-D, the result is the usual.
+
+>>> a = np.array([[1, 0],
+...               [0, 1]])
+>>> b = np.array([1, 2])
+>>> np.matmul(a, b)
+array([1, 2])
+>>> np.matmul(b, a)
+array([1, 2])
+
+
+Broadcasting is conventional for stacks of arrays
+
+>>> a = np.arange(2 * 2 * 4).reshape((2, 2, 4))
+>>> b = np.arange(2 * 2 * 4).reshape((2, 4, 2))
+>>> np.matmul(a,b).shape
+(2, 2, 2)
+>>> np.matmul(a, b)[0, 1, 1]
+98
+>>> sum(a[0, 1, :] * b[0 , :, 1])
+98
+
+Vector, vector returns the scalar inner product, but neither argument
+is complex-conjugated:
+
+>>> np.matmul([2j, 3j], [2j, 3j])
+(-13+0j)
+
+Scalar multiplication raises an error.
+
+>>> np.matmul([1,2], 3)
+Traceback (most recent call last):
+...
+ValueError: matmul: Input operand 1 does not have enough dimensions ...
+
+The ``@`` operator can be used as a shorthand for ``np.matmul`` on
+ndarrays.
+
+>>> x1 = np.array([2j, 3j])
+>>> x2 = np.array([2j, 3j])
+>>> x1 @ x2
+(-13+0j)
+
+.. versionadded:: 1.10.0" :arglists '[[self & [args {:as kwargs}]]]} matmul (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "matmul"))))
+
+(def ^{:doc "
+Wrapper functions to more user-friendly calling of certain math functions
+whose output data-type is different than the input data-type in certain
+domains of the input.
+
+For example, for functions like `log` with branch cuts, the versions in this
+module provide the mathematically valid answers in the complex plane::
+
+  >>> import math
+  >>> from numpy.lib import scimath
+  >>> scimath.log(-math.exp(1)) == (1+1j*math.pi)
+  True
+
+Similarly, `sqrt`, other base logarithms, `power` and trig functions are
+correctly handled.  See their respective docstrings for specific examples.
+
+Functions
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+   sqrt
+   log
+   log2
+   logn
+   log10
+   power
+   arccos
+   arcsin
+   arctanh
+
+"} emath (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "emath"))))
+
+(def ^{:doc "
+    Compute the arithmetic mean along the specified axis.
+
+    Returns the average of the array elements.  The average is taken over
+    the flattened array by default, otherwise over the specified axis.
+    `float64` intermediate and return values are used for integer inputs.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose mean is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which the means are computed. The default is to
+        compute the mean of the flattened array.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a mean is performed over multiple axes,
+        instead of a single axis or all the axes as before.
+    dtype : data-type, optional
+        Type to use in computing the mean.  For integer inputs, the default
+        is `float64`; for floating point inputs, it is the same as the
+        input dtype.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary.
+        See :ref:`ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `mean` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    where : array_like of bool, optional
+        Elements to include in the mean. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    m : ndarray, see dtype parameter above
+        If `out=None`, returns a new array containing the mean values,
+        otherwise a reference to the output array is returned.
+
+    See Also
+    --------
+    average : Weighted average
+    std, var, nanmean, nanstd, nanvar
+
+    Notes
+    -----
+    The arithmetic mean is the sum of the elements along the axis divided
+    by the number of elements.
+
+    Note that for floating-point input, the mean is computed using the
+    same precision the input has.  Depending on the input data, this can
+    cause the results to be inaccurate, especially for `float32` (see
+    example below).  Specifying a higher-precision accumulator using the
+    `dtype` keyword can alleviate this issue.
+
+    By default, `float16` results are computed using `float32` intermediates
+    for extra precision.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> np.mean(a)
+    2.5
+    >>> np.mean(a, axis=0)
+    array([2., 3.])
+    >>> np.mean(a, axis=1)
+    array([1.5, 3.5])
+
+    In single precision, `mean` can be inaccurate:
+
+    >>> a = np.zeros((2, 512*512), dtype=np.float32)
+    >>> a[0, :] = 1.0
+    >>> a[1, :] = 0.1
+    >>> np.mean(a)
+    0.54999924
+
+    Computing the mean in float64 is more accurate:
+
+    >>> np.mean(a, dtype=np.float64)
+    0.55000000074505806 # may vary
+
+    Specifying a where argument:
+    >>> a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]])
+    >>> np.mean(a)
+    12.0
+    >>> np.mean(a, where=[[True], [False], [False]])
+    9.0
+
+    " :arglists '[[& [args {:as kwargs}]]]} mean (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mean"))))
+
+(def ^{:doc "Unsigned integer type, compatible with C ``unsigned int``.
+
+    :Character code: ``'I'``
+    :Canonical name: `numpy.uintc`
+    :Alias on this platform: `numpy.uint32`: 32-bit unsigned integer (``0`` to ``4_294_967_295``)." :arglists '[[self & [args {:as kwargs}]]]} uint32 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint32"))))
+
+(def ^{:doc "
+    Check if all elements of input array are true.
+
+    See Also
+    --------
+    numpy.all : Equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]]} alltrue (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "alltrue"))))
+
+(def ^{:doc "Find the wrapper for the array with the highest priority.
+
+    In case of ties, leftmost wins. If no wrapper is found, return None
+    " :arglists '[[& [args]]]} get_array_wrap (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "get_array_wrap"))))
+
+(def ^{:doc "
+    Load data from a text file.
+
+    Each row in the text file must have the same number of values.
+
+    Parameters
+    ----------
+    fname : file, str, or pathlib.Path
+        File, filename, or generator to read.  If the filename extension is
+        ``.gz`` or ``.bz2``, the file is first decompressed. Note that
+        generators should return byte strings.
+    dtype : data-type, optional
+        Data-type of the resulting array; default: float.  If this is a
+        structured data-type, the resulting array will be 1-dimensional, and
+        each row will be interpreted as an element of the array.  In this
+        case, the number of columns used must match the number of fields in
+        the data-type.
+    comments : str or sequence of str, optional
+        The characters or list of characters used to indicate the start of a
+        comment. None implies no comments. For backwards compatibility, byte
+        strings will be decoded as 'latin1'. The default is '#'.
+    delimiter : str, optional
+        The string used to separate values. For backwards compatibility, byte
+        strings will be decoded as 'latin1'. The default is whitespace.
+    converters : dict, optional
+        A dictionary mapping column number to a function that will parse the
+        column string into the desired value.  E.g., if column 0 is a date
+        string: ``converters = {0: datestr2num}``.  Converters can also be
+        used to provide a default value for missing data (but see also
+        `genfromtxt`): ``converters = {3: lambda s: float(s.strip() or 0)}``.
+        Default: None.
+    skiprows : int, optional
+        Skip the first `skiprows` lines, including comments; default: 0.
+    usecols : int or sequence, optional
+        Which columns to read, with 0 being the first. For example,
+        ``usecols = (1,4,5)`` will extract the 2nd, 5th and 6th columns.
+        The default, None, results in all columns being read.
+
+        .. versionchanged:: 1.11.0
+            When a single column has to be read it is possible to use
+            an integer instead of a tuple. E.g ``usecols = 3`` reads the
+            fourth column the same way as ``usecols = (3,)`` would.
+    unpack : bool, optional
+        If True, the returned array is transposed, so that arguments may be
+        unpacked using ``x, y, z = loadtxt(...)``.  When used with a
+        structured data-type, arrays are returned for each field.
+        Default is False.
+    ndmin : int, optional
+        The returned array will have at least `ndmin` dimensions.
+        Otherwise mono-dimensional axes will be squeezed.
+        Legal values: 0 (default), 1 or 2.
+
+        .. versionadded:: 1.6.0
+    encoding : str, optional
+        Encoding used to decode the inputfile. Does not apply to input streams.
+        The special value 'bytes' enables backward compatibility workarounds
+        that ensures you receive byte arrays as results if possible and passes
+        'latin1' encoded strings to converters. Override this value to receive
+        unicode arrays and pass strings as input to converters.  If set to None
+        the system default is used. The default value is 'bytes'.
+
+        .. versionadded:: 1.14.0
+    max_rows : int, optional
+        Read `max_rows` lines of content after `skiprows` lines. The default
+        is to read all the lines.
+
+        .. versionadded:: 1.16.0
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        Data read from the text file.
+
+    See Also
+    --------
+    load, fromstring, fromregex
+    genfromtxt : Load data with missing values handled as specified.
+    scipy.io.loadmat : reads MATLAB data files
+
+    Notes
+    -----
+    This function aims to be a fast reader for simply formatted files.  The
+    `genfromtxt` function provides more sophisticated handling of, e.g.,
+    lines with missing values.
+
+    .. versionadded:: 1.10.0
+
+    The strings produced by the Python float.hex method can be used as
+    input for floats.
+
+    Examples
+    --------
+    >>> from io import StringIO   # StringIO behaves like a file object
+    >>> c = StringIO(\"0 1\\n2 3\")
+    >>> np.loadtxt(c)
+    array([[0., 1.],
+           [2., 3.]])
+
+    >>> d = StringIO(\"M 21 72\\nF 35 58\")
+    >>> np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),
+    ...                      'formats': ('S1', 'i4', 'f4')})
+    array([(b'M', 21, 72.), (b'F', 35, 58.)],
+          dtype=[('gender', 'S1'), ('age', '<i4'), ('weight', '<f4')])
+
+    >>> c = StringIO(\"1,0,2\\n3,0,4\")
+    >>> x, y = np.loadtxt(c, delimiter=',', usecols=(0, 2), unpack=True)
+    >>> x
+    array([1., 3.])
+    >>> y
+    array([2., 4.])
+
+    This example shows how `converters` can be used to convert a field
+    with a trailing minus sign into a negative number.
+
+    >>> s = StringIO('10.01 31.25-\\n19.22 64.31\\n17.57- 63.94')
+    >>> def conv(fld):
+    ...     return -float(fld[:-1]) if fld.endswith(b'-') else float(fld)
+    ...
+    >>> np.loadtxt(s, converters={0: conv, 1: conv})
+    array([[ 10.01, -31.25],
+           [ 19.22,  64.31],
+           [-17.57,  63.94]])
+    " :arglists '[[fname & [{max_rows :max_rows, encoding :encoding, ndmin :ndmin, like :like, dtype :dtype, comments :comments, unpack :unpack, converters :converters, delimiter :delimiter, skiprows :skiprows, usecols :usecols}]] [fname & [{encoding :encoding, ndmin :ndmin, like :like, dtype :dtype, comments :comments, unpack :unpack, converters :converters, delimiter :delimiter, skiprows :skiprows, usecols :usecols}]] [fname & [{ndmin :ndmin, like :like, dtype :dtype, comments :comments, unpack :unpack, converters :converters, delimiter :delimiter, skiprows :skiprows, usecols :usecols}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols, unpack :unpack, like :like}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, usecols :usecols, like :like}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, skiprows :skiprows, like :like}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, converters :converters, like :like}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, like :like}]] [fname & [{dtype :dtype, comments :comments, like :like}]] [fname & [{dtype :dtype, like :like}]] [fname & [{like :like}]]]} loadtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "loadtxt"))))
+
+(def ^{:doc "
+    Compute the variance along the specified axis.
+
+    Returns the variance of the array elements, a measure of the spread of a
+    distribution.  The variance is computed for the flattened array by
+    default, otherwise over the specified axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose variance is desired.  If `a` is not an
+        array, a conversion is attempted.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which the variance is computed.  The default is to
+        compute the variance of the flattened array.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a variance is performed over multiple axes,
+        instead of a single axis or all the axes as before.
+    dtype : data-type, optional
+        Type to use in computing the variance.  For arrays of integer type
+        the default is `float64`; for arrays of float types it is the same as
+        the array type.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  It must have
+        the same shape as the expected output, but the type is cast if
+        necessary.
+    ddof : int, optional
+        \"Delta Degrees of Freedom\": the divisor used in the calculation is
+        ``N - ddof``, where ``N`` represents the number of elements. By
+        default `ddof` is zero.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `var` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    where : array_like of bool, optional
+        Elements to include in the variance. See `~numpy.ufunc.reduce` for
+        details.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    variance : ndarray, see dtype parameter above
+        If ``out=None``, returns a new array containing the variance;
+        otherwise, a reference to the output array is returned.
+
+    See Also
+    --------
+    std, mean, nanmean, nanstd, nanvar
+    :ref:`ufuncs-output-type`
+
+    Notes
+    -----
+    The variance is the average of the squared deviations from the mean,
+    i.e.,  ``var = mean(x)``, where ``x = abs(a - a.mean())**2``.
+
+    The mean is typically calculated as ``x.sum() / N``, where ``N = len(x)``.
+    If, however, `ddof` is specified, the divisor ``N - ddof`` is used
+    instead.  In standard statistical practice, ``ddof=1`` provides an
+    unbiased estimator of the variance of a hypothetical infinite population.
+    ``ddof=0`` provides a maximum likelihood estimate of the variance for
+    normally distributed variables.
+
+    Note that for complex numbers, the absolute value is taken before
+    squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the variance is computed using the same
+    precision the input has.  Depending on the input data, this can cause
+    the results to be inaccurate, especially for `float32` (see example
+    below).  Specifying a higher-accuracy accumulator using the ``dtype``
+    keyword can alleviate this issue.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> np.var(a)
+    1.25
+    >>> np.var(a, axis=0)
+    array([1.,  1.])
+    >>> np.var(a, axis=1)
+    array([0.25,  0.25])
+
+    In single precision, var() can be inaccurate:
+
+    >>> a = np.zeros((2, 512*512), dtype=np.float32)
+    >>> a[0, :] = 1.0
+    >>> a[1, :] = 0.1
+    >>> np.var(a)
+    0.20250003
+
+    Computing the variance in float64 is more accurate:
+
+    >>> np.var(a, dtype=np.float64)
+    0.20249999932944759 # may vary
+    >>> ((1-0.55)**2 + (0.1-0.55)**2)/2
+    0.2025
+
+    Specifying a where argument:
+
+    >>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
+    >>> np.var(a)
+    6.833333333333333 # may vary
+    >>> np.var(a, where=[[True], [True], [False]])
+    4.0
+
+    " :arglists '[[& [args {:as kwargs}]]]} var (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "var"))))
+
+(def ^{:doc "
+    Take values from the input array by matching 1d index and data slices.
+
+    This iterates over matching 1d slices oriented along the specified axis in
+    the index and data arrays, and uses the former to look up values in the
+    latter. These slices can be different lengths.
+
+    Functions returning an index along an axis, like `argsort` and
+    `argpartition`, produce suitable indices for this function.
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    arr: ndarray (Ni..., M, Nk...)
+        Source array
+    indices: ndarray (Ni..., J, Nk...)
+        Indices to take along each 1d slice of `arr`. This must match the
+        dimension of arr, but dimensions Ni and Nj only need to broadcast
+        against `arr`.
+    axis: int
+        The axis to take 1d slices along. If axis is None, the input array is
+        treated as if it had first been flattened to 1d, for consistency with
+        `sort` and `argsort`.
+
+    Returns
+    -------
+    out: ndarray (Ni..., J, Nk...)
+        The indexed result.
+
+    Notes
+    -----
+    This is equivalent to (but faster than) the following use of `ndindex` and
+    `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::
+
+        Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
+        J = indices.shape[axis]  # Need not equal M
+        out = np.empty(Ni + (J,) + Nk)
+
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                a_1d       = a      [ii + s_[:,] + kk]
+                indices_1d = indices[ii + s_[:,] + kk]
+                out_1d     = out    [ii + s_[:,] + kk]
+                for j in range(J):
+                    out_1d[j] = a_1d[indices_1d[j]]
+
+    Equivalently, eliminating the inner loop, the last two lines would be::
+
+                out_1d[:] = a_1d[indices_1d]
+
+    See Also
+    --------
+    take : Take along an axis, using the same indices for every 1d slice
+    put_along_axis :
+        Put values into the destination array by matching 1d index and data slices
+
+    Examples
+    --------
+
+    For this sample array
+
+    >>> a = np.array([[10, 30, 20], [60, 40, 50]])
+
+    We can sort either by using sort directly, or argsort and this function
+
+    >>> np.sort(a, axis=1)
+    array([[10, 20, 30],
+           [40, 50, 60]])
+    >>> ai = np.argsort(a, axis=1); ai
+    array([[0, 2, 1],
+           [1, 2, 0]])
+    >>> np.take_along_axis(a, ai, axis=1)
+    array([[10, 20, 30],
+           [40, 50, 60]])
+
+    The same works for max and min, if you expand the dimensions:
+
+    >>> np.expand_dims(np.max(a, axis=1), axis=1)
+    array([[30],
+           [60]])
+    >>> ai = np.expand_dims(np.argmax(a, axis=1), axis=1)
+    >>> ai
+    array([[1],
+           [0]])
+    >>> np.take_along_axis(a, ai, axis=1)
+    array([[30],
+           [60]])
+
+    If we want to get the max and min at the same time, we can stack the
+    indices first
+
+    >>> ai_min = np.expand_dims(np.argmin(a, axis=1), axis=1)
+    >>> ai_max = np.expand_dims(np.argmax(a, axis=1), axis=1)
+    >>> ai = np.concatenate([ai_min, ai_max], axis=1)
+    >>> ai
+    array([[0, 1],
+           [1, 0]])
+    >>> np.take_along_axis(a, ai, axis=1)
+    array([[10, 30],
+           [40, 60]])
+    " :arglists '[[& [args {:as kwargs}]]]} take_along_axis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "take_along_axis"))))
+
+(def ^{:doc "
+    Return the product of array elements over a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a product is performed.  The default,
+        axis=None, will calculate the product of all the elements in the
+        input array. If axis is negative it counts from the last to the
+        first axis.
+
+        .. versionadded:: 1.7.0
+
+        If axis is a tuple of ints, a product is performed on all of the
+        axes specified in the tuple instead of a single axis or all the
+        axes as before.
+    dtype : dtype, optional
+        The type of the returned array, as well as of the accumulator in
+        which the elements are multiplied.  The dtype of `a` is used by
+        default unless `a` has an integer dtype of less precision than the
+        default platform integer.  In that case, if `a` is signed then the
+        platform integer is used while if `a` is unsigned then an unsigned
+        integer of the same precision as the platform integer is used.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output, but the type of the output
+        values will be cast if necessary.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in the
+        result as dimensions with size one. With this option, the result
+        will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `prod` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+    initial : scalar, optional
+        The starting value for this product. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to include in the product. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    product_along_axis : ndarray, see `dtype` parameter above.
+        An array shaped as `a` but with the specified axis removed.
+        Returns a reference to `out` if specified.
+
+    See Also
+    --------
+    ndarray.prod : equivalent method
+    :ref:`ufuncs-output-type`
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.  That means that, on a 32-bit platform:
+
+    >>> x = np.array([536870910, 536870910, 536870910, 536870910])
+    >>> np.prod(x)
+    16 # may vary
+
+    The product of an empty array is the neutral element 1:
+
+    >>> np.prod([])
+    1.0
+
+    Examples
+    --------
+    By default, calculate the product of all elements:
+
+    >>> np.prod([1.,2.])
+    2.0
+
+    Even when the input array is two-dimensional:
+
+    >>> np.prod([[1.,2.],[3.,4.]])
+    24.0
+
+    But we can also specify the axis over which to multiply:
+
+    >>> np.prod([[1.,2.],[3.,4.]], axis=1)
+    array([  2.,  12.])
+
+    Or select specific elements to include:
+
+    >>> np.prod([1., np.nan, 3.], where=[True, False, True])
+    3.0
+
+    If the type of `x` is unsigned, then the output type is
+    the unsigned platform integer:
+
+    >>> x = np.array([1, 2, 3], dtype=np.uint8)
+    >>> np.prod(x).dtype == np.uint
+    True
+
+    If `x` is of a signed integer type, then the output type
+    is the default platform integer:
+
+    >>> x = np.array([1, 2, 3], dtype=np.int8)
+    >>> np.prod(x).dtype == int
+    True
+
+    You can also start the product with a value other than one:
+
+    >>> np.prod([1, 2], initial=5)
+    10
+    " :arglists '[[& [args {:as kwargs}]]]} prod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "prod"))))
+
+(def ^{:doc "
+    Load arrays or pickled objects from ``.npy``, ``.npz`` or pickled files.
+
+    .. warning:: Loading files that contain object arrays uses the ``pickle``
+                 module, which is not secure against erroneous or maliciously
+                 constructed data. Consider passing ``allow_pickle=False`` to
+                 load data that is known not to contain object arrays for the
+                 safer handling of untrusted sources.
+
+    Parameters
+    ----------
+    file : file-like object, string, or pathlib.Path
+        The file to read. File-like objects must support the
+        ``seek()`` and ``read()`` methods. Pickled files require that the
+        file-like object support the ``readline()`` method as well.
+    mmap_mode : {None, 'r+', 'r', 'w+', 'c'}, optional
+        If not None, then memory-map the file, using the given mode (see
+        `numpy.memmap` for a detailed description of the modes).  A
+        memory-mapped array is kept on disk. However, it can be accessed
+        and sliced like any ndarray.  Memory mapping is especially useful
+        for accessing small fragments of large files without reading the
+        entire file into memory.
+    allow_pickle : bool, optional
+        Allow loading pickled object arrays stored in npy files. Reasons for
+        disallowing pickles include security, as loading pickled data can
+        execute arbitrary code. If pickles are disallowed, loading object
+        arrays will fail. Default: False
+
+        .. versionchanged:: 1.16.3
+            Made default False in response to CVE-2019-6446.
+
+    fix_imports : bool, optional
+        Only useful when loading Python 2 generated pickled files on Python 3,
+        which includes npy/npz files containing object arrays. If `fix_imports`
+        is True, pickle will try to map the old Python 2 names to the new names
+        used in Python 3.
+    encoding : str, optional
+        What encoding to use when reading Python 2 strings. Only useful when
+        loading Python 2 generated pickled files in Python 3, which includes
+        npy/npz files containing object arrays. Values other than 'latin1',
+        'ASCII', and 'bytes' are not allowed, as they can corrupt numerical
+        data. Default: 'ASCII'
+
+    Returns
+    -------
+    result : array, tuple, dict, etc.
+        Data stored in the file. For ``.npz`` files, the returned instance
+        of NpzFile class must be closed to avoid leaking file descriptors.
+
+    Raises
+    ------
+    IOError
+        If the input file does not exist or cannot be read.
+    ValueError
+        The file contains an object array, but allow_pickle=False given.
+
+    See Also
+    --------
+    save, savez, savez_compressed, loadtxt
+    memmap : Create a memory-map to an array stored in a file on disk.
+    lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.
+
+    Notes
+    -----
+    - If the file contains pickle data, then whatever object is stored
+      in the pickle is returned.
+    - If the file is a ``.npy`` file, then a single array is returned.
+    - If the file is a ``.npz`` file, then a dictionary-like object is
+      returned, containing ``{filename: array}`` key-value pairs, one for
+      each file in the archive.
+    - If the file is a ``.npz`` file, the returned value supports the
+      context manager protocol in a similar fashion to the open function::
+
+        with load('foo.npz') as data:
+            a = data['a']
+
+      The underlying file descriptor is closed when exiting the 'with'
+      block.
+
+    Examples
+    --------
+    Store data to disk, and load it again:
+
+    >>> np.save('/tmp/123', np.array([[1, 2, 3], [4, 5, 6]]))
+    >>> np.load('/tmp/123.npy')
+    array([[1, 2, 3],
+           [4, 5, 6]])
+
+    Store compressed data to disk, and load it again:
+
+    >>> a=np.array([[1, 2, 3], [4, 5, 6]])
+    >>> b=np.array([1, 2])
+    >>> np.savez('/tmp/123.npz', a=a, b=b)
+    >>> data = np.load('/tmp/123.npz')
+    >>> data['a']
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> data['b']
+    array([1, 2])
+    >>> data.close()
+
+    Mem-map the stored array, and then access the second row
+    directly from disk:
+
+    >>> X = np.load('/tmp/123.npy', mmap_mode='r')
+    >>> X[1, :]
+    memmap([4, 5, 6])
+
+    " :arglists '[[file & [{mmap_mode :mmap_mode, allow_pickle :allow_pickle, fix_imports :fix_imports, encoding :encoding}]] [file & [{mmap_mode :mmap_mode, allow_pickle :allow_pickle, fix_imports :fix_imports}]] [file & [{mmap_mode :mmap_mode, allow_pickle :allow_pickle}]] [file & [{mmap_mode :mmap_mode}]] [file]]} load (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "load"))))
+
+(def ^{:doc "
+    Sum of array elements over a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Elements to sum.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a sum is performed.  The default,
+        axis=None, will sum all of the elements of the input array.  If
+        axis is negative it counts from the last to the first axis.
+
+        .. versionadded:: 1.7.0
+
+        If axis is a tuple of ints, a sum is performed on all of the axes
+        specified in the tuple instead of a single axis or all the axes as
+        before.
+    dtype : dtype, optional
+        The type of the returned array and of the accumulator in which the
+        elements are summed.  The dtype of `a` is used by default unless `a`
+        has an integer dtype of less precision than the default platform
+        integer.  In that case, if `a` is signed then the platform integer
+        is used while if `a` is unsigned then an unsigned integer of the
+        same precision as the platform integer is used.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output, but the type of the output
+        values will be cast if necessary.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `sum` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+    initial : scalar, optional
+        Starting value for the sum. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to include in the sum. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    sum_along_axis : ndarray
+        An array with the same shape as `a`, with the specified
+        axis removed.   If `a` is a 0-d array, or if `axis` is None, a scalar
+        is returned.  If an output array is specified, a reference to
+        `out` is returned.
+
+    See Also
+    --------
+    ndarray.sum : Equivalent method.
+
+    add.reduce : Equivalent functionality of `add`.
+
+    cumsum : Cumulative sum of array elements.
+
+    trapz : Integration of array values using the composite trapezoidal rule.
+
+    mean, average
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.
+
+    The sum of an empty array is the neutral element 0:
+
+    >>> np.sum([])
+    0.0
+
+    For floating point numbers the numerical precision of sum (and
+    ``np.add.reduce``) is in general limited by directly adding each number
+    individually to the result causing rounding errors in every step.
+    However, often numpy will use a  numerically better approach (partial
+    pairwise summation) leading to improved precision in many use-cases.
+    This improved precision is always provided when no ``axis`` is given.
+    When ``axis`` is given, it will depend on which axis is summed.
+    Technically, to provide the best speed possible, the improved precision
+    is only used when the summation is along the fast axis in memory.
+    Note that the exact precision may vary depending on other parameters.
+    In contrast to NumPy, Python's ``math.fsum`` function uses a slower but
+    more precise approach to summation.
+    Especially when summing a large number of lower precision floating point
+    numbers, such as ``float32``, numerical errors can become significant.
+    In such cases it can be advisable to use `dtype=\"float64\"` to use a higher
+    precision for the output.
+
+    Examples
+    --------
+    >>> np.sum([0.5, 1.5])
+    2.0
+    >>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)
+    1
+    >>> np.sum([[0, 1], [0, 5]])
+    6
+    >>> np.sum([[0, 1], [0, 5]], axis=0)
+    array([0, 6])
+    >>> np.sum([[0, 1], [0, 5]], axis=1)
+    array([1, 5])
+    >>> np.sum([[0, 1], [np.nan, 5]], where=[False, True], axis=1)
+    array([1., 5.])
+
+    If the accumulator is too small, overflow occurs:
+
+    >>> np.ones(128, dtype=np.int8).sum(dtype=np.int8)
+    -128
+
+    You can also start the sum with a value other than zero:
+
+    >>> np.sum([10], initial=5)
+    15
+    " :arglists '[[& [args {:as kwargs}]]]} sum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sum"))))
+
+(def ^{:doc "Signed integer type, compatible with Python `int` and C ``long``.
+
+    :Character code: ``'l'``
+    :Canonical name: `numpy.int_`
+    :Alias on this platform: `numpy.int64`: 64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``).
+    :Alias on this platform: `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]]} int64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int64"))))
+
+(def ^{:doc "
+    Determine if a class is a subclass of a second class.
+
+    `issubclass_` is equivalent to the Python built-in ``issubclass``,
+    except that it returns False instead of raising a TypeError if one
+    of the arguments is not a class.
+
+    Parameters
+    ----------
+    arg1 : class
+        Input class. True is returned if `arg1` is a subclass of `arg2`.
+    arg2 : class or tuple of classes.
+        Input class. If a tuple of classes, True is returned if `arg1` is a
+        subclass of any of the tuple elements.
+
+    Returns
+    -------
+    out : bool
+        Whether `arg1` is a subclass of `arg2` or not.
+
+    See Also
+    --------
+    issubsctype, issubdtype, issctype
+
+    Examples
+    --------
+    >>> np.issubclass_(np.int32, int)
+    False
+    >>> np.issubclass_(np.int32, float)
+    False
+    >>> np.issubclass_(np.float64, float)
+    True
+
+    " :arglists '[[arg1 arg2]]} issubclass_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issubclass_"))))
+
+(def ^{:doc "A datetime stored as a 64-bit integer, counting from ``1970-01-01T00:00:00``.
+
+    >>> np.datetime64(10, 'Y')
+    numpy.datetime64('1980')
+    >>> np.datetime64(10, 'D')
+    numpy.datetime64('1970-01-11')
+    
+    See :ref:`arrays.datetime` for more information.
+
+    :Character code: ``'M'``" :arglists '[[self & [args {:as kwargs}]]]} Datetime64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "Datetime64"))))
+
+(def ^{:doc "OS routines for NT or Posix depending on what system we're on.
+
+This exports:
+  - all functions from posix or nt, e.g. unlink, stat, etc.
+  - os.path is either posixpath or ntpath
+  - os.name is either 'posix' or 'nt'
+  - os.curdir is a string representing the current directory (always '.')
+  - os.pardir is a string representing the parent directory (always '..')
+  - os.sep is the (or a most common) pathname separator ('/' or '\\\\')
+  - os.extsep is the extension separator (always '.')
+  - os.altsep is the alternate pathname separator (None or '/')
+  - os.pathsep is the component separator used in $PATH etc
+  - os.linesep is the line separator in text files ('\\r' or '\\n' or '\\r\\n')
+  - os.defpath is the default search path for executables
+  - os.devnull is the file path of the null device ('/dev/null', etc.)
+
+Programs that import and use 'os' stand a better chance of being
+portable between different platforms.  Of course, they must then
+only use functions that are defined by all platforms (e.g., unlink
+and opendir), and leave all pathname manipulation to os.path
+(e.g., split and join).
+"} os (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "os"))))
+
+(def ^{:doc "Complex number type composed of two extended-precision floating-point
+    numbers.
+
+    :Character code: ``'G'``
+    :Canonical name: `numpy.clongdouble`
+    :Alias: `numpy.clongfloat`
+    :Alias: `numpy.longcomplex`
+    :Alias on this platform: `numpy.complex256`: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} longcomplex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longcomplex"))))
+
+(def ^{:doc "
+    dot(a, b, out=None)
+
+    Dot product of two arrays. Specifically,
+
+    - If both `a` and `b` are 1-D arrays, it is inner product of vectors
+      (without complex conjugation).
+
+    - If both `a` and `b` are 2-D arrays, it is matrix multiplication,
+      but using :func:`matmul` or ``a @ b`` is preferred.
+
+    - If either `a` or `b` is 0-D (scalar), it is equivalent to :func:`multiply`
+      and using ``numpy.multiply(a, b)`` or ``a * b`` is preferred.
+
+    - If `a` is an N-D array and `b` is a 1-D array, it is a sum product over
+      the last axis of `a` and `b`.
+
+    - If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a
+      sum product over the last axis of `a` and the second-to-last axis of `b`::
+
+        dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
+
+    Parameters
+    ----------
+    a : array_like
+        First argument.
+    b : array_like
+        Second argument.
+    out : ndarray, optional
+        Output argument. This must have the exact kind that would be returned
+        if it was not used. In particular, it must have the right type, must be
+        C-contiguous, and its dtype must be the dtype that would be returned
+        for `dot(a,b)`. This is a performance feature. Therefore, if these
+        conditions are not met, an exception is raised, instead of attempting
+        to be flexible.
+
+    Returns
+    -------
+    output : ndarray
+        Returns the dot product of `a` and `b`.  If `a` and `b` are both
+        scalars or both 1-D arrays then a scalar is returned; otherwise
+        an array is returned.
+        If `out` is given, then it is returned.
+
+    Raises
+    ------
+    ValueError
+        If the last dimension of `a` is not the same size as
+        the second-to-last dimension of `b`.
+
+    See Also
+    --------
+    vdot : Complex-conjugating dot product.
+    tensordot : Sum products over arbitrary axes.
+    einsum : Einstein summation convention.
+    matmul : '@' operator as method with out parameter.
+    linalg.multi_dot : Chained dot product.
+
+    Examples
+    --------
+    >>> np.dot(3, 4)
+    12
+
+    Neither argument is complex-conjugated:
+
+    >>> np.dot([2j, 3j], [2j, 3j])
+    (-13+0j)
+
+    For 2-D arrays it is the matrix product:
+
+    >>> a = [[1, 0], [0, 1]]
+    >>> b = [[4, 1], [2, 2]]
+    >>> np.dot(a, b)
+    array([[4, 1],
+           [2, 2]])
+
+    >>> a = np.arange(3*4*5*6).reshape((3,4,5,6))
+    >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))
+    >>> np.dot(a, b)[2,3,2,1,2,2]
+    499128
+    >>> sum(a[2,3,2,:] * b[1,2,:,2])
+    499128
+
+    " :arglists '[[& [args {:as kwargs}]]]} dot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dot"))))
+
+(def ^{:doc "
+    Return the sum along diagonals of the array.
+
+    If `a` is 2-D, the sum along its diagonal with the given offset
+    is returned, i.e., the sum of elements ``a[i,i+offset]`` for all i.
+
+    If `a` has more than two dimensions, then the axes specified by axis1 and
+    axis2 are used to determine the 2-D sub-arrays whose traces are returned.
+    The shape of the resulting array is the same as that of `a` with `axis1`
+    and `axis2` removed.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array, from which the diagonals are taken.
+    offset : int, optional
+        Offset of the diagonal from the main diagonal. Can be both positive
+        and negative. Defaults to 0.
+    axis1, axis2 : int, optional
+        Axes to be used as the first and second axis of the 2-D sub-arrays
+        from which the diagonals should be taken. Defaults are the first two
+        axes of `a`.
+    dtype : dtype, optional
+        Determines the data-type of the returned array and of the accumulator
+        where the elements are summed. If dtype has the value None and `a` is
+        of integer type of precision less than the default integer
+        precision, then the default integer precision is used. Otherwise,
+        the precision is the same as that of `a`.
+    out : ndarray, optional
+        Array into which the output is placed. Its type is preserved and
+        it must be of the right shape to hold the output.
+
+    Returns
+    -------
+    sum_along_diagonals : ndarray
+        If `a` is 2-D, the sum along the diagonal is returned.  If `a` has
+        larger dimensions, then an array of sums along diagonals is returned.
+
+    See Also
+    --------
+    diag, diagonal, diagflat
+
+    Examples
+    --------
+    >>> np.trace(np.eye(3))
+    3.0
+    >>> a = np.arange(8).reshape((2,2,2))
+    >>> np.trace(a)
+    array([6, 8])
+
+    >>> a = np.arange(24).reshape((2,2,2,3))
+    >>> np.trace(a).shape
+    (2, 3)
+
+    " :arglists '[[& [args {:as kwargs}]]]} trace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trace"))))
+
+(def ^{:doc ""} BUFSIZE 8192)
+
+(def ^{:doc "
+    Return the indices of the minimum values in the specified axis ignoring
+    NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the results
+    cannot be trusted if a slice contains only NaNs and Infs.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : int, optional
+        Axis along which to operate.  By default flattened input is used.
+
+    Returns
+    -------
+    index_array : ndarray
+        An array of indices or a single index value.
+
+    See Also
+    --------
+    argmin, nanargmax
+
+    Examples
+    --------
+    >>> a = np.array([[np.nan, 4], [2, 3]])
+    >>> np.argmin(a)
+    0
+    >>> np.nanargmin(a)
+    2
+    >>> np.nanargmin(a, axis=0)
+    array([1, 1])
+    >>> np.nanargmin(a, axis=1)
+    array([1, 0])
+
+    " :arglists '[[& [args {:as kwargs}]]]} nanargmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanargmin"))))
+
+(def ^{:doc "cbrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the cube-root of an array, element-wise.
+
+.. versionadded:: 1.10.0
+
+Parameters
+----------
+x : array_like
+    The values whose cube-roots are required.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    An array of the same shape as `x`, containing the cube
+    cube-root of each element in `x`.
+    If `out` was provided, `y` is a reference to it.
+    This is a scalar if `x` is a scalar.
+
+
+Examples
+--------
+>>> np.cbrt([1,8,27])
+array([ 1.,  2.,  3.])" :arglists '[[self & [args {:as kwargs}]]]} cbrt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cbrt"))))
+
+(def ^{:doc "
+    min_scalar_type(a)
+
+    For scalar ``a``, returns the data type with the smallest size
+    and smallest scalar kind which can hold its value.  For non-scalar
+    array ``a``, returns the vector's dtype unmodified.
+
+    Floating point values are not demoted to integers,
+    and complex values are not demoted to floats.
+
+    Parameters
+    ----------
+    a : scalar or array_like
+        The value whose minimal data type is to be found.
+
+    Returns
+    -------
+    out : dtype
+        The minimal data type.
+
+    Notes
+    -----
+    .. versionadded:: 1.6.0
+
+    See Also
+    --------
+    result_type, promote_types, dtype, can_cast
+
+    Examples
+    --------
+    >>> np.min_scalar_type(10)
+    dtype('uint8')
+
+    >>> np.min_scalar_type(-260)
+    dtype('int16')
+
+    >>> np.min_scalar_type(3.1)
+    dtype('float16')
+
+    >>> np.min_scalar_type(1e50)
+    dtype('float64')
+
+    >>> np.min_scalar_type(np.arange(4,dtype='f8'))
+    dtype('float64')
+
+    " :arglists '[[& [args {:as kwargs}]]]} min_scalar_type (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "min_scalar_type"))))
+
+(def ^{:doc "
+    Return the cross product of two (arrays of) vectors.
+
+    The cross product of `a` and `b` in :math:`R^3` is a vector perpendicular
+    to both `a` and `b`.  If `a` and `b` are arrays of vectors, the vectors
+    are defined by the last axis of `a` and `b` by default, and these axes
+    can have dimensions 2 or 3.  Where the dimension of either `a` or `b` is
+    2, the third component of the input vector is assumed to be zero and the
+    cross product calculated accordingly.  In cases where both input vectors
+    have dimension 2, the z-component of the cross product is returned.
+
+    Parameters
+    ----------
+    a : array_like
+        Components of the first vector(s).
+    b : array_like
+        Components of the second vector(s).
+    axisa : int, optional
+        Axis of `a` that defines the vector(s).  By default, the last axis.
+    axisb : int, optional
+        Axis of `b` that defines the vector(s).  By default, the last axis.
+    axisc : int, optional
+        Axis of `c` containing the cross product vector(s).  Ignored if
+        both input vectors have dimension 2, as the return is scalar.
+        By default, the last axis.
+    axis : int, optional
+        If defined, the axis of `a`, `b` and `c` that defines the vector(s)
+        and cross product(s).  Overrides `axisa`, `axisb` and `axisc`.
+
+    Returns
+    -------
+    c : ndarray
+        Vector cross product(s).
+
+    Raises
+    ------
+    ValueError
+        When the dimension of the vector(s) in `a` and/or `b` does not
+        equal 2 or 3.
+
+    See Also
+    --------
+    inner : Inner product
+    outer : Outer product.
+    ix_ : Construct index arrays.
+
+    Notes
+    -----
+    .. versionadded:: 1.9.0
+
+    Supports full broadcasting of the inputs.
+
+    Examples
+    --------
+    Vector cross-product.
+
+    >>> x = [1, 2, 3]
+    >>> y = [4, 5, 6]
+    >>> np.cross(x, y)
+    array([-3,  6, -3])
+
+    One vector with dimension 2.
+
+    >>> x = [1, 2]
+    >>> y = [4, 5, 6]
+    >>> np.cross(x, y)
+    array([12, -6, -3])
+
+    Equivalently:
+
+    >>> x = [1, 2, 0]
+    >>> y = [4, 5, 6]
+    >>> np.cross(x, y)
+    array([12, -6, -3])
+
+    Both vectors with dimension 2.
+
+    >>> x = [1,2]
+    >>> y = [4,5]
+    >>> np.cross(x, y)
+    array(-3)
+
+    Multiple vector cross-products. Note that the direction of the cross
+    product vector is defined by the `right-hand rule`.
+
+    >>> x = np.array([[1,2,3], [4,5,6]])
+    >>> y = np.array([[4,5,6], [1,2,3]])
+    >>> np.cross(x, y)
+    array([[-3,  6, -3],
+           [ 3, -6,  3]])
+
+    The orientation of `c` can be changed using the `axisc` keyword.
+
+    >>> np.cross(x, y, axisc=0)
+    array([[-3,  3],
+           [ 6, -6],
+           [-3,  3]])
+
+    Change the vector definition of `x` and `y` using `axisa` and `axisb`.
+
+    >>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]])
+    >>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]])
+    >>> np.cross(x, y)
+    array([[ -6,  12,  -6],
+           [  0,   0,   0],
+           [  6, -12,   6]])
+    >>> np.cross(x, y, axisa=0, axisb=0)
+    array([[-24,  48, -24],
+           [-30,  60, -30],
+           [-36,  72, -36]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} cross (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cross"))))
+
+(def ^{:doc "Capsule objects let you wrap a C \"void *\" pointer in a Python
+object.  They're a way of passing data through the Python interpreter
+without creating your own custom type.
+
+Capsules are used for communication between extension modules.
+They provide a way for an extension module to export a C interface
+to other extension modules, so that extension modules can use the
+Python import mechanism to link to one another.
+"} _UFUNC_API (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_UFUNC_API"))))
+
+(def ^{:doc "
+    Return the character for the minimum-size type to which given types can
+    be safely cast.
+
+    The returned type character must represent the smallest size dtype such
+    that an array of the returned type can handle the data from an array of
+    all types in `typechars` (or if `typechars` is an array, then its
+    dtype.char).
+
+    Parameters
+    ----------
+    typechars : list of str or array_like
+        If a list of strings, each string should represent a dtype.
+        If array_like, the character representation of the array dtype is used.
+    typeset : str or list of str, optional
+        The set of characters that the returned character is chosen from.
+        The default set is 'GDFgdf'.
+    default : str, optional
+        The default character, this is returned if none of the characters in
+        `typechars` matches a character in `typeset`.
+
+    Returns
+    -------
+    typechar : str
+        The character representing the minimum-size type that was found.
+
+    See Also
+    --------
+    dtype, sctype2char, maximum_sctype
+
+    Examples
+    --------
+    >>> np.mintypecode(['d', 'f', 'S'])
+    'd'
+    >>> x = np.array([1.1, 2-3.j])
+    >>> np.mintypecode(x)
+    'D'
+
+    >>> np.mintypecode('abceh', default='G')
+    'G'
+
+    " :arglists '[[typechars & [{typeset :typeset, default :default}]] [typechars & [{typeset :typeset}]] [typechars]]} mintypecode (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mintypecode"))))
+
+(def ^{:doc "
+    Return the cumulative product of elements along a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        Axis along which the cumulative product is computed.  By default
+        the input is flattened.
+    dtype : dtype, optional
+        Type of the returned array, as well as of the accumulator in which
+        the elements are multiplied.  If *dtype* is not specified, it
+        defaults to the dtype of `a`, unless `a` has an integer dtype with
+        a precision less than that of the default platform integer.  In
+        that case, the default platform integer is used instead.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type of the resulting values will be cast if necessary.
+
+    Returns
+    -------
+    cumprod : ndarray
+        A new array holding the result is returned unless `out` is
+        specified, in which case a reference to out is returned.
+
+    See Also
+    --------
+    :ref:`ufuncs-output-type`
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.
+
+    Examples
+    --------
+    >>> a = np.array([1,2,3])
+    >>> np.cumprod(a) # intermediate results 1, 1*2
+    ...               # total product 1*2*3 = 6
+    array([1, 2, 6])
+    >>> a = np.array([[1, 2, 3], [4, 5, 6]])
+    >>> np.cumprod(a, dtype=float) # specify type of output
+    array([   1.,    2.,    6.,   24.,  120.,  720.])
+
+    The cumulative product for each column (i.e., over the rows) of `a`:
+
+    >>> np.cumprod(a, axis=0)
+    array([[ 1,  2,  3],
+           [ 4, 10, 18]])
+
+    The cumulative product for each row (i.e. over the columns) of `a`:
+
+    >>> np.cumprod(a,axis=1)
+    array([[  1,   2,   6],
+           [  4,  20, 120]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} cumprod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cumprod"))))
+
+(def ^{:doc "
+    Repeat elements of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    repeats : int or array of ints
+        The number of repetitions for each element.  `repeats` is broadcasted
+        to fit the shape of the given axis.
+    axis : int, optional
+        The axis along which to repeat values.  By default, use the
+        flattened input array, and return a flat output array.
+
+    Returns
+    -------
+    repeated_array : ndarray
+        Output array which has the same shape as `a`, except along
+        the given axis.
+
+    See Also
+    --------
+    tile : Tile an array.
+    unique : Find the unique elements of an array.
+
+    Examples
+    --------
+    >>> np.repeat(3, 4)
+    array([3, 3, 3, 3])
+    >>> x = np.array([[1,2],[3,4]])
+    >>> np.repeat(x, 2)
+    array([1, 1, 2, 2, 3, 3, 4, 4])
+    >>> np.repeat(x, 3, axis=1)
+    array([[1, 1, 1, 2, 2, 2],
+           [3, 3, 3, 4, 4, 4]])
+    >>> np.repeat(x, [1, 2], axis=0)
+    array([[1, 2],
+           [3, 4],
+           [3, 4]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} repeat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "repeat"))))
+
+(def ^{:doc "
+    matrix(data, dtype=None, copy=True)
+
+    .. note:: It is no longer recommended to use this class, even for linear
+              algebra. Instead use regular arrays. The class may be removed
+              in the future.
+
+    Returns a matrix from an array-like object, or from a string of data.
+    A matrix is a specialized 2-D array that retains its 2-D nature
+    through operations.  It has certain special operators, such as ``*``
+    (matrix multiplication) and ``**`` (matrix power).
+
+    Parameters
+    ----------
+    data : array_like or string
+       If `data` is a string, it is interpreted as a matrix with commas
+       or spaces separating columns, and semicolons separating rows.
+    dtype : data-type
+       Data-type of the output matrix.
+    copy : bool
+       If `data` is already an `ndarray`, then this flag determines
+       whether the data is copied (the default), or whether a view is
+       constructed.
+
+    See Also
+    --------
+    array
+
+    Examples
+    --------
+    >>> a = np.matrix('1 2; 3 4')
+    >>> a
+    matrix([[1, 2],
+            [3, 4]])
+
+    >>> np.matrix([[1, 2], [3, 4]])
+    matrix([[1, 2],
+            [3, 4]])
+
+    " :arglists '[[self & [args {:as kwargs}]]]} matrix (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "matrix"))))
+
+(def ^{:doc "less_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the truth value of (x1 <= x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+greater, less, greater_equal, equal, not_equal
+
+Examples
+--------
+>>> np.less_equal([4, 2, 1], [2, 2, 2])
+array([False,  True,  True])
+
+The ``<=`` operator can be used as a shorthand for ``np.less_equal`` on
+ndarrays.
+
+>>> a = np.array([4, 2, 1])
+>>> b = np.array([2, 2, 2])
+>>> a <= b
+array([False,  True,  True])" :arglists '[[self & [args {:as kwargs}]]]} less_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "less_equal"))))
+
+(def ^{:doc "
+    Return the Kaiser window.
+
+    The Kaiser window is a taper formed by using a Bessel function.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+    beta : float
+        Shape parameter for window.
+
+    Returns
+    -------
+    out : array
+        The window, with the maximum value normalized to one (the value
+        one appears only if the number of samples is odd).
+
+    See Also
+    --------
+    bartlett, blackman, hamming, hanning
+
+    Notes
+    -----
+    The Kaiser window is defined as
+
+    .. math::  w(n) = I_0\\left( \\beta \\sqrt{1-\\frac{4n^2}{(M-1)^2}}
+               \\right)/I_0(\\beta)
+
+    with
+
+    .. math:: \\quad -\\frac{M-1}{2} \\leq n \\leq \\frac{M-1}{2},
+
+    where :math:`I_0` is the modified zeroth-order Bessel function.
+
+    The Kaiser was named for Jim Kaiser, who discovered a simple
+    approximation to the DPSS window based on Bessel functions.  The Kaiser
+    window is a very good approximation to the Digital Prolate Spheroidal
+    Sequence, or Slepian window, which is the transform which maximizes the
+    energy in the main lobe of the window relative to total energy.
+
+    The Kaiser can approximate many other windows by varying the beta
+    parameter.
+
+    ====  =======================
+    beta  Window shape
+    ====  =======================
+    0     Rectangular
+    5     Similar to a Hamming
+    6     Similar to a Hanning
+    8.6   Similar to a Blackman
+    ====  =======================
+
+    A beta value of 14 is probably a good starting point. Note that as beta
+    gets large, the window narrows, and so the number of samples needs to be
+    large enough to sample the increasingly narrow spike, otherwise NaNs will
+    get returned.
+
+    Most references to the Kaiser window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    \"removing the foot\", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function.
+
+    References
+    ----------
+    .. [1] J. F. Kaiser, \"Digital Filters\" - Ch 7 in \"Systems analysis by
+           digital computer\", Editors: F.F. Kuo and J.F. Kaiser, p 218-285.
+           John Wiley and Sons, New York, (1966).
+    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\", The
+           University of Alberta Press, 1975, pp. 177-178.
+    .. [3] Wikipedia, \"Window function\",
+           https://en.wikipedia.org/wiki/Window_function
+
+    Examples
+    --------
+    >>> import matplotlib.pyplot as plt
+    >>> np.kaiser(12, 14)
+     array([7.72686684e-06, 3.46009194e-03, 4.65200189e-02, # may vary
+            2.29737120e-01, 5.99885316e-01, 9.45674898e-01,
+            9.45674898e-01, 5.99885316e-01, 2.29737120e-01,
+            4.65200189e-02, 3.46009194e-03, 7.72686684e-06])
+
+
+    Plot the window and the frequency response:
+
+    >>> from numpy.fft import fft, fftshift
+    >>> window = np.kaiser(51, 14)
+    >>> plt.plot(window)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Kaiser window\")
+    Text(0.5, 1.0, 'Kaiser window')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"Sample\")
+    Text(0.5, 0, 'Sample')
+    >>> plt.show()
+
+    >>> plt.figure()
+    <Figure size 640x480 with 0 Axes>
+    >>> A = fft(window, 2048) / 25.5
+    >>> mag = np.abs(fftshift(A))
+    >>> freq = np.linspace(-0.5, 0.5, len(A))
+    >>> response = 20 * np.log10(mag)
+    >>> response = np.clip(response, -100, 100)
+    >>> plt.plot(freq, response)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Frequency response of Kaiser window\")
+    Text(0.5, 1.0, 'Frequency response of Kaiser window')
+    >>> plt.ylabel(\"Magnitude [dB]\")
+    Text(0, 0.5, 'Magnitude [dB]')
+    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
+    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
+    >>> plt.axis('tight')
+    (-0.5, 0.5, -100.0, ...) # may vary
+    >>> plt.show()
+
+    " :arglists '[[M beta]]} kaiser (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "kaiser"))))
+
+(def ^{:doc "add_ufunc_docstring(ufunc, new_docstring)
+
+    Replace the docstring for a ufunc with new_docstring.
+    This method will only work if the current docstring for
+    the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)
+
+    Parameters
+    ----------
+    ufunc : numpy.ufunc
+        A ufunc whose current doc is NULL.
+    new_docstring : string
+        The new docstring for the ufunc.
+
+    Notes
+    -----
+    This method allocates memory for new_docstring on
+    the heap. Technically this creates a mempory leak, since this
+    memory will not be reclaimed until the end of the program
+    even if the ufunc itself is removed. However this will only
+    be a problem if the user is repeatedly creating ufuncs with
+    no documentation, adding documentation via add_newdoc_ufunc,
+    and then throwing away the ufunc." :arglists '[[self & [args {:as kwargs}]]]} add_newdoc_ufunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add_newdoc_ufunc"))))
+
+(def ^{:doc "Create a memory-map to an array stored in a *binary* file on disk.
+
+    Memory-mapped files are used for accessing small segments of large files
+    on disk, without reading the entire file into memory.  NumPy's
+    memmap's are array-like objects.  This differs from Python's ``mmap``
+    module, which uses file-like objects.
+
+    This subclass of ndarray has some unpleasant interactions with
+    some operations, because it doesn't quite fit properly as a subclass.
+    An alternative to using this subclass is to create the ``mmap``
+    object yourself, then create an ndarray with ndarray.__new__ directly,
+    passing the object created in its 'buffer=' parameter.
+
+    This class may at some point be turned into a factory function
+    which returns a view into an mmap buffer.
+
+    Flush the memmap instance to write the changes to the file. Currently there
+    is no API to close the underlying ``mmap``. It is tricky to ensure the 
+    resource is actually closed, since it may be shared between different
+    memmap instances.
+
+
+    Parameters
+    ----------
+    filename : str, file-like object, or pathlib.Path instance
+        The file name or file object to be used as the array data buffer.
+    dtype : data-type, optional
+        The data-type used to interpret the file contents.
+        Default is `uint8`.
+    mode : {'r+', 'r', 'w+', 'c'}, optional
+        The file is opened in this mode:
+
+        +------+-------------------------------------------------------------+
+        | 'r'  | Open existing file for reading only.                        |
+        +------+-------------------------------------------------------------+
+        | 'r+' | Open existing file for reading and writing.                 |
+        +------+-------------------------------------------------------------+
+        | 'w+' | Create or overwrite existing file for reading and writing.  |
+        +------+-------------------------------------------------------------+
+        | 'c'  | Copy-on-write: assignments affect data in memory, but       |
+        |      | changes are not saved to disk.  The file on disk is         |
+        |      | read-only.                                                  |
+        +------+-------------------------------------------------------------+
+
+        Default is 'r+'.
+    offset : int, optional
+        In the file, array data starts at this offset. Since `offset` is
+        measured in bytes, it should normally be a multiple of the byte-size
+        of `dtype`. When ``mode != 'r'``, even positive offsets beyond end of
+        file are valid; The file will be extended to accommodate the
+        additional data. By default, ``memmap`` will start at the beginning of
+        the file, even if ``filename`` is a file pointer ``fp`` and
+        ``fp.tell() != 0``.
+    shape : tuple, optional
+        The desired shape of the array. If ``mode == 'r'`` and the number
+        of remaining bytes after `offset` is not a multiple of the byte-size
+        of `dtype`, you must specify `shape`. By default, the returned array
+        will be 1-D with the number of elements determined by file size
+        and data-type.
+    order : {'C', 'F'}, optional
+        Specify the order of the ndarray memory layout:
+        :term:`row-major`, C-style or :term:`column-major`,
+        Fortran-style.  This only has an effect if the shape is
+        greater than 1-D.  The default order is 'C'.
+
+    Attributes
+    ----------
+    filename : str or pathlib.Path instance
+        Path to the mapped file.
+    offset : int
+        Offset position in the file.
+    mode : str
+        File mode.
+
+    Methods
+    -------
+    flush
+        Flush any changes in memory to file on disk.
+        When you delete a memmap object, flush is called first to write
+        changes to disk.
+
+
+    See also
+    --------
+    lib.format.open_memmap : Create or load a memory-mapped ``.npy`` file.
+
+    Notes
+    -----
+    The memmap object can be used anywhere an ndarray is accepted.
+    Given a memmap ``fp``, ``isinstance(fp, numpy.ndarray)`` returns
+    ``True``.
+    
+    Memory-mapped files cannot be larger than 2GB on 32-bit systems.
+
+    When a memmap causes a file to be created or extended beyond its
+    current size in the filesystem, the contents of the new part are
+    unspecified. On systems with POSIX filesystem semantics, the extended
+    part will be filled with zero bytes.
+
+    Examples
+    --------
+    >>> data = np.arange(12, dtype='float32')
+    >>> data.resize((3,4))
+
+    This example uses a temporary file so that doctest doesn't write
+    files to your directory. You would use a 'normal' filename.
+
+    >>> from tempfile import mkdtemp
+    >>> import os.path as path
+    >>> filename = path.join(mkdtemp(), 'newfile.dat')
+
+    Create a memmap with dtype and shape that matches our data:
+
+    >>> fp = np.memmap(filename, dtype='float32', mode='w+', shape=(3,4))
+    >>> fp
+    memmap([[0., 0., 0., 0.],
+            [0., 0., 0., 0.],
+            [0., 0., 0., 0.]], dtype=float32)
+
+    Write data to memmap array:
+
+    >>> fp[:] = data[:]
+    >>> fp
+    memmap([[  0.,   1.,   2.,   3.],
+            [  4.,   5.,   6.,   7.],
+            [  8.,   9.,  10.,  11.]], dtype=float32)
+
+    >>> fp.filename == path.abspath(filename)
+    True
+
+    Flushes memory changes to disk in order to read them back
+
+    >>> fp.flush()
+
+    Load the memmap and verify data was stored:
+
+    >>> newfp = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
+    >>> newfp
+    memmap([[  0.,   1.,   2.,   3.],
+            [  4.,   5.,   6.,   7.],
+            [  8.,   9.,  10.,  11.]], dtype=float32)
+
+    Read-only memmap:
+
+    >>> fpr = np.memmap(filename, dtype='float32', mode='r', shape=(3,4))
+    >>> fpr.flags.writeable
+    False
+
+    Copy-on-write memmap:
+
+    >>> fpc = np.memmap(filename, dtype='float32', mode='c', shape=(3,4))
+    >>> fpc.flags.writeable
+    True
+
+    It's possible to assign to copy-on-write array, but values are only
+    written into the memory copy of the array, and not written to disk:
+
+    >>> fpc
+    memmap([[  0.,   1.,   2.,   3.],
+            [  4.,   5.,   6.,   7.],
+            [  8.,   9.,  10.,  11.]], dtype=float32)
+    >>> fpc[0,:] = 0
+    >>> fpc
+    memmap([[  0.,   0.,   0.,   0.],
+            [  4.,   5.,   6.,   7.],
+            [  8.,   9.,  10.,  11.]], dtype=float32)
+
+    File on disk is unchanged:
+
+    >>> fpr
+    memmap([[  0.,   1.,   2.,   3.],
+            [  4.,   5.,   6.,   7.],
+            [  8.,   9.,  10.,  11.]], dtype=float32)
+
+    Offset into a memmap:
+
+    >>> fpo = np.memmap(filename, dtype='float32', mode='r', offset=16)
+    >>> fpo
+    memmap([  4.,   5.,   6.,   7.,   8.,   9.,  10.,  11.], dtype=float32)
+
+    " :arglists '[[self & [args {:as kwargs}]]]} memmap (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "memmap"))))
+
+(def ^{:doc ""} RAISE 2)
+
+(def ^{:doc "
+    Return the indices of the elements that are non-zero.
+
+    Returns a tuple of arrays, one for each dimension of `a`,
+    containing the indices of the non-zero elements in that
+    dimension. The values in `a` are always tested and returned in
+    row-major, C-style order.
+
+    To group the indices by element, rather than dimension, use `argwhere`,
+    which returns a row for each non-zero element.
+
+    .. note::
+
+       When called on a zero-d array or scalar, ``nonzero(a)`` is treated
+       as ``nonzero(atleast_1d(a))``.
+
+       .. deprecated:: 1.17.0
+
+          Use `atleast_1d` explicitly if this behavior is deliberate.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+
+    Returns
+    -------
+    tuple_of_arrays : tuple
+        Indices of elements that are non-zero.
+
+    See Also
+    --------
+    flatnonzero :
+        Return indices that are non-zero in the flattened version of the input
+        array.
+    ndarray.nonzero :
+        Equivalent ndarray method.
+    count_nonzero :
+        Counts the number of non-zero elements in the input array.
+
+    Notes
+    -----
+    While the nonzero values can be obtained with ``a[nonzero(a)]``, it is
+    recommended to use ``x[x.astype(bool)]`` or ``x[x != 0]`` instead, which
+    will correctly handle 0-d arrays.
+
+    Examples
+    --------
+    >>> x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
+    >>> x
+    array([[3, 0, 0],
+           [0, 4, 0],
+           [5, 6, 0]])
+    >>> np.nonzero(x)
+    (array([0, 1, 2, 2]), array([0, 1, 0, 1]))
+
+    >>> x[np.nonzero(x)]
+    array([3, 4, 5, 6])
+    >>> np.transpose(np.nonzero(x))
+    array([[0, 0],
+           [1, 1],
+           [2, 0],
+           [2, 1]])
+
+    A common use for ``nonzero`` is to find the indices of an array, where
+    a condition is True.  Given an array `a`, the condition `a` > 3 is a
+    boolean array and since False is interpreted as 0, np.nonzero(a > 3)
+    yields the indices of the `a` where the condition is true.
+
+    >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    >>> a > 3
+    array([[False, False, False],
+           [ True,  True,  True],
+           [ True,  True,  True]])
+    >>> np.nonzero(a > 3)
+    (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
+
+    Using this result to index `a` is equivalent to using the mask directly:
+
+    >>> a[np.nonzero(a > 3)]
+    array([4, 5, 6, 7, 8, 9])
+    >>> a[a > 3]  # prefer this spelling
+    array([4, 5, 6, 7, 8, 9])
+
+    ``nonzero`` can also be called as a method of the array.
+
+    >>> (a > 3).nonzero()
+    (array([1, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
+
+    " :arglists '[[& [args {:as kwargs}]]]} nonzero (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nonzero"))))
+
+(def ^{:doc "Concrete implementation of SourceLoader using the file system."} __loader__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__loader__"))))
+
+(def ^{:doc "
+    Roll the specified axis backwards, until it lies in a given position.
+
+    This function continues to be supported for backward compatibility, but you
+    should prefer `moveaxis`. The `moveaxis` function was added in NumPy
+    1.11.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input array.
+    axis : int
+        The axis to be rolled. The positions of the other axes do not
+        change relative to one another.
+    start : int, optional
+        When ``start <= axis``, the axis is rolled back until it lies in
+        this position. When ``start > axis``, the axis is rolled until it
+        lies before this position. The default, 0, results in a \"complete\"
+        roll. The following table describes how negative values of ``start``
+        are interpreted:
+
+        .. table::
+           :align: left
+
+           +-------------------+----------------------+
+           |     ``start``     | Normalized ``start`` |
+           +===================+======================+
+           | ``-(arr.ndim+1)`` | raise ``AxisError``  |
+           +-------------------+----------------------+
+           | ``-arr.ndim``     | 0                    |
+           +-------------------+----------------------+
+           | |vdots|           | |vdots|              |
+           +-------------------+----------------------+
+           | ``-1``            | ``arr.ndim-1``       |
+           +-------------------+----------------------+
+           | ``0``             | ``0``                |
+           +-------------------+----------------------+
+           | |vdots|           | |vdots|              |
+           +-------------------+----------------------+
+           | ``arr.ndim``      | ``arr.ndim``         |
+           +-------------------+----------------------+
+           | ``arr.ndim + 1``  | raise ``AxisError``  |
+           +-------------------+----------------------+
+           
+        .. |vdots|   unicode:: U+22EE .. Vertical Ellipsis
+
+    Returns
+    -------
+    res : ndarray
+        For NumPy >= 1.10.0 a view of `a` is always returned. For earlier
+        NumPy versions a view of `a` is returned only if the order of the
+        axes is changed, otherwise the input array is returned.
+
+    See Also
+    --------
+    moveaxis : Move array axes to new positions.
+    roll : Roll the elements of an array by a number of positions along a
+        given axis.
+
+    Examples
+    --------
+    >>> a = np.ones((3,4,5,6))
+    >>> np.rollaxis(a, 3, 1).shape
+    (3, 6, 4, 5)
+    >>> np.rollaxis(a, 2).shape
+    (5, 3, 4, 6)
+    >>> np.rollaxis(a, 1, 4).shape
+    (3, 5, 6, 4)
+
+    " :arglists '[[& [args {:as kwargs}]]]} rollaxis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rollaxis"))))
+
+(def ^{:doc ""} ERR_RAISE 2)
+
+(def ^{:doc "isnat(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Test element-wise for NaT (not a time) and return result as a boolean array.
+
+.. versionadded:: 1.13.0
+
+Parameters
+----------
+x : array_like
+    Input array with datetime or timedelta data type.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or bool
+    True where ``x`` is NaT, false otherwise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+isnan, isinf, isneginf, isposinf, isfinite
+
+Examples
+--------
+>>> np.isnat(np.datetime64(\"NaT\"))
+True
+>>> np.isnat(np.datetime64(\"2016-01-01\"))
+False
+>>> np.isnat(np.array([\"NaT\", \"2016-01-01\"], dtype=\"datetime64[ns]\"))
+array([ True, False])" :arglists '[[self & [args {:as kwargs}]]]} isnat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isnat"))))
+
+(def ^{:doc "
+    Return the roots of a polynomial with coefficients given in p.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide </reference/routines.polynomials>`.
+
+    The values in the rank-1 array `p` are coefficients of a polynomial.
+    If the length of `p` is n+1 then the polynomial is described by::
+
+      p[0] * x**n + p[1] * x**(n-1) + ... + p[n-1]*x + p[n]
+
+    Parameters
+    ----------
+    p : array_like
+        Rank-1 array of polynomial coefficients.
+
+    Returns
+    -------
+    out : ndarray
+        An array containing the roots of the polynomial.
+
+    Raises
+    ------
+    ValueError
+        When `p` cannot be converted to a rank-1 array.
+
+    See also
+    --------
+    poly : Find the coefficients of a polynomial with a given sequence
+           of roots.
+    polyval : Compute polynomial values.
+    polyfit : Least squares polynomial fit.
+    poly1d : A one-dimensional polynomial class.
+
+    Notes
+    -----
+    The algorithm relies on computing the eigenvalues of the
+    companion matrix [1]_.
+
+    References
+    ----------
+    .. [1] R. A. Horn & C. R. Johnson, *Matrix Analysis*.  Cambridge, UK:
+        Cambridge University Press, 1999, pp. 146-7.
+
+    Examples
+    --------
+    >>> coeff = [3.2, 2, 1]
+    >>> np.roots(coeff)
+    array([-0.3125+0.46351241j, -0.3125-0.46351241j])
+
+    " :arglists '[[& [args {:as kwargs}]]]} roots (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "roots"))))
+
+(def ^{:doc "
+    Return the maximum of an array or maximum along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to operate.  By default, flattened input is
+        used.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, the maximum is selected over multiple axes,
+        instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternative output array in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+        See :ref:`ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `amax` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    initial : scalar, optional
+        The minimum value of an output element. Must be present to allow
+        computation on empty slice. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to compare for the maximum. See `~numpy.ufunc.reduce`
+        for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    amax : ndarray or scalar
+        Maximum of `a`. If `axis` is None, the result is a scalar value.
+        If `axis` is given, the result is an array of dimension
+        ``a.ndim - 1``.
+
+    See Also
+    --------
+    amin :
+        The minimum value of an array along a given axis, propagating any NaNs.
+    nanmax :
+        The maximum value of an array along a given axis, ignoring any NaNs.
+    maximum :
+        Element-wise maximum of two arrays, propagating any NaNs.
+    fmax :
+        Element-wise maximum of two arrays, ignoring any NaNs.
+    argmax :
+        Return the indices of the maximum values.
+
+    nanmin, minimum, fmin
+
+    Notes
+    -----
+    NaN values are propagated, that is if at least one item is NaN, the
+    corresponding max value will be NaN as well. To ignore NaN values
+    (MATLAB behavior), please use nanmax.
+
+    Don't use `amax` for element-wise comparison of 2 arrays; when
+    ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
+    ``amax(a, axis=0)``.
+
+    Examples
+    --------
+    >>> a = np.arange(4).reshape((2,2))
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> np.amax(a)           # Maximum of the flattened array
+    3
+    >>> np.amax(a, axis=0)   # Maxima along the first axis
+    array([2, 3])
+    >>> np.amax(a, axis=1)   # Maxima along the second axis
+    array([1, 3])
+    >>> np.amax(a, where=[False, True], initial=-1, axis=0)
+    array([-1,  3])
+    >>> b = np.arange(5, dtype=float)
+    >>> b[2] = np.NaN
+    >>> np.amax(b)
+    nan
+    >>> np.amax(b, where=~np.isnan(b), initial=-1)
+    4.0
+    >>> np.nanmax(b)
+    4.0
+
+    You can use an initial value to compute the maximum of an empty slice, or
+    to initialize it to a different value:
+
+    >>> np.max([[-50], [10]], axis=-1, initial=0)
+    array([ 0, 10])
+
+    Notice that the initial value is used as one of the elements for which the
+    maximum is determined, unlike for the default argument Python's max
+    function, which is only used for empty iterables.
+
+    >>> np.max([5], initial=6)
+    6
+    >>> max([5], default=6)
+    5
+    " :arglists '[[& [args {:as kwargs}]]]} max (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "max"))))
+
+(def ^{:doc "
+    Get help information for a function, class, or module.
+
+    Parameters
+    ----------
+    object : object or str, optional
+        Input object or name to get information about. If `object` is a
+        numpy object, its docstring is given. If it is a string, available
+        modules are searched for matching objects.  If None, information
+        about `info` itself is returned.
+    maxwidth : int, optional
+        Printing width.
+    output : file like object, optional
+        File like object that the output is written to, default is
+        ``stdout``.  The object has to be opened in 'w' or 'a' mode.
+    toplevel : str, optional
+        Start search at this level.
+
+    See Also
+    --------
+    source, lookfor
+
+    Notes
+    -----
+    When used interactively with an object, ``np.info(obj)`` is equivalent
+    to ``help(obj)`` on the Python prompt or ``obj?`` on the IPython
+    prompt.
+
+    Examples
+    --------
+    >>> np.info(np.polyval) # doctest: +SKIP
+       polyval(p, x)
+         Evaluate the polynomial p at x.
+         ...
+
+    When using a string for `object` it is possible to get multiple results.
+
+    >>> np.info('fft') # doctest: +SKIP
+         *** Found in numpy ***
+    Core FFT routines
+    ...
+         *** Found in numpy.fft ***
+     fft(a, n=None, axis=-1)
+    ...
+         *** Repeat reference found in numpy.fft.fftpack ***
+         *** Total of 3 references found. ***
+
+    " :arglists '[[& [{object :object, maxwidth :maxwidth, output :output, toplevel :toplevel}]] [& [{object :object, maxwidth :maxwidth, output :output}]] [& [{object :object, maxwidth :maxwidth}]] [& [{object :object}]] []]} info (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "info"))))
+
+(def ^{:doc "
+Compatibility module.
+
+This module contains duplicated code from Python itself or 3rd party
+extensions, which may be included for the following reasons:
+
+  * compatibility
+  * we may only need a small subset of the copied library/module
+
+"} compat (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "compat"))))
+
+(def ^{:doc "
+    Split an array into multiple sub-arrays vertically (row-wise).
+
+    Please refer to the ``split`` documentation.  ``vsplit`` is equivalent
+    to ``split`` with `axis=0` (default), the array is always split along the
+    first axis regardless of the array dimension.
+
+    See Also
+    --------
+    split : Split an array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> x = np.arange(16.0).reshape(4, 4)
+    >>> x
+    array([[ 0.,   1.,   2.,   3.],
+           [ 4.,   5.,   6.,   7.],
+           [ 8.,   9.,  10.,  11.],
+           [12.,  13.,  14.,  15.]])
+    >>> np.vsplit(x, 2)
+    [array([[0., 1., 2., 3.],
+           [4., 5., 6., 7.]]), array([[ 8.,  9., 10., 11.],
+           [12., 13., 14., 15.]])]
+    >>> np.vsplit(x, np.array([3, 6]))
+    [array([[ 0.,  1.,  2.,  3.],
+           [ 4.,  5.,  6.,  7.],
+           [ 8.,  9., 10., 11.]]), array([[12., 13., 14., 15.]]), array([], shape=(0, 4), dtype=float64)]
+
+    With a higher dimensional array the split is still along the first axis.
+
+    >>> x = np.arange(8.0).reshape(2, 2, 2)
+    >>> x
+    array([[[0.,  1.],
+            [2.,  3.]],
+           [[4.,  5.],
+            [6.,  7.]]])
+    >>> np.vsplit(x, 2)
+    [array([[[0., 1.],
+            [2., 3.]]]), array([[[4., 5.],
+            [6., 7.]]])]
+
+    " :arglists '[[& [args {:as kwargs}]]]} vsplit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vsplit"))))
+
+(def ^{:doc "
+    Difference (subtraction) of two polynomials.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide </reference/routines.polynomials>`.
+
+    Given two polynomials `a1` and `a2`, returns ``a1 - a2``.
+    `a1` and `a2` can be either array_like sequences of the polynomials'
+    coefficients (including coefficients equal to zero), or `poly1d` objects.
+
+    Parameters
+    ----------
+    a1, a2 : array_like or poly1d
+        Minuend and subtrahend polynomials, respectively.
+
+    Returns
+    -------
+    out : ndarray or poly1d
+        Array or `poly1d` object of the difference polynomial's coefficients.
+
+    See Also
+    --------
+    polyval, polydiv, polymul, polyadd
+
+    Examples
+    --------
+    .. math:: (2 x^2 + 10 x - 2) - (3 x^2 + 10 x -4) = (-x^2 + 2)
+
+    >>> np.polysub([2, 10, -2], [3, 10, -4])
+    array([-1,  0,  2])
+
+    " :arglists '[[& [args {:as kwargs}]]]} polysub (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polysub"))))
+
+(def ^{:doc "
+    True if two arrays have the same shape and elements, False otherwise.
+
+    Parameters
+    ----------
+    a1, a2 : array_like
+        Input arrays.
+    equal_nan : bool
+        Whether to compare NaN's as equal. If the dtype of a1 and a2 is
+        complex, values will be considered equal if either the real or the
+        imaginary component of a given value is ``nan``.
+
+        .. versionadded:: 1.19.0
+
+    Returns
+    -------
+    b : bool
+        Returns True if the arrays are equal.
+
+    See Also
+    --------
+    allclose: Returns True if two arrays are element-wise equal within a
+              tolerance.
+    array_equiv: Returns True if input arrays are shape consistent and all
+                 elements equal.
+
+    Examples
+    --------
+    >>> np.array_equal([1, 2], [1, 2])
+    True
+    >>> np.array_equal(np.array([1, 2]), np.array([1, 2]))
+    True
+    >>> np.array_equal([1, 2], [1, 2, 3])
+    False
+    >>> np.array_equal([1, 2], [1, 4])
+    False
+    >>> a = np.array([1, np.nan])
+    >>> np.array_equal(a, a)
+    False
+    >>> np.array_equal(a, a, equal_nan=True)
+    True
+
+    When ``equal_nan`` is True, complex values with nan components are
+    considered equal if either the real *or* the imaginary components are nan.
+
+    >>> a = np.array([1 + 1j])
+    >>> b = a.copy()
+    >>> a.real = np.nan
+    >>> b.imag = np.nan
+    >>> np.array_equal(a, b, equal_nan=True)
+    True
+    " :arglists '[[& [args {:as kwargs}]]]} array_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_equal"))))
+
+(def ^{:doc "
+    Return evenly spaced numbers over a specified interval.
+
+    Returns `num` evenly spaced samples, calculated over the
+    interval [`start`, `stop`].
+
+    The endpoint of the interval can optionally be excluded.
+
+    .. versionchanged:: 1.16.0
+        Non-scalar `start` and `stop` are now supported.
+
+    .. versionchanged:: 1.20.0
+        Values are rounded towards ``-inf`` instead of ``0`` when an
+        integer ``dtype`` is specified. The old behavior can
+        still be obtained with ``np.linspace(start, stop, num).astype(int)``
+
+    Parameters
+    ----------
+    start : array_like
+        The starting value of the sequence.
+    stop : array_like
+        The end value of the sequence, unless `endpoint` is set to False.
+        In that case, the sequence consists of all but the last of ``num + 1``
+        evenly spaced samples, so that `stop` is excluded.  Note that the step
+        size changes when `endpoint` is False.
+    num : int, optional
+        Number of samples to generate. Default is 50. Must be non-negative.
+    endpoint : bool, optional
+        If True, `stop` is the last sample. Otherwise, it is not included.
+        Default is True.
+    retstep : bool, optional
+        If True, return (`samples`, `step`), where `step` is the spacing
+        between samples.
+    dtype : dtype, optional
+        The type of the output array.  If `dtype` is not given, the data type
+        is inferred from `start` and `stop`. The inferred dtype will never be
+        an integer; `float` is chosen even if the arguments would produce an
+        array of integers.
+
+        .. versionadded:: 1.9.0
+
+    axis : int, optional
+        The axis in the result to store the samples.  Relevant only if start
+        or stop are array-like.  By default (0), the samples will be along a
+        new axis inserted at the beginning. Use -1 to get an axis at the end.
+
+        .. versionadded:: 1.16.0
+
+    Returns
+    -------
+    samples : ndarray
+        There are `num` equally spaced samples in the closed interval
+        ``[start, stop]`` or the half-open interval ``[start, stop)``
+        (depending on whether `endpoint` is True or False).
+    step : float, optional
+        Only returned if `retstep` is True
+
+        Size of spacing between samples.
+
+
+    See Also
+    --------
+    arange : Similar to `linspace`, but uses a step size (instead of the
+             number of samples).
+    geomspace : Similar to `linspace`, but with numbers spaced evenly on a log
+                scale (a geometric progression).
+    logspace : Similar to `geomspace`, but with the end points specified as
+               logarithms.
+
+    Examples
+    --------
+    >>> np.linspace(2.0, 3.0, num=5)
+    array([2.  , 2.25, 2.5 , 2.75, 3.  ])
+    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)
+    array([2. ,  2.2,  2.4,  2.6,  2.8])
+    >>> np.linspace(2.0, 3.0, num=5, retstep=True)
+    (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)
+
+    Graphical illustration:
+
+    >>> import matplotlib.pyplot as plt
+    >>> N = 8
+    >>> y = np.zeros(N)
+    >>> x1 = np.linspace(0, 10, N, endpoint=True)
+    >>> x2 = np.linspace(0, 10, N, endpoint=False)
+    >>> plt.plot(x1, y, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.plot(x2, y + 0.5, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.ylim([-0.5, 1])
+    (-0.5, 1)
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]]} linspace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "linspace"))))
+
+(def ^{:doc "
+    Interpret the input as a matrix.
+
+    Unlike `matrix`, `asmatrix` does not make a copy if the input is already
+    a matrix or an ndarray.  Equivalent to ``matrix(data, copy=False)``.
+
+    Parameters
+    ----------
+    data : array_like
+        Input data.
+    dtype : data-type
+       Data-type of the output matrix.
+
+    Returns
+    -------
+    mat : matrix
+        `data` interpreted as a matrix.
+
+    Examples
+    --------
+    >>> x = np.array([[1, 2], [3, 4]])
+
+    >>> m = np.asmatrix(x)
+
+    >>> x[0,0] = 5
+
+    >>> m
+    matrix([[5, 2],
+            [3, 4]])
+
+    " :arglists '[[data & [{dtype :dtype}]] [data]]} mat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mat"))))
+
+(def ^{:doc "frombuffer(buffer, dtype=float, count=-1, offset=0, *, like=None)
+
+    Interpret a buffer as a 1-dimensional array.
+
+    Parameters
+    ----------
+    buffer : buffer_like
+        An object that exposes the buffer interface.
+    dtype : data-type, optional
+        Data-type of the returned array; default: float.
+    count : int, optional
+        Number of items to read. ``-1`` means all data in the buffer.
+    offset : int, optional
+        Start reading the buffer from this offset (in bytes); default: 0.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Notes
+    -----
+    If the buffer has data that is not in machine byte-order, this should
+    be specified as part of the data-type, e.g.::
+
+      >>> dt = np.dtype(int)
+      >>> dt = dt.newbyteorder('>')
+      >>> np.frombuffer(buf, dtype=dt) # doctest: +SKIP
+
+    The data of the resulting array will not be byteswapped, but will be
+    interpreted correctly.
+
+    Examples
+    --------
+    >>> s = b'hello world'
+    >>> np.frombuffer(s, dtype='S1', count=5, offset=6)
+    array([b'w', b'o', b'r', b'l', b'd'], dtype='|S1')
+
+    >>> np.frombuffer(b'\\x01\\x02', dtype=np.uint8)
+    array([1, 2], dtype=uint8)
+    >>> np.frombuffer(b'\\x01\\x02\\x03\\x04\\x05', dtype=np.uint8, count=3)
+    array([1, 2, 3], dtype=uint8)" :arglists '[[self & [args {:as kwargs}]]]} frombuffer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "frombuffer"))))
+
+(def ^{:doc "Flat iterator object to iterate over arrays.
+
+    A `flatiter` iterator is returned by ``x.flat`` for any array `x`.
+    It allows iterating over the array as if it were a 1-D array,
+    either in a for-loop or by calling its `next` method.
+
+    Iteration is done in row-major, C-style order (the last
+    index varying the fastest). The iterator can also be indexed using
+    basic slicing or advanced indexing.
+
+    See Also
+    --------
+    ndarray.flat : Return a flat iterator over an array.
+    ndarray.flatten : Returns a flattened copy of an array.
+
+    Notes
+    -----
+    A `flatiter` iterator can not be constructed directly from Python code
+    by calling the `flatiter` constructor.
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2, 3)
+    >>> fl = x.flat
+    >>> type(fl)
+    <class 'numpy.flatiter'>
+    >>> for item in fl:
+    ...     print(item)
+    ...
+    0
+    1
+    2
+    3
+    4
+    5
+
+    >>> fl[2:4]
+    array([2, 3])" :arglists '[[self & [args {:as kwargs}]]]} flatiter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flatiter"))))
+
+(def ^{:doc "
+    Set the size of the buffer used in ufuncs.
+
+    Parameters
+    ----------
+    size : int
+        Size of buffer.
+
+    " :arglists '[[size]]} setbufsize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "setbufsize"))))
+
+(def ^{:doc ""} PZERO 0.0)
+
+(def ^{:doc "Built-in mutable sequence.
+
+If no argument is given, the constructor creates a new empty list.
+The argument must be an iterable if specified."} __all__ (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* "__all__")))) 
+
+(def ^{:doc "
+    busday_count(begindates, enddates, weekmask='1111100', holidays=[], busdaycal=None, out=None)
+
+    Counts the number of valid days between `begindates` and
+    `enddates`, not including the day of `enddates`.
+
+    If ``enddates`` specifies a date value that is earlier than the
+    corresponding ``begindates`` date value, the count will be negative.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    begindates : array_like of datetime64[D]
+        The array of the first dates for counting.
+    enddates : array_like of datetime64[D]
+        The array of the end dates for counting, which are excluded
+        from the count themselves.
+    weekmask : str or array_like of bool, optional
+        A seven-element array indicating which of Monday through Sunday are
+        valid days. May be specified as a length-seven list or array, like
+        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
+        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
+        weekdays, optionally separated by white space. Valid abbreviations
+        are: Mon Tue Wed Thu Fri Sat Sun
+    holidays : array_like of datetime64[D], optional
+        An array of dates to consider as invalid dates.  They may be
+        specified in any order, and NaT (not-a-time) dates are ignored.
+        This list is saved in a normalized form that is suited for
+        fast calculations of valid days.
+    busdaycal : busdaycalendar, optional
+        A `busdaycalendar` object which specifies the valid days. If this
+        parameter is provided, neither weekmask nor holidays may be
+        provided.
+    out : array of int, optional
+        If provided, this array is filled with the result.
+
+    Returns
+    -------
+    out : array of int
+        An array with a shape from broadcasting ``begindates`` and ``enddates``
+        together, containing the number of valid days between
+        the begin and end dates.
+
+    See Also
+    --------
+    busdaycalendar: An object that specifies a custom set of valid days.
+    is_busday : Returns a boolean array indicating valid days.
+    busday_offset : Applies an offset counted in valid days.
+
+    Examples
+    --------
+    >>> # Number of weekdays in January 2011
+    ... np.busday_count('2011-01', '2011-02')
+    21
+    >>> # Number of weekdays in 2011
+    >>> np.busday_count('2011', '2012')
+    260
+    >>> # Number of Saturdays in 2011
+    ... np.busday_count('2011', '2012', weekmask='Sat')
+    53
+    " :arglists '[[& [args {:as kwargs}]]]} busday_count (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "busday_count"))))
+
+(def ^{:doc "
+    Return an antiderivative (indefinite integral) of a polynomial.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide </reference/routines.polynomials>`.
+
+    The returned order `m` antiderivative `P` of polynomial `p` satisfies
+    :math:`\\frac{d^m}{dx^m}P(x) = p(x)` and is defined up to `m - 1`
+    integration constants `k`. The constants determine the low-order
+    polynomial part
+
+    .. math:: \\frac{k_{m-1}}{0!} x^0 + \\ldots + \\frac{k_0}{(m-1)!}x^{m-1}
+
+    of `P` so that :math:`P^{(j)}(0) = k_{m-j-1}`.
+
+    Parameters
+    ----------
+    p : array_like or poly1d
+        Polynomial to integrate.
+        A sequence is interpreted as polynomial coefficients, see `poly1d`.
+    m : int, optional
+        Order of the antiderivative. (Default: 1)
+    k : list of `m` scalars or scalar, optional
+        Integration constants. They are given in the order of integration:
+        those corresponding to highest-order terms come first.
+
+        If ``None`` (default), all constants are assumed to be zero.
+        If `m = 1`, a single scalar can be given instead of a list.
+
+    See Also
+    --------
+    polyder : derivative of a polynomial
+    poly1d.integ : equivalent method
+
+    Examples
+    --------
+    The defining property of the antiderivative:
+
+    >>> p = np.poly1d([1,1,1])
+    >>> P = np.polyint(p)
+    >>> P
+     poly1d([ 0.33333333,  0.5       ,  1.        ,  0.        ]) # may vary
+    >>> np.polyder(P) == p
+    True
+
+    The integration constants default to zero, but can be specified:
+
+    >>> P = np.polyint(p, 3)
+    >>> P(0)
+    0.0
+    >>> np.polyder(P)(0)
+    0.0
+    >>> np.polyder(P, 2)(0)
+    0.0
+    >>> P = np.polyint(p, 3, k=[6,5,3])
+    >>> P
+    poly1d([ 0.01666667,  0.04166667,  0.16666667,  3. ,  5. ,  3. ]) # may vary
+
+    Note that 3 = 6 / 2!, and that the constants are given in the order of
+    integrations. Constant of the highest-order polynomial term comes first:
+
+    >>> np.polyder(P, 2)(0)
+    6.0
+    >>> np.polyder(P, 1)(0)
+    5.0
+    >>> P(0)
+    3.0
+
+    " :arglists '[[& [args {:as kwargs}]]]} polyint (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyint"))))
+
+(def ^{:doc "maximum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Element-wise maximum of array elements.
+
+Compare two arrays and returns a new array containing the element-wise
+maxima. If one of the elements being compared is a NaN, then that
+element is returned. If both elements are NaNs then the first is
+returned. The latter distinction is important for complex NaNs, which
+are defined as at least one of the real or imaginary parts being a NaN.
+The net effect is that NaNs are propagated.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays holding the elements to be compared.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The maximum of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+minimum :
+    Element-wise minimum of two arrays, propagates NaNs.
+fmax :
+    Element-wise maximum of two arrays, ignores NaNs.
+amax :
+    The maximum value of an array along a given axis, propagates NaNs.
+nanmax :
+    The maximum value of an array along a given axis, ignores NaNs.
+
+fmin, amin, nanmin
+
+Notes
+-----
+The maximum is equivalent to ``np.where(x1 >= x2, x1, x2)`` when
+neither x1 nor x2 are nans, but it is faster and does proper
+broadcasting.
+
+Examples
+--------
+>>> np.maximum([2, 3, 4], [1, 5, 2])
+array([2, 5, 4])
+
+>>> np.maximum(np.eye(2), [0.5, 2]) # broadcasting
+array([[ 1. ,  2. ],
+       [ 0.5,  2. ]])
+
+>>> np.maximum([np.nan, 0, np.nan], [0, np.nan, np.nan])
+array([nan, nan, nan])
+>>> np.maximum(np.Inf, 1)
+inf" :arglists '[[self & [args {:as kwargs}]]]} maximum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "maximum"))))
+
+(def ^{:doc "negative(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Numerical negative, element-wise.
+
+Parameters
+----------
+x : array_like or scalar
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    Returned array or scalar: `y = -x`.
+    This is a scalar if `x` is a scalar.
+
+Examples
+--------
+>>> np.negative([1.,-1.])
+array([-1.,  1.])
+
+The unary ``-`` operator can be used as a shorthand for ``np.negative`` on
+ndarrays.
+
+>>> x1 = np.array(([1., -1.]))
+>>> -x1
+array([-1.,  1.])" :arglists '[[self & [args {:as kwargs}]]]} negative (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "negative"))))
+
+(def ^{:doc "
+    Return specified diagonals.
+
+    If `a` is 2-D, returns the diagonal of `a` with the given offset,
+    i.e., the collection of elements of the form ``a[i, i+offset]``.  If
+    `a` has more than two dimensions, then the axes specified by `axis1`
+    and `axis2` are used to determine the 2-D sub-array whose diagonal is
+    returned.  The shape of the resulting array can be determined by
+    removing `axis1` and `axis2` and appending an index to the right equal
+    to the size of the resulting diagonals.
+
+    In versions of NumPy prior to 1.7, this function always returned a new,
+    independent array containing a copy of the values in the diagonal.
+
+    In NumPy 1.7 and 1.8, it continues to return a copy of the diagonal,
+    but depending on this fact is deprecated. Writing to the resulting
+    array continues to work as it used to, but a FutureWarning is issued.
+
+    Starting in NumPy 1.9 it returns a read-only view on the original array.
+    Attempting to write to the resulting array will produce an error.
+
+    In some future release, it will return a read/write view and writing to
+    the returned array will alter your original array.  The returned array
+    will have the same type as the input array.
+
+    If you don't write to the array returned by this function, then you can
+    just ignore all of the above.
+
+    If you depend on the current behavior, then we suggest copying the
+    returned array explicitly, i.e., use ``np.diagonal(a).copy()`` instead
+    of just ``np.diagonal(a)``. This will work with both past and future
+    versions of NumPy.
+
+    Parameters
+    ----------
+    a : array_like
+        Array from which the diagonals are taken.
+    offset : int, optional
+        Offset of the diagonal from the main diagonal.  Can be positive or
+        negative.  Defaults to main diagonal (0).
+    axis1 : int, optional
+        Axis to be used as the first axis of the 2-D sub-arrays from which
+        the diagonals should be taken.  Defaults to first axis (0).
+    axis2 : int, optional
+        Axis to be used as the second axis of the 2-D sub-arrays from
+        which the diagonals should be taken. Defaults to second axis (1).
+
+    Returns
+    -------
+    array_of_diagonals : ndarray
+        If `a` is 2-D, then a 1-D array containing the diagonal and of the
+        same type as `a` is returned unless `a` is a `matrix`, in which case
+        a 1-D array rather than a (2-D) `matrix` is returned in order to
+        maintain backward compatibility.
+
+        If ``a.ndim > 2``, then the dimensions specified by `axis1` and `axis2`
+        are removed, and a new axis inserted at the end corresponding to the
+        diagonal.
+
+    Raises
+    ------
+    ValueError
+        If the dimension of `a` is less than 2.
+
+    See Also
+    --------
+    diag : MATLAB work-a-like for 1-D and 2-D arrays.
+    diagflat : Create diagonal arrays.
+    trace : Sum along diagonals.
+
+    Examples
+    --------
+    >>> a = np.arange(4).reshape(2,2)
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> a.diagonal()
+    array([0, 3])
+    >>> a.diagonal(1)
+    array([1])
+
+    A 3-D example:
+
+    >>> a = np.arange(8).reshape(2,2,2); a
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+    >>> a.diagonal(0,  # Main diagonals of two arrays created by skipping
+    ...            0,  # across the outer(left)-most axis last and
+    ...            1)  # the \"middle\" (row) axis first.
+    array([[0, 6],
+           [1, 7]])
+
+    The sub-arrays whose main diagonals we just obtained; note that each
+    corresponds to fixing the right-most (column) axis, and that the
+    diagonals are \"packed\" in rows.
+
+    >>> a[:,:,0]  # main diagonal is [0 6]
+    array([[0, 2],
+           [4, 6]])
+    >>> a[:,:,1]  # main diagonal is [1 7]
+    array([[1, 3],
+           [5, 7]])
+
+    The anti-diagonal can be obtained by reversing the order of elements
+    using either `numpy.flipud` or `numpy.fliplr`.
+
+    >>> a = np.arange(9).reshape(3, 3)
+    >>> a
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+    >>> np.fliplr(a).diagonal()  # Horizontal flip
+    array([2, 4, 6])
+    >>> np.flipud(a).diagonal()  # Vertical flip
+    array([6, 4, 2])
+
+    Note that the order in which the diagonal is retrieved varies depending
+    on the flip function.
+    " :arglists '[[& [args {:as kwargs}]]]} diagonal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diagonal"))))
+
+(def ^{:doc "
+    einsum_path(subscripts, *operands, optimize='greedy')
+
+    Evaluates the lowest cost contraction order for an einsum expression by
+    considering the creation of intermediate arrays.
+
+    Parameters
+    ----------
+    subscripts : str
+        Specifies the subscripts for summation.
+    *operands : list of array_like
+        These are the arrays for the operation.
+    optimize : {bool, list, tuple, 'greedy', 'optimal'}
+        Choose the type of path. If a tuple is provided, the second argument is
+        assumed to be the maximum intermediate size created. If only a single
+        argument is provided the largest input or output array size is used
+        as a maximum intermediate size.
+
+        * if a list is given that starts with ``einsum_path``, uses this as the
+          contraction path
+        * if False no optimization is taken
+        * if True defaults to the 'greedy' algorithm
+        * 'optimal' An algorithm that combinatorially explores all possible
+          ways of contracting the listed tensors and choosest the least costly
+          path. Scales exponentially with the number of terms in the
+          contraction.
+        * 'greedy' An algorithm that chooses the best pair contraction
+          at each step. Effectively, this algorithm searches the largest inner,
+          Hadamard, and then outer products at each step. Scales cubically with
+          the number of terms in the contraction. Equivalent to the 'optimal'
+          path for most contractions.
+
+        Default is 'greedy'.
+
+    Returns
+    -------
+    path : list of tuples
+        A list representation of the einsum path.
+    string_repr : str
+        A printable representation of the einsum path.
+
+    Notes
+    -----
+    The resulting path indicates which terms of the input contraction should be
+    contracted first, the result of this contraction is then appended to the
+    end of the contraction list. This list can then be iterated over until all
+    intermediate contractions are complete.
+
+    See Also
+    --------
+    einsum, linalg.multi_dot
+
+    Examples
+    --------
+
+    We can begin with a chain dot example. In this case, it is optimal to
+    contract the ``b`` and ``c`` tensors first as represented by the first
+    element of the path ``(1, 2)``. The resulting tensor is added to the end
+    of the contraction and the remaining contraction ``(0, 1)`` is then
+    completed.
+
+    >>> np.random.seed(123)
+    >>> a = np.random.rand(2, 2)
+    >>> b = np.random.rand(2, 5)
+    >>> c = np.random.rand(5, 2)
+    >>> path_info = np.einsum_path('ij,jk,kl->il', a, b, c, optimize='greedy')
+    >>> print(path_info[0])
+    ['einsum_path', (1, 2), (0, 1)]
+    >>> print(path_info[1])
+      Complete contraction:  ij,jk,kl->il # may vary
+             Naive scaling:  4
+         Optimized scaling:  3
+          Naive FLOP count:  1.600e+02
+      Optimized FLOP count:  5.600e+01
+       Theoretical speedup:  2.857
+      Largest intermediate:  4.000e+00 elements
+    -------------------------------------------------------------------------
+    scaling                  current                                remaining
+    -------------------------------------------------------------------------
+       3                   kl,jk->jl                                ij,jl->il
+       3                   jl,ij->il                                   il->il
+
+
+    A more complex index transformation example.
+
+    >>> I = np.random.rand(10, 10, 10, 10)
+    >>> C = np.random.rand(10, 10)
+    >>> path_info = np.einsum_path('ea,fb,abcd,gc,hd->efgh', C, C, I, C, C,
+    ...                            optimize='greedy')
+
+    >>> print(path_info[0])
+    ['einsum_path', (0, 2), (0, 3), (0, 2), (0, 1)]
+    >>> print(path_info[1]) 
+      Complete contraction:  ea,fb,abcd,gc,hd->efgh # may vary
+             Naive scaling:  8
+         Optimized scaling:  5
+          Naive FLOP count:  8.000e+08
+      Optimized FLOP count:  8.000e+05
+       Theoretical speedup:  1000.000
+      Largest intermediate:  1.000e+04 elements
+    --------------------------------------------------------------------------
+    scaling                  current                                remaining
+    --------------------------------------------------------------------------
+       5               abcd,ea->bcde                      fb,gc,hd,bcde->efgh
+       5               bcde,fb->cdef                         gc,hd,cdef->efgh
+       5               cdef,gc->defg                            hd,defg->efgh
+       5               defg,hd->efgh                               efgh->efgh
+    " :arglists '[[& [args {:as kwargs}]]]} einsum_path (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "einsum_path"))))
+
+(def ^{:doc ""} FPE_DIVIDEBYZERO 1)
+
+(def ^{:doc "
+    Return an ndarray of the provided type that satisfies requirements.
+
+    This function is useful to be sure that an array with the correct flags
+    is returned for passing to compiled code (perhaps through ctypes).
+
+    Parameters
+    ----------
+    a : array_like
+       The object to be converted to a type-and-requirement-satisfying array.
+    dtype : data-type
+       The required data-type. If None preserve the current dtype. If your
+       application requires the data to be in native byteorder, include
+       a byteorder specification as a part of the dtype specification.
+    requirements : str or list of str
+       The requirements list can be any of the following
+
+       * 'F_CONTIGUOUS' ('F') - ensure a Fortran-contiguous array
+       * 'C_CONTIGUOUS' ('C') - ensure a C-contiguous array
+       * 'ALIGNED' ('A')      - ensure a data-type aligned array
+       * 'WRITEABLE' ('W')    - ensure a writable array
+       * 'OWNDATA' ('O')      - ensure an array that owns its own data
+       * 'ENSUREARRAY', ('E') - ensure a base array, instead of a subclass
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        Array with specified requirements and type if given.
+
+    See Also
+    --------
+    asarray : Convert input to an ndarray.
+    asanyarray : Convert to an ndarray, but pass through ndarray subclasses.
+    ascontiguousarray : Convert input to a contiguous array.
+    asfortranarray : Convert input to an ndarray with column-major
+                     memory order.
+    ndarray.flags : Information about the memory layout of the array.
+
+    Notes
+    -----
+    The returned array will be guaranteed to have the listed requirements
+    by making a copy if needed.
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2,3)
+    >>> x.flags
+      C_CONTIGUOUS : True
+      F_CONTIGUOUS : False
+      OWNDATA : False
+      WRITEABLE : True
+      ALIGNED : True
+      WRITEBACKIFCOPY : False
+      UPDATEIFCOPY : False
+
+    >>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])
+    >>> y.flags
+      C_CONTIGUOUS : False
+      F_CONTIGUOUS : True
+      OWNDATA : True
+      WRITEABLE : True
+      ALIGNED : True
+      WRITEBACKIFCOPY : False
+      UPDATEIFCOPY : False
+
+    " :arglists '[[a & [{dtype :dtype, requirements :requirements, like :like}]] [a & [{dtype :dtype, like :like}]] [a & [{like :like}]]]} require (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "require"))))
+
+(def ^{:doc "
+    Return the cumulative sum of array elements over a given axis treating Not a
+    Numbers (NaNs) as zero.  The cumulative sum does not change when NaNs are
+    encountered and leading NaNs are replaced by zeros.
+
+    Zeros are returned for slices that are all-NaN or empty.
+
+    .. versionadded:: 1.12.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        Axis along which the cumulative sum is computed. The default
+        (None) is to compute the cumsum over the flattened array.
+    dtype : dtype, optional
+        Type of the returned array and of the accumulator in which the
+        elements are summed.  If `dtype` is not specified, it defaults
+        to the dtype of `a`, unless `a` has an integer dtype with a
+        precision less than that of the default platform integer.  In
+        that case, the default platform integer is used.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary. See :ref:`ufuncs-output-type` for
+        more details.
+
+    Returns
+    -------
+    nancumsum : ndarray.
+        A new array holding the result is returned unless `out` is
+        specified, in which it is returned. The result has the same
+        size as `a`, and the same shape as `a` if `axis` is not None
+        or `a` is a 1-d array.
+
+    See Also
+    --------
+    numpy.cumsum : Cumulative sum across array propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> np.nancumsum(1)
+    array([1])
+    >>> np.nancumsum([1])
+    array([1])
+    >>> np.nancumsum([1, np.nan])
+    array([1.,  1.])
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nancumsum(a)
+    array([1.,  3.,  6.,  6.])
+    >>> np.nancumsum(a, axis=0)
+    array([[1.,  2.],
+           [4.,  2.]])
+    >>> np.nancumsum(a, axis=1)
+    array([[1.,  3.],
+           [3.,  3.]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} nancumsum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nancumsum"))))
+
+(def ^{:doc "Complex number type composed of two extended-precision floating-point
+    numbers.
+
+    :Character code: ``'G'``
+    :Canonical name: `numpy.clongdouble`
+    :Alias: `numpy.clongfloat`
+    :Alias: `numpy.longcomplex`
+    :Alias on this platform: `numpy.complex256`: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} clongfloat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "clongfloat"))))
+
+(def ^{:doc "isnan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Test element-wise for NaN and return result as a boolean array.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or bool
+    True where ``x`` is NaN, false otherwise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+isinf, isneginf, isposinf, isfinite, isnat
+
+Notes
+-----
+NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+(IEEE 754). This means that Not a Number is not equivalent to infinity.
+
+Examples
+--------
+>>> np.isnan(np.nan)
+True
+>>> np.isnan(np.inf)
+False
+>>> np.isnan([np.log(-1.),1.,np.log(0)])
+array([ True, False, False])" :arglists '[[self & [args {:as kwargs}]]]} isnan (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isnan"))))
+
+(def ^{:doc "reciprocal(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the reciprocal of the argument, element-wise.
+
+Calculates ``1/x``.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    Return array.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+.. note::
+    This function is not designed to work with integers.
+
+For integer arguments with absolute value larger than 1 the result is
+always zero because of the way Python handles integer division.  For
+integer zero the result is an overflow.
+
+Examples
+--------
+>>> np.reciprocal(2.)
+0.5
+>>> np.reciprocal([1, 2., 3.33])
+array([ 1.       ,  0.5      ,  0.3003003])" :arglists '[[self & [args {:as kwargs}]]]} reciprocal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "reciprocal"))))
+
+(def ^{:doc "
+    Return a partitioned copy of an array.
+
+    Creates a copy of the array with its elements rearranged in such a
+    way that the value of the element in k-th position is in the
+    position it would be in a sorted array. All elements smaller than
+    the k-th element are moved before this element and all equal or
+    greater are moved behind it. The ordering of the elements in the two
+    partitions is undefined.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array to be sorted.
+    kth : int or sequence of ints
+        Element index to partition by. The k-th value of the element
+        will be in its final sorted position and all smaller elements
+        will be moved before it and all equal or greater elements behind
+        it. The order of all elements in the partitions is undefined. If
+        provided with a sequence of k-th it will partition all elements
+        indexed by k-th  of them into their sorted position at once.
+    axis : int or None, optional
+        Axis along which to sort. If None, the array is flattened before
+        sorting. The default is -1, which sorts along the last axis.
+    kind : {'introselect'}, optional
+        Selection algorithm. Default is 'introselect'.
+    order : str or list of str, optional
+        When `a` is an array with fields defined, this argument
+        specifies which fields to compare first, second, etc.  A single
+        field can be specified as a string.  Not all fields need be
+        specified, but unspecified fields will still be used, in the
+        order in which they come up in the dtype, to break ties.
+
+    Returns
+    -------
+    partitioned_array : ndarray
+        Array of the same type and shape as `a`.
+
+    See Also
+    --------
+    ndarray.partition : Method to sort an array in-place.
+    argpartition : Indirect partition.
+    sort : Full sorting
+
+    Notes
+    -----
+    The various selection algorithms are characterized by their average
+    speed, worst case performance, work space size, and whether they are
+    stable. A stable sort keeps items with the same key in the same
+    relative order. The available algorithms have the following
+    properties:
+
+    ================= ======= ============= ============ =======
+       kind            speed   worst case    work space  stable
+    ================= ======= ============= ============ =======
+    'introselect'        1        O(n)           0         no
+    ================= ======= ============= ============ =======
+
+    All the partition algorithms make temporary copies of the data when
+    partitioning along any but the last axis.  Consequently,
+    partitioning along the last axis is faster and uses less space than
+    partitioning along any other axis.
+
+    The sort order for complex numbers is lexicographic. If both the
+    real and imaginary parts are non-nan then the order is determined by
+    the real parts except when they are equal, in which case the order
+    is determined by the imaginary parts.
+
+    Examples
+    --------
+    >>> a = np.array([3, 4, 2, 1])
+    >>> np.partition(a, 3)
+    array([2, 1, 3, 4])
+
+    >>> np.partition(a, (1, 3))
+    array([1, 2, 3, 4])
+
+    " :arglists '[[& [args {:as kwargs}]]]} partition (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "partition"))))
+
+(def ^{:doc "
+    where(condition, [x, y])
+
+    Return elements chosen from `x` or `y` depending on `condition`.
+
+    .. note::
+        When only `condition` is provided, this function is a shorthand for
+        ``np.asarray(condition).nonzero()``. Using `nonzero` directly should be
+        preferred, as it behaves correctly for subclasses. The rest of this
+        documentation covers only the case where all three arguments are
+        provided.
+
+    Parameters
+    ----------
+    condition : array_like, bool
+        Where True, yield `x`, otherwise yield `y`.
+    x, y : array_like
+        Values from which to choose. `x`, `y` and `condition` need to be
+        broadcastable to some shape.
+
+    Returns
+    -------
+    out : ndarray
+        An array with elements from `x` where `condition` is True, and elements
+        from `y` elsewhere.
+
+    See Also
+    --------
+    choose
+    nonzero : The function that is called when x and y are omitted
+
+    Notes
+    -----
+    If all the arrays are 1-D, `where` is equivalent to::
+
+        [xv if c else yv
+         for c, xv, yv in zip(condition, x, y)]
+
+    Examples
+    --------
+    >>> a = np.arange(10)
+    >>> a
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    >>> np.where(a < 5, a, 10*a)
+    array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])
+
+    This can be used on multidimensional arrays too:
+
+    >>> np.where([[True, False], [True, True]],
+    ...          [[1, 2], [3, 4]],
+    ...          [[9, 8], [7, 6]])
+    array([[1, 8],
+           [3, 4]])
+
+    The shapes of x, y, and the condition are broadcast together:
+
+    >>> x, y = np.ogrid[:3, :4]
+    >>> np.where(x < y, x, 10 + y)  # both x and 10+y are broadcast
+    array([[10,  0,  0,  0],
+           [10, 11,  1,  1],
+           [10, 11, 12,  2]])
+
+    >>> a = np.array([[0, 1, 2],
+    ...               [0, 2, 4],
+    ...               [0, 3, 6]])
+    >>> np.where(a < 4, a, -1)  # -1 is broadcast
+    array([[ 0,  1,  2],
+           [ 0,  2, -1],
+           [ 0,  3, -1]])
+    " :arglists '[[& [args {:as kwargs}]]]} where (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "where"))))
+
+(def ^{:doc "minimum(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Element-wise minimum of array elements.
+
+Compare two arrays and returns a new array containing the element-wise
+minima. If one of the elements being compared is a NaN, then that
+element is returned. If both elements are NaNs then the first is
+returned. The latter distinction is important for complex NaNs, which
+are defined as at least one of the real or imaginary parts being a NaN.
+The net effect is that NaNs are propagated.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays holding the elements to be compared.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The minimum of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+maximum :
+    Element-wise maximum of two arrays, propagates NaNs.
+fmin :
+    Element-wise minimum of two arrays, ignores NaNs.
+amin :
+    The minimum value of an array along a given axis, propagates NaNs.
+nanmin :
+    The minimum value of an array along a given axis, ignores NaNs.
+
+fmax, amax, nanmax
+
+Notes
+-----
+The minimum is equivalent to ``np.where(x1 <= x2, x1, x2)`` when
+neither x1 nor x2 are NaNs, but it is faster and does proper
+broadcasting.
+
+Examples
+--------
+>>> np.minimum([2, 3, 4], [1, 5, 2])
+array([1, 3, 2])
+
+>>> np.minimum(np.eye(2), [0.5, 2]) # broadcasting
+array([[ 0.5,  0. ],
+       [ 0. ,  1. ]])
+
+>>> np.minimum([np.nan, 0, np.nan],[0, np.nan, np.nan])
+array([nan, nan, nan])
+>>> np.minimum(-np.Inf, 1)
+-inf" :arglists '[[self & [args {:as kwargs}]]]} minimum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "minimum"))))
+
+(def ^{:doc "
+    One-dimensional linear interpolation.
+
+    Returns the one-dimensional piecewise linear interpolant to a function
+    with given discrete data points (`xp`, `fp`), evaluated at `x`.
+
+    Parameters
+    ----------
+    x : array_like
+        The x-coordinates at which to evaluate the interpolated values.
+
+    xp : 1-D sequence of floats
+        The x-coordinates of the data points, must be increasing if argument
+        `period` is not specified. Otherwise, `xp` is internally sorted after
+        normalizing the periodic boundaries with ``xp = xp % period``.
+
+    fp : 1-D sequence of float or complex
+        The y-coordinates of the data points, same length as `xp`.
+
+    left : optional float or complex corresponding to fp
+        Value to return for `x < xp[0]`, default is `fp[0]`.
+
+    right : optional float or complex corresponding to fp
+        Value to return for `x > xp[-1]`, default is `fp[-1]`.
+
+    period : None or float, optional
+        A period for the x-coordinates. This parameter allows the proper
+        interpolation of angular x-coordinates. Parameters `left` and `right`
+        are ignored if `period` is specified.
+
+        .. versionadded:: 1.10.0
+
+    Returns
+    -------
+    y : float or complex (corresponding to fp) or ndarray
+        The interpolated values, same shape as `x`.
+
+    Raises
+    ------
+    ValueError
+        If `xp` and `fp` have different length
+        If `xp` or `fp` are not 1-D sequences
+        If `period == 0`
+
+    See Also
+    --------
+    scipy.interpolate
+
+    Notes
+    -----
+    The x-coordinate sequence is expected to be increasing, but this is not
+    explicitly enforced.  However, if the sequence `xp` is non-increasing,
+    interpolation results are meaningless.
+
+    Note that, since NaN is unsortable, `xp` also cannot contain NaNs.
+
+    A simple check for `xp` being strictly increasing is::
+
+        np.all(np.diff(xp) > 0)
+
+    Examples
+    --------
+    >>> xp = [1, 2, 3]
+    >>> fp = [3, 2, 0]
+    >>> np.interp(2.5, xp, fp)
+    1.0
+    >>> np.interp([0, 1, 1.5, 2.72, 3.14], xp, fp)
+    array([3.  , 3.  , 2.5 , 0.56, 0.  ])
+    >>> UNDEF = -99.0
+    >>> np.interp(3.14, xp, fp, right=UNDEF)
+    -99.0
+
+    Plot an interpolant to the sine function:
+
+    >>> x = np.linspace(0, 2*np.pi, 10)
+    >>> y = np.sin(x)
+    >>> xvals = np.linspace(0, 2*np.pi, 50)
+    >>> yinterp = np.interp(xvals, x, y)
+    >>> import matplotlib.pyplot as plt
+    >>> plt.plot(x, y, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.plot(xvals, yinterp, '-x')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.show()
+
+    Interpolation with periodic x-coordinates:
+
+    >>> x = [-180, -170, -185, 185, -10, -5, 0, 365]
+    >>> xp = [190, -190, 350, -350]
+    >>> fp = [5, 10, 3, 4]
+    >>> np.interp(x, xp, fp, period=360)
+    array([7.5 , 5.  , 8.75, 6.25, 3.  , 3.25, 3.5 , 3.75])
+
+    Complex interpolation:
+
+    >>> x = [1.5, 4.0]
+    >>> xp = [2,3,5]
+    >>> fp = [1.0j, 0, 2+3j]
+    >>> np.interp(x, xp, fp)
+    array([0.+1.j , 1.+1.5j])
+
+    " :arglists '[[& [args {:as kwargs}]]]} interp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "interp"))))
+
+(def ^{:doc "
+    Load data from a text file, with missing values handled as specified.
+
+    Each line past the first `skip_header` lines is split at the `delimiter`
+    character, and characters following the `comments` character are discarded.
+
+    Parameters
+    ----------
+    fname : file, str, pathlib.Path, list of str, generator
+        File, filename, list, or generator to read.  If the filename
+        extension is `.gz` or `.bz2`, the file is first decompressed. Note
+        that generators must return byte strings. The strings
+        in a list or produced by a generator are treated as lines.
+    dtype : dtype, optional
+        Data type of the resulting array.
+        If None, the dtypes will be determined by the contents of each
+        column, individually.
+    comments : str, optional
+        The character used to indicate the start of a comment.
+        All the characters occurring on a line after a comment are discarded
+    delimiter : str, int, or sequence, optional
+        The string used to separate values.  By default, any consecutive
+        whitespaces act as delimiter.  An integer or sequence of integers
+        can also be provided as width(s) of each field.
+    skiprows : int, optional
+        `skiprows` was removed in numpy 1.10. Please use `skip_header` instead.
+    skip_header : int, optional
+        The number of lines to skip at the beginning of the file.
+    skip_footer : int, optional
+        The number of lines to skip at the end of the file.
+    converters : variable, optional
+        The set of functions that convert the data of a column to a value.
+        The converters can also be used to provide a default value
+        for missing data: ``converters = {3: lambda s: float(s or 0)}``.
+    missing : variable, optional
+        `missing` was removed in numpy 1.10. Please use `missing_values`
+        instead.
+    missing_values : variable, optional
+        The set of strings corresponding to missing data.
+    filling_values : variable, optional
+        The set of values to be used as default when the data are missing.
+    usecols : sequence, optional
+        Which columns to read, with 0 being the first.  For example,
+        ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.
+    names : {None, True, str, sequence}, optional
+        If `names` is True, the field names are read from the first line after
+        the first `skip_header` lines.  This line can optionally be proceeded
+        by a comment delimiter. If `names` is a sequence or a single-string of
+        comma-separated names, the names will be used to define the field names
+        in a structured dtype. If `names` is None, the names of the dtype
+        fields will be used, if any.
+    excludelist : sequence, optional
+        A list of names to exclude. This list is appended to the default list
+        ['return','file','print']. Excluded names are appended an underscore:
+        for example, `file` would become `file_`.
+    deletechars : str, optional
+        A string combining invalid characters that must be deleted from the
+        names.
+    defaultfmt : str, optional
+        A format used to define default field names, such as \"f%i\" or \"f_%02i\".
+    autostrip : bool, optional
+        Whether to automatically strip white spaces from the variables.
+    replace_space : char, optional
+        Character(s) used in replacement of white spaces in the variables
+        names. By default, use a '_'.
+    case_sensitive : {True, False, 'upper', 'lower'}, optional
+        If True, field names are case sensitive.
+        If False or 'upper', field names are converted to upper case.
+        If 'lower', field names are converted to lower case.
+    unpack : bool, optional
+        If True, the returned array is transposed, so that arguments may be
+        unpacked using ``x, y, z = genfromtxt(...)``.  When used with a
+        structured data-type, arrays are returned for each field.
+        Default is False.
+    usemask : bool, optional
+        If True, return a masked array.
+        If False, return a regular array.
+    loose : bool, optional
+        If True, do not raise errors for invalid values.
+    invalid_raise : bool, optional
+        If True, an exception is raised if an inconsistency is detected in the
+        number of columns.
+        If False, a warning is emitted and the offending lines are skipped.
+    max_rows : int,  optional
+        The maximum number of rows to read. Must not be used with skip_footer
+        at the same time.  If given, the value must be at least 1. Default is
+        to read the entire file.
+
+        .. versionadded:: 1.10.0
+    encoding : str, optional
+        Encoding used to decode the inputfile. Does not apply when `fname` is
+        a file object.  The special value 'bytes' enables backward compatibility
+        workarounds that ensure that you receive byte arrays when possible
+        and passes latin1 encoded strings to converters. Override this value to
+        receive unicode arrays and pass strings as input to converters.  If set
+        to None the system default is used. The default value is 'bytes'.
+
+        .. versionadded:: 1.14.0
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        Data read from the text file. If `usemask` is True, this is a
+        masked array.
+
+    See Also
+    --------
+    numpy.loadtxt : equivalent function when no data is missing.
+
+    Notes
+    -----
+    * When spaces are used as delimiters, or when no delimiter has been given
+      as input, there should not be any missing data between two fields.
+    * When the variables are named (either by a flexible dtype or with `names`),
+      there must not be any header in the file (else a ValueError
+      exception is raised).
+    * Individual values are not stripped of spaces by default.
+      When using a custom converter, make sure the function does remove spaces.
+
+    References
+    ----------
+    .. [1] NumPy User Guide, section `I/O with NumPy
+           <https://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html>`_.
+
+    Examples
+    --------
+    >>> from io import StringIO
+    >>> import numpy as np
+
+    Comma delimited file with mixed dtype
+
+    >>> s = StringIO(u\"1,1.3,abcde\")
+    >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),
+    ... ('mystring','S5')], delimiter=\",\")
+    >>> data
+    array((1, 1.3, b'abcde'),
+          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
+
+    Using dtype = None
+
+    >>> _ = s.seek(0) # needed for StringIO example only
+    >>> data = np.genfromtxt(s, dtype=None,
+    ... names = ['myint','myfloat','mystring'], delimiter=\",\")
+    >>> data
+    array((1, 1.3, b'abcde'),
+          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
+
+    Specifying dtype and names
+
+    >>> _ = s.seek(0)
+    >>> data = np.genfromtxt(s, dtype=\"i8,f8,S5\",
+    ... names=['myint','myfloat','mystring'], delimiter=\",\")
+    >>> data
+    array((1, 1.3, b'abcde'),
+          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', 'S5')])
+
+    An example with fixed-width columns
+
+    >>> s = StringIO(u\"11.3abcde\")
+    >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],
+    ...     delimiter=[1,3,5])
+    >>> data
+    array((1, 1.3, b'abcde'),
+          dtype=[('intvar', '<i8'), ('fltvar', '<f8'), ('strvar', 'S5')])
+
+    An example to show comments
+
+    >>> f = StringIO('''
+    ... text,# of chars
+    ... hello world,11
+    ... numpy,5''')
+    >>> np.genfromtxt(f, dtype='S12,S12', delimiter=',')
+    array([(b'text', b''), (b'hello world', b'11'), (b'numpy', b'5')],
+      dtype=[('f0', 'S12'), ('f1', 'S12')])
+
+    " :arglists '[[fname & [{names :names, max_rows :max_rows, encoding :encoding, case_sensitive :case_sensitive, usemask :usemask, like :like, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, max_rows :max_rows, case_sensitive :case_sensitive, usemask :usemask, like :like, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, usemask :usemask, like :like, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, invalid_raise :invalid_raise, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, usemask :usemask, like :like, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, loose :loose, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, usemask :usemask, like :like, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, like :like, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, unpack :unpack, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, like :like, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, defaultfmt :defaultfmt, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, case_sensitive :case_sensitive, like :like, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, like :like, dtype :dtype, skip_header :skip_header, autostrip :autostrip, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, like :like, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, replace_space :replace_space, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, like :like, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, deletechars :deletechars, excludelist :excludelist, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, like :like, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, excludelist :excludelist, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{names :names, like :like, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{like :like, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, delimiter :delimiter, missing_values :missing_values, usecols :usecols}]] [fname & [{like :like, dtype :dtype, skip_header :skip_header, skip_footer :skip_footer, comments :comments, converters :converters, filling_values :filling_values, delimiter :delimiter, missing_values :missing_values}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters, missing_values :missing_values, like :like}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, converters :converters, like :like}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, skip_footer :skip_footer, like :like}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, skip_header :skip_header, like :like}]] [fname & [{dtype :dtype, comments :comments, delimiter :delimiter, like :like}]] [fname & [{dtype :dtype, comments :comments, like :like}]] [fname & [{dtype :dtype, like :like}]] [fname & [{like :like}]]]} genfromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "genfromtxt"))))
+
+(def ^{:doc "
+    errstate(**kwargs)
+
+    Context manager for floating-point error handling.
+
+    Using an instance of `errstate` as a context manager allows statements in
+    that context to execute with a known error handling behavior. Upon entering
+    the context the error handling is set with `seterr` and `seterrcall`, and
+    upon exiting it is reset to what it was before.
+
+    ..  versionchanged:: 1.17.0
+        `errstate` is also usable as a function decorator, saving
+        a level of indentation if an entire function is wrapped.
+        See :py:class:`contextlib.ContextDecorator` for more information.
+
+    Parameters
+    ----------
+    kwargs : {divide, over, under, invalid}
+        Keyword arguments. The valid keywords are the possible floating-point
+        exceptions. Each keyword should have a string value that defines the
+        treatment for the particular error. Possible values are
+        {'ignore', 'warn', 'raise', 'call', 'print', 'log'}.
+
+    See Also
+    --------
+    seterr, geterr, seterrcall, geterrcall
+
+    Notes
+    -----
+    For complete documentation of the types of floating-point exceptions and
+    treatment options, see `seterr`.
+
+    Examples
+    --------
+    >>> from collections import OrderedDict
+    >>> olderr = np.seterr(all='ignore')  # Set error handling to known state.
+
+    >>> np.arange(3) / 0.
+    array([nan, inf, inf])
+    >>> with np.errstate(divide='warn'):
+    ...     np.arange(3) / 0.
+    array([nan, inf, inf])
+
+    >>> np.sqrt(-1)
+    nan
+    >>> with np.errstate(invalid='raise'):
+    ...     np.sqrt(-1)
+    Traceback (most recent call last):
+      File \"<stdin>\", line 2, in <module>
+    FloatingPointError: invalid value encountered in sqrt
+
+    Outside the context the error handling behavior has not changed:
+
+    >>> OrderedDict(sorted(np.geterr().items()))
+    OrderedDict([('divide', 'ignore'), ('invalid', 'ignore'), ('over', 'ignore'), ('under', 'ignore')])
+
+    " :arglists '[[self & [{call :call, :as kwargs}]]]} errstate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "errstate"))))
+
+(def ^{:doc "set_numeric_ops(op1=func1, op2=func2, ...)
+
+    Set numerical operators for array objects.
+
+    .. deprecated:: 1.16
+
+        For the general case, use :c:func:`PyUFunc_ReplaceLoopBySignature`.
+        For ndarray subclasses, define the ``__array_ufunc__`` method and
+        override the relevant ufunc.
+
+    Parameters
+    ----------
+    op1, op2, ... : callable
+        Each ``op = func`` pair describes an operator to be replaced.
+        For example, ``add = lambda x, y: np.add(x, y) % 5`` would replace
+        addition by modulus 5 addition.
+
+    Returns
+    -------
+    saved_ops : list of callables
+        A list of all operators, stored before making replacements.
+
+    Notes
+    -----
+    .. WARNING::
+       Use with care!  Incorrect usage may lead to memory errors.
+
+    A function replacing an operator cannot make use of that operator.
+    For example, when replacing add, you may not use ``+``.  Instead,
+    directly call ufuncs.
+
+    Examples
+    --------
+    >>> def add_mod5(x, y):
+    ...     return np.add(x, y) % 5
+    ...
+    >>> old_funcs = np.set_numeric_ops(add=add_mod5)
+
+    >>> x = np.arange(12).reshape((3, 4))
+    >>> x + x
+    array([[0, 2, 4, 1],
+           [3, 0, 2, 4],
+           [1, 3, 0, 2]])
+
+    >>> ignore = np.set_numeric_ops(**old_funcs) # restore operators" :arglists '[[self & [args {:as kwargs}]]]} set_numeric_ops (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "set_numeric_ops"))))
+
+(def ^{:doc "degrees(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Convert angles from radians to degrees.
+
+Parameters
+----------
+x : array_like
+    Input array in radians.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray of floats
+    The corresponding degree values; if `out` was supplied this is a
+    reference to it.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+rad2deg : equivalent function
+
+Examples
+--------
+Convert a radian array to degrees
+
+>>> rad = np.arange(12.)*np.pi/6
+>>> np.degrees(rad)
+array([   0.,   30.,   60.,   90.,  120.,  150.,  180.,  210.,  240.,
+        270.,  300.,  330.])
+
+>>> out = np.zeros((rad.shape))
+>>> r = np.degrees(rad, out)
+>>> np.all(r == out)
+True" :arglists '[[self & [args {:as kwargs}]]]} degrees (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "degrees"))))
+
+(def ^{:doc ""} True_ true)
+
+(def ^{:doc "
+    Calculate the n-th discrete difference along the given axis.
+
+    The first difference is given by ``out[i] = a[i+1] - a[i]`` along
+    the given axis, higher differences are calculated by using `diff`
+    recursively.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array
+    n : int, optional
+        The number of times values are differenced. If zero, the input
+        is returned as-is.
+    axis : int, optional
+        The axis along which the difference is taken, default is the
+        last axis.
+    prepend, append : array_like, optional
+        Values to prepend or append to `a` along axis prior to
+        performing the difference.  Scalar values are expanded to
+        arrays with length 1 in the direction of axis and the shape
+        of the input array in along all other axes.  Otherwise the
+        dimension and shape must match `a` except along axis.
+
+        .. versionadded:: 1.16.0
+
+    Returns
+    -------
+    diff : ndarray
+        The n-th differences. The shape of the output is the same as `a`
+        except along `axis` where the dimension is smaller by `n`. The
+        type of the output is the same as the type of the difference
+        between any two elements of `a`. This is the same as the type of
+        `a` in most cases. A notable exception is `datetime64`, which
+        results in a `timedelta64` output array.
+
+    See Also
+    --------
+    gradient, ediff1d, cumsum
+
+    Notes
+    -----
+    Type is preserved for boolean arrays, so the result will contain
+    `False` when consecutive elements are the same and `True` when they
+    differ.
+
+    For unsigned integer arrays, the results will also be unsigned. This
+    should not be surprising, as the result is consistent with
+    calculating the difference directly:
+
+    >>> u8_arr = np.array([1, 0], dtype=np.uint8)
+    >>> np.diff(u8_arr)
+    array([255], dtype=uint8)
+    >>> u8_arr[1,...] - u8_arr[0,...]
+    255
+
+    If this is not desirable, then the array should be cast to a larger
+    integer type first:
+
+    >>> i16_arr = u8_arr.astype(np.int16)
+    >>> np.diff(i16_arr)
+    array([-1], dtype=int16)
+
+    Examples
+    --------
+    >>> x = np.array([1, 2, 4, 7, 0])
+    >>> np.diff(x)
+    array([ 1,  2,  3, -7])
+    >>> np.diff(x, n=2)
+    array([  1,   1, -10])
+
+    >>> x = np.array([[1, 3, 6, 10], [0, 5, 6, 8]])
+    >>> np.diff(x)
+    array([[2, 3, 4],
+           [5, 1, 2]])
+    >>> np.diff(x, axis=0)
+    array([[-1,  2,  0, -2]])
+
+    >>> x = np.arange('1066-10-13', '1066-10-16', dtype=np.datetime64)
+    >>> np.diff(x)
+    array([1, 1], dtype='timedelta64[D]')
+
+    " :arglists '[[& [args {:as kwargs}]]]} diff (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diff"))))
+
+(def ^{:doc "
+    Calculates `element in test_elements`, broadcasting over `element` only.
+    Returns a boolean array of the same shape as `element` that is True
+    where an element of `element` is in `test_elements` and False otherwise.
+
+    Parameters
+    ----------
+    element : array_like
+        Input array.
+    test_elements : array_like
+        The values against which to test each value of `element`.
+        This argument is flattened if it is an array or array_like.
+        See notes for behavior with non-array-like parameters.
+    assume_unique : bool, optional
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+    invert : bool, optional
+        If True, the values in the returned array are inverted, as if
+        calculating `element not in test_elements`. Default is False.
+        ``np.isin(a, b, invert=True)`` is equivalent to (but faster
+        than) ``np.invert(np.isin(a, b))``.
+
+    Returns
+    -------
+    isin : ndarray, bool
+        Has the same shape as `element`. The values `element[isin]`
+        are in `test_elements`.
+
+    See Also
+    --------
+    in1d                  : Flattened version of this function.
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Notes
+    -----
+
+    `isin` is an element-wise function version of the python keyword `in`.
+    ``isin(a, b)`` is roughly equivalent to
+    ``np.array([item in b for item in a])`` if `a` and `b` are 1-D sequences.
+
+    `element` and `test_elements` are converted to arrays if they are not
+    already. If `test_elements` is a set (or other non-sequence collection)
+    it will be converted to an object array with one element, rather than an
+    array of the values contained in `test_elements`. This is a consequence
+    of the `array` constructor's way of handling non-sequence collections.
+    Converting the set to a list usually gives the desired behavior.
+
+    .. versionadded:: 1.13.0
+
+    Examples
+    --------
+    >>> element = 2*np.arange(4).reshape((2, 2))
+    >>> element
+    array([[0, 2],
+           [4, 6]])
+    >>> test_elements = [1, 2, 4, 8]
+    >>> mask = np.isin(element, test_elements)
+    >>> mask
+    array([[False,  True],
+           [ True, False]])
+    >>> element[mask]
+    array([2, 4])
+
+    The indices of the matched values can be obtained with `nonzero`:
+
+    >>> np.nonzero(mask)
+    (array([0, 1]), array([1, 0]))
+
+    The test can also be inverted:
+
+    >>> mask = np.isin(element, test_elements, invert=True)
+    >>> mask
+    array([[ True, False],
+           [False,  True]])
+    >>> element[mask]
+    array([0, 6])
+
+    Because of how `array` handles sets, the following does not
+    work as expected:
+
+    >>> test_set = {1, 2, 4, 8}
+    >>> np.isin(element, test_set)
+    array([[False, False],
+           [False, False]])
+
+    Casting the set to a list gives the expected result:
+
+    >>> np.isin(element, list(test_set))
+    array([[False,  True],
+           [ True, False]])
+    " :arglists '[[& [args {:as kwargs}]]]} isin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isin"))))
+
+(def ^{:doc "
+    Returns the indices of the minimum values along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        By default, the index is into the flattened array, otherwise
+        along the specified axis.
+    out : array, optional
+        If provided, the result will be inserted into this array. It should
+        be of the appropriate shape and dtype.
+
+    Returns
+    -------
+    index_array : ndarray of ints
+        Array of indices into the array. It has the same shape as `a.shape`
+        with the dimension along `axis` removed.
+
+    See Also
+    --------
+    ndarray.argmin, argmax
+    amin : The minimum value along a given axis.
+    unravel_index : Convert a flat index into an index tuple.
+    take_along_axis : Apply ``np.expand_dims(index_array, axis)``
+                      from argmin to an array as if by calling min.
+
+    Notes
+    -----
+    In case of multiple occurrences of the minimum values, the indices
+    corresponding to the first occurrence are returned.
+
+    Examples
+    --------
+    >>> a = np.arange(6).reshape(2,3) + 10
+    >>> a
+    array([[10, 11, 12],
+           [13, 14, 15]])
+    >>> np.argmin(a)
+    0
+    >>> np.argmin(a, axis=0)
+    array([0, 0, 0])
+    >>> np.argmin(a, axis=1)
+    array([0, 0])
+
+    Indices of the minimum elements of a N-dimensional array:
+
+    >>> ind = np.unravel_index(np.argmin(a, axis=None), a.shape)
+    >>> ind
+    (0, 0)
+    >>> a[ind]
+    10
+
+    >>> b = np.arange(6) + 10
+    >>> b[4] = 10
+    >>> b
+    array([10, 11, 12, 13, 10, 15])
+    >>> np.argmin(b)  # Only the first occurrence is returned.
+    0
+
+    >>> x = np.array([[4,2,3], [1,0,3]])
+    >>> index_array = np.argmin(x, axis=-1)
+    >>> # Same as np.min(x, axis=-1, keepdims=True)
+    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1)
+    array([[2],
+           [0]])
+    >>> # Same as np.max(x, axis=-1)
+    >>> np.take_along_axis(x, np.expand_dims(index_array, axis=-1), axis=-1).squeeze(axis=-1)
+    array([2, 0])
+
+    " :arglists '[[& [args {:as kwargs}]]]} argmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argmin"))))
+
+(def ^{:doc "
+    chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,
+              strides=None, order=None)
+
+    Provides a convenient view on arrays of string and unicode values.
+
+    .. note::
+       The `chararray` class exists for backwards compatibility with
+       Numarray, it is not recommended for new development. Starting from numpy
+       1.4, if one needs arrays of strings, it is recommended to use arrays of
+       `dtype` `object_`, `string_` or `unicode_`, and use the free functions
+       in the `numpy.char` module for fast vectorized string operations.
+
+    Versus a regular NumPy array of type `str` or `unicode`, this
+    class adds the following functionality:
+
+      1) values automatically have whitespace removed from the end
+         when indexed
+
+      2) comparison operators automatically remove whitespace from the
+         end when comparing values
+
+      3) vectorized string operations are provided as methods
+         (e.g. `.endswith`) and infix operators (e.g. ``\"+\", \"*\", \"%\"``)
+
+    chararrays should be created using `numpy.char.array` or
+    `numpy.char.asarray`, rather than this constructor directly.
+
+    This constructor creates the array, using `buffer` (with `offset`
+    and `strides`) if it is not ``None``. If `buffer` is ``None``, then
+    constructs a new array with `strides` in \"C order\", unless both
+    ``len(shape) >= 2`` and ``order='F'``, in which case `strides`
+    is in \"Fortran order\".
+
+    Methods
+    -------
+    astype
+    argsort
+    copy
+    count
+    decode
+    dump
+    dumps
+    encode
+    endswith
+    expandtabs
+    fill
+    find
+    flatten
+    getfield
+    index
+    isalnum
+    isalpha
+    isdecimal
+    isdigit
+    islower
+    isnumeric
+    isspace
+    istitle
+    isupper
+    item
+    join
+    ljust
+    lower
+    lstrip
+    nonzero
+    put
+    ravel
+    repeat
+    replace
+    reshape
+    resize
+    rfind
+    rindex
+    rjust
+    rsplit
+    rstrip
+    searchsorted
+    setfield
+    setflags
+    sort
+    split
+    splitlines
+    squeeze
+    startswith
+    strip
+    swapaxes
+    swapcase
+    take
+    title
+    tofile
+    tolist
+    tostring
+    translate
+    transpose
+    upper
+    view
+    zfill
+
+    Parameters
+    ----------
+    shape : tuple
+        Shape of the array.
+    itemsize : int, optional
+        Length of each array element, in number of characters. Default is 1.
+    unicode : bool, optional
+        Are the array elements of type unicode (True) or string (False).
+        Default is False.
+    buffer : object exposing the buffer interface or str, optional
+        Memory address of the start of the array data.  Default is None,
+        in which case a new array is created.
+    offset : int, optional
+        Fixed stride displacement from the beginning of an axis?
+        Default is 0. Needs to be >=0.
+    strides : array_like of ints, optional
+        Strides for the array (see `ndarray.strides` for full description).
+        Default is None.
+    order : {'C', 'F'}, optional
+        The order in which the array data is stored in memory: 'C' ->
+        \"row major\" order (the default), 'F' -> \"column major\"
+        (Fortran) order.
+
+    Examples
+    --------
+    >>> charar = np.chararray((3, 3))
+    >>> charar[:] = 'a'
+    >>> charar
+    chararray([[b'a', b'a', b'a'],
+               [b'a', b'a', b'a'],
+               [b'a', b'a', b'a']], dtype='|S1')
+
+    >>> charar = np.chararray(charar.shape, itemsize=5)
+    >>> charar[:] = 'abc'
+    >>> charar
+    chararray([[b'abc', b'abc', b'abc'],
+               [b'abc', b'abc', b'abc'],
+               [b'abc', b'abc', b'abc']], dtype='|S5')
+
+    " :arglists '[[self & [args {:as kwargs}]]]} chararray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "chararray"))))
+
+(def ^{:doc "
+    shares_memory(a, b, max_work=None)
+
+    Determine if two arrays share memory.
+
+    .. warning::
+
+       This function can be exponentially slow for some inputs, unless
+       `max_work` is set to a finite number or ``MAY_SHARE_BOUNDS``.
+       If in doubt, use `numpy.may_share_memory` instead.
+
+    Parameters
+    ----------
+    a, b : ndarray
+        Input arrays
+    max_work : int, optional
+        Effort to spend on solving the overlap problem (maximum number
+        of candidate solutions to consider). The following special
+        values are recognized:
+
+        max_work=MAY_SHARE_EXACT  (default)
+            The problem is solved exactly. In this case, the function returns
+            True only if there is an element shared between the arrays. Finding
+            the exact solution may take extremely long in some cases.
+        max_work=MAY_SHARE_BOUNDS
+            Only the memory bounds of a and b are checked.
+
+    Raises
+    ------
+    numpy.TooHardError
+        Exceeded max_work.
+
+    Returns
+    -------
+    out : bool
+
+    See Also
+    --------
+    may_share_memory
+
+    Examples
+    --------
+    >>> x = np.array([1, 2, 3, 4])
+    >>> np.shares_memory(x, np.array([5, 6, 7]))
+    False
+    >>> np.shares_memory(x[::2], x)
+    True
+    >>> np.shares_memory(x[::2], x[1::2])
+    False
+
+    Checking whether two arrays share memory is NP-complete, and
+    runtime may increase exponentially in the number of
+    dimensions. Hence, `max_work` should generally be set to a finite
+    number, as it is possible to construct examples that take
+    extremely long to run:
+
+    >>> from numpy.lib.stride_tricks import as_strided
+    >>> x = np.zeros([192163377], dtype=np.int8)
+    >>> x1 = as_strided(x, strides=(36674, 61119, 85569), shape=(1049, 1049, 1049))
+    >>> x2 = as_strided(x[64023025:], strides=(12223, 12224, 1), shape=(1049, 1049, 1))
+    >>> np.shares_memory(x1, x2, max_work=1000)
+    Traceback (most recent call last):
+    ...
+    numpy.TooHardError: Exceeded max_work
+
+    Running ``np.shares_memory(x1, x2)`` without `max_work` set takes
+    around 1 minute for this case. It is possible to find problems
+    that take still significantly longer.
+
+    " :arglists '[[& [args {:as kwargs}]]]} shares_memory (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "shares_memory"))))
+
+(def ^{:doc "
+    Reverse the order of elements in an array along the given axis.
+
+    The shape of the array is preserved, but the elements are reordered.
+
+    .. versionadded:: 1.12.0
+
+    Parameters
+    ----------
+    m : array_like
+        Input array.
+    axis : None or int or tuple of ints, optional
+         Axis or axes along which to flip over. The default,
+         axis=None, will flip over all of the axes of the input array.
+         If axis is negative it counts from the last to the first axis.
+
+         If axis is a tuple of ints, flipping is performed on all of the axes
+         specified in the tuple.
+
+         .. versionchanged:: 1.15.0
+            None and tuples of axes are supported
+
+    Returns
+    -------
+    out : array_like
+        A view of `m` with the entries of axis reversed.  Since a view is
+        returned, this operation is done in constant time.
+
+    See Also
+    --------
+    flipud : Flip an array vertically (axis=0).
+    fliplr : Flip an array horizontally (axis=1).
+
+    Notes
+    -----
+    flip(m, 0) is equivalent to flipud(m).
+
+    flip(m, 1) is equivalent to fliplr(m).
+
+    flip(m, n) corresponds to ``m[...,::-1,...]`` with ``::-1`` at position n.
+
+    flip(m) corresponds to ``m[::-1,::-1,...,::-1]`` with ``::-1`` at all
+    positions.
+
+    flip(m, (0, 1)) corresponds to ``m[::-1,::-1,...]`` with ``::-1`` at
+    position 0 and position 1.
+
+    Examples
+    --------
+    >>> A = np.arange(8).reshape((2,2,2))
+    >>> A
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+    >>> np.flip(A, 0)
+    array([[[4, 5],
+            [6, 7]],
+           [[0, 1],
+            [2, 3]]])
+    >>> np.flip(A, 1)
+    array([[[2, 3],
+            [0, 1]],
+           [[6, 7],
+            [4, 5]]])
+    >>> np.flip(A)
+    array([[[7, 6],
+            [5, 4]],
+           [[3, 2],
+            [1, 0]]])
+    >>> np.flip(A, (0, 2))
+    array([[[5, 4],
+            [7, 6]],
+           [[1, 0],
+            [3, 2]]])
+    >>> A = np.random.randn(3,4,5)
+    >>> np.all(np.flip(A,2) == A[:,:,::-1,...])
+    True
+    " :arglists '[[& [args {:as kwargs}]]]} flip (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flip"))))
+
+(def ^{:doc "
+    Assemble an nd-array from nested lists of blocks.
+
+    Blocks in the innermost lists are concatenated (see `concatenate`) along
+    the last dimension (-1), then these are concatenated along the
+    second-last dimension (-2), and so on until the outermost list is reached.
+
+    Blocks can be of any dimension, but will not be broadcasted using the normal
+    rules. Instead, leading axes of size 1 are inserted, to make ``block.ndim``
+    the same for all blocks. This is primarily useful for working with scalars,
+    and means that code like ``np.block([v, 1])`` is valid, where
+    ``v.ndim == 1``.
+
+    When the nested list is two levels deep, this allows block matrices to be
+    constructed from their components.
+
+    .. versionadded:: 1.13.0
+
+    Parameters
+    ----------
+    arrays : nested list of array_like or scalars (but not tuples)
+        If passed a single ndarray or scalar (a nested list of depth 0), this
+        is returned unmodified (and not copied).
+
+        Elements shapes must match along the appropriate axes (without
+        broadcasting), but leading 1s will be prepended to the shape as
+        necessary to make the dimensions match.
+
+    Returns
+    -------
+    block_array : ndarray
+        The array assembled from the given blocks.
+
+        The dimensionality of the output is equal to the greatest of:
+        * the dimensionality of all the inputs
+        * the depth to which the input list is nested
+
+    Raises
+    ------
+    ValueError
+        * If list depths are mismatched - for instance, ``[[a, b], c]`` is
+          illegal, and should be spelt ``[[a, b], [c]]``
+        * If lists are empty - for instance, ``[[a, b], []]``
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays along an existing axis.
+    stack : Join a sequence of arrays along a new axis.
+    vstack : Stack arrays in sequence vertically (row wise).
+    hstack : Stack arrays in sequence horizontally (column wise).
+    dstack : Stack arrays in sequence depth wise (along third axis).
+    column_stack : Stack 1-D arrays as columns into a 2-D array.
+    vsplit : Split an array into multiple sub-arrays vertically (row-wise).
+
+    Notes
+    -----
+
+    When called with only scalars, ``np.block`` is equivalent to an ndarray
+    call. So ``np.block([[1, 2], [3, 4]])`` is equivalent to
+    ``np.array([[1, 2], [3, 4]])``.
+
+    This function does not enforce that the blocks lie on a fixed grid.
+    ``np.block([[a, b], [c, d]])`` is not restricted to arrays of the form::
+
+        AAAbb
+        AAAbb
+        cccDD
+
+    But is also allowed to produce, for some ``a, b, c, d``::
+
+        AAAbb
+        AAAbb
+        cDDDD
+
+    Since concatenation happens along the last axis first, `block` is _not_
+    capable of producing the following directly::
+
+        AAAbb
+        cccbb
+        cccDD
+
+    Matlab's \"square bracket stacking\", ``[A, B, ...; p, q, ...]``, is
+    equivalent to ``np.block([[A, B, ...], [p, q, ...]])``.
+
+    Examples
+    --------
+    The most common use of this function is to build a block matrix
+
+    >>> A = np.eye(2) * 2
+    >>> B = np.eye(3) * 3
+    >>> np.block([
+    ...     [A,               np.zeros((2, 3))],
+    ...     [np.ones((3, 2)), B               ]
+    ... ])
+    array([[2., 0., 0., 0., 0.],
+           [0., 2., 0., 0., 0.],
+           [1., 1., 3., 0., 0.],
+           [1., 1., 0., 3., 0.],
+           [1., 1., 0., 0., 3.]])
+
+    With a list of depth 1, `block` can be used as `hstack`
+
+    >>> np.block([1, 2, 3])              # hstack([1, 2, 3])
+    array([1, 2, 3])
+
+    >>> a = np.array([1, 2, 3])
+    >>> b = np.array([2, 3, 4])
+    >>> np.block([a, b, 10])             # hstack([a, b, 10])
+    array([ 1,  2,  3,  2,  3,  4, 10])
+
+    >>> A = np.ones((2, 2), int)
+    >>> B = 2 * A
+    >>> np.block([A, B])                 # hstack([A, B])
+    array([[1, 1, 2, 2],
+           [1, 1, 2, 2]])
+
+    With a list of depth 2, `block` can be used in place of `vstack`:
+
+    >>> a = np.array([1, 2, 3])
+    >>> b = np.array([2, 3, 4])
+    >>> np.block([[a], [b]])             # vstack([a, b])
+    array([[1, 2, 3],
+           [2, 3, 4]])
+
+    >>> A = np.ones((2, 2), int)
+    >>> B = 2 * A
+    >>> np.block([[A], [B]])             # vstack([A, B])
+    array([[1, 1],
+           [1, 1],
+           [2, 2],
+           [2, 2]])
+
+    It can also be used in places of `atleast_1d` and `atleast_2d`
+
+    >>> a = np.array(0)
+    >>> b = np.array([1])
+    >>> np.block([a])                    # atleast_1d(a)
+    array([0])
+    >>> np.block([b])                    # atleast_1d(b)
+    array([1])
+
+    >>> np.block([[a]])                  # atleast_2d(a)
+    array([[0]])
+    >>> np.block([[b]])                  # atleast_2d(b)
+    array([[1]])
+
+
+    " :arglists '[[& [args {:as kwargs}]]]} block (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "block"))))
+
+(def ^{:doc "
+    putmask(a, mask, values)
+
+    Changes elements of an array based on conditional and input values.
+
+    Sets ``a.flat[n] = values[n]`` for each n where ``mask.flat[n]==True``.
+
+    If `values` is not the same size as `a` and `mask` then it will repeat.
+    This gives behavior different from ``a[mask] = values``.
+
+    Parameters
+    ----------
+    a : ndarray
+        Target array.
+    mask : array_like
+        Boolean mask array. It has to be the same shape as `a`.
+    values : array_like
+        Values to put into `a` where `mask` is True. If `values` is smaller
+        than `a` it will be repeated.
+
+    See Also
+    --------
+    place, put, take, copyto
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2, 3)
+    >>> np.putmask(x, x>2, x**2)
+    >>> x
+    array([[ 0,  1,  2],
+           [ 9, 16, 25]])
+
+    If `values` is smaller than `a` it is repeated:
+
+    >>> x = np.arange(5)
+    >>> np.putmask(x, x>1, [-33, -44])
+    >>> x
+    array([  0,   1, -33, -44, -33])
+
+    " :arglists '[[& [args {:as kwargs}]]]} putmask (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "putmask"))))
+
+(def ^{:doc "arctanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Inverse hyperbolic tangent element-wise.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Array of the same shape as `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+emath.arctanh
+
+Notes
+-----
+`arctanh` is a multivalued function: for each `x` there are infinitely
+many numbers `z` such that `tanh(z) = x`. The convention is to return
+the `z` whose imaginary part lies in `[-pi/2, pi/2]`.
+
+For real-valued input data types, `arctanh` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arctanh` is a complex analytical function
+that has branch cuts `[-1, -inf]` and `[1, inf]` and is continuous from
+above on the former and from below on the latter.
+
+The inverse hyperbolic tangent is also known as `atanh` or ``tanh^-1``.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Inverse hyperbolic function\",
+       https://en.wikipedia.org/wiki/Arctanh
+
+Examples
+--------
+>>> np.arctanh([0, -0.5])
+array([ 0.        , -0.54930614])" :arglists '[[self & [args {:as kwargs}]]]} arctanh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arctanh"))))
+
+(def ^{:doc "
+    Take elements from an array along an axis.
+
+    When axis is not None, this function does the same thing as \"fancy\"
+    indexing (indexing arrays using arrays); however, it can be easier to use
+    if you need elements along a given axis. A call such as
+    ``np.take(arr, indices, axis=3)`` is equivalent to
+    ``arr[:,:,:,indices,...]``.
+
+    Explained without fancy indexing, this is equivalent to the following use
+    of `ndindex`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of
+    indices::
+
+        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+        Nj = indices.shape
+        for ii in ndindex(Ni):
+            for jj in ndindex(Nj):
+                for kk in ndindex(Nk):
+                    out[ii + jj + kk] = a[ii + (indices[jj],) + kk]
+
+    Parameters
+    ----------
+    a : array_like (Ni..., M, Nk...)
+        The source array.
+    indices : array_like (Nj...)
+        The indices of the values to extract.
+
+        .. versionadded:: 1.8.0
+
+        Also allow scalars for indices.
+    axis : int, optional
+        The axis over which to select values. By default, the flattened
+        input array is used.
+    out : ndarray, optional (Ni..., Nj..., Nk...)
+        If provided, the result will be placed in this array. It should
+        be of the appropriate shape and dtype. Note that `out` is always
+        buffered if `mode='raise'`; use other modes for better performance.
+    mode : {'raise', 'wrap', 'clip'}, optional
+        Specifies how out-of-bounds indices will behave.
+
+        * 'raise' -- raise an error (default)
+        * 'wrap' -- wrap around
+        * 'clip' -- clip to the range
+
+        'clip' mode means that all indices that are too large are replaced
+        by the index that addresses the last element along that axis. Note
+        that this disables indexing with negative numbers.
+
+    Returns
+    -------
+    out : ndarray (Ni..., Nj..., Nk...)
+        The returned array has the same type as `a`.
+
+    See Also
+    --------
+    compress : Take elements using a boolean mask
+    ndarray.take : equivalent method
+    take_along_axis : Take elements by matching the array and the index arrays
+
+    Notes
+    -----
+
+    By eliminating the inner loop in the description above, and using `s_` to
+    build simple slice objects, `take` can be expressed  in terms of applying
+    fancy indexing to each 1-d slice::
+
+        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nj):
+                out[ii + s_[...,] + kk] = a[ii + s_[:,] + kk][indices]
+
+    For this reason, it is equivalent to (but faster than) the following use
+    of `apply_along_axis`::
+
+        out = np.apply_along_axis(lambda a_1d: a_1d[indices], axis, a)
+
+    Examples
+    --------
+    >>> a = [4, 3, 5, 7, 6, 8]
+    >>> indices = [0, 1, 4]
+    >>> np.take(a, indices)
+    array([4, 3, 6])
+
+    In this example if `a` is an ndarray, \"fancy\" indexing can be used.
+
+    >>> a = np.array(a)
+    >>> a[indices]
+    array([4, 3, 6])
+
+    If `indices` is not one dimensional, the output also has these dimensions.
+
+    >>> np.take(a, [[0, 1], [2, 3]])
+    array([[4, 3],
+           [5, 7]])
+    " :arglists '[[& [args {:as kwargs}]]]} take (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "take"))))
+
+(def ^{:doc "conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the complex conjugate, element-wise.
+
+The complex conjugate of a complex number is obtained by changing the
+sign of its imaginary part.
+
+Parameters
+----------
+x : array_like
+    Input value.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The complex conjugate of `x`, with same dtype as `y`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+`conj` is an alias for `conjugate`:
+
+>>> np.conj is np.conjugate
+True
+
+Examples
+--------
+>>> np.conjugate(1+2j)
+(1-2j)
+
+>>> x = np.eye(2) + 1j * np.eye(2)
+>>> np.conjugate(x)
+array([[ 1.-1.j,  0.-0.j],
+       [ 0.-0.j,  1.-1.j]])" :arglists '[[self & [args {:as kwargs}]]]} conjugate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "conjugate"))))
+
+(def ^{:doc "" :arglists '[[attr]]} __getattr__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__getattr__"))))
+
+(def ^{:doc "
+    Set the floating-point error callback function or log object.
+
+    There are two ways to capture floating-point error messages.  The first
+    is to set the error-handler to 'call', using `seterr`.  Then, set
+    the function to call using this function.
+
+    The second is to set the error-handler to 'log', using `seterr`.
+    Floating-point errors then trigger a call to the 'write' method of
+    the provided object.
+
+    Parameters
+    ----------
+    func : callable f(err, flag) or object with write method
+        Function to call upon floating-point errors ('call'-mode) or
+        object whose 'write' method is used to log such message ('log'-mode).
+
+        The call function takes two arguments. The first is a string describing
+        the type of error (such as \"divide by zero\", \"overflow\", \"underflow\",
+        or \"invalid value\"), and the second is the status flag.  The flag is a
+        byte, whose four least-significant bits indicate the type of error, one
+        of \"divide\", \"over\", \"under\", \"invalid\"::
+
+          [0 0 0 0 divide over under invalid]
+
+        In other words, ``flags = divide + 2*over + 4*under + 8*invalid``.
+
+        If an object is provided, its write method should take one argument,
+        a string.
+
+    Returns
+    -------
+    h : callable, log instance or None
+        The old error handler.
+
+    See Also
+    --------
+    seterr, geterr, geterrcall
+
+    Examples
+    --------
+    Callback upon error:
+
+    >>> def err_handler(type, flag):
+    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
+    ...
+
+    >>> saved_handler = np.seterrcall(err_handler)
+    >>> save_err = np.seterr(all='call')
+    >>> from collections import OrderedDict
+
+    >>> np.array([1, 2, 3]) / 0.0
+    Floating point error (divide by zero), with flag 1
+    array([inf, inf, inf])
+
+    >>> np.seterrcall(saved_handler)
+    <function err_handler at 0x...>
+    >>> OrderedDict(sorted(np.seterr(**save_err).items()))
+    OrderedDict([('divide', 'call'), ('invalid', 'call'), ('over', 'call'), ('under', 'call')])
+
+    Log error message:
+
+    >>> class Log:
+    ...     def write(self, msg):
+    ...         print(\"LOG: %s\" % msg)
+    ...
+
+    >>> log = Log()
+    >>> saved_handler = np.seterrcall(log)
+    >>> save_err = np.seterr(all='log')
+
+    >>> np.array([1, 2, 3]) / 0.0
+    LOG: Warning: divide by zero encountered in true_divide
+    array([inf, inf, inf])
+
+    >>> np.seterrcall(saved_handler)
+    <numpy.core.numeric.Log object at 0x...>
+    >>> OrderedDict(sorted(np.seterr(**save_err).items()))
+    OrderedDict([('divide', 'log'), ('invalid', 'log'), ('over', 'log'), ('under', 'log')])
+
+    " :arglists '[[func]]} seterrcall (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "seterrcall"))))
+
+(def ^{:doc ""} SHIFT_OVERFLOW 3)
+
+(def ^{:doc "
+    Returns a bool array, where True if input element is complex.
+
+    What is tested is whether the input has a non-zero imaginary part, not if
+    the input type is complex.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray of bools
+        Output array.
+
+    See Also
+    --------
+    isreal
+    iscomplexobj : Return True if x is a complex type or an array of complex
+                   numbers.
+
+    Examples
+    --------
+    >>> np.iscomplex([1+1j, 1+0j, 4.5, 3, 2, 2j])
+    array([ True, False, False, False, False,  True])
+
+    " :arglists '[[& [args {:as kwargs}]]]} iscomplex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iscomplex"))))
+
+(def ^{:doc "Unsigned integer type, compatible with C ``unsigned short``.
+
+    :Character code: ``'H'``
+    :Canonical name: `numpy.ushort`
+    :Alias on this platform: `numpy.uint16`: 16-bit unsigned integer (``0`` to ``65_535``)." :arglists '[[self & [args {:as kwargs}]]]} ushort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ushort"))))
+
+(def ^{:doc "fmod(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the element-wise remainder of division.
+
+This is the NumPy implementation of the C library function fmod, the
+remainder has the same sign as the dividend `x1`. It is equivalent to
+the Matlab(TM) ``rem`` function and should not be confused with the
+Python modulus operator ``x1 % x2``.
+
+Parameters
+----------
+x1 : array_like
+    Dividend.
+x2 : array_like
+    Divisor.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : array_like
+    The remainder of the division of `x1` by `x2`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+remainder : Equivalent to the Python ``%`` operator.
+divide
+
+Notes
+-----
+The result of the modulo operation for negative dividend and divisors
+is bound by conventions. For `fmod`, the sign of result is the sign of
+the dividend, while for `remainder` the sign of the result is the sign
+of the divisor. The `fmod` function is equivalent to the Matlab(TM)
+``rem`` function.
+
+Examples
+--------
+>>> np.fmod([-3, -2, -1, 1, 2, 3], 2)
+array([-1,  0, -1,  1,  0,  1])
+>>> np.remainder([-3, -2, -1, 1, 2, 3], 2)
+array([1, 0, 1, 1, 0, 1])
+
+>>> np.fmod([5, 3], [2, 2.])
+array([ 1.,  1.])
+>>> a = np.arange(-3, 3).reshape(3, 2)
+>>> a
+array([[-3, -2],
+       [-1,  0],
+       [ 1,  2]])
+>>> np.fmod(a, [2,2])
+array([[-1,  0],
+       [-1,  0],
+       [ 1,  0]])" :arglists '[[self & [args {:as kwargs}]]]} fmod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fmod"))))
+
+(def ^{:doc "
+    can_cast(from_, to, casting='safe')
+
+    Returns True if cast between data types can occur according to the
+    casting rule.  If from is a scalar or array scalar, also returns
+    True if the scalar value can be cast without overflow or truncation
+    to an integer.
+
+    Parameters
+    ----------
+    from_ : dtype, dtype specifier, scalar, or array
+        Data type, scalar, or array to cast from.
+    to : dtype or dtype specifier
+        Data type to cast to.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur.
+
+          * 'no' means the data types should not be cast at all.
+          * 'equiv' means only byte-order changes are allowed.
+          * 'safe' means only casts which can preserve values are allowed.
+          * 'same_kind' means only safe casts or casts within a kind,
+            like float64 to float32, are allowed.
+          * 'unsafe' means any data conversions may be done.
+
+    Returns
+    -------
+    out : bool
+        True if cast can occur according to the casting rule.
+
+    Notes
+    -----
+    .. versionchanged:: 1.17.0
+       Casting between a simple data type and a structured one is possible only
+       for \"unsafe\" casting.  Casting to multiple fields is allowed, but
+       casting from multiple fields is not.
+
+    .. versionchanged:: 1.9.0
+       Casting from numeric to string types in 'safe' casting mode requires
+       that the string dtype length is long enough to store the maximum
+       integer/float value converted.
+
+    See also
+    --------
+    dtype, result_type
+
+    Examples
+    --------
+    Basic examples
+
+    >>> np.can_cast(np.int32, np.int64)
+    True
+    >>> np.can_cast(np.float64, complex)
+    True
+    >>> np.can_cast(complex, float)
+    False
+
+    >>> np.can_cast('i8', 'f8')
+    True
+    >>> np.can_cast('i8', 'f4')
+    False
+    >>> np.can_cast('i4', 'S4')
+    False
+
+    Casting scalars
+
+    >>> np.can_cast(100, 'i1')
+    True
+    >>> np.can_cast(150, 'i1')
+    False
+    >>> np.can_cast(150, 'u1')
+    True
+
+    >>> np.can_cast(3.5e100, np.float32)
+    False
+    >>> np.can_cast(1000.0, np.float32)
+    True
+
+    Array scalar checks the value, array does not
+
+    >>> np.can_cast(np.array(1000.0), np.float32)
+    True
+    >>> np.can_cast(np.array([1000.0]), np.float32)
+    False
+
+    Using the casting rules
+
+    >>> np.can_cast('i8', 'i8', 'no')
+    True
+    >>> np.can_cast('<i8', '>i8', 'no')
+    False
+
+    >>> np.can_cast('<i8', '>i8', 'equiv')
+    True
+    >>> np.can_cast('<i4', '>i8', 'equiv')
+    False
+
+    >>> np.can_cast('<i4', '>i8', 'safe')
+    True
+    >>> np.can_cast('<i8', '>i4', 'safe')
+    False
+
+    >>> np.can_cast('<i8', '>i4', 'same_kind')
+    True
+    >>> np.can_cast('<i8', '>u4', 'same_kind')
+    False
+
+    >>> np.can_cast('<i8', '>u4', 'unsafe')
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]]} can_cast (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "can_cast"))))
+
+(def ^{:doc "
+    Compute the q-th quantile of the data along the specified axis.
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    q : array_like of float
+        Quantile or sequence of quantiles to compute, which must be between
+        0 and 1 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the quantiles are computed. The
+        default is to compute the quantile(s) along a flattened
+        version of the array.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by intermediate
+        calculations, to save memory. In this case, the contents of the input
+        `a` after this function completes is undefined.
+    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
+        This optional parameter specifies the interpolation method to
+        use when the desired quantile lies between two data points
+        ``i < j``:
+
+            * linear: ``i + (j - i) * fraction``, where ``fraction``
+              is the fractional part of the index surrounded by ``i``
+              and ``j``.
+            * lower: ``i``.
+            * higher: ``j``.
+            * nearest: ``i`` or ``j``, whichever is nearest.
+            * midpoint: ``(i + j) / 2``.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+    Returns
+    -------
+    quantile : scalar or ndarray
+        If `q` is a single quantile and `axis=None`, then the result
+        is a scalar. If multiple quantiles are given, first axis of
+        the result corresponds to the quantiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean
+    percentile : equivalent to quantile, but with q in the range [0, 100].
+    median : equivalent to ``quantile(..., 0.5)``
+    nanquantile
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the q-th quantile of
+    ``V`` is the value ``q`` of the way from the minimum to the
+    maximum in a sorted copy of ``V``. The values and distances of
+    the two nearest neighbors as well as the `interpolation` parameter
+    will determine the quantile if the normalized ranking does not
+    match the location of ``q`` exactly. This function is the same as
+    the median if ``q=0.5``, the same as the minimum if ``q=0.0`` and the
+    same as the maximum if ``q=1.0``.
+
+    Examples
+    --------
+    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
+    >>> a
+    array([[10,  7,  4],
+           [ 3,  2,  1]])
+    >>> np.quantile(a, 0.5)
+    3.5
+    >>> np.quantile(a, 0.5, axis=0)
+    array([6.5, 4.5, 2.5])
+    >>> np.quantile(a, 0.5, axis=1)
+    array([7.,  2.])
+    >>> np.quantile(a, 0.5, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+    >>> m = np.quantile(a, 0.5, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.quantile(a, 0.5, axis=0, out=out)
+    array([6.5, 4.5, 2.5])
+    >>> m
+    array([6.5, 4.5, 2.5])
+    >>> b = a.copy()
+    >>> np.quantile(b, 0.5, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a == b)
+    " :arglists '[[& [args {:as kwargs}]]]} quantile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "quantile"))))
+
+(def ^{:doc ""} use_hugepage 1)
+
+(def ^{:doc "
+    Unwrap by changing deltas between values to 2*pi complement.
+
+    Unwrap radian phase `p` by changing absolute jumps greater than
+    `discont` to their 2*pi complement along the given axis.
+
+    Parameters
+    ----------
+    p : array_like
+        Input array.
+    discont : float, optional
+        Maximum discontinuity between values, default is ``pi``.
+    axis : int, optional
+        Axis along which unwrap will operate, default is the last axis.
+
+    Returns
+    -------
+    out : ndarray
+        Output array.
+
+    See Also
+    --------
+    rad2deg, deg2rad
+
+    Notes
+    -----
+    If the discontinuity in `p` is smaller than ``pi``, but larger than
+    `discont`, no unwrapping is done because taking the 2*pi complement
+    would only make the discontinuity larger.
+
+    Examples
+    --------
+    >>> phase = np.linspace(0, np.pi, num=5)
+    >>> phase[3:] += np.pi
+    >>> phase
+    array([ 0.        ,  0.78539816,  1.57079633,  5.49778714,  6.28318531]) # may vary
+    >>> np.unwrap(phase)
+    array([ 0.        ,  0.78539816,  1.57079633, -0.78539816,  0.        ]) # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]]} unwrap (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unwrap"))))
+
+(def ^{:doc ""} __file__ "/home/chrisn/miniconda3/lib/python3.9/site-packages/numpy/__init__.py")
+
+(def ^{:doc "Signed integer type, compatible with C ``short``.
+
+    :Character code: ``'h'``
+    :Canonical name: `numpy.short`
+    :Alias on this platform: `numpy.int16`: 16-bit signed integer (``-32_768`` to ``32_767``)." :arglists '[[self & [args {:as kwargs}]]]} short (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "short"))))
+
+(def ^{:doc "
+    datetime_as_string(arr, unit=None, timezone='naive', casting='same_kind')
+
+    Convert an array of datetimes into an array of strings.
+
+    Parameters
+    ----------
+    arr : array_like of datetime64
+        The array of UTC timestamps to format.
+    unit : str
+        One of None, 'auto', or a :ref:`datetime unit <arrays.dtypes.dateunits>`.
+    timezone : {'naive', 'UTC', 'local'} or tzinfo
+        Timezone information to use when displaying the datetime. If 'UTC', end
+        with a Z to indicate UTC time. If 'local', convert to the local timezone
+        first, and suffix with a +-#### timezone offset. If a tzinfo object,
+        then do as with 'local', but use the specified timezone.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}
+        Casting to allow when changing between datetime units.
+
+    Returns
+    -------
+    str_arr : ndarray
+        An array of strings the same shape as `arr`.
+
+    Examples
+    --------
+    >>> import pytz
+    >>> d = np.arange('2002-10-27T04:30', 4*60, 60, dtype='M8[m]')
+    >>> d
+    array(['2002-10-27T04:30', '2002-10-27T05:30', '2002-10-27T06:30',
+           '2002-10-27T07:30'], dtype='datetime64[m]')
+
+    Setting the timezone to UTC shows the same information, but with a Z suffix
+
+    >>> np.datetime_as_string(d, timezone='UTC')
+    array(['2002-10-27T04:30Z', '2002-10-27T05:30Z', '2002-10-27T06:30Z',
+           '2002-10-27T07:30Z'], dtype='<U35')
+
+    Note that we picked datetimes that cross a DST boundary. Passing in a
+    ``pytz`` timezone object will print the appropriate offset
+
+    >>> np.datetime_as_string(d, timezone=pytz.timezone('US/Eastern'))
+    array(['2002-10-27T00:30-0400', '2002-10-27T01:30-0400',
+           '2002-10-27T01:30-0500', '2002-10-27T02:30-0500'], dtype='<U39')
+
+    Passing in a unit will change the precision
+
+    >>> np.datetime_as_string(d, unit='h')
+    array(['2002-10-27T04', '2002-10-27T05', '2002-10-27T06', '2002-10-27T07'],
+          dtype='<U32')
+    >>> np.datetime_as_string(d, unit='s')
+    array(['2002-10-27T04:30:00', '2002-10-27T05:30:00', '2002-10-27T06:30:00',
+           '2002-10-27T07:30:00'], dtype='<U38')
+
+    'casting' can be used to specify whether precision can be changed
+
+    >>> np.datetime_as_string(d, unit='h', casting='safe')
+    Traceback (most recent call last):
+        ...
+    TypeError: Cannot create a datetime string as units 'h' from a NumPy
+    datetime with units 'm' according to the rule 'safe'
+    " :arglists '[[& [args {:as kwargs}]]]} datetime_as_string (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "datetime_as_string"))))
+
+(def ^{:doc "datetime_data(dtype, /)
+
+    Get information about the step size of a date or time type.
+
+    The returned tuple can be passed as the second argument of `numpy.datetime64` and
+    `numpy.timedelta64`.
+
+    Parameters
+    ----------
+    dtype : dtype
+        The dtype object, which must be a `datetime64` or `timedelta64` type.
+
+    Returns
+    -------
+    unit : str
+        The :ref:`datetime unit <arrays.dtypes.dateunits>` on which this dtype
+        is based.
+    count : int
+        The number of base units in a step.
+
+    Examples
+    --------
+    >>> dt_25s = np.dtype('timedelta64[25s]')
+    >>> np.datetime_data(dt_25s)
+    ('s', 25)
+    >>> np.array(10, dt_25s).astype('timedelta64[s]')
+    array(250, dtype='timedelta64[s]')
+
+    The result can be used to construct a datetime that uses the same units
+    as a timedelta
+
+    >>> np.datetime64('2010', np.datetime_data(dt_25s))
+    numpy.datetime64('2010-01-01T00:00:00','25s')" :arglists '[[self & [args {:as kwargs}]]]} datetime_data (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "datetime_data"))))
+
+(def ^{:doc ""} nan ##NaN)
+
+(def ^{:doc "
+    Return the imaginary part of the complex argument.
+
+    Parameters
+    ----------
+    val : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray or scalar
+        The imaginary component of the complex argument. If `val` is real,
+        the type of `val` is used for the output.  If `val` has complex
+        elements, the returned type is float.
+
+    See Also
+    --------
+    real, angle, real_if_close
+
+    Examples
+    --------
+    >>> a = np.array([1+2j, 3+4j, 5+6j])
+    >>> a.imag
+    array([2.,  4.,  6.])
+    >>> a.imag = np.array([8, 10, 12])
+    >>> a
+    array([1. +8.j,  3.+10.j,  5.+12.j])
+    >>> np.imag(1 + 1j)
+    1.0
+
+    " :arglists '[[& [args {:as kwargs}]]]} imag (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "imag"))))
+
+(def ^{:doc "
+    Counts the number of non-zero values in the array ``a``.
+
+    The word \"non-zero\" is in reference to the Python 2.x
+    built-in method ``__nonzero__()`` (renamed ``__bool__()``
+    in Python 3.x) of Python objects that tests an object's
+    \"truthfulness\". For example, any number is considered
+    truthful if it is nonzero, whereas any string is considered
+    truthful if it is not the empty string. Thus, this function
+    (recursively) counts how many elements in ``a`` (and in
+    sub-arrays thereof) have their ``__nonzero__()`` or ``__bool__()``
+    method evaluated to ``True``.
+
+    Parameters
+    ----------
+    a : array_like
+        The array for which to count non-zeros.
+    axis : int or tuple, optional
+        Axis or tuple of axes along which to count non-zeros.
+        Default is None, meaning that non-zeros will be counted
+        along a flattened version of ``a``.
+
+        .. versionadded:: 1.12.0
+
+    keepdims : bool, optional
+        If this is set to True, the axes that are counted are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        .. versionadded:: 1.19.0
+
+    Returns
+    -------
+    count : int or array of int
+        Number of non-zero values in the array along a given axis.
+        Otherwise, the total number of non-zero values in the array
+        is returned.
+
+    See Also
+    --------
+    nonzero : Return the coordinates of all the non-zero values.
+
+    Examples
+    --------
+    >>> np.count_nonzero(np.eye(4))
+    4
+    >>> a = np.array([[0, 1, 7, 0],
+    ...               [3, 0, 2, 19]])
+    >>> np.count_nonzero(a)
+    5
+    >>> np.count_nonzero(a, axis=0)
+    array([1, 1, 2, 1])
+    >>> np.count_nonzero(a, axis=1)
+    array([2, 3])
+    >>> np.count_nonzero(a, axis=1, keepdims=True)
+    array([[2],
+           [3]])
+    " :arglists '[[& [args {:as kwargs}]]]} count_nonzero (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "count_nonzero"))))
+
+(def ^{:doc "Extended-precision floating-point number type, compatible with C
+    ``long double`` but not necessarily with IEEE 754 quadruple-precision.
+
+    :Character code: ``'g'``
+    :Canonical name: `numpy.longdouble`
+    :Alias: `numpy.longfloat`
+    :Alias on this platform: `numpy.float128`: 128-bit extended-precision floating-point number type." :arglists '[[self & [args {:as kwargs}]]]} float128 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float128"))))
+
+(def ^{:doc "greater(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the truth value of (x1 > x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+
+See Also
+--------
+greater_equal, less, less_equal, equal, not_equal
+
+Examples
+--------
+>>> np.greater([4,2],[2,2])
+array([ True, False])
+
+The ``>`` operator can be used as a shorthand for ``np.greater`` on
+ndarrays.
+
+>>> a = np.array([4, 2])
+>>> b = np.array([2, 2])
+>>> a > b
+array([ True, False])" :arglists '[[self & [args {:as kwargs}]]]} greater (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "greater"))))
+
+(def ^{:doc "
+    Return a sorted copy of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Array to be sorted.
+    axis : int or None, optional
+        Axis along which to sort. If None, the array is flattened before
+        sorting. The default is -1, which sorts along the last axis.
+    kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
+        Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
+        and 'mergesort' use timsort or radix sort under the covers and, in general,
+        the actual implementation will vary with data type. The 'mergesort' option
+        is retained for backwards compatibility.
+
+        .. versionchanged:: 1.15.0.
+           The 'stable' option was added.
+
+    order : str or list of str, optional
+        When `a` is an array with fields defined, this argument specifies
+        which fields to compare first, second, etc.  A single field can
+        be specified as a string, and not all fields need be specified,
+        but unspecified fields will still be used, in the order in which
+        they come up in the dtype, to break ties.
+
+    Returns
+    -------
+    sorted_array : ndarray
+        Array of the same type and shape as `a`.
+
+    See Also
+    --------
+    ndarray.sort : Method to sort an array in-place.
+    argsort : Indirect sort.
+    lexsort : Indirect stable sort on multiple keys.
+    searchsorted : Find elements in a sorted array.
+    partition : Partial sort.
+
+    Notes
+    -----
+    The various sorting algorithms are characterized by their average speed,
+    worst case performance, work space size, and whether they are stable. A
+    stable sort keeps items with the same key in the same relative
+    order. The four algorithms implemented in NumPy have the following
+    properties:
+
+    =========== ======= ============= ============ ========
+       kind      speed   worst case    work space   stable
+    =========== ======= ============= ============ ========
+    'quicksort'    1     O(n^2)            0          no
+    'heapsort'     3     O(n*log(n))       0          no
+    'mergesort'    2     O(n*log(n))      ~n/2        yes
+    'timsort'      2     O(n*log(n))      ~n/2        yes
+    =========== ======= ============= ============ ========
+
+    .. note:: The datatype determines which of 'mergesort' or 'timsort'
+       is actually used, even if 'mergesort' is specified. User selection
+       at a finer scale is not currently available.
+
+    All the sort algorithms make temporary copies of the data when
+    sorting along any but the last axis.  Consequently, sorting along
+    the last axis is faster and uses less space than sorting along
+    any other axis.
+
+    The sort order for complex numbers is lexicographic. If both the real
+    and imaginary parts are non-nan then the order is determined by the
+    real parts except when they are equal, in which case the order is
+    determined by the imaginary parts.
+
+    Previous to numpy 1.4.0 sorting real and complex arrays containing nan
+    values led to undefined behaviour. In numpy versions >= 1.4.0 nan
+    values are sorted to the end. The extended sort order is:
+
+      * Real: [R, nan]
+      * Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]
+
+    where R is a non-nan real value. Complex values with the same nan
+    placements are sorted according to the non-nan part if it exists.
+    Non-nan values are sorted as before.
+
+    .. versionadded:: 1.12.0
+
+    quicksort has been changed to `introsort <https://en.wikipedia.org/wiki/Introsort>`_.
+    When sorting does not make enough progress it switches to
+    `heapsort <https://en.wikipedia.org/wiki/Heapsort>`_.
+    This implementation makes quicksort O(n*log(n)) in the worst case.
+
+    'stable' automatically chooses the best stable sorting algorithm
+    for the data type being sorted.
+    It, along with 'mergesort' is currently mapped to
+    `timsort <https://en.wikipedia.org/wiki/Timsort>`_
+    or `radix sort <https://en.wikipedia.org/wiki/Radix_sort>`_
+    depending on the data type.
+    API forward compatibility currently limits the
+    ability to select the implementation and it is hardwired for the different
+    data types.
+
+    .. versionadded:: 1.17.0
+
+    Timsort is added for better performance on already or nearly
+    sorted data. On random data timsort is almost identical to
+    mergesort. It is now used for stable sort while quicksort is still the
+    default sort if none is chosen. For timsort details, refer to
+    `CPython listsort.txt <https://github.com/python/cpython/blob/3.7/Objects/listsort.txt>`_.
+    'mergesort' and 'stable' are mapped to radix sort for integer data types. Radix sort is an
+    O(n) sort instead of O(n log n).
+
+    .. versionchanged:: 1.18.0
+
+    NaT now sorts to the end of arrays for consistency with NaN.
+
+    Examples
+    --------
+    >>> a = np.array([[1,4],[3,1]])
+    >>> np.sort(a)                # sort along the last axis
+    array([[1, 4],
+           [1, 3]])
+    >>> np.sort(a, axis=None)     # sort the flattened array
+    array([1, 1, 3, 4])
+    >>> np.sort(a, axis=0)        # sort along the first axis
+    array([[1, 1],
+           [3, 4]])
+
+    Use the `order` keyword to specify a field to use when sorting a
+    structured array:
+
+    >>> dtype = [('name', 'S10'), ('height', float), ('age', int)]
+    >>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),
+    ...           ('Galahad', 1.7, 38)]
+    >>> a = np.array(values, dtype=dtype)       # create a structured array
+    >>> np.sort(a, order='height')                        # doctest: +SKIP
+    array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),
+           ('Lancelot', 1.8999999999999999, 38)],
+          dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])
+
+    Sort by age, then height if ages are equal:
+
+    >>> np.sort(a, order=['age', 'height'])               # doctest: +SKIP
+    array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),
+           ('Arthur', 1.8, 41)],
+          dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])
+
+    " :arglists '[[& [args {:as kwargs}]]]} sort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sort"))))
+
+(def ^{:doc "
+    A one-dimensional polynomial class.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide </reference/routines.polynomials>`.
+
+    A convenience class, used to encapsulate \"natural\" operations on
+    polynomials so that said operations may take on their customary
+    form in code (see Examples).
+
+    Parameters
+    ----------
+    c_or_r : array_like
+        The polynomial's coefficients, in decreasing powers, or if
+        the value of the second parameter is True, the polynomial's
+        roots (values where the polynomial evaluates to 0).  For example,
+        ``poly1d([1, 2, 3])`` returns an object that represents
+        :math:`x^2 + 2x + 3`, whereas ``poly1d([1, 2, 3], True)`` returns
+        one that represents :math:`(x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x -6`.
+    r : bool, optional
+        If True, `c_or_r` specifies the polynomial's roots; the default
+        is False.
+    variable : str, optional
+        Changes the variable used when printing `p` from `x` to `variable`
+        (see Examples).
+
+    Examples
+    --------
+    Construct the polynomial :math:`x^2 + 2x + 3`:
+
+    >>> p = np.poly1d([1, 2, 3])
+    >>> print(np.poly1d(p))
+       2
+    1 x + 2 x + 3
+
+    Evaluate the polynomial at :math:`x = 0.5`:
+
+    >>> p(0.5)
+    4.25
+
+    Find the roots:
+
+    >>> p.r
+    array([-1.+1.41421356j, -1.-1.41421356j])
+    >>> p(p.r)
+    array([ -4.44089210e-16+0.j,  -4.44089210e-16+0.j]) # may vary
+
+    These numbers in the previous line represent (0, 0) to machine precision
+
+    Show the coefficients:
+
+    >>> p.c
+    array([1, 2, 3])
+
+    Display the order (the leading zero-coefficients are removed):
+
+    >>> p.order
+    2
+
+    Show the coefficient of the k-th power in the polynomial
+    (which is equivalent to ``p.c[-(i+1)]``):
+
+    >>> p[1]
+    2
+
+    Polynomials can be added, subtracted, multiplied, and divided
+    (returns quotient and remainder):
+
+    >>> p * p
+    poly1d([ 1,  4, 10, 12,  9])
+
+    >>> (p**3 + 4) / p
+    (poly1d([ 1.,  4., 10., 12.,  9.]), poly1d([4.]))
+
+    ``asarray(p)`` gives the coefficient array, so polynomials can be
+    used in all functions that accept arrays:
+
+    >>> p**2 # square of polynomial
+    poly1d([ 1,  4, 10, 12,  9])
+
+    >>> np.square(p) # square of individual coefficients
+    array([1, 4, 9])
+
+    The variable used in the string representation of `p` can be modified,
+    using the `variable` parameter:
+
+    >>> p = np.poly1d([1,2,3], variable='z')
+    >>> print(p)
+       2
+    1 z + 2 z + 3
+
+    Construct a polynomial from its roots:
+
+    >>> np.poly1d([1, 2], True)
+    poly1d([ 1., -3.,  2.])
+
+    This is the same polynomial as obtained by:
+
+    >>> np.poly1d([1, -1]) * np.poly1d([1, -2])
+    poly1d([ 1, -3,  2])
+
+    " :arglists '[[self c_or_r & [{r :r, variable :variable}]] [self c_or_r & [{r :r}]] [self c_or_r]]} poly1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "poly1d"))))
+
+(def ^{:doc "isfinite(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Test element-wise for finiteness (not infinity or not Not a Number).
+
+The result is returned as a boolean array.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray, bool
+    True where ``x`` is not positive infinity, negative infinity,
+    or NaN; false otherwise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+isinf, isneginf, isposinf, isnan
+
+Notes
+-----
+Not a Number, positive infinity and negative infinity are considered
+to be non-finite.
+
+NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+(IEEE 754). This means that Not a Number is not equivalent to infinity.
+Also that positive infinity is not equivalent to negative infinity. But
+infinity is equivalent to positive infinity.  Errors result if the
+second argument is also supplied when `x` is a scalar input, or if
+first and second arguments have different shapes.
+
+Examples
+--------
+>>> np.isfinite(1)
+True
+>>> np.isfinite(0)
+True
+>>> np.isfinite(np.nan)
+False
+>>> np.isfinite(np.inf)
+False
+>>> np.isfinite(np.NINF)
+False
+>>> np.isfinite([np.log(-1.),1.,np.log(0)])
+array([False,  True, False])
+
+>>> x = np.array([-np.inf, 0., np.inf])
+>>> y = np.array([2, 2, 2])
+>>> np.isfinite(x, y)
+array([0, 1, 0])
+>>> y
+array([0, 1, 0])" :arglists '[[self & [args {:as kwargs}]]]} isfinite (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isfinite"))))
+
+(def ^{:doc "log(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Natural logarithm, element-wise.
+
+The natural logarithm `log` is the inverse of the exponential function,
+so that `log(exp(x)) = x`. The natural logarithm is logarithm in base
+`e`.
+
+Parameters
+----------
+x : array_like
+    Input value.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The natural logarithm of `x`, element-wise.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+log10, log2, log1p, emath.log
+
+Notes
+-----
+Logarithm is a multivalued function: for each `x` there is an infinite
+number of `z` such that `exp(z) = x`. The convention is to return the
+`z` whose imaginary part lies in `[-pi, pi]`.
+
+For real-valued input data types, `log` always returns real output. For
+each value that cannot be expressed as a real number or infinity, it
+yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `log` is a complex analytical function that
+has a branch cut `[-inf, 0]` and is continuous from above on it. `log`
+handles the floating-point negative zero as an infinitesimal negative
+number, conforming to the C99 standard.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm
+
+Examples
+--------
+>>> np.log([1, np.e, np.e**2, 0])
+array([  0.,   1.,   2., -Inf])" :arglists '[[self & [args {:as kwargs}]]]} log (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log"))))
+
+(def ^{:doc "Complex number type composed of two double-precision floating-point
+    numbers, compatible with Python `complex`.
+
+    :Character code: ``'D'``
+    :Canonical name: `numpy.cdouble`
+    :Alias: `numpy.cfloat`
+    :Alias: `numpy.complex_`
+    :Alias on this platform: `numpy.complex128`: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} complex128 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex128"))))
+
+(def ^{:doc "
+    Construct an array by executing a function over each coordinate.
+
+    The resulting array therefore has a value ``fn(x, y, z)`` at
+    coordinate ``(x, y, z)``.
+
+    Parameters
+    ----------
+    function : callable
+        The function is called with N parameters, where N is the rank of
+        `shape`.  Each parameter represents the coordinates of the array
+        varying along a specific axis.  For example, if `shape`
+        were ``(2, 2)``, then the parameters would be
+        ``array([[0, 0], [1, 1]])`` and ``array([[0, 1], [0, 1]])``
+    shape : (N,) tuple of ints
+        Shape of the output array, which also determines the shape of
+        the coordinate arrays passed to `function`.
+    dtype : data-type, optional
+        Data-type of the coordinate arrays passed to `function`.
+        By default, `dtype` is float.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    fromfunction : any
+        The result of the call to `function` is passed back directly.
+        Therefore the shape of `fromfunction` is completely determined by
+        `function`.  If `function` returns a scalar value, the shape of
+        `fromfunction` would not match the `shape` parameter.
+
+    See Also
+    --------
+    indices, meshgrid
+
+    Notes
+    -----
+    Keywords other than `dtype` are passed to `function`.
+
+    Examples
+    --------
+    >>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)
+    array([[ True, False, False],
+           [False,  True, False],
+           [False, False,  True]])
+
+    >>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)
+    array([[0, 1, 2],
+           [1, 2, 3],
+           [2, 3, 4]])
+
+    " :arglists '[[function shape & [{dtype :dtype, like :like, :as kwargs}]]]} fromfunction (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromfunction"))))
+
+(def ^{:doc "
+    Return the cumulative product of array elements over a given axis treating Not a
+    Numbers (NaNs) as one.  The cumulative product does not change when NaNs are
+    encountered and leading NaNs are replaced by ones.
+
+    Ones are returned for slices that are all-NaN or empty.
+
+    .. versionadded:: 1.12.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        Axis along which the cumulative product is computed.  By default
+        the input is flattened.
+    dtype : dtype, optional
+        Type of the returned array, as well as of the accumulator in which
+        the elements are multiplied.  If *dtype* is not specified, it
+        defaults to the dtype of `a`, unless `a` has an integer dtype with
+        a precision less than that of the default platform integer.  In
+        that case, the default platform integer is used instead.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type of the resulting values will be cast if necessary.
+
+    Returns
+    -------
+    nancumprod : ndarray
+        A new array holding the result is returned unless `out` is
+        specified, in which case it is returned.
+
+    See Also
+    --------
+    numpy.cumprod : Cumulative product across array propagating NaNs.
+    isnan : Show which elements are NaN.
+
+    Examples
+    --------
+    >>> np.nancumprod(1)
+    array([1])
+    >>> np.nancumprod([1])
+    array([1])
+    >>> np.nancumprod([1, np.nan])
+    array([1.,  1.])
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nancumprod(a)
+    array([1.,  2.,  6.,  6.])
+    >>> np.nancumprod(a, axis=0)
+    array([[1.,  2.],
+           [3.,  2.]])
+    >>> np.nancumprod(a, axis=1)
+    array([[1.,  2.],
+           [3.,  3.]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} nancumprod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nancumprod"))))
+
+(def ^{:doc "divmod(x1, x2[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return element-wise quotient and remainder simultaneously.
+
+.. versionadded:: 1.13.0
+
+``np.divmod(x, y)`` is equivalent to ``(x // y, x % y)``, but faster
+because it avoids redundant work. It is used to implement the Python
+built-in function ``divmod`` on NumPy arrays.
+
+Parameters
+----------
+x1 : array_like
+    Dividend array.
+x2 : array_like
+    Divisor array.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out1 : ndarray
+    Element-wise quotient resulting from floor division.
+    This is a scalar if both `x1` and `x2` are scalars.
+out2 : ndarray
+    Element-wise remainder from floor division.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+floor_divide : Equivalent to Python's ``//`` operator.
+remainder : Equivalent to Python's ``%`` operator.
+modf : Equivalent to ``divmod(x, 1)`` for positive ``x`` with the return
+       values switched.
+
+Examples
+--------
+>>> np.divmod(np.arange(5), 3)
+(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))
+
+The `divmod` function can be used as a shorthand for ``np.divmod`` on
+ndarrays.
+
+>>> x = np.arange(5)
+>>> divmod(x, 3)
+(array([0, 0, 0, 1, 1]), array([0, 1, 2, 0, 1]))" :arglists '[[self & [args {:as kwargs}]]]} divmod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "divmod"))))
+
+(def ^{:doc ""} ERR_DEFAULT 521)
+
+(def ^{:doc "
+    Return the indices to access the main diagonal of an n-dimensional array.
+
+    See `diag_indices` for full details.
+
+    Parameters
+    ----------
+    arr : array, at least 2-D
+
+    See Also
+    --------
+    diag_indices
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    " :arglists '[[& [args {:as kwargs}]]]} diag_indices_from (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diag_indices_from"))))
+
+(def ^{:doc "
+    Save an array to a text file.
+
+    Parameters
+    ----------
+    fname : filename or file handle
+        If the filename ends in ``.gz``, the file is automatically saved in
+        compressed gzip format.  `loadtxt` understands gzipped files
+        transparently.
+    X : 1D or 2D array_like
+        Data to be saved to a text file.
+    fmt : str or sequence of strs, optional
+        A single format (%10.5f), a sequence of formats, or a
+        multi-format string, e.g. 'Iteration %d -- %10.5f', in which
+        case `delimiter` is ignored. For complex `X`, the legal options
+        for `fmt` are:
+
+        * a single specifier, `fmt='%.4e'`, resulting in numbers formatted
+          like `' (%s+%sj)' % (fmt, fmt)`
+        * a full string specifying every real and imaginary part, e.g.
+          `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns
+        * a list of specifiers, one per column - in this case, the real
+          and imaginary part must have separate specifiers,
+          e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns
+    delimiter : str, optional
+        String or character separating columns.
+    newline : str, optional
+        String or character separating lines.
+
+        .. versionadded:: 1.5.0
+    header : str, optional
+        String that will be written at the beginning of the file.
+
+        .. versionadded:: 1.7.0
+    footer : str, optional
+        String that will be written at the end of the file.
+
+        .. versionadded:: 1.7.0
+    comments : str, optional
+        String that will be prepended to the ``header`` and ``footer`` strings,
+        to mark them as comments. Default: '# ',  as expected by e.g.
+        ``numpy.loadtxt``.
+
+        .. versionadded:: 1.7.0
+    encoding : {None, str}, optional
+        Encoding used to encode the outputfile. Does not apply to output
+        streams. If the encoding is something other than 'bytes' or 'latin1'
+        you will not be able to load the file in NumPy versions < 1.14. Default
+        is 'latin1'.
+
+        .. versionadded:: 1.14.0
+
+
+    See Also
+    --------
+    save : Save an array to a binary file in NumPy ``.npy`` format
+    savez : Save several arrays into an uncompressed ``.npz`` archive
+    savez_compressed : Save several arrays into a compressed ``.npz`` archive
+
+    Notes
+    -----
+    Further explanation of the `fmt` parameter
+    (``%[flag]width[.precision]specifier``):
+
+    flags:
+        ``-`` : left justify
+
+        ``+`` : Forces to precede result with + or -.
+
+        ``0`` : Left pad the number with zeros instead of space (see width).
+
+    width:
+        Minimum number of characters to be printed. The value is not truncated
+        if it has more characters.
+
+    precision:
+        - For integer specifiers (eg. ``d,i,o,x``), the minimum number of
+          digits.
+        - For ``e, E`` and ``f`` specifiers, the number of digits to print
+          after the decimal point.
+        - For ``g`` and ``G``, the maximum number of significant digits.
+        - For ``s``, the maximum number of characters.
+
+    specifiers:
+        ``c`` : character
+
+        ``d`` or ``i`` : signed decimal integer
+
+        ``e`` or ``E`` : scientific notation with ``e`` or ``E``.
+
+        ``f`` : decimal floating point
+
+        ``g,G`` : use the shorter of ``e,E`` or ``f``
+
+        ``o`` : signed octal
+
+        ``s`` : string of characters
+
+        ``u`` : unsigned decimal integer
+
+        ``x,X`` : unsigned hexadecimal integer
+
+    This explanation of ``fmt`` is not complete, for an exhaustive
+    specification see [1]_.
+
+    References
+    ----------
+    .. [1] `Format Specification Mini-Language
+           <https://docs.python.org/library/string.html#format-specification-mini-language>`_,
+           Python Documentation.
+
+    Examples
+    --------
+    >>> x = y = z = np.arange(0.0,5.0,1.0)
+    >>> np.savetxt('test.out', x, delimiter=',')   # X is an array
+    >>> np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays
+    >>> np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation
+
+    " :arglists '[[& [args {:as kwargs}]]]} savetxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "savetxt"))))
+
+(def ^{:doc "A timedelta stored as a 64-bit integer.
+    
+    See :ref:`arrays.datetime` for more information.
+
+    :Character code: ``'m'``" :arglists '[[self & [args {:as kwargs}]]]} timedelta64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "timedelta64"))))
+
+(def ^{:doc "
+    View inputs as arrays with at least three dimensions.
+
+    Parameters
+    ----------
+    arys1, arys2, ... : array_like
+        One or more array-like sequences.  Non-array inputs are converted to
+        arrays.  Arrays that already have three or more dimensions are
+        preserved.
+
+    Returns
+    -------
+    res1, res2, ... : ndarray
+        An array, or list of arrays, each with ``a.ndim >= 3``.  Copies are
+        avoided where possible, and views with three or more dimensions are
+        returned.  For example, a 1-D array of shape ``(N,)`` becomes a view
+        of shape ``(1, N, 1)``, and a 2-D array of shape ``(M, N)`` becomes a
+        view of shape ``(M, N, 1)``.
+
+    See Also
+    --------
+    atleast_1d, atleast_2d
+
+    Examples
+    --------
+    >>> np.atleast_3d(3.0)
+    array([[[3.]]])
+
+    >>> x = np.arange(3.0)
+    >>> np.atleast_3d(x).shape
+    (1, 3, 1)
+
+    >>> x = np.arange(12.0).reshape(4,3)
+    >>> np.atleast_3d(x).shape
+    (4, 3, 1)
+    >>> np.atleast_3d(x).base is x.base  # x is a reshape, so not base itself
+    True
+
+    >>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):
+    ...     print(arr, arr.shape) # doctest: +SKIP
+    ...
+    [[[1]
+      [2]]] (1, 2, 1)
+    [[[1]
+      [2]]] (1, 2, 1)
+    [[[1 2]]] (1, 1, 2)
+
+    " :arglists '[[& [args {:as kwargs}]]]} atleast_3d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "atleast_3d"))))
+
+(def ^{:doc "ndarray(shape, dtype=float, buffer=None, offset=0,
+            strides=None, order=None)
+
+    An array object represents a multidimensional, homogeneous array
+    of fixed-size items.  An associated data-type object describes the
+    format of each element in the array (its byte-order, how many bytes it
+    occupies in memory, whether it is an integer, a floating point number,
+    or something else, etc.)
+
+    Arrays should be constructed using `array`, `zeros` or `empty` (refer
+    to the See Also section below).  The parameters given here refer to
+    a low-level method (`ndarray(...)`) for instantiating an array.
+
+    For more information, refer to the `numpy` module and examine the
+    methods and attributes of an array.
+
+    Parameters
+    ----------
+    (for the __new__ method; see Notes below)
+
+    shape : tuple of ints
+        Shape of created array.
+    dtype : data-type, optional
+        Any object that can be interpreted as a numpy data type.
+    buffer : object exposing buffer interface, optional
+        Used to fill the array with data.
+    offset : int, optional
+        Offset of array data in buffer.
+    strides : tuple of ints, optional
+        Strides of data in memory.
+    order : {'C', 'F'}, optional
+        Row-major (C-style) or column-major (Fortran-style) order.
+
+    Attributes
+    ----------
+    T : ndarray
+        Transpose of the array.
+    data : buffer
+        The array's elements, in memory.
+    dtype : dtype object
+        Describes the format of the elements in the array.
+    flags : dict
+        Dictionary containing information related to memory use, e.g.,
+        'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.
+    flat : numpy.flatiter object
+        Flattened version of the array as an iterator.  The iterator
+        allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for
+        assignment examples; TODO).
+    imag : ndarray
+        Imaginary part of the array.
+    real : ndarray
+        Real part of the array.
+    size : int
+        Number of elements in the array.
+    itemsize : int
+        The memory use of each array element in bytes.
+    nbytes : int
+        The total number of bytes required to store the array data,
+        i.e., ``itemsize * size``.
+    ndim : int
+        The array's number of dimensions.
+    shape : tuple of ints
+        Shape of the array.
+    strides : tuple of ints
+        The step-size required to move from one element to the next in
+        memory. For example, a contiguous ``(3, 4)`` array of type
+        ``int16`` in C-order has strides ``(8, 2)``.  This implies that
+        to move from element to element in memory requires jumps of 2 bytes.
+        To move from row-to-row, one needs to jump 8 bytes at a time
+        (``2 * 4``).
+    ctypes : ctypes object
+        Class containing properties of the array needed for interaction
+        with ctypes.
+    base : ndarray
+        If the array is a view into another array, that array is its `base`
+        (unless that array is also a view).  The `base` array is where the
+        array data is actually stored.
+
+    See Also
+    --------
+    array : Construct an array.
+    zeros : Create an array, each element of which is zero.
+    empty : Create an array, but leave its allocated memory unchanged (i.e.,
+            it contains \"garbage\").
+    dtype : Create a data-type.
+
+    Notes
+    -----
+    There are two modes of creating an array using ``__new__``:
+
+    1. If `buffer` is None, then only `shape`, `dtype`, and `order`
+       are used.
+    2. If `buffer` is an object exposing the buffer interface, then
+       all keywords are interpreted.
+
+    No ``__init__`` method is needed because the array is fully initialized
+    after the ``__new__`` method.
+
+    Examples
+    --------
+    These examples illustrate the low-level `ndarray` constructor.  Refer
+    to the `See Also` section above for easier ways of constructing an
+    ndarray.
+
+    First mode, `buffer` is None:
+
+    >>> np.ndarray(shape=(2,2), dtype=float, order='F')
+    array([[0.0e+000, 0.0e+000], # random
+           [     nan, 2.5e-323]])
+
+    Second mode:
+
+    >>> np.ndarray((2,), buffer=np.array([1,2,3]),
+    ...            offset=np.int_().itemsize,
+    ...            dtype=int) # offset = 1*itemsize, i.e. skip first element
+    array([2, 3])" :arglists '[[self & [args {:as kwargs}]]]} ndarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndarray"))))
+
+(def ^{:doc "
+    Return the product of array elements over a given axis.
+
+    See Also
+    --------
+    prod : equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]]} product (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "product"))))
+
+(def ^{:doc "Built-in mutable sequence.
+
+If no argument is given, the constructor creates a new empty list.
+The argument must be an iterable if specified."} __path__ (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* "__path__")))) 
+
+(def ^{:doc "
+    Range of values (maximum - minimum) along an axis.
+
+    The name of the function comes from the acronym for 'peak to peak'.
+
+    .. warning::
+        `ptp` preserves the data type of the array. This means the
+        return value for an input of signed integers with n bits
+        (e.g. `np.int8`, `np.int16`, etc) is also a signed integer
+        with n bits.  In that case, peak-to-peak values greater than
+        ``2**(n-1)-1`` will be returned as negative values. An example
+        with a work-around is shown below.
+
+    Parameters
+    ----------
+    a : array_like
+        Input values.
+    axis : None or int or tuple of ints, optional
+        Axis along which to find the peaks.  By default, flatten the
+        array.  `axis` may be negative, in
+        which case it counts from the last to the first axis.
+
+        .. versionadded:: 1.15.0
+
+        If this is a tuple of ints, a reduction is performed on multiple
+        axes, instead of a single axis or all the axes as before.
+    out : array_like
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type of the output values will be cast if necessary.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `ptp` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    Returns
+    -------
+    ptp : ndarray
+        A new array holding the result, unless `out` was
+        specified, in which case a reference to `out` is returned.
+
+    Examples
+    --------
+    >>> x = np.array([[4, 9, 2, 10],
+    ...               [6, 9, 7, 12]])
+
+    >>> np.ptp(x, axis=1)
+    array([8, 6])
+
+    >>> np.ptp(x, axis=0)
+    array([2, 0, 5, 2])
+
+    >>> np.ptp(x)
+    10
+
+    This example shows that a negative value can be returned when
+    the input is an array of signed integers.
+
+    >>> y = np.array([[1, 127],
+    ...               [0, 127],
+    ...               [-1, 127],
+    ...               [-2, 127]], dtype=np.int8)
+    >>> np.ptp(y, axis=1)
+    array([ 126,  127, -128, -127], dtype=int8)
+
+    A work-around is to use the `view()` method to view the result as
+    unsigned integers with the same bit width:
+
+    >>> np.ptp(y, axis=1).view(np.uint8)
+    array([126, 127, 128, 129], dtype=uint8)
+
+    " :arglists '[[& [args {:as kwargs}]]]} ptp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ptp"))))
+
+(def ^{:doc "Abstract base class of all floating-point scalar types." :arglists '[[self & [args {:as kwargs}]]]} floating (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "floating"))))
+
+(def ^{:doc "arctan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Trigonometric inverse tangent, element-wise.
+
+The inverse of tan, so that if ``y = tan(x)`` then ``x = arctan(y)``.
+
+Parameters
+----------
+x : array_like
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Out has the same shape as `x`.  Its real part is in
+    ``[-pi/2, pi/2]`` (``arctan(+/-inf)`` returns ``+/-pi/2``).
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+arctan2 : The \"four quadrant\" arctan of the angle formed by (`x`, `y`)
+    and the positive `x`-axis.
+angle : Argument of complex values.
+
+Notes
+-----
+`arctan` is a multi-valued function: for each `x` there are infinitely
+many numbers `z` such that tan(`z`) = `x`.  The convention is to return
+the angle `z` whose real part lies in [-pi/2, pi/2].
+
+For real-valued input data types, `arctan` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arctan` is a complex analytic function that
+has [`1j, infj`] and [`-1j, -infj`] as branch cuts, and is continuous
+from the left on the former and from the right on the latter.
+
+The inverse tangent is also known as `atan` or tan^{-1}.
+
+References
+----------
+Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
+10th printing, New York: Dover, 1964, pp. 79.
+http://www.math.sfu.ca/~cbm/aands/
+
+Examples
+--------
+We expect the arctan of 0 to be 0, and of 1 to be pi/4:
+
+>>> np.arctan([0, 1])
+array([ 0.        ,  0.78539816])
+
+>>> np.pi/4
+0.78539816339744828
+
+Plot arctan:
+
+>>> import matplotlib.pyplot as plt
+>>> x = np.linspace(-10, 10)
+>>> plt.plot(x, np.arctan(x))
+>>> plt.axis('tight')
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]]} arctan (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arctan"))))
+
+(def ^{:doc "fromstring(string, dtype=float, count=-1, sep='', *, like=None)
+
+    A new 1-D array initialized from text data in a string.
+
+    Parameters
+    ----------
+    string : str
+        A string containing the data.
+    dtype : data-type, optional
+        The data type of the array; default: float.  For binary input data,
+        the data must be in exactly this format. Most builtin numeric types are
+        supported and extension types may be supported.
+
+        .. versionadded:: 1.18.0
+            Complex dtypes.
+
+    count : int, optional
+        Read this number of `dtype` elements from the data.  If this is
+        negative (the default), the count will be determined from the
+        length of the data.
+    sep : str, optional
+        The string separating numbers in the data; extra whitespace between
+        elements is also ignored.
+
+        .. deprecated:: 1.14
+            Passing ``sep=''``, the default, is deprecated since it will
+            trigger the deprecated binary mode of this function. This mode
+            interprets `string` as binary bytes, rather than ASCII text with
+            decimal numbers, an operation which is better spelt
+            ``frombuffer(string, dtype, count)``. If `string` contains unicode
+            text, the binary mode of `fromstring` will first encode it into
+            bytes using either utf-8 (python 3) or the default encoding
+            (python 2), neither of which produce sane results.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    arr : ndarray
+        The constructed array.
+
+    Raises
+    ------
+    ValueError
+        If the string is not the correct size to satisfy the requested
+        `dtype` and `count`.
+
+    See Also
+    --------
+    frombuffer, fromfile, fromiter
+
+    Examples
+    --------
+    >>> np.fromstring('1 2', dtype=int, sep=' ')
+    array([1, 2])
+    >>> np.fromstring('1, 2', dtype=int, sep=',')
+    array([1, 2])" :arglists '[[self & [args {:as kwargs}]]]} fromstring (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromstring"))))
+
+(def ^{:doc "Special keyword value.
+
+    The instance of this class may be used as the default value assigned to a
+    deprecated keyword in order to check if it has been given a user defined
+    value.
+    "} _NoValue (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_NoValue"))))
+
+(def ^{:doc "Abstract base class of all signed integer scalar types." :arglists '[[self & [args {:as kwargs}]]]} signedinteger (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "signedinteger"))))
+
+(def ^{:doc "
+    Test whether any array element along a given axis evaluates to True.
+
+    Returns single boolean unless `axis` is not ``None``
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a logical OR reduction is performed.
+        The default (``axis=None``) is to perform a logical OR over all
+        the dimensions of the input array. `axis` may be negative, in
+        which case it counts from the last to the first axis.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a reduction is performed on multiple
+        axes, instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  It must have
+        the same shape as the expected output and its type is preserved
+        (e.g., if it is of type float, then it will remain so, returning
+        1.0 for True and 0.0 for False, regardless of the type of `a`).
+        See :ref:`ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `any` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    where : array_like of bool, optional
+        Elements to include in checking for any `True` values.
+        See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    any : bool or ndarray
+        A new boolean or `ndarray` is returned unless `out` is specified,
+        in which case a reference to `out` is returned.
+
+    See Also
+    --------
+    ndarray.any : equivalent method
+
+    all : Test whether all elements along a given axis evaluate to True.
+
+    Notes
+    -----
+    Not a Number (NaN), positive infinity and negative infinity evaluate
+    to `True` because these are not equal to zero.
+
+    Examples
+    --------
+    >>> np.any([[True, False], [True, True]])
+    True
+
+    >>> np.any([[True, False], [False, False]], axis=0)
+    array([ True, False])
+
+    >>> np.any([-1, 0, 5])
+    True
+
+    >>> np.any(np.nan)
+    True
+
+    >>> np.any([[True, False], [False, False]], where=[[False], [True]])
+    False
+
+    >>> o=np.array(False)
+    >>> z=np.any([-1, 4, 5], out=o)
+    >>> z, o
+    (array(True), array(True))
+    >>> # Check now that z is a reference to o
+    >>> z is o
+    True
+    >>> id(z), id(o) # identity of z and o              # doctest: +SKIP
+    (191614240, 191614240)
+
+    " :arglists '[[& [args {:as kwargs}]]]} any (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "any"))))
+
+(def ^{:doc "
+    Return the angle of the complex argument.
+
+    Parameters
+    ----------
+    z : array_like
+        A complex number or sequence of complex numbers.
+    deg : bool, optional
+        Return angle in degrees if True, radians if False (default).
+
+    Returns
+    -------
+    angle : ndarray or scalar
+        The counterclockwise angle from the positive real axis on the complex
+        plane in the range ``(-pi, pi]``, with dtype as numpy.float64.
+
+        .. versionchanged:: 1.16.0
+            This function works on subclasses of ndarray like `ma.array`.
+
+    See Also
+    --------
+    arctan2
+    absolute
+
+    Notes
+    -----
+    Although the angle of the complex number 0 is undefined, ``numpy.angle(0)``
+    returns the value 0.
+
+    Examples
+    --------
+    >>> np.angle([1.0, 1.0j, 1+1j])               # in radians
+    array([ 0.        ,  1.57079633,  0.78539816]) # may vary
+    >>> np.angle(1+1j, deg=True)                  # in degrees
+    45.0
+
+    " :arglists '[[& [args {:as kwargs}]]]} angle (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "angle"))))
+
+(def ^{:doc "
+    Gives a new shape to an array without changing its data.
+
+    Parameters
+    ----------
+    a : array_like
+        Array to be reshaped.
+    newshape : int or tuple of ints
+        The new shape should be compatible with the original shape. If
+        an integer, then the result will be a 1-D array of that length.
+        One shape dimension can be -1. In this case, the value is
+        inferred from the length of the array and remaining dimensions.
+    order : {'C', 'F', 'A'}, optional
+        Read the elements of `a` using this index order, and place the
+        elements into the reshaped array using this index order.  'C'
+        means to read / write the elements using C-like index order,
+        with the last axis index changing fastest, back to the first
+        axis index changing slowest. 'F' means to read / write the
+        elements using Fortran-like index order, with the first index
+        changing fastest, and the last index changing slowest. Note that
+        the 'C' and 'F' options take no account of the memory layout of
+        the underlying array, and only refer to the order of indexing.
+        'A' means to read / write the elements in Fortran-like index
+        order if `a` is Fortran *contiguous* in memory, C-like order
+        otherwise.
+
+    Returns
+    -------
+    reshaped_array : ndarray
+        This will be a new view object if possible; otherwise, it will
+        be a copy.  Note there is no guarantee of the *memory layout* (C- or
+        Fortran- contiguous) of the returned array.
+
+    See Also
+    --------
+    ndarray.reshape : Equivalent method.
+
+    Notes
+    -----
+    It is not always possible to change the shape of an array without
+    copying the data. If you want an error to be raised when the data is copied,
+    you should assign the new shape to the shape attribute of the array::
+
+     >>> a = np.zeros((10, 2))
+
+     # A transpose makes the array non-contiguous
+     >>> b = a.T
+
+     # Taking a view makes it possible to modify the shape without modifying
+     # the initial object.
+     >>> c = b.view()
+     >>> c.shape = (20)
+     Traceback (most recent call last):
+        ...
+     AttributeError: Incompatible shape for in-place modification. Use
+     `.reshape()` to make a copy with the desired shape.
+
+    The `order` keyword gives the index ordering both for *fetching* the values
+    from `a`, and then *placing* the values into the output array.
+    For example, let's say you have an array:
+
+    >>> a = np.arange(6).reshape((3, 2))
+    >>> a
+    array([[0, 1],
+           [2, 3],
+           [4, 5]])
+
+    You can think of reshaping as first raveling the array (using the given
+    index order), then inserting the elements from the raveled array into the
+    new array using the same kind of index ordering as was used for the
+    raveling.
+
+    >>> np.reshape(a, (2, 3)) # C-like index ordering
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.reshape(np.ravel(a), (2, 3)) # equivalent to C ravel then C reshape
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.reshape(a, (2, 3), order='F') # Fortran-like index ordering
+    array([[0, 4, 3],
+           [2, 1, 5]])
+    >>> np.reshape(np.ravel(a, order='F'), (2, 3), order='F')
+    array([[0, 4, 3],
+           [2, 1, 5]])
+
+    Examples
+    --------
+    >>> a = np.array([[1,2,3], [4,5,6]])
+    >>> np.reshape(a, 6)
+    array([1, 2, 3, 4, 5, 6])
+    >>> np.reshape(a, 6, order='F')
+    array([1, 4, 2, 5, 3, 6])
+
+    >>> np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2
+    array([[1, 2],
+           [3, 4],
+           [5, 6]])
+    " :arglists '[[& [args {:as kwargs}]]]} reshape (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "reshape"))))
+
+(def ^{:doc "
+    Modified Bessel function of the first kind, order 0.
+
+    Usually denoted :math:`I_0`.
+
+    Parameters
+    ----------
+    x : array_like of float
+        Argument of the Bessel function.
+
+    Returns
+    -------
+    out : ndarray, shape = x.shape, dtype = float
+        The modified Bessel function evaluated at each of the elements of `x`.
+
+    See Also
+    --------
+    scipy.special.i0, scipy.special.iv, scipy.special.ive
+
+    Notes
+    -----
+    The scipy implementation is recommended over this function: it is a
+    proper ufunc written in C, and more than an order of magnitude faster.
+
+    We use the algorithm published by Clenshaw [1]_ and referenced by
+    Abramowitz and Stegun [2]_, for which the function domain is
+    partitioned into the two intervals [0,8] and (8,inf), and Chebyshev
+    polynomial expansions are employed in each interval. Relative error on
+    the domain [0,30] using IEEE arithmetic is documented [3]_ as having a
+    peak of 5.8e-16 with an rms of 1.4e-16 (n = 30000).
+
+    References
+    ----------
+    .. [1] C. W. Clenshaw, \"Chebyshev series for mathematical functions\", in
+           *National Physical Laboratory Mathematical Tables*, vol. 5, London:
+           Her Majesty's Stationery Office, 1962.
+    .. [2] M. Abramowitz and I. A. Stegun, *Handbook of Mathematical
+           Functions*, 10th printing, New York: Dover, 1964, pp. 379.
+           http://www.math.sfu.ca/~cbm/aands/page_379.htm
+    .. [3] https://metacpan.org/pod/distribution/Math-Cephes/lib/Math/Cephes.pod#i0:-Modified-Bessel-function-of-order-zero
+
+    Examples
+    --------
+    >>> np.i0(0.)
+    array(1.0)
+    >>> np.i0([0, 1, 2, 3])
+    array([1.        , 1.26606588, 2.2795853 , 4.88079259])
+
+    " :arglists '[[& [args {:as kwargs}]]]} i0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "i0"))))
+
+(def ^{:doc "
+    Multidimensional index iterator.
+
+    Return an iterator yielding pairs of array coordinates and values.
+
+    Parameters
+    ----------
+    arr : ndarray
+      Input array.
+
+    See Also
+    --------
+    ndindex, flatiter
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> for index, x in np.ndenumerate(a):
+    ...     print(index, x)
+    (0, 0) 1
+    (0, 1) 2
+    (1, 0) 3
+    (1, 1) 4
+
+    " :arglists '[[self arr]]} ndenumerate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndenumerate"))))
+
+(def ^{:doc "
+    Return the Hamming window.
+
+    The Hamming window is a taper formed by using a weighted cosine.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+
+    Returns
+    -------
+    out : ndarray
+        The window, with the maximum value normalized to one (the value
+        one appears only if the number of samples is odd).
+
+    See Also
+    --------
+    bartlett, blackman, hanning, kaiser
+
+    Notes
+    -----
+    The Hamming window is defined as
+
+    .. math::  w(n) = 0.54 - 0.46cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
+               \\qquad 0 \\leq n \\leq M-1
+
+    The Hamming was named for R. W. Hamming, an associate of J. W. Tukey
+    and is described in Blackman and Tukey. It was recommended for
+    smoothing the truncated autocovariance function in the time domain.
+    Most references to the Hamming window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    \"removing the foot\", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function.
+
+    References
+    ----------
+    .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
+           spectra, Dover Publications, New York.
+    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\", The
+           University of Alberta Press, 1975, pp. 109-110.
+    .. [3] Wikipedia, \"Window function\",
+           https://en.wikipedia.org/wiki/Window_function
+    .. [4] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
+           \"Numerical Recipes\", Cambridge University Press, 1986, page 425.
+
+    Examples
+    --------
+    >>> np.hamming(12)
+    array([ 0.08      ,  0.15302337,  0.34890909,  0.60546483,  0.84123594, # may vary
+            0.98136677,  0.98136677,  0.84123594,  0.60546483,  0.34890909,
+            0.15302337,  0.08      ])
+
+    Plot the window and the frequency response:
+
+    >>> import matplotlib.pyplot as plt
+    >>> from numpy.fft import fft, fftshift
+    >>> window = np.hamming(51)
+    >>> plt.plot(window)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Hamming window\")
+    Text(0.5, 1.0, 'Hamming window')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"Sample\")
+    Text(0.5, 0, 'Sample')
+    >>> plt.show()
+
+    >>> plt.figure()
+    <Figure size 640x480 with 0 Axes>
+    >>> A = fft(window, 2048) / 25.5
+    >>> mag = np.abs(fftshift(A))
+    >>> freq = np.linspace(-0.5, 0.5, len(A))
+    >>> response = 20 * np.log10(mag)
+    >>> response = np.clip(response, -100, 100)
+    >>> plt.plot(freq, response)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Frequency response of Hamming window\")
+    Text(0.5, 1.0, 'Frequency response of Hamming window')
+    >>> plt.ylabel(\"Magnitude [dB]\")
+    Text(0, 0.5, 'Magnitude [dB]')
+    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
+    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
+    >>> plt.axis('tight')
+    ...
+    >>> plt.show()
+
+    " :arglists '[[M]]} hamming (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hamming"))))
+
+(def ^{:doc ""} NAN ##NaN)
+
+(def ^{:doc ""} Infinity ##Inf)
+
+(def ^{:doc ""} MAY_SHARE_EXACT -1)
+
+(def ^{:doc "
+    Return a string representation of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    max_line_width : int, optional
+        Inserts newlines if text is longer than `max_line_width`.
+        Defaults to ``numpy.get_printoptions()['linewidth']``.
+    precision : int or None, optional
+        Floating point precision.
+        Defaults to ``numpy.get_printoptions()['precision']``.
+    suppress_small : bool, optional
+        Represent numbers \"very close\" to zero as zero; default is False.
+        Very close is defined by precision: if the precision is 8, e.g.,
+        numbers smaller (in absolute value) than 5e-9 are represented as
+        zero.
+        Defaults to ``numpy.get_printoptions()['suppress']``.
+    separator : str, optional
+        Inserted between elements.
+    prefix : str, optional
+    suffix: str, optional
+        The length of the prefix and suffix strings are used to respectively
+        align and wrap the output. An array is typically printed as::
+
+          prefix + array2string(a) + suffix
+
+        The output is left-padded by the length of the prefix string, and
+        wrapping is forced at the column ``max_line_width - len(suffix)``.
+        It should be noted that the content of prefix and suffix strings are
+        not included in the output.
+    style : _NoValue, optional
+        Has no effect, do not use.
+
+        .. deprecated:: 1.14.0
+    formatter : dict of callables, optional
+        If not None, the keys should indicate the type(s) that the respective
+        formatting function applies to.  Callables should return a string.
+        Types that are not specified (by their corresponding keys) are handled
+        by the default formatters.  Individual types for which a formatter
+        can be set are:
+
+        - 'bool'
+        - 'int'
+        - 'timedelta' : a `numpy.timedelta64`
+        - 'datetime' : a `numpy.datetime64`
+        - 'float'
+        - 'longfloat' : 128-bit floats
+        - 'complexfloat'
+        - 'longcomplexfloat' : composed of two 128-bit floats
+        - 'void' : type `numpy.void`
+        - 'numpystr' : types `numpy.string_` and `numpy.unicode_`
+        - 'str' : all other strings
+
+        Other keys that can be used to set a group of types at once are:
+
+        - 'all' : sets all types
+        - 'int_kind' : sets 'int'
+        - 'float_kind' : sets 'float' and 'longfloat'
+        - 'complex_kind' : sets 'complexfloat' and 'longcomplexfloat'
+        - 'str_kind' : sets 'str' and 'numpystr'
+    threshold : int, optional
+        Total number of array elements which trigger summarization
+        rather than full repr.
+        Defaults to ``numpy.get_printoptions()['threshold']``.
+    edgeitems : int, optional
+        Number of array items in summary at beginning and end of
+        each dimension.
+        Defaults to ``numpy.get_printoptions()['edgeitems']``.
+    sign : string, either '-', '+', or ' ', optional
+        Controls printing of the sign of floating-point types. If '+', always
+        print the sign of positive values. If ' ', always prints a space
+        (whitespace character) in the sign position of positive values.  If
+        '-', omit the sign character of positive values.
+        Defaults to ``numpy.get_printoptions()['sign']``.
+    floatmode : str, optional
+        Controls the interpretation of the `precision` option for
+        floating-point types.
+        Defaults to ``numpy.get_printoptions()['floatmode']``.
+        Can take the following values:
+
+        - 'fixed': Always print exactly `precision` fractional digits,
+          even if this would print more or fewer digits than
+          necessary to specify the value uniquely.
+        - 'unique': Print the minimum number of fractional digits necessary
+          to represent each value uniquely. Different elements may
+          have a different number of digits.  The value of the
+          `precision` option is ignored.
+        - 'maxprec': Print at most `precision` fractional digits, but if
+          an element can be uniquely represented with fewer digits
+          only print it with that many.
+        - 'maxprec_equal': Print at most `precision` fractional digits,
+          but if every element in the array can be uniquely
+          represented with an equal number of fewer digits, use that
+          many digits for all elements.
+    legacy : string or `False`, optional
+        If set to the string `'1.13'` enables 1.13 legacy printing mode. This
+        approximates numpy 1.13 print output by including a space in the sign
+        position of floats and different behavior for 0d arrays. If set to
+        `False`, disables legacy mode. Unrecognized strings will be ignored
+        with a warning for forward compatibility.
+
+        .. versionadded:: 1.14.0
+
+    Returns
+    -------
+    array_str : str
+        String representation of the array.
+
+    Raises
+    ------
+    TypeError
+        if a callable in `formatter` does not return a string.
+
+    See Also
+    --------
+    array_str, array_repr, set_printoptions, get_printoptions
+
+    Notes
+    -----
+    If a formatter is specified for a certain type, the `precision` keyword is
+    ignored for that type.
+
+    This is a very flexible function; `array_repr` and `array_str` are using
+    `array2string` internally so keywords with the same name should work
+    identically in all three functions.
+
+    Examples
+    --------
+    >>> x = np.array([1e-16,1,2,3])
+    >>> np.array2string(x, precision=2, separator=',',
+    ...                       suppress_small=True)
+    '[0.,1.,2.,3.]'
+
+    >>> x  = np.arange(3.)
+    >>> np.array2string(x, formatter={'float_kind':lambda x: \"%.2f\" % x})
+    '[0.00 1.00 2.00]'
+
+    >>> x  = np.arange(3)
+    >>> np.array2string(x, formatter={'int':lambda x: hex(x)})
+    '[0x0 0x1 0x2]'
+
+    " :arglists '[[& [args {:as kwargs}]]]} array2string (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array2string"))))
+
+(def ^{:doc "
+    Display a message on a device.
+
+    Parameters
+    ----------
+    mesg : str
+        Message to display.
+    device : object
+        Device to write message. If None, defaults to ``sys.stdout`` which is
+        very similar to ``print``. `device` needs to have ``write()`` and
+        ``flush()`` methods.
+    linefeed : bool, optional
+        Option whether to print a line feed or not. Defaults to True.
+
+    Raises
+    ------
+    AttributeError
+        If `device` does not have a ``write()`` or ``flush()`` method.
+
+    Examples
+    --------
+    Besides ``sys.stdout``, a file-like object can also be used as it has
+    both required methods:
+
+    >>> from io import StringIO
+    >>> buf = StringIO()
+    >>> np.disp(u'\"Display\" in a file', device=buf)
+    >>> buf.getvalue()
+    '\"Display\" in a file\\n'
+
+    " :arglists '[[mesg & [{device :device, linefeed :linefeed}]] [mesg & [{device :device}]] [mesg]]} disp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "disp"))))
+
+(def ^{:doc "
+    packbits(a, axis=None, bitorder='big')
+
+    Packs the elements of a binary-valued array into bits in a uint8 array.
+
+    The result is padded to full bytes by inserting zero bits at the end.
+
+    Parameters
+    ----------
+    a : array_like
+        An array of integers or booleans whose elements should be packed to
+        bits.
+    axis : int, optional
+        The dimension over which bit-packing is done.
+        ``None`` implies packing the flattened array.
+    bitorder : {'big', 'little'}, optional
+        The order of the input bits. 'big' will mimic bin(val),
+        ``[0, 0, 0, 0, 0, 0, 1, 1] => 3 = 0b00000011``, 'little' will
+        reverse the order so ``[1, 1, 0, 0, 0, 0, 0, 0] => 3``.
+        Defaults to 'big'.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    packed : ndarray
+        Array of type uint8 whose elements represent bits corresponding to the
+        logical (0 or nonzero) value of the input elements. The shape of
+        `packed` has the same number of dimensions as the input (unless `axis`
+        is None, in which case the output is 1-D).
+
+    See Also
+    --------
+    unpackbits: Unpacks elements of a uint8 array into a binary-valued output
+                array.
+
+    Examples
+    --------
+    >>> a = np.array([[[1,0,1],
+    ...                [0,1,0]],
+    ...               [[1,1,0],
+    ...                [0,0,1]]])
+    >>> b = np.packbits(a, axis=-1)
+    >>> b
+    array([[[160],
+            [ 64]],
+           [[192],
+            [ 32]]], dtype=uint8)
+
+    Note that in binary 160 = 1010 0000, 64 = 0100 0000, 192 = 1100 0000,
+    and 32 = 0010 0000.
+
+    " :arglists '[[& [args {:as kwargs}]]]} packbits (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "packbits"))))
+
+(def ^{:doc ""} ERR_WARN 1)
+
+(def ^{:doc "
+    Compute the q-th percentile of the data along the specified axis.
+
+    Returns the q-th percentile(s) of the array elements.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    q : array_like of float
+        Percentile or sequence of percentiles to compute, which must be between
+        0 and 100 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the percentiles are computed. The
+        default is to compute the percentile(s) along a flattened
+        version of the array.
+
+        .. versionchanged:: 1.9.0
+            A tuple of axes is supported
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by intermediate
+        calculations, to save memory. In this case, the contents of the input
+        `a` after this function completes is undefined.
+
+    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
+        This optional parameter specifies the interpolation method to
+        use when the desired percentile lies between two data points
+        ``i < j``:
+
+        * 'linear': ``i + (j - i) * fraction``, where ``fraction``
+          is the fractional part of the index surrounded by ``i``
+          and ``j``.
+        * 'lower': ``i``.
+        * 'higher': ``j``.
+        * 'nearest': ``i`` or ``j``, whichever is nearest.
+        * 'midpoint': ``(i + j) / 2``.
+
+        .. versionadded:: 1.9.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+        .. versionadded:: 1.9.0
+
+    Returns
+    -------
+    percentile : scalar or ndarray
+        If `q` is a single percentile and `axis=None`, then the result
+        is a scalar. If multiple percentiles are given, first axis of
+        the result corresponds to the percentiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean
+    median : equivalent to ``percentile(..., 50)``
+    nanpercentile
+    quantile : equivalent to percentile, except with q in the range [0, 1].
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the q-th percentile of
+    ``V`` is the value ``q/100`` of the way from the minimum to the
+    maximum in a sorted copy of ``V``. The values and distances of
+    the two nearest neighbors as well as the `interpolation` parameter
+    will determine the percentile if the normalized ranking does not
+    match the location of ``q`` exactly. This function is the same as
+    the median if ``q=50``, the same as the minimum if ``q=0`` and the
+    same as the maximum if ``q=100``.
+
+    Examples
+    --------
+    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
+    >>> a
+    array([[10,  7,  4],
+           [ 3,  2,  1]])
+    >>> np.percentile(a, 50)
+    3.5
+    >>> np.percentile(a, 50, axis=0)
+    array([6.5, 4.5, 2.5])
+    >>> np.percentile(a, 50, axis=1)
+    array([7.,  2.])
+    >>> np.percentile(a, 50, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+
+    >>> m = np.percentile(a, 50, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.percentile(a, 50, axis=0, out=out)
+    array([6.5, 4.5, 2.5])
+    >>> m
+    array([6.5, 4.5, 2.5])
+
+    >>> b = a.copy()
+    >>> np.percentile(b, 50, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a == b)
+
+    The different types of interpolation can be visualized graphically:
+
+    .. plot::
+
+        import matplotlib.pyplot as plt
+
+        a = np.arange(4)
+        p = np.linspace(0, 100, 6001)
+        ax = plt.gca()
+        lines = [
+            ('linear', None),
+            ('higher', '--'),
+            ('lower', '--'),
+            ('nearest', '-.'),
+            ('midpoint', '-.'),
+        ]
+        for interpolation, style in lines:
+            ax.plot(
+                p, np.percentile(a, p, interpolation=interpolation),
+                label=interpolation, linestyle=style)
+        ax.set(
+            title='Interpolation methods for list: ' + str(a),
+            xlabel='Percentile',
+            ylabel='List item returned',
+            yticks=a)
+        ax.legend()
+        plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]]} percentile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "percentile"))))
+
+(def ^{:doc "
+    Compute the qth quantile of the data along the specified axis,
+    while ignoring nan values.
+    Returns the qth quantile(s) of the array elements.
+
+    .. versionadded:: 1.15.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array, containing
+        nan values to be ignored
+    q : array_like of float
+        Quantile or sequence of quantiles to compute, which must be between
+        0 and 1 inclusive.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the quantiles are computed. The
+        default is to compute the quantile(s) along a flattened
+        version of the array.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+        If True, then allow the input array `a` to be modified by intermediate
+        calculations, to save memory. In this case, the contents of the input
+        `a` after this function completes is undefined.
+    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
+        This optional parameter specifies the interpolation method to
+        use when the desired quantile lies between two data points
+        ``i < j``:
+
+        * linear: ``i + (j - i) * fraction``, where ``fraction``
+          is the fractional part of the index surrounded by ``i``
+          and ``j``.
+        * lower: ``i``.
+        * higher: ``j``.
+        * nearest: ``i`` or ``j``, whichever is nearest.
+        * midpoint: ``(i + j) / 2``.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left in
+        the result as dimensions with size one. With this option, the
+        result will broadcast correctly against the original array `a`.
+
+        If this is anything but the default value it will be passed
+        through (in the special case of an empty array) to the
+        `mean` function of the underlying array.  If the array is
+        a sub-class and `mean` does not have the kwarg `keepdims` this
+        will raise a RuntimeError.
+
+    Returns
+    -------
+    quantile : scalar or ndarray
+        If `q` is a single percentile and `axis=None`, then the result
+        is a scalar. If multiple quantiles are given, first axis of
+        the result corresponds to the quantiles. The other axes are
+        the axes that remain after the reduction of `a`. If the input
+        contains integers or floats smaller than ``float64``, the output
+        data-type is ``float64``. Otherwise, the output data-type is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    quantile
+    nanmean, nanmedian
+    nanmedian : equivalent to ``nanquantile(..., 0.5)``
+    nanpercentile : same as nanquantile, but with q in the range [0, 100].
+
+    Examples
+    --------
+    >>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
+    >>> a[0][1] = np.nan
+    >>> a
+    array([[10.,  nan,   4.],
+          [ 3.,   2.,   1.]])
+    >>> np.quantile(a, 0.5)
+    nan
+    >>> np.nanquantile(a, 0.5)
+    3.0
+    >>> np.nanquantile(a, 0.5, axis=0)
+    array([6.5, 2. , 2.5])
+    >>> np.nanquantile(a, 0.5, axis=1, keepdims=True)
+    array([[7.],
+           [2.]])
+    >>> m = np.nanquantile(a, 0.5, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.nanquantile(a, 0.5, axis=0, out=out)
+    array([6.5, 2. , 2.5])
+    >>> m
+    array([6.5,  2. ,  2.5])
+    >>> b = a.copy()
+    >>> np.nanquantile(b, 0.5, axis=1, overwrite_input=True)
+    array([7., 2.])
+    >>> assert not np.all(a==b)
+    " :arglists '[[& [args {:as kwargs}]]]} nanquantile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanquantile"))))
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} typecodes (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "typecodes")))) 
+
+(def ^{:doc "
+    Lower triangle of an array.
+
+    Return a copy of an array with elements above the `k`-th diagonal zeroed.
+
+    Parameters
+    ----------
+    m : array_like, shape (M, N)
+        Input array.
+    k : int, optional
+        Diagonal above which to zero elements.  `k = 0` (the default) is the
+        main diagonal, `k < 0` is below it and `k > 0` is above.
+
+    Returns
+    -------
+    tril : ndarray, shape (M, N)
+        Lower triangle of `m`, of same shape and data-type as `m`.
+
+    See Also
+    --------
+    triu : same thing, only for the upper triangle
+
+    Examples
+    --------
+    >>> np.tril([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
+    array([[ 0,  0,  0],
+           [ 4,  0,  0],
+           [ 7,  8,  0],
+           [10, 11, 12]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} tril (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tril"))))
+
+(def ^{:doc "sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Trigonometric sine, element-wise.
+
+Parameters
+----------
+x : array_like
+    Angle, in radians (:math:`2 \\pi` rad equals 360 degrees).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : array_like
+    The sine of each element of x.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+arcsin, sinh, cos
+
+Notes
+-----
+The sine is one of the fundamental functions of trigonometry (the
+mathematical study of triangles).  Consider a circle of radius 1
+centered on the origin.  A ray comes in from the :math:`+x` axis, makes
+an angle at the origin (measured counter-clockwise from that axis), and
+departs from the origin.  The :math:`y` coordinate of the outgoing
+ray's intersection with the unit circle is the sine of that angle.  It
+ranges from -1 for :math:`x=3\\pi / 2` to +1 for :math:`\\pi / 2.`  The
+function has zeroes where the angle is a multiple of :math:`\\pi`.
+Sines of angles between :math:`\\pi` and :math:`2\\pi` are negative.
+The numerous properties of the sine and related functions are included
+in any standard trigonometry text.
+
+Examples
+--------
+Print sine of one angle:
+
+>>> np.sin(np.pi/2.)
+1.0
+
+Print sines of an array of angles given in degrees:
+
+>>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. )
+array([ 0.        ,  0.5       ,  0.70710678,  0.8660254 ,  1.        ])
+
+Plot the sine function:
+
+>>> import matplotlib.pylab as plt
+>>> x = np.linspace(-np.pi, np.pi, 201)
+>>> plt.plot(x, np.sin(x))
+>>> plt.xlabel('Angle [rad]')
+>>> plt.ylabel('sin(x)')
+>>> plt.axis('tight')
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]]} sin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sin"))))
+
+(def ^{:doc "
+    Flip array in the up/down direction.
+
+    Flip the entries in each column in the up/down direction.
+    Rows are preserved, but appear in a different order than before.
+
+    Parameters
+    ----------
+    m : array_like
+        Input array.
+
+    Returns
+    -------
+    out : array_like
+        A view of `m` with the rows reversed.  Since a view is
+        returned, this operation is :math:`\\mathcal O(1)`.
+
+    See Also
+    --------
+    fliplr : Flip array in the left/right direction.
+    rot90 : Rotate array counterclockwise.
+
+    Notes
+    -----
+    Equivalent to ``m[::-1,...]``.
+    Does not require the array to be two-dimensional.
+
+    Examples
+    --------
+    >>> A = np.diag([1.0, 2, 3])
+    >>> A
+    array([[1.,  0.,  0.],
+           [0.,  2.,  0.],
+           [0.,  0.,  3.]])
+    >>> np.flipud(A)
+    array([[0.,  0.,  3.],
+           [0.,  2.,  0.],
+           [1.,  0.,  0.]])
+
+    >>> A = np.random.randn(2,3,5)
+    >>> np.all(np.flipud(A) == A[::-1,...])
+    True
+
+    >>> np.flipud([1,2])
+    array([2, 1])
+
+    " :arglists '[[& [args {:as kwargs}]]]} flipud (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "flipud"))))
+
+(def ^{:doc "power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+First array elements raised to powers from second array, element-wise.
+
+Raise each base in `x1` to the positionally-corresponding power in
+`x2`.  `x1` and `x2` must be broadcastable to the same shape. Note that an
+integer type raised to a negative integer power will raise a ValueError.
+
+Parameters
+----------
+x1 : array_like
+    The bases.
+x2 : array_like
+    The exponents.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The bases in `x1` raised to the exponents in `x2`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+float_power : power function that promotes integers to float
+
+Examples
+--------
+Cube each element in an array.
+
+>>> x1 = np.arange(6)
+>>> x1
+[0, 1, 2, 3, 4, 5]
+>>> np.power(x1, 3)
+array([  0,   1,   8,  27,  64, 125])
+
+Raise the bases to different exponents.
+
+>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
+>>> np.power(x1, x2)
+array([  0.,   1.,   8.,  27.,  16.,   5.])
+
+The effect of broadcasting.
+
+>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
+>>> x2
+array([[1, 2, 3, 3, 2, 1],
+       [1, 2, 3, 3, 2, 1]])
+>>> np.power(x1, x2)
+array([[ 0,  1,  8, 27, 16,  5],
+       [ 0,  1,  8, 27, 16,  5]])
+
+The ``**`` operator can be used as a shorthand for ``np.power`` on
+ndarrays.
+
+>>> x2 = np.array([1, 2, 3, 3, 2, 1])
+>>> x1 = np.arange(6)
+>>> x1 ** x2
+array([ 0,  1,  8, 27, 16,  5])" :arglists '[[self & [args {:as kwargs}]]]} power (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "power"))))
+
+(def ^{:doc ""} pi 3.141592653589793)
+
+(def ^{:doc "
+Pytest test running.
+
+This module implements the ``test()`` function for NumPy modules. The usual
+boiler plate for doing that is to put the following in the module
+``__init__.py`` file::
+
+    from numpy._pytesttester import PytestTester
+    test = PytestTester(__name__)
+    del PytestTester
+
+
+Warnings filtering and other runtime settings should be dealt with in the
+``pytest.ini`` file in the numpy repo root. The behavior of the test depends on
+whether or not that file is found as follows:
+
+* ``pytest.ini`` is present (develop mode)
+    All warnings except those explicitly filtered out are raised as error.
+* ``pytest.ini`` is absent (release mode)
+    DeprecationWarnings and PendingDeprecationWarnings are ignored, other
+    warnings are passed through.
+
+In practice, tests run from the numpy repo are run in develop mode. That
+includes the standard ``python runtests.py`` invocation.
+
+This module is imported by every numpy subpackage, so lies at the top level to
+simplify circular import issues. For the same reason, it contains no numpy
+imports at module scope, instead importing numpy within function calls.
+"} _pytesttester (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_pytesttester"))))
+
+(def ^{:doc "fabs(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the absolute values element-wise.
+
+This function returns the absolute values (positive magnitude) of the
+data in `x`. Complex values are not handled, use `absolute` to find the
+absolute values of complex data.
+
+Parameters
+----------
+x : array_like
+    The array of numbers for which the absolute values are required. If
+    `x` is a scalar, the result `y` will also be a scalar.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The absolute values of `x`, the returned values are always floats.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+absolute : Absolute values including `complex` types.
+
+Examples
+--------
+>>> np.fabs(-1)
+1.0
+>>> np.fabs([-1.2, 1.2])
+array([ 1.2,  1.2])" :arglists '[[self & [args {:as kwargs}]]]} fabs (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fabs"))))
+
+(def ^{:doc "gcd(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns the greatest common divisor of ``|x1|`` and ``|x2|``
+
+Parameters
+----------
+x1, x2 : array_like, int
+    Arrays of values.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+
+Returns
+-------
+y : ndarray or scalar
+    The greatest common divisor of the absolute value of the inputs
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+lcm : The lowest common multiple
+
+Examples
+--------
+>>> np.gcd(12, 20)
+4
+>>> np.gcd.reduce([15, 25, 35])
+5
+>>> np.gcd(np.arange(6), 20)
+array([20,  1,  2,  1,  4,  5])" :arglists '[[self & [args {:as kwargs}]]]} gcd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "gcd"))))
+
+(def ^{:doc "hypot(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Given the \"legs\" of a right triangle, return its hypotenuse.
+
+Equivalent to ``sqrt(x1**2 + x2**2)``, element-wise.  If `x1` or
+`x2` is scalar_like (i.e., unambiguously cast-able to a scalar type),
+it is broadcast for use with each element of the other argument.
+(See Examples)
+
+Parameters
+----------
+x1, x2 : array_like
+    Leg of the triangle(s).
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+z : ndarray
+    The hypotenuse of the triangle(s).
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Examples
+--------
+>>> np.hypot(3*np.ones((3, 3)), 4*np.ones((3, 3)))
+array([[ 5.,  5.,  5.],
+       [ 5.,  5.,  5.],
+       [ 5.,  5.,  5.]])
+
+Example showing broadcast of scalar_like argument:
+
+>>> np.hypot(3*np.ones((3, 3)), [4])
+array([[ 5.,  5.,  5.],
+       [ 5.,  5.,  5.],
+       [ 5.,  5.,  5.]])" :arglists '[[self & [args {:as kwargs}]]]} hypot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hypot"))))
+
+(def ^{:doc "A unicode string.
+
+    When used in arrays, this type strips trailing null codepoints.
+
+    Unlike the builtin `str`, this supports the :ref:`python:bufferobjects`, exposing its
+    contents as UCS4:
+
+    >>> m = memoryview(np.str_(\"abc\"))
+    >>> m.format
+    '3w'
+    >>> m.tobytes()
+    b'a\\x00\\x00\\x00b\\x00\\x00\\x00c\\x00\\x00\\x00'
+
+    :Character code: ``'U'``
+    :Alias: `numpy.unicode_`" :arglists '[[self & [args {:as kwargs}]]]} unicode_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unicode_"))))
+
+(def ^{:doc "Create nditers for use in nested loops
+
+    Create a tuple of `nditer` objects which iterate in nested loops over
+    different axes of the op argument. The first iterator is used in the
+    outermost loop, the last in the innermost loop. Advancing one will change
+    the subsequent iterators to point at its new element.
+
+    Parameters
+    ----------
+    op : ndarray or sequence of array_like
+        The array(s) to iterate over.
+
+    axes : list of list of int
+        Each item is used as an \"op_axes\" argument to an nditer
+
+    flags, op_flags, op_dtypes, order, casting, buffersize (optional)
+        See `nditer` parameters of the same name
+
+    Returns
+    -------
+    iters : tuple of nditer
+        An nditer for each item in `axes`, outermost first
+
+    See Also
+    --------
+    nditer
+
+    Examples
+    --------
+
+    Basic usage. Note how y is the \"flattened\" version of
+    [a[:, 0, :], a[:, 1, 0], a[:, 2, :]] since we specified
+    the first iter's axes as [1]
+
+    >>> a = np.arange(12).reshape(2, 3, 2)
+    >>> i, j = np.nested_iters(a, [[1], [0, 2]], flags=[\"multi_index\"])
+    >>> for x in i:
+    ...      print(i.multi_index)
+    ...      for y in j:
+    ...          print('', j.multi_index, y)
+    (0,)
+     (0, 0) 0
+     (0, 1) 1
+     (1, 0) 6
+     (1, 1) 7
+    (1,)
+     (0, 0) 2
+     (0, 1) 3
+     (1, 0) 8
+     (1, 1) 9
+    (2,)
+     (0, 0) 4
+     (0, 1) 5
+     (1, 0) 10
+     (1, 1) 11" :arglists '[[self & [args {:as kwargs}]]]} nested_iters (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nested_iters"))))
+
+(def ^{:doc "This module provides access to the mathematical functions
+defined by the C standard."} math (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "math"))))
+
+(def ^{:doc "
+=============
+Masked Arrays
+=============
+
+Arrays sometimes contain invalid or missing data.  When doing operations
+on such arrays, we wish to suppress invalid values, which is the purpose masked
+arrays fulfill (an example of typical use is given below).
+
+For example, examine the following array:
+
+>>> x = np.array([2, 1, 3, np.nan, 5, 2, 3, np.nan])
+
+When we try to calculate the mean of the data, the result is undetermined:
+
+>>> np.mean(x)
+nan
+
+The mean is calculated using roughly ``np.sum(x)/len(x)``, but since
+any number added to ``NaN`` [1]_ produces ``NaN``, this doesn't work.  Enter
+masked arrays:
+
+>>> m = np.ma.masked_array(x, np.isnan(x))
+>>> m
+masked_array(data = [2.0 1.0 3.0 -- 5.0 2.0 3.0 --],
+      mask = [False False False  True False False False  True],
+      fill_value=1e+20)
+
+Here, we construct a masked array that suppress all ``NaN`` values.  We
+may now proceed to calculate the mean of the other values:
+
+>>> np.mean(m)
+2.6666666666666665
+
+.. [1] Not-a-Number, a floating point value that is the result of an
+       invalid operation.
+
+.. moduleauthor:: Pierre Gerard-Marchant
+.. moduleauthor:: Jarrod Millman
+
+"} ma (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ma"))))
+
+(def ^{:doc "
+    Load ASCII data stored in a file and return it as a single array.
+
+    .. deprecated:: 1.17
+        ndfromtxt` is a deprecated alias of `genfromtxt` which
+        overwrites the ``usemask`` argument with `False` even when
+        explicitly called as ``ndfromtxt(..., usemask=True)``.
+        Use `genfromtxt` instead.
+
+    Parameters
+    ----------
+    fname, kwargs : For a description of input parameters, see `genfromtxt`.
+
+    See Also
+    --------
+    numpy.genfromtxt : generic function.
+
+    " :arglists '[[fname & [{:as kwargs}]]]} ndfromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndfromtxt"))))
+
+(def ^{:doc "bitwise_and(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the bit-wise AND of two arrays element-wise.
+
+Computes the bit-wise AND of the underlying binary representation of
+the integers in the input arrays. This ufunc implements the C/Python
+operator ``&``.
+
+Parameters
+----------
+x1, x2 : array_like
+    Only integer and boolean types are handled.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Result.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_and
+bitwise_or
+bitwise_xor
+binary_repr :
+    Return the binary representation of the input number as a string.
+
+Examples
+--------
+The number 13 is represented by ``00001101``.  Likewise, 17 is
+represented by ``00010001``.  The bit-wise AND of 13 and 17 is
+therefore ``000000001``, or 1:
+
+>>> np.bitwise_and(13, 17)
+1
+
+>>> np.bitwise_and(14, 13)
+12
+>>> np.binary_repr(12)
+'1100'
+>>> np.bitwise_and([14,3], 13)
+array([12,  1])
+
+>>> np.bitwise_and([11,7], [4,25])
+array([0, 1])
+>>> np.bitwise_and(np.array([2,5,255]), np.array([3,14,16]))
+array([ 2,  4, 16])
+>>> np.bitwise_and([True, True], [False, True])
+array([False,  True])
+
+The ``&`` operator can be used as a shorthand for ``np.bitwise_and`` on
+ndarrays.
+
+>>> x1 = np.array([2, 5, 255])
+>>> x2 = np.array([3, 14, 16])
+>>> x1 & x2
+array([ 2,  4, 16])" :arglists '[[self & [args {:as kwargs}]]]} bitwise_and (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_and"))))
+
+(def ^{:doc "Complex number type composed of two double-precision floating-point
+    numbers, compatible with Python `complex`.
+
+    :Character code: ``'D'``
+    :Canonical name: `numpy.cdouble`
+    :Alias: `numpy.cfloat`
+    :Alias: `numpy.complex_`
+    :Alias on this platform: `numpy.complex128`: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} cdouble (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cdouble"))))
+
+(def ^{:doc "
+    Return the real part of the complex argument.
+
+    Parameters
+    ----------
+    val : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray or scalar
+        The real component of the complex argument. If `val` is real, the type
+        of `val` is used for the output.  If `val` has complex elements, the
+        returned type is float.
+
+    See Also
+    --------
+    real_if_close, imag, angle
+
+    Examples
+    --------
+    >>> a = np.array([1+2j, 3+4j, 5+6j])
+    >>> a.real
+    array([1.,  3.,  5.])
+    >>> a.real = 9
+    >>> a
+    array([9.+2.j,  9.+4.j,  9.+6.j])
+    >>> a.real = np.array([9, 8, 7])
+    >>> a
+    array([9.+2.j,  8.+4.j,  7.+6.j])
+    >>> np.real(1 + 1j)
+    1.0
+
+    " :arglists '[[& [args {:as kwargs}]]]} real (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "real"))))
+
+(def ^{:doc "fmin(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Element-wise minimum of array elements.
+
+Compare two arrays and returns a new array containing the element-wise
+minima. If one of the elements being compared is a NaN, then the
+non-nan element is returned. If both elements are NaNs then the first
+is returned.  The latter distinction is important for complex NaNs,
+which are defined as at least one of the real or imaginary parts being
+a NaN. The net effect is that NaNs are ignored when possible.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays holding the elements to be compared.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The minimum of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+fmax :
+    Element-wise maximum of two arrays, ignores NaNs.
+minimum :
+    Element-wise minimum of two arrays, propagates NaNs.
+amin :
+    The minimum value of an array along a given axis, propagates NaNs.
+nanmin :
+    The minimum value of an array along a given axis, ignores NaNs.
+
+maximum, amax, nanmax
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+The fmin is equivalent to ``np.where(x1 <= x2, x1, x2)`` when neither
+x1 nor x2 are NaNs, but it is faster and does proper broadcasting.
+
+Examples
+--------
+>>> np.fmin([2, 3, 4], [1, 5, 2])
+array([1, 3, 2])
+
+>>> np.fmin(np.eye(2), [0.5, 2])
+array([[ 0.5,  0. ],
+       [ 0. ,  1. ]])
+
+>>> np.fmin([np.nan, 0, np.nan],[0, np.nan, np.nan])
+array([ 0.,  0., nan])" :arglists '[[self & [args {:as kwargs}]]]} fmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fmin"))))
+
+(def ^{:doc "
+    Format a floating-point scalar as a decimal string in positional notation.
+
+    Provides control over rounding, trimming and padding. Uses and assumes
+    IEEE unbiased rounding. Uses the \"Dragon4\" algorithm.
+
+    Parameters
+    ----------
+    x : python float or numpy floating scalar
+        Value to format.
+    precision : non-negative integer or None, optional
+        Maximum number of digits to print. May be None if `unique` is
+        `True`, but must be an integer if unique is `False`.
+    unique : boolean, optional
+        If `True`, use a digit-generation strategy which gives the shortest
+        representation which uniquely identifies the floating-point number from
+        other values of the same type, by judicious rounding. If `precision`
+        was omitted, print out all necessary digits, otherwise digit generation
+        is cut off after `precision` digits and the remaining value is rounded.
+        If `False`, digits are generated as if printing an infinite-precision
+        value and stopping after `precision` digits, rounding the remaining
+        value.
+    fractional : boolean, optional
+        If `True`, the cutoff of `precision` digits refers to the total number
+        of digits after the decimal point, including leading zeros.
+        If `False`, `precision` refers to the total number of significant
+        digits, before or after the decimal point, ignoring leading zeros.
+    trim : one of 'k', '.', '0', '-', optional
+        Controls post-processing trimming of trailing digits, as follows:
+
+        * 'k' : keep trailing zeros, keep decimal point (no trimming)
+        * '.' : trim all trailing zeros, leave decimal point
+        * '0' : trim all but the zero before the decimal point. Insert the
+          zero if it is missing.
+        * '-' : trim trailing zeros and any trailing decimal point
+    sign : boolean, optional
+        Whether to show the sign for positive values.
+    pad_left : non-negative integer, optional
+        Pad the left side of the string with whitespace until at least that
+        many characters are to the left of the decimal point.
+    pad_right : non-negative integer, optional
+        Pad the right side of the string with whitespace until at least that
+        many characters are to the right of the decimal point.
+
+    Returns
+    -------
+    rep : string
+        The string representation of the floating point value
+
+    See Also
+    --------
+    format_float_scientific
+
+    Examples
+    --------
+    >>> np.format_float_positional(np.float32(np.pi))
+    '3.1415927'
+    >>> np.format_float_positional(np.float16(np.pi))
+    '3.14'
+    >>> np.format_float_positional(np.float16(0.3))
+    '0.3'
+    >>> np.format_float_positional(np.float16(0.3), unique=False, precision=10)
+    '0.3000488281'
+    " :arglists '[[x & [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign, pad_left :pad_left, pad_right :pad_right}]] [x & [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign, pad_left :pad_left}]] [x & [{precision :precision, unique :unique, fractional :fractional, trim :trim, sign :sign}]] [x & [{precision :precision, unique :unique, fractional :fractional, trim :trim}]] [x & [{precision :precision, unique :unique, fractional :fractional}]] [x & [{precision :precision, unique :unique}]] [x & [{precision :precision}]] [x]]} format_float_positional (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "format_float_positional"))))
+
+(def ^{:doc "" :arglists '[[]]} __dir__ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "__dir__"))))
+
+(def ^{:doc "
+    vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False,
+              signature=None)
+
+    Generalized function class.
+
+    Define a vectorized function which takes a nested sequence of objects or
+    numpy arrays as inputs and returns a single numpy array or a tuple of numpy
+    arrays. The vectorized function evaluates `pyfunc` over successive tuples
+    of the input arrays like the python map function, except it uses the
+    broadcasting rules of numpy.
+
+    The data type of the output of `vectorized` is determined by calling
+    the function with the first element of the input.  This can be avoided
+    by specifying the `otypes` argument.
+
+    Parameters
+    ----------
+    pyfunc : callable
+        A python function or method.
+    otypes : str or list of dtypes, optional
+        The output data type. It must be specified as either a string of
+        typecode characters or a list of data type specifiers. There should
+        be one data type specifier for each output.
+    doc : str, optional
+        The docstring for the function. If None, the docstring will be the
+        ``pyfunc.__doc__``.
+    excluded : set, optional
+        Set of strings or integers representing the positional or keyword
+        arguments for which the function will not be vectorized.  These will be
+        passed directly to `pyfunc` unmodified.
+
+        .. versionadded:: 1.7.0
+
+    cache : bool, optional
+        If `True`, then cache the first function call that determines the number
+        of outputs if `otypes` is not provided.
+
+        .. versionadded:: 1.7.0
+
+    signature : string, optional
+        Generalized universal function signature, e.g., ``(m,n),(n)->(m)`` for
+        vectorized matrix-vector multiplication. If provided, ``pyfunc`` will
+        be called with (and expected to return) arrays with shapes given by the
+        size of corresponding core dimensions. By default, ``pyfunc`` is
+        assumed to take scalars as input and output.
+
+        .. versionadded:: 1.12.0
+
+    Returns
+    -------
+    vectorized : callable
+        Vectorized function.
+
+    See Also
+    --------
+    frompyfunc : Takes an arbitrary Python function and returns a ufunc
+
+    Notes
+    -----
+    The `vectorize` function is provided primarily for convenience, not for
+    performance. The implementation is essentially a for loop.
+
+    If `otypes` is not specified, then a call to the function with the
+    first argument will be used to determine the number of outputs.  The
+    results of this call will be cached if `cache` is `True` to prevent
+    calling the function twice.  However, to implement the cache, the
+    original function must be wrapped which will slow down subsequent
+    calls, so only do this if your function is expensive.
+
+    The new keyword argument interface and `excluded` argument support
+    further degrades performance.
+
+    References
+    ----------
+    .. [1] :doc:`/reference/c-api/generalized-ufuncs`
+
+    Examples
+    --------
+    >>> def myfunc(a, b):
+    ...     \"Return a-b if a>b, otherwise return a+b\"
+    ...     if a > b:
+    ...         return a - b
+    ...     else:
+    ...         return a + b
+
+    >>> vfunc = np.vectorize(myfunc)
+    >>> vfunc([1, 2, 3, 4], 2)
+    array([3, 4, 1, 2])
+
+    The docstring is taken from the input function to `vectorize` unless it
+    is specified:
+
+    >>> vfunc.__doc__
+    'Return a-b if a>b, otherwise return a+b'
+    >>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`')
+    >>> vfunc.__doc__
+    'Vectorized `myfunc`'
+
+    The output type is determined by evaluating the first element of the input,
+    unless it is specified:
+
+    >>> out = vfunc([1, 2, 3, 4], 2)
+    >>> type(out[0])
+    <class 'numpy.int64'>
+    >>> vfunc = np.vectorize(myfunc, otypes=[float])
+    >>> out = vfunc([1, 2, 3, 4], 2)
+    >>> type(out[0])
+    <class 'numpy.float64'>
+
+    The `excluded` argument can be used to prevent vectorizing over certain
+    arguments.  This can be useful for array-like arguments of a fixed length
+    such as the coefficients for a polynomial as in `polyval`:
+
+    >>> def mypolyval(p, x):
+    ...     _p = list(p)
+    ...     res = _p.pop(0)
+    ...     while _p:
+    ...         res = res*x + _p.pop(0)
+    ...     return res
+    >>> vpolyval = np.vectorize(mypolyval, excluded=['p'])
+    >>> vpolyval(p=[1, 2, 3], x=[0, 1])
+    array([3, 6])
+
+    Positional arguments may also be excluded by specifying their position:
+
+    >>> vpolyval.excluded.add(0)
+    >>> vpolyval([1, 2, 3], x=[0, 1])
+    array([3, 6])
+
+    The `signature` argument allows for vectorizing functions that act on
+    non-scalar arrays of fixed length. For example, you can use it for a
+    vectorized calculation of Pearson correlation coefficient and its p-value:
+
+    >>> import scipy.stats
+    >>> pearsonr = np.vectorize(scipy.stats.pearsonr,
+    ...                 signature='(n),(n)->(),()')
+    >>> pearsonr([[0, 1, 2, 3]], [[1, 2, 3, 4], [4, 3, 2, 1]])
+    (array([ 1., -1.]), array([ 0.,  0.]))
+
+    Or for a vectorized convolution:
+
+    >>> convolve = np.vectorize(np.convolve, signature='(n),(m)->(k)')
+    >>> convolve(np.eye(4), [1, 2, 1])
+    array([[1., 2., 1., 0., 0., 0.],
+           [0., 1., 2., 1., 0., 0.],
+           [0., 0., 1., 2., 1., 0.],
+           [0., 0., 0., 1., 2., 1.]])
+
+    " :arglists '[[self pyfunc & [{otypes :otypes, doc :doc, excluded :excluded, cache :cache, signature :signature}]] [self pyfunc & [{otypes :otypes, doc :doc, excluded :excluded, cache :cache}]] [self pyfunc & [{otypes :otypes, doc :doc, excluded :excluded}]] [self pyfunc & [{otypes :otypes, doc :doc}]] [self pyfunc & [{otypes :otypes}]] [self pyfunc]]} vectorize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vectorize"))))
+
+(def ^{:doc "radians(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Convert angles from degrees to radians.
+
+Parameters
+----------
+x : array_like
+    Input array in degrees.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding radian values.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+deg2rad : equivalent function
+
+Examples
+--------
+Convert a degree array to radians
+
+>>> deg = np.arange(12.) * 30.
+>>> np.radians(deg)
+array([ 0.        ,  0.52359878,  1.04719755,  1.57079633,  2.0943951 ,
+        2.61799388,  3.14159265,  3.66519143,  4.1887902 ,  4.71238898,
+        5.23598776,  5.75958653])
+
+>>> out = np.zeros((deg.shape))
+>>> ret = np.radians(deg, out)
+>>> ret is out
+True" :arglists '[[self & [args {:as kwargs}]]]} radians (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "radians"))))
+
+(def ^{:doc "
+    Compute the histogram of a set of data.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data. The histogram is computed over the flattened array.
+    bins : int or sequence of scalars or str, optional
+        If `bins` is an int, it defines the number of equal-width
+        bins in the given range (10, by default). If `bins` is a
+        sequence, it defines a monotonically increasing array of bin edges,
+        including the rightmost edge, allowing for non-uniform bin widths.
+
+        .. versionadded:: 1.11.0
+
+        If `bins` is a string, it defines the method used to calculate the
+        optimal bin width, as defined by `histogram_bin_edges`.
+
+    range : (float, float), optional
+        The lower and upper range of the bins.  If not provided, range
+        is simply ``(a.min(), a.max())``.  Values outside the range are
+        ignored. The first element of the range must be less than or
+        equal to the second. `range` affects the automatic bin
+        computation as well. While bin width is computed to be optimal
+        based on the actual data within `range`, the bin count will fill
+        the entire range including portions containing no data.
+    normed : bool, optional
+
+        .. deprecated:: 1.6.0
+
+        This is equivalent to the `density` argument, but produces incorrect
+        results for unequal bin widths. It should not be used.
+
+        .. versionchanged:: 1.15.0
+            DeprecationWarnings are actually emitted.
+
+    weights : array_like, optional
+        An array of weights, of the same shape as `a`.  Each value in
+        `a` only contributes its associated weight towards the bin count
+        (instead of 1). If `density` is True, the weights are
+        normalized, so that the integral of the density over the range
+        remains 1.
+    density : bool, optional
+        If ``False``, the result will contain the number of samples in
+        each bin. If ``True``, the result is the value of the
+        probability *density* function at the bin, normalized such that
+        the *integral* over the range is 1. Note that the sum of the
+        histogram values will not be equal to 1 unless bins of unity
+        width are chosen; it is not a probability *mass* function.
+
+        Overrides the ``normed`` keyword if given.
+
+    Returns
+    -------
+    hist : array
+        The values of the histogram. See `density` and `weights` for a
+        description of the possible semantics.
+    bin_edges : array of dtype float
+        Return the bin edges ``(length(hist)+1)``.
+
+
+    See Also
+    --------
+    histogramdd, bincount, searchsorted, digitize, histogram_bin_edges
+
+    Notes
+    -----
+    All but the last (righthand-most) bin is half-open.  In other words,
+    if `bins` is::
+
+      [1, 2, 3, 4]
+
+    then the first bin is ``[1, 2)`` (including 1, but excluding 2) and
+    the second ``[2, 3)``.  The last bin, however, is ``[3, 4]``, which
+    *includes* 4.
+
+
+    Examples
+    --------
+    >>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3])
+    (array([0, 2, 1]), array([0, 1, 2, 3]))
+    >>> np.histogram(np.arange(4), bins=np.arange(5), density=True)
+    (array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4]))
+    >>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3])
+    (array([1, 4, 1]), array([0, 1, 2, 3]))
+
+    >>> a = np.arange(5)
+    >>> hist, bin_edges = np.histogram(a, density=True)
+    >>> hist
+    array([0.5, 0. , 0.5, 0. , 0. , 0.5, 0. , 0.5, 0. , 0.5])
+    >>> hist.sum()
+    2.4999999999999996
+    >>> np.sum(hist * np.diff(bin_edges))
+    1.0
+
+    .. versionadded:: 1.11.0
+
+    Automated Bin Selection Methods example, using 2 peak random data
+    with 2000 points:
+
+    >>> import matplotlib.pyplot as plt
+    >>> rng = np.random.RandomState(10)  # deterministic random data
+    >>> a = np.hstack((rng.normal(size=1000),
+    ...                rng.normal(loc=5, scale=2, size=1000)))
+    >>> _ = plt.hist(a, bins='auto')  # arguments are passed to np.histogram
+    >>> plt.title(\"Histogram with 'auto' bins\")
+    Text(0.5, 1.0, \"Histogram with 'auto' bins\")
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]]} histogram (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "histogram"))))
+
+(def ^{:doc ""} UFUNC_PYVALS_NAME "UFUNC_PYVALS")
+
+(def ^{:doc "
+    Check if the array is Fortran contiguous but *not* C contiguous.
+
+    This function is obsolete and, because of changes due to relaxed stride
+    checking, its return value for the same array may differ for versions
+    of NumPy >= 1.10.0 and previous versions. If you only want to check if an
+    array is Fortran contiguous use ``a.flags.f_contiguous`` instead.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input array.
+
+    Returns
+    -------
+    isfortran : bool
+        Returns True if the array is Fortran contiguous but *not* C contiguous.
+
+
+    Examples
+    --------
+
+    np.array allows to specify whether the array is written in C-contiguous
+    order (last index varies the fastest), or FORTRAN-contiguous order in
+    memory (first index varies the fastest).
+
+    >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
+    >>> a
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> np.isfortran(a)
+    False
+
+    >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F')
+    >>> b
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> np.isfortran(b)
+    True
+
+
+    The transpose of a C-ordered array is a FORTRAN-ordered array.
+
+    >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
+    >>> a
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> np.isfortran(a)
+    False
+    >>> b = a.T
+    >>> b
+    array([[1, 4],
+           [2, 5],
+           [3, 6]])
+    >>> np.isfortran(b)
+    True
+
+    C-ordered arrays evaluate as False even if they are also FORTRAN-ordered.
+
+    >>> np.isfortran(np.array([1, 2], order='F'))
+    False
+
+    " :arglists '[[a]]} isfortran (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isfortran"))))
+
+(def ^{:doc "Half-precision floating-point number type.
+
+    :Character code: ``'e'``
+    :Canonical name: `numpy.half`
+    :Alias on this platform: `numpy.float16`: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa." :arglists '[[self & [args {:as kwargs}]]]} float16 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float16"))))
+
+(def ^{:doc "
+    Find indices where elements should be inserted to maintain order.
+
+    Find the indices into a sorted array `a` such that, if the
+    corresponding elements in `v` were inserted before the indices, the
+    order of `a` would be preserved.
+
+    Assuming that `a` is sorted:
+
+    ======  ============================
+    `side`  returned index `i` satisfies
+    ======  ============================
+    left    ``a[i-1] < v <= a[i]``
+    right   ``a[i-1] <= v < a[i]``
+    ======  ============================
+
+    Parameters
+    ----------
+    a : 1-D array_like
+        Input array. If `sorter` is None, then it must be sorted in
+        ascending order, otherwise `sorter` must be an array of indices
+        that sort it.
+    v : array_like
+        Values to insert into `a`.
+    side : {'left', 'right'}, optional
+        If 'left', the index of the first suitable location found is given.
+        If 'right', return the last such index.  If there is no suitable
+        index, return either 0 or N (where N is the length of `a`).
+    sorter : 1-D array_like, optional
+        Optional array of integer indices that sort array a into ascending
+        order. They are typically the result of argsort.
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    indices : array of ints
+        Array of insertion points with the same shape as `v`.
+
+    See Also
+    --------
+    sort : Return a sorted copy of an array.
+    histogram : Produce histogram from 1-D data.
+
+    Notes
+    -----
+    Binary search is used to find the required insertion points.
+
+    As of NumPy 1.4.0 `searchsorted` works with real/complex arrays containing
+    `nan` values. The enhanced sort order is documented in `sort`.
+
+    This function uses the same algorithm as the builtin python `bisect.bisect_left`
+    (``side='left'``) and `bisect.bisect_right` (``side='right'``) functions,
+    which is also vectorized in the `v` argument.
+
+    Examples
+    --------
+    >>> np.searchsorted([1,2,3,4,5], 3)
+    2
+    >>> np.searchsorted([1,2,3,4,5], 3, side='right')
+    3
+    >>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
+    array([0, 5, 1, 2])
+
+    " :arglists '[[& [args {:as kwargs}]]]} searchsorted (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "searchsorted"))))
+
+(def ^{:doc "fromiter(iterable, dtype, count=-1, *, like=None)
+
+    Create a new 1-dimensional array from an iterable object.
+
+    Parameters
+    ----------
+    iterable : iterable object
+        An iterable object providing data for the array.
+    dtype : data-type
+        The data-type of the returned array.
+    count : int, optional
+        The number of items to read from *iterable*.  The default is -1,
+        which means all data is read.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        The output array.
+
+    Notes
+    -----
+    Specify `count` to improve performance.  It allows ``fromiter`` to
+    pre-allocate the output array, instead of resizing it on demand.
+
+    Examples
+    --------
+    >>> iterable = (x*x for x in range(5))
+    >>> np.fromiter(iterable, float)
+    array([  0.,   1.,   4.,   9.,  16.])" :arglists '[[self & [args {:as kwargs}]]]} fromiter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fromiter"))))
+
+(def ^{:doc "Abstract base class of all character string scalar types." :arglists '[[self & [args {:as kwargs}]]]} character (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "character"))))
+
+(def ^{:doc "Unsigned integer type, compatible with C ``unsigned long``.
+
+    :Character code: ``'L'``
+    :Canonical name: `numpy.uint`
+    :Alias on this platform: `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``).
+    :Alias on this platform: `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]]} uint64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint64"))))
+
+(def ^{:doc "
+    Return a new array of given shape and type, filled with `fill_value`.
+
+    Parameters
+    ----------
+    shape : int or sequence of ints
+        Shape of the new array, e.g., ``(2, 3)`` or ``2``.
+    fill_value : scalar or array_like
+        Fill value.
+    dtype : data-type, optional
+        The desired data-type for the array  The default, None, means
+         `np.array(fill_value).dtype`.
+    order : {'C', 'F'}, optional
+        Whether to store multidimensional data in C- or Fortran-contiguous
+        (row- or column-wise) order in memory.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of `fill_value` with the given shape, dtype, and order.
+
+    See Also
+    --------
+    full_like : Return a new array with shape of input filled with value.
+    empty : Return a new uninitialized array.
+    ones : Return a new array setting values to one.
+    zeros : Return a new array setting values to zero.
+
+    Examples
+    --------
+    >>> np.full((2, 2), np.inf)
+    array([[inf, inf],
+           [inf, inf]])
+    >>> np.full((2, 2), 10)
+    array([[10, 10],
+           [10, 10]])
+
+    >>> np.full((2, 2), [1, 2])
+    array([[1, 2],
+           [1, 2]])
+
+    " :arglists '[[shape fill_value & [{dtype :dtype, order :order, like :like}]] [shape fill_value & [{dtype :dtype, like :like}]] [shape fill_value & [{like :like}]]]} full (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "full"))))
+
+(def ^{:doc "
+    Return the elements of an array that satisfy some condition.
+
+    This is equivalent to ``np.compress(ravel(condition), ravel(arr))``.  If
+    `condition` is boolean ``np.extract`` is equivalent to ``arr[condition]``.
+
+    Note that `place` does the exact opposite of `extract`.
+
+    Parameters
+    ----------
+    condition : array_like
+        An array whose nonzero or True entries indicate the elements of `arr`
+        to extract.
+    arr : array_like
+        Input array of the same size as `condition`.
+
+    Returns
+    -------
+    extract : ndarray
+        Rank 1 array of values from `arr` where `condition` is True.
+
+    See Also
+    --------
+    take, put, copyto, compress, place
+
+    Examples
+    --------
+    >>> arr = np.arange(12).reshape((3, 4))
+    >>> arr
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11]])
+    >>> condition = np.mod(arr, 3)==0
+    >>> condition
+    array([[ True, False, False,  True],
+           [False, False,  True, False],
+           [False,  True, False, False]])
+    >>> np.extract(condition, arr)
+    array([0, 3, 6, 9])
+
+
+    If `condition` is boolean:
+
+    >>> arr[condition]
+    array([0, 3, 6, 9])
+
+    " :arglists '[[& [args {:as kwargs}]]]} extract (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "extract"))))
+
+(def ^{:doc "
+    unravel_index(indices, shape, order='C')
+
+    Converts a flat index or array of flat indices into a tuple
+    of coordinate arrays.
+
+    Parameters
+    ----------
+    indices : array_like
+        An integer array whose elements are indices into the flattened
+        version of an array of dimensions ``shape``. Before version 1.6.0,
+        this function accepted just one index value.
+    shape : tuple of ints
+        The shape of the array to use for unraveling ``indices``.
+
+        .. versionchanged:: 1.16.0
+            Renamed from ``dims`` to ``shape``.
+
+    order : {'C', 'F'}, optional
+        Determines whether the indices should be viewed as indexing in
+        row-major (C-style) or column-major (Fortran-style) order.
+
+        .. versionadded:: 1.6.0
+
+    Returns
+    -------
+    unraveled_coords : tuple of ndarray
+        Each array in the tuple has the same shape as the ``indices``
+        array.
+
+    See Also
+    --------
+    ravel_multi_index
+
+    Examples
+    --------
+    >>> np.unravel_index([22, 41, 37], (7,6))
+    (array([3, 6, 6]), array([4, 5, 1]))
+    >>> np.unravel_index([31, 41, 13], (7,6), order='F')
+    (array([3, 6, 6]), array([4, 5, 1]))
+
+    >>> np.unravel_index(1621, (6,7,8,9))
+    (3, 1, 4, 1)
+
+    " :arglists '[[& [args {:as kwargs}]]]} unravel_index (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unravel_index"))))
+
+(def ^{:doc "
+    Return the Blackman window.
+
+    The Blackman window is a taper formed by using the first three
+    terms of a summation of cosines. It was designed to have close to the
+    minimal leakage possible.  It is close to optimal, only slightly worse
+    than a Kaiser window.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an empty
+        array is returned.
+
+    Returns
+    -------
+    out : ndarray
+        The window, with the maximum value normalized to one (the value one
+        appears only if the number of samples is odd).
+
+    See Also
+    --------
+    bartlett, hamming, hanning, kaiser
+
+    Notes
+    -----
+    The Blackman window is defined as
+
+    .. math::  w(n) = 0.42 - 0.5 \\cos(2\\pi n/M) + 0.08 \\cos(4\\pi n/M)
+
+    Most references to the Blackman window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    \"removing the foot\", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function. It is known as a
+    \"near optimal\" tapering function, almost as good (by some measures)
+    as the kaiser window.
+
+    References
+    ----------
+    Blackman, R.B. and Tukey, J.W., (1958) The measurement of power spectra,
+    Dover Publications, New York.
+
+    Oppenheim, A.V., and R.W. Schafer. Discrete-Time Signal Processing.
+    Upper Saddle River, NJ: Prentice-Hall, 1999, pp. 468-471.
+
+    Examples
+    --------
+    >>> import matplotlib.pyplot as plt
+    >>> np.blackman(12)
+    array([-1.38777878e-17,   3.26064346e-02,   1.59903635e-01, # may vary
+            4.14397981e-01,   7.36045180e-01,   9.67046769e-01,
+            9.67046769e-01,   7.36045180e-01,   4.14397981e-01,
+            1.59903635e-01,   3.26064346e-02,  -1.38777878e-17])
+
+    Plot the window and the frequency response:
+
+    >>> from numpy.fft import fft, fftshift
+    >>> window = np.blackman(51)
+    >>> plt.plot(window)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Blackman window\")
+    Text(0.5, 1.0, 'Blackman window')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"Sample\")
+    Text(0.5, 0, 'Sample')
+    >>> plt.show()
+
+    >>> plt.figure()
+    <Figure size 640x480 with 0 Axes>
+    >>> A = fft(window, 2048) / 25.5
+    >>> mag = np.abs(fftshift(A))
+    >>> freq = np.linspace(-0.5, 0.5, len(A))
+    >>> with np.errstate(divide='ignore', invalid='ignore'):
+    ...     response = 20 * np.log10(mag)
+    ...
+    >>> response = np.clip(response, -100, 100)
+    >>> plt.plot(freq, response)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Frequency response of Blackman window\")
+    Text(0.5, 1.0, 'Frequency response of Blackman window')
+    >>> plt.ylabel(\"Magnitude [dB]\")
+    Text(0, 0.5, 'Magnitude [dB]')
+    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
+    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
+    >>> _ = plt.axis('tight')
+    >>> plt.show()
+
+    " :arglists '[[M]]} blackman (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "blackman"))))
+
+(def ^{:doc "
+This module contains a set of functions for vectorized string
+operations and methods.
+
+.. note::
+   The `chararray` class exists for backwards compatibility with
+   Numarray, it is not recommended for new development. Starting from numpy
+   1.4, if one needs arrays of strings, it is recommended to use arrays of
+   `dtype` `object_`, `string_` or `unicode_`, and use the free functions
+   in the `numpy.char` module for fast vectorized string operations.
+
+Some methods will only be available if the corresponding string method is
+available in your version of Python.
+
+The preferred alias for `defchararray` is `numpy.char`.
+
+"} char (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "char"))))
+
+(def ^{:doc "
+    Construct an array by repeating A the number of times given by reps.
+
+    If `reps` has length ``d``, the result will have dimension of
+    ``max(d, A.ndim)``.
+
+    If ``A.ndim < d``, `A` is promoted to be d-dimensional by prepending new
+    axes. So a shape (3,) array is promoted to (1, 3) for 2-D replication,
+    or shape (1, 1, 3) for 3-D replication. If this is not the desired
+    behavior, promote `A` to d-dimensions manually before calling this
+    function.
+
+    If ``A.ndim > d``, `reps` is promoted to `A`.ndim by pre-pending 1's to it.
+    Thus for an `A` of shape (2, 3, 4, 5), a `reps` of (2, 2) is treated as
+    (1, 1, 2, 2).
+
+    Note : Although tile may be used for broadcasting, it is strongly
+    recommended to use numpy's broadcasting operations and functions.
+
+    Parameters
+    ----------
+    A : array_like
+        The input array.
+    reps : array_like
+        The number of repetitions of `A` along each axis.
+
+    Returns
+    -------
+    c : ndarray
+        The tiled output array.
+
+    See Also
+    --------
+    repeat : Repeat elements of an array.
+    broadcast_to : Broadcast an array to a new shape
+
+    Examples
+    --------
+    >>> a = np.array([0, 1, 2])
+    >>> np.tile(a, 2)
+    array([0, 1, 2, 0, 1, 2])
+    >>> np.tile(a, (2, 2))
+    array([[0, 1, 2, 0, 1, 2],
+           [0, 1, 2, 0, 1, 2]])
+    >>> np.tile(a, (2, 1, 2))
+    array([[[0, 1, 2, 0, 1, 2]],
+           [[0, 1, 2, 0, 1, 2]]])
+
+    >>> b = np.array([[1, 2], [3, 4]])
+    >>> np.tile(b, 2)
+    array([[1, 2, 1, 2],
+           [3, 4, 3, 4]])
+    >>> np.tile(b, (2, 1))
+    array([[1, 2],
+           [3, 4],
+           [1, 2],
+           [3, 4]])
+
+    >>> c = np.array([1,2,3,4])
+    >>> np.tile(c,(4,1))
+    array([[1, 2, 3, 4],
+           [1, 2, 3, 4],
+           [1, 2, 3, 4],
+           [1, 2, 3, 4]])
+    " :arglists '[[& [args {:as kwargs}]]]} tile (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tile"))))
+
+(def ^{:doc "Produce an object that mimics broadcasting.
+
+    Parameters
+    ----------
+    in1, in2, ... : array_like
+        Input parameters.
+
+    Returns
+    -------
+    b : broadcast object
+        Broadcast the input parameters against one another, and
+        return an object that encapsulates the result.
+        Amongst others, it has ``shape`` and ``nd`` properties, and
+        may be used as an iterator.
+
+    See Also
+    --------
+    broadcast_arrays
+    broadcast_to
+    broadcast_shapes
+
+    Examples
+    --------
+
+    Manually adding two vectors, using broadcasting:
+
+    >>> x = np.array([[1], [2], [3]])
+    >>> y = np.array([4, 5, 6])
+    >>> b = np.broadcast(x, y)
+
+    >>> out = np.empty(b.shape)
+    >>> out.flat = [u+v for (u,v) in b]
+    >>> out
+    array([[5.,  6.,  7.],
+           [6.,  7.,  8.],
+           [7.,  8.,  9.]])
+
+    Compare against built-in broadcasting:
+
+    >>> x + y
+    array([[5, 6, 7],
+           [6, 7, 8],
+           [7, 8, 9]])" :arglists '[[self & [args {:as kwargs}]]]} broadcast (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "broadcast"))))
+
+(def ^{:doc "Half-precision floating-point number type.
+
+    :Character code: ``'e'``
+    :Canonical name: `numpy.half`
+    :Alias on this platform: `numpy.float16`: 16-bit-precision floating-point number type: sign bit, 5 bits exponent, 10 bits mantissa." :arglists '[[self & [args {:as kwargs}]]]} half (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "half"))))
+
+(def ^{:doc "
+    Find the set difference of two arrays.
+
+    Return the unique values in `ar1` that are not in `ar2`.
+
+    Parameters
+    ----------
+    ar1 : array_like
+        Input array.
+    ar2 : array_like
+        Input comparison array.
+    assume_unique : bool
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  Default is False.
+
+    Returns
+    -------
+    setdiff1d : ndarray
+        1D array of values in `ar1` that are not in `ar2`. The result
+        is sorted when `assume_unique=False`, but otherwise only sorted
+        if the input is sorted.
+
+    See Also
+    --------
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Examples
+    --------
+    >>> a = np.array([1, 2, 3, 2, 4, 1])
+    >>> b = np.array([3, 4, 5, 6])
+    >>> np.setdiff1d(a, b)
+    array([1, 2])
+
+    " :arglists '[[& [args {:as kwargs}]]]} setdiff1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "setdiff1d"))))
+
+(def ^{:doc "remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return element-wise remainder of division.
+
+Computes the remainder complementary to the `floor_divide` function.  It is
+equivalent to the Python modulus operator``x1 % x2`` and has the same sign
+as the divisor `x2`. The MATLAB function equivalent to ``np.remainder``
+is ``mod``.
+
+.. warning::
+
+    This should not be confused with:
+
+    * Python 3.7's `math.remainder` and C's ``remainder``, which
+      computes the IEEE remainder, which are the complement to
+      ``round(x1 / x2)``.
+    * The MATLAB ``rem`` function and or the C ``%`` operator which is the
+      complement to ``int(x1 / x2)``.
+
+Parameters
+----------
+x1 : array_like
+    Dividend array.
+x2 : array_like
+    Divisor array.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+floor_divide : Equivalent of Python ``//`` operator.
+divmod : Simultaneous floor division and remainder.
+fmod : Equivalent of the MATLAB ``rem`` function.
+divide, floor
+
+Notes
+-----
+Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
+integers.
+``mod`` is an alias of ``remainder``.
+
+Examples
+--------
+>>> np.remainder([4, 7], [2, 3])
+array([0, 1])
+>>> np.remainder(np.arange(7), 5)
+array([0, 1, 2, 3, 4, 0, 1])
+
+The ``%`` operator can be used as a shorthand for ``np.remainder`` on
+ndarrays.
+
+>>> x1 = np.arange(7)
+>>> x1 % 5
+array([0, 1, 2, 3, 4, 0, 1])" :arglists '[[self & [args {:as kwargs}]]]} remainder (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "remainder"))))
+
+(def ^{:doc ""} ALLOW_THREADS 1)
+
+(def ^{:doc "exp(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Calculate the exponential of all elements in the input array.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise exponential of `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+expm1 : Calculate ``exp(x) - 1`` for all elements in the array.
+exp2  : Calculate ``2**x`` for all elements in the array.
+
+Notes
+-----
+The irrational number ``e`` is also known as Euler's number.  It is
+approximately 2.718281, and is the base of the natural logarithm,
+``ln`` (this means that, if :math:`x = \\ln y = \\log_e y`,
+then :math:`e^x = y`. For real input, ``exp(x)`` is always positive.
+
+For complex arguments, ``x = a + ib``, we can write
+:math:`e^x = e^a e^{ib}`.  The first term, :math:`e^a`, is already
+known (it is the real argument, described above).  The second term,
+:math:`e^{ib}`, is :math:`\\cos b + i \\sin b`, a function with
+magnitude 1 and a periodic phase.
+
+References
+----------
+.. [1] Wikipedia, \"Exponential function\",
+       https://en.wikipedia.org/wiki/Exponential_function
+.. [2] M. Abramovitz and I. A. Stegun, \"Handbook of Mathematical Functions
+       with Formulas, Graphs, and Mathematical Tables,\" Dover, 1964, p. 69,
+       http://www.math.sfu.ca/~cbm/aands/page_69.htm
+
+Examples
+--------
+Plot the magnitude and phase of ``exp(x)`` in the complex plane:
+
+>>> import matplotlib.pyplot as plt
+
+>>> x = np.linspace(-2*np.pi, 2*np.pi, 100)
+>>> xx = x + 1j * x[:, np.newaxis] # a + ib over complex plane
+>>> out = np.exp(xx)
+
+>>> plt.subplot(121)
+>>> plt.imshow(np.abs(out),
+...            extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='gray')
+>>> plt.title('Magnitude of exp(x)')
+
+>>> plt.subplot(122)
+>>> plt.imshow(np.angle(out),
+...            extent=[-2*np.pi, 2*np.pi, -2*np.pi, 2*np.pi], cmap='hsv')
+>>> plt.title('Phase (angle) of exp(x)')
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]]} exp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "exp"))))
+
+(def ^{:doc "
+    Compute the outer product of two vectors.
+
+    Given two vectors, ``a = [a0, a1, ..., aM]`` and
+    ``b = [b0, b1, ..., bN]``,
+    the outer product [1]_ is::
+
+      [[a0*b0  a0*b1 ... a0*bN ]
+       [a1*b0    .
+       [ ...          .
+       [aM*b0            aM*bN ]]
+
+    Parameters
+    ----------
+    a : (M,) array_like
+        First input vector.  Input is flattened if
+        not already 1-dimensional.
+    b : (N,) array_like
+        Second input vector.  Input is flattened if
+        not already 1-dimensional.
+    out : (M, N) ndarray, optional
+        A location where the result is stored
+
+        .. versionadded:: 1.9.0
+
+    Returns
+    -------
+    out : (M, N) ndarray
+        ``out[i, j] = a[i] * b[j]``
+
+    See also
+    --------
+    inner
+    einsum : ``einsum('i,j->ij', a.ravel(), b.ravel())`` is the equivalent.
+    ufunc.outer : A generalization to dimensions other than 1D and other
+                  operations. ``np.multiply.outer(a.ravel(), b.ravel())``
+                  is the equivalent.
+    tensordot : ``np.tensordot(a.ravel(), b.ravel(), axes=((), ()))``
+                is the equivalent.
+
+    References
+    ----------
+    .. [1] : G. H. Golub and C. F. Van Loan, *Matrix Computations*, 3rd
+             ed., Baltimore, MD, Johns Hopkins University Press, 1996,
+             pg. 8.
+
+    Examples
+    --------
+    Make a (*very* coarse) grid for computing a Mandelbrot set:
+
+    >>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))
+    >>> rl
+    array([[-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.],
+           [-2., -1.,  0.,  1.,  2.]])
+    >>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))
+    >>> im
+    array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
+           [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
+           [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
+           [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
+           [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
+    >>> grid = rl + im
+    >>> grid
+    array([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
+           [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
+           [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
+           [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
+           [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]])
+
+    An example using a \"vector\" of letters:
+
+    >>> x = np.array(['a', 'b', 'c'], dtype=object)
+    >>> np.outer(x, [1, 2, 3])
+    array([['a', 'aa', 'aaa'],
+           ['b', 'bb', 'bbb'],
+           ['c', 'cc', 'ccc']], dtype=object)
+
+    " :arglists '[[& [args {:as kwargs}]]]} outer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "outer"))))
+
+(def ^{:doc "Unsigned integer type, compatible with C ``unsigned char``.
+
+    :Character code: ``'B'``
+    :Canonical name: `numpy.ubyte`
+    :Alias on this platform: `numpy.uint8`: 8-bit unsigned integer (``0`` to ``255``)." :arglists '[[self & [args {:as kwargs}]]]} uint8 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uint8"))))
+
+(def ^{:doc "
+    View inputs as arrays with at least two dimensions.
+
+    Parameters
+    ----------
+    arys1, arys2, ... : array_like
+        One or more array-like sequences.  Non-array inputs are converted
+        to arrays.  Arrays that already have two or more dimensions are
+        preserved.
+
+    Returns
+    -------
+    res, res2, ... : ndarray
+        An array, or list of arrays, each with ``a.ndim >= 2``.
+        Copies are avoided where possible, and views with two or more
+        dimensions are returned.
+
+    See Also
+    --------
+    atleast_1d, atleast_3d
+
+    Examples
+    --------
+    >>> np.atleast_2d(3.0)
+    array([[3.]])
+
+    >>> x = np.arange(3.0)
+    >>> np.atleast_2d(x)
+    array([[0., 1., 2.]])
+    >>> np.atleast_2d(x).base is x
+    True
+
+    >>> np.atleast_2d(1, [1, 2], [[1, 2]])
+    [array([[1]]), array([[1, 2]]), array([[1, 2]])]
+
+    " :arglists '[[& [args {:as kwargs}]]]} atleast_2d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "atleast_2d"))))
+
+(def ^{:doc ""} SHIFT_DIVIDEBYZERO 0)
+
+(def ^{:doc "
+    lexsort(keys, axis=-1)
+
+    Perform an indirect stable sort using a sequence of keys.
+
+    Given multiple sorting keys, which can be interpreted as columns in a
+    spreadsheet, lexsort returns an array of integer indices that describes
+    the sort order by multiple columns. The last key in the sequence is used
+    for the primary sort order, the second-to-last key for the secondary sort
+    order, and so on. The keys argument must be a sequence of objects that
+    can be converted to arrays of the same shape. If a 2D array is provided
+    for the keys argument, its rows are interpreted as the sorting keys and
+    sorting is according to the last row, second last row etc.
+
+    Parameters
+    ----------
+    keys : (k, N) array or tuple containing k (N,)-shaped sequences
+        The `k` different \"columns\" to be sorted.  The last column (or row if
+        `keys` is a 2D array) is the primary sort key.
+    axis : int, optional
+        Axis to be indirectly sorted.  By default, sort over the last axis.
+
+    Returns
+    -------
+    indices : (N,) ndarray of ints
+        Array of indices that sort the keys along the specified axis.
+
+    See Also
+    --------
+    argsort : Indirect sort.
+    ndarray.sort : In-place sort.
+    sort : Return a sorted copy of an array.
+
+    Examples
+    --------
+    Sort names: first by surname, then by name.
+
+    >>> surnames =    ('Hertz',    'Galilei', 'Hertz')
+    >>> first_names = ('Heinrich', 'Galileo', 'Gustav')
+    >>> ind = np.lexsort((first_names, surnames))
+    >>> ind
+    array([1, 2, 0])
+
+    >>> [surnames[i] + \", \" + first_names[i] for i in ind]
+    ['Galilei, Galileo', 'Hertz, Gustav', 'Hertz, Heinrich']
+
+    Sort two columns of numbers:
+
+    >>> a = [1,5,1,4,3,4,4] # First column
+    >>> b = [9,4,0,4,0,2,1] # Second column
+    >>> ind = np.lexsort((b,a)) # Sort by a, then by b
+    >>> ind
+    array([2, 0, 4, 6, 5, 3, 1])
+
+    >>> [(a[i],b[i]) for i in ind]
+    [(1, 0), (1, 9), (3, 0), (4, 1), (4, 2), (4, 4), (5, 4)]
+
+    Note that sorting is first according to the elements of ``a``.
+    Secondary sorting is according to the elements of ``b``.
+
+    A normal ``argsort`` would have yielded:
+
+    >>> [(a[i],b[i]) for i in np.argsort(a)]
+    [(1, 9), (1, 0), (3, 0), (4, 4), (4, 2), (4, 1), (5, 4)]
+
+    Structured arrays are sorted lexically by ``argsort``:
+
+    >>> x = np.array([(1,9), (5,4), (1,0), (4,4), (3,0), (4,2), (4,1)],
+    ...              dtype=np.dtype([('x', int), ('y', int)]))
+
+    >>> np.argsort(x) # or np.argsort(x, order=('x', 'y'))
+    array([2, 0, 4, 6, 5, 3, 1])
+
+    " :arglists '[[& [args {:as kwargs}]]]} lexsort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "lexsort"))))
+
+(def ^{:doc "subtract(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Subtract arguments, element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays to be subtracted from each other.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The difference of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+Equivalent to ``x1 - x2`` in terms of array broadcasting.
+
+Examples
+--------
+>>> np.subtract(1.0, 4.0)
+-3.0
+
+>>> x1 = np.arange(9.0).reshape((3, 3))
+>>> x2 = np.arange(3.0)
+>>> np.subtract(x1, x2)
+array([[ 0.,  0.,  0.],
+       [ 3.,  3.,  3.],
+       [ 6.,  6.,  6.]])
+
+The ``-`` operator can be used as a shorthand for ``np.subtract`` on
+ndarrays.
+
+>>> x1 = np.arange(9.0).reshape((3, 3))
+>>> x2 = np.arange(3.0)
+>>> x1 - x2
+array([[0., 0., 0.],
+       [3., 3., 3.],
+       [6., 6., 6.]])" :arglists '[[self & [args {:as kwargs}]]]} subtract (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "subtract"))))
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} sctypeDict (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "sctypeDict")))) 
+
+(def ^{:doc ""} FPE_OVERFLOW 2)
+
+(def ^{:doc "
+    Returns a bool array, where True if input element is real.
+
+    If element has complex type with zero complex part, the return value
+    for that element is True.
+
+    Parameters
+    ----------
+    x : array_like
+        Input array.
+
+    Returns
+    -------
+    out : ndarray, bool
+        Boolean array of same shape as `x`.
+
+    See Also
+    --------
+    iscomplex
+    isrealobj : Return True if x is not a complex type.
+
+    Examples
+    --------
+    >>> np.isreal([1+1j, 1+0j, 4.5, 3, 2, 2j])
+    array([False,  True,  True,  True,  True, False])
+
+    " :arglists '[[& [args {:as kwargs}]]]} isreal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isreal"))))
+
+(def ^{:doc "
+    Convert an array of size 1 to its scalar equivalent.
+
+    .. deprecated:: 1.16
+
+        Deprecated, use `numpy.ndarray.item()` instead.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input array of size 1.
+
+    Returns
+    -------
+    out : scalar
+        Scalar representation of `a`. The output data type is the same type
+        returned by the input's `item` method.
+
+    Examples
+    --------
+    >>> np.asscalar(np.array([24]))
+    24
+    " :arglists '[[& [args {:as kwargs}]]]} asscalar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asscalar"))))
+
+(def ^{:doc "
+    Return an array drawn from elements in choicelist, depending on conditions.
+
+    Parameters
+    ----------
+    condlist : list of bool ndarrays
+        The list of conditions which determine from which array in `choicelist`
+        the output elements are taken. When multiple conditions are satisfied,
+        the first one encountered in `condlist` is used.
+    choicelist : list of ndarrays
+        The list of arrays from which the output elements are taken. It has
+        to be of the same length as `condlist`.
+    default : scalar, optional
+        The element inserted in `output` when all conditions evaluate to False.
+
+    Returns
+    -------
+    output : ndarray
+        The output at position m is the m-th element of the array in
+        `choicelist` where the m-th element of the corresponding array in
+        `condlist` is True.
+
+    See Also
+    --------
+    where : Return elements from one of two arrays depending on condition.
+    take, choose, compress, diag, diagonal
+
+    Examples
+    --------
+    >>> x = np.arange(10)
+    >>> condlist = [x<3, x>5]
+    >>> choicelist = [x, x**2]
+    >>> np.select(condlist, choicelist)
+    array([ 0,  1,  2, ..., 49, 64, 81])
+
+    " :arglists '[[& [args {:as kwargs}]]]} select (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "select"))))
+
+(def ^{:doc "
+    Return the identity array.
+
+    The identity array is a square array with ones on
+    the main diagonal.
+
+    Parameters
+    ----------
+    n : int
+        Number of rows (and columns) in `n` x `n` output.
+    dtype : data-type, optional
+        Data-type of the output.  Defaults to ``float``.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        `n` x `n` array with its main diagonal set to one,
+        and all other elements 0.
+
+    Examples
+    --------
+    >>> np.identity(3)
+    array([[1.,  0.,  0.],
+           [0.,  1.,  0.],
+           [0.,  0.,  1.]])
+
+    " :arglists '[[n & [{dtype :dtype, like :like}]] [n & [{like :like}]]]} identity (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "identity"))))
+
+(def ^{:doc "
+    Get the current way of handling floating-point errors.
+
+    Returns
+    -------
+    res : dict
+        A dictionary with keys \"divide\", \"over\", \"under\", and \"invalid\",
+        whose values are from the strings \"ignore\", \"print\", \"log\", \"warn\",
+        \"raise\", and \"call\". The keys represent possible floating-point
+        exceptions, and the values define how these exceptions are handled.
+
+    See Also
+    --------
+    geterrcall, seterr, seterrcall
+
+    Notes
+    -----
+    For complete documentation of the types of floating-point exceptions and
+    treatment options, see `seterr`.
+
+    Examples
+    --------
+    >>> from collections import OrderedDict
+    >>> sorted(np.geterr().items())
+    [('divide', 'warn'), ('invalid', 'warn'), ('over', 'warn'), ('under', 'ignore')]
+    >>> np.arange(3.) / np.arange(3.)
+    array([nan,  1.,  1.])
+
+    >>> oldsettings = np.seterr(all='warn', over='raise')
+    >>> OrderedDict(sorted(np.geterr().items()))
+    OrderedDict([('divide', 'warn'), ('invalid', 'warn'), ('over', 'raise'), ('under', 'warn')])
+    >>> np.arange(3.) / np.arange(3.)
+    array([nan,  1.,  1.])
+
+    " :arglists '[[]]} geterr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geterr"))))
+
+(def ^{:doc "
+    Return a 2-D array with ones on the diagonal and zeros elsewhere.
+
+    Parameters
+    ----------
+    N : int
+      Number of rows in the output.
+    M : int, optional
+      Number of columns in the output. If None, defaults to `N`.
+    k : int, optional
+      Index of the diagonal: 0 (the default) refers to the main diagonal,
+      a positive value refers to an upper diagonal, and a negative value
+      to a lower diagonal.
+    dtype : data-type, optional
+      Data-type of the returned array.
+    order : {'C', 'F'}, optional
+        Whether the output should be stored in row-major (C-style) or
+        column-major (Fortran-style) order in memory.
+
+        .. versionadded:: 1.14.0
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    I : ndarray of shape (N,M)
+      An array where all elements are equal to zero, except for the `k`-th
+      diagonal, whose values are equal to one.
+
+    See Also
+    --------
+    identity : (almost) equivalent function
+    diag : diagonal 2-D array from a 1-D array specified by the user.
+
+    Examples
+    --------
+    >>> np.eye(2, dtype=int)
+    array([[1, 0],
+           [0, 1]])
+    >>> np.eye(3, k=1)
+    array([[0.,  1.,  0.],
+           [0.,  0.,  1.],
+           [0.,  0.,  0.]])
+
+    " :arglists '[[N & [{M :M, k :k, dtype :dtype, order :order, like :like}]] [N & [{M :M, k :k, dtype :dtype, like :like}]] [N & [{M :M, k :k, like :like}]] [N & [{M :M, like :like}]] [N & [{like :like}]]]} eye (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "eye"))))
+
+(def ^{:doc "heaviside(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the Heaviside step function.
+
+The Heaviside step function is defined as::
+
+                          0   if x1 < 0
+    heaviside(x1, x2) =  x2   if x1 == 0
+                          1   if x1 > 0
+
+where `x2` is often taken to be 0.5, but 0 and 1 are also sometimes used.
+
+Parameters
+----------
+x1 : array_like
+    Input values.
+x2 : array_like
+    The value of the function when x1 is 0.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    The output array, element-wise Heaviside step function of `x1`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+.. versionadded:: 1.13.0
+
+References
+----------
+.. Wikipedia, \"Heaviside step function\",
+   https://en.wikipedia.org/wiki/Heaviside_step_function
+
+Examples
+--------
+>>> np.heaviside([-1.5, 0, 2.0], 0.5)
+array([ 0. ,  0.5,  1. ])
+>>> np.heaviside([-1.5, 0, 2.0], 1)
+array([ 0.,  1.,  1.])" :arglists '[[self & [args {:as kwargs}]]]} heaviside (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "heaviside"))))
+
+(def ^{:doc "
+    busday_offset(dates, offsets, roll='raise', weekmask='1111100', holidays=None, busdaycal=None, out=None)
+
+    First adjusts the date to fall on a valid day according to
+    the ``roll`` rule, then applies offsets to the given dates
+    counted in valid days.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    dates : array_like of datetime64[D]
+        The array of dates to process.
+    offsets : array_like of int
+        The array of offsets, which is broadcast with ``dates``.
+    roll : {'raise', 'nat', 'forward', 'following', 'backward', 'preceding', 'modifiedfollowing', 'modifiedpreceding'}, optional
+        How to treat dates that do not fall on a valid day. The default
+        is 'raise'.
+
+          * 'raise' means to raise an exception for an invalid day.
+          * 'nat' means to return a NaT (not-a-time) for an invalid day.
+          * 'forward' and 'following' mean to take the first valid day
+            later in time.
+          * 'backward' and 'preceding' mean to take the first valid day
+            earlier in time.
+          * 'modifiedfollowing' means to take the first valid day
+            later in time unless it is across a Month boundary, in which
+            case to take the first valid day earlier in time.
+          * 'modifiedpreceding' means to take the first valid day
+            earlier in time unless it is across a Month boundary, in which
+            case to take the first valid day later in time.
+    weekmask : str or array_like of bool, optional
+        A seven-element array indicating which of Monday through Sunday are
+        valid days. May be specified as a length-seven list or array, like
+        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
+        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
+        weekdays, optionally separated by white space. Valid abbreviations
+        are: Mon Tue Wed Thu Fri Sat Sun
+    holidays : array_like of datetime64[D], optional
+        An array of dates to consider as invalid dates.  They may be
+        specified in any order, and NaT (not-a-time) dates are ignored.
+        This list is saved in a normalized form that is suited for
+        fast calculations of valid days.
+    busdaycal : busdaycalendar, optional
+        A `busdaycalendar` object which specifies the valid days. If this
+        parameter is provided, neither weekmask nor holidays may be
+        provided.
+    out : array of datetime64[D], optional
+        If provided, this array is filled with the result.
+
+    Returns
+    -------
+    out : array of datetime64[D]
+        An array with a shape from broadcasting ``dates`` and ``offsets``
+        together, containing the dates with offsets applied.
+
+    See Also
+    --------
+    busdaycalendar: An object that specifies a custom set of valid days.
+    is_busday : Returns a boolean array indicating valid days.
+    busday_count : Counts how many valid days are in a half-open date range.
+
+    Examples
+    --------
+    >>> # First business day in October 2011 (not accounting for holidays)
+    ... np.busday_offset('2011-10', 0, roll='forward')
+    numpy.datetime64('2011-10-03')
+    >>> # Last business day in February 2012 (not accounting for holidays)
+    ... np.busday_offset('2012-03', -1, roll='forward')
+    numpy.datetime64('2012-02-29')
+    >>> # Third Wednesday in January 2011
+    ... np.busday_offset('2011-01', 2, roll='forward', weekmask='Wed')
+    numpy.datetime64('2011-01-19')
+    >>> # 2012 Mother's Day in Canada and the U.S.
+    ... np.busday_offset('2012-05', 1, roll='forward', weekmask='Sun')
+    numpy.datetime64('2012-05-13')
+
+    >>> # First business day on or after a date
+    ... np.busday_offset('2011-03-20', 0, roll='forward')
+    numpy.datetime64('2011-03-21')
+    >>> np.busday_offset('2011-03-22', 0, roll='forward')
+    numpy.datetime64('2011-03-22')
+    >>> # First business day after a date
+    ... np.busday_offset('2011-03-20', 1, roll='backward')
+    numpy.datetime64('2011-03-21')
+    >>> np.busday_offset('2011-03-22', 1, roll='backward')
+    numpy.datetime64('2011-03-23')
+    " :arglists '[[& [args {:as kwargs}]]]} busday_offset (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "busday_offset"))))
+
+(def ^{:doc "greater_equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the truth value of (x1 >= x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : bool or ndarray of bool
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+greater, less, less_equal, equal, not_equal
+
+Examples
+--------
+>>> np.greater_equal([4, 2, 1], [2, 2, 2])
+array([ True, True, False])
+
+The ``>=`` operator can be used as a shorthand for ``np.greater_equal``
+on ndarrays.
+
+>>> a = np.array([4, 2, 1])
+>>> b = np.array([2, 2, 2])
+>>> a >= b
+array([ True,  True, False])" :arglists '[[self & [args {:as kwargs}]]]} greater_equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "greater_equal"))))
+
+(def ^{:doc ""} ERR_IGNORE 0)
+
+(def ^{:doc "Signed integer type, compatible with C ``unsigned long long``.
+
+    :Character code: ``'Q'``" :arglists '[[self & [args {:as kwargs}]]]} ulonglong (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ulonglong"))))
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} typeDict (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "typeDict")))) 
+
+(def ^{:doc "
+    Split an array into multiple sub-arrays as views into `ary`.
+
+    Parameters
+    ----------
+    ary : ndarray
+        Array to be divided into sub-arrays.
+    indices_or_sections : int or 1-D array
+        If `indices_or_sections` is an integer, N, the array will be divided
+        into N equal arrays along `axis`.  If such a split is not possible,
+        an error is raised.
+
+        If `indices_or_sections` is a 1-D array of sorted integers, the entries
+        indicate where along `axis` the array is split.  For example,
+        ``[2, 3]`` would, for ``axis=0``, result in
+
+          - ary[:2]
+          - ary[2:3]
+          - ary[3:]
+
+        If an index exceeds the dimension of the array along `axis`,
+        an empty sub-array is returned correspondingly.
+    axis : int, optional
+        The axis along which to split, default is 0.
+
+    Returns
+    -------
+    sub-arrays : list of ndarrays
+        A list of sub-arrays as views into `ary`.
+
+    Raises
+    ------
+    ValueError
+        If `indices_or_sections` is given as an integer, but
+        a split does not result in equal division.
+
+    See Also
+    --------
+    array_split : Split an array into multiple sub-arrays of equal or
+                  near-equal size.  Does not raise an exception if
+                  an equal division cannot be made.
+    hsplit : Split array into multiple sub-arrays horizontally (column-wise).
+    vsplit : Split array into multiple sub-arrays vertically (row wise).
+    dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
+    concatenate : Join a sequence of arrays along an existing axis.
+    stack : Join a sequence of arrays along a new axis.
+    hstack : Stack arrays in sequence horizontally (column wise).
+    vstack : Stack arrays in sequence vertically (row wise).
+    dstack : Stack arrays in sequence depth wise (along third dimension).
+
+    Examples
+    --------
+    >>> x = np.arange(9.0)
+    >>> np.split(x, 3)
+    [array([0.,  1.,  2.]), array([3.,  4.,  5.]), array([6.,  7.,  8.])]
+
+    >>> x = np.arange(8.0)
+    >>> np.split(x, [3, 5, 6, 10])
+    [array([0.,  1.,  2.]),
+     array([3.,  4.]),
+     array([5.]),
+     array([6.,  7.]),
+     array([], dtype=float64)]
+
+    " :arglists '[[& [args {:as kwargs}]]]} split (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "split"))))
+
+(def ^{:doc "
+    Return an array converted to a float type.
+
+    Parameters
+    ----------
+    a : array_like
+        The input array.
+    dtype : str or dtype object, optional
+        Float type code to coerce input array `a`.  If `dtype` is one of the
+        'int' dtypes, it is replaced with float64.
+
+    Returns
+    -------
+    out : ndarray
+        The input `a` as a float ndarray.
+
+    Examples
+    --------
+    >>> np.asfarray([2, 3])
+    array([2.,  3.])
+    >>> np.asfarray([2, 3], dtype='float')
+    array([2.,  3.])
+    >>> np.asfarray([2, 3], dtype='int8')
+    array([2.,  3.])
+
+    " :arglists '[[& [args {:as kwargs}]]]} asfarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asfarray"))))
+
+(def ^{:doc "
+    Load ASCII data from a file and return it in a record array.
+
+    If ``usemask=False`` a standard `recarray` is returned,
+    if ``usemask=True`` a MaskedRecords array is returned.
+
+    Parameters
+    ----------
+    fname, kwargs : For a description of input parameters, see `genfromtxt`.
+
+    See Also
+    --------
+    numpy.genfromtxt : generic function
+
+    Notes
+    -----
+    By default, `dtype` is None, which means that the data-type of the output
+    array will be determined from the data.
+
+    " :arglists '[[fname & [{:as kwargs}]]]} recfromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "recfromtxt"))))
+
+(def ^{:doc "
+    empty_like(prototype, dtype=None, order='K', subok=True, shape=None)
+
+    Return a new array with the same shape and type as a given array.
+
+    Parameters
+    ----------
+    prototype : array_like
+        The shape and data-type of `prototype` define these same attributes
+        of the returned array.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+
+        .. versionadded:: 1.6.0
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `prototype` is Fortran
+        contiguous, 'C' otherwise. 'K' means match the layout of `prototype`
+        as closely as possible.
+
+        .. versionadded:: 1.6.0
+    subok : bool, optional.
+        If True, then the newly created array will use the sub-class
+        type of `prototype`, otherwise it will be a base-class array. Defaults
+        to True.
+    shape : int or sequence of ints, optional.
+        Overrides the shape of the result. If order='K' and the number of
+        dimensions is unchanged, will try to keep order, otherwise,
+        order='C' is implied.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of uninitialized (arbitrary) data with the same
+        shape and type as `prototype`.
+
+    See Also
+    --------
+    ones_like : Return an array of ones with shape and type of input.
+    zeros_like : Return an array of zeros with shape and type of input.
+    full_like : Return a new array with shape of input filled with value.
+    empty : Return a new uninitialized array.
+
+    Notes
+    -----
+    This function does *not* initialize the returned array; to do that use
+    `zeros_like` or `ones_like` instead.  It may be marginally faster than
+    the functions that do set the array values.
+
+    Examples
+    --------
+    >>> a = ([1,2,3], [4,5,6])                         # a is array-like
+    >>> np.empty_like(a)
+    array([[-1073741821, -1073741821,           3],    # uninitialized
+           [          0,           0, -1073741821]])
+    >>> a = np.array([[1., 2., 3.],[4.,5.,6.]])
+    >>> np.empty_like(a)
+    array([[ -2.00000715e+000,   1.48219694e-323,  -2.00000572e+000], # uninitialized
+           [  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} empty_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "empty_like"))))
+
+(def ^{:doc "log10(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the base 10 logarithm of the input array, element-wise.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The logarithm to the base 10 of `x`, element-wise. NaNs are
+    returned where x is negative.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+emath.log10
+
+Notes
+-----
+Logarithm is a multivalued function: for each `x` there is an infinite
+number of `z` such that `10**z = x`. The convention is to return the
+`z` whose imaginary part lies in `[-pi, pi]`.
+
+For real-valued input data types, `log10` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `log10` is a complex analytical function that
+has a branch cut `[-inf, 0]` and is continuous from above on it.
+`log10` handles the floating-point negative zero as an infinitesimal
+negative number, conforming to the C99 standard.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 67. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Logarithm\". https://en.wikipedia.org/wiki/Logarithm
+
+Examples
+--------
+>>> np.log10([1e-15, -3.])
+array([-15.,  nan])" :arglists '[[self & [args {:as kwargs}]]]} log10 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log10"))))
+
+(def ^{:doc "
+    Return the indices to access (n, n) arrays, given a masking function.
+
+    Assume `mask_func` is a function that, for a square array a of size
+    ``(n, n)`` with a possible offset argument `k`, when called as
+    ``mask_func(a, k)`` returns a new array with zeros in certain locations
+    (functions like `triu` or `tril` do precisely this). Then this function
+    returns the indices where the non-zero values would be located.
+
+    Parameters
+    ----------
+    n : int
+        The returned indices will be valid to access arrays of shape (n, n).
+    mask_func : callable
+        A function whose call signature is similar to that of `triu`, `tril`.
+        That is, ``mask_func(x, k)`` returns a boolean array, shaped like `x`.
+        `k` is an optional argument to the function.
+    k : scalar
+        An optional argument which is passed through to `mask_func`. Functions
+        like `triu`, `tril` take a second argument that is interpreted as an
+        offset.
+
+    Returns
+    -------
+    indices : tuple of arrays.
+        The `n` arrays of indices corresponding to the locations where
+        ``mask_func(np.ones((n, n)), k)`` is True.
+
+    See Also
+    --------
+    triu, tril, triu_indices, tril_indices
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    These are the indices that would allow you to access the upper triangular
+    part of any 3x3 array:
+
+    >>> iu = np.mask_indices(3, np.triu)
+
+    For example, if `a` is a 3x3 array:
+
+    >>> a = np.arange(9).reshape(3, 3)
+    >>> a
+    array([[0, 1, 2],
+           [3, 4, 5],
+           [6, 7, 8]])
+    >>> a[iu]
+    array([0, 1, 2, 4, 5, 8])
+
+    An offset can be passed also to the masking function.  This gets us the
+    indices starting on the first diagonal right of the main one:
+
+    >>> iu1 = np.mask_indices(3, np.triu, 1)
+
+    with which we now extract only three elements:
+
+    >>> a[iu1]
+    array([1, 2, 5])
+
+    " :arglists '[[n mask_func & [{k :k}]] [n mask_func]]} mask_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mask_indices"))))
+
+(def ^{:doc "A unicode string.
+
+    When used in arrays, this type strips trailing null codepoints.
+
+    Unlike the builtin `str`, this supports the :ref:`python:bufferobjects`, exposing its
+    contents as UCS4:
+
+    >>> m = memoryview(np.str_(\"abc\"))
+    >>> m.format
+    '3w'
+    >>> m.tobytes()
+    b'a\\x00\\x00\\x00b\\x00\\x00\\x00c\\x00\\x00\\x00'
+
+    :Character code: ``'U'``
+    :Alias: `numpy.unicode_`" :arglists '[[self & [args {:as kwargs}]]]} str0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "str0"))))
+
+(def ^{:doc "Abstract base class of all numeric scalar types." :arglists '[[self & [args {:as kwargs}]]]} number (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "number"))))
+
+(def ^{:doc "
+    Return the indices of the maximum values in the specified axis ignoring
+    NaNs. For all-NaN slices ``ValueError`` is raised. Warning: the
+    results cannot be trusted if a slice contains only NaNs and -Infs.
+
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : int, optional
+        Axis along which to operate.  By default flattened input is used.
+
+    Returns
+    -------
+    index_array : ndarray
+        An array of indices or a single index value.
+
+    See Also
+    --------
+    argmax, nanargmin
+
+    Examples
+    --------
+    >>> a = np.array([[np.nan, 4], [2, 3]])
+    >>> np.argmax(a)
+    0
+    >>> np.nanargmax(a)
+    1
+    >>> np.nanargmax(a, axis=0)
+    array([1, 0])
+    >>> np.nanargmax(a, axis=1)
+    array([1, 1])
+
+    " :arglists '[[& [args {:as kwargs}]]]} nanargmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanargmax"))))
+
+(def ^{:doc "
+    Return the normalized sinc function.
+
+    The sinc function is :math:`\\sin(\\pi x)/(\\pi x)`.
+
+    .. note::
+
+        Note the normalization factor of ``pi`` used in the definition.
+        This is the most commonly used definition in signal processing.
+        Use ``sinc(x / np.pi)`` to obtain the unnormalized sinc function
+        :math:`\\sin(x)/(x)` that is more common in mathematics.
+
+    Parameters
+    ----------
+    x : ndarray
+        Array (possibly multi-dimensional) of values for which to to
+        calculate ``sinc(x)``.
+
+    Returns
+    -------
+    out : ndarray
+        ``sinc(x)``, which has the same shape as the input.
+
+    Notes
+    -----
+    ``sinc(0)`` is the limit value 1.
+
+    The name sinc is short for \"sine cardinal\" or \"sinus cardinalis\".
+
+    The sinc function is used in various signal processing applications,
+    including in anti-aliasing, in the construction of a Lanczos resampling
+    filter, and in interpolation.
+
+    For bandlimited interpolation of discrete-time signals, the ideal
+    interpolation kernel is proportional to the sinc function.
+
+    References
+    ----------
+    .. [1] Weisstein, Eric W. \"Sinc Function.\" From MathWorld--A Wolfram Web
+           Resource. http://mathworld.wolfram.com/SincFunction.html
+    .. [2] Wikipedia, \"Sinc function\",
+           https://en.wikipedia.org/wiki/Sinc_function
+
+    Examples
+    --------
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.linspace(-4, 4, 41)
+    >>> np.sinc(x)
+     array([-3.89804309e-17,  -4.92362781e-02,  -8.40918587e-02, # may vary
+            -8.90384387e-02,  -5.84680802e-02,   3.89804309e-17,
+            6.68206631e-02,   1.16434881e-01,   1.26137788e-01,
+            8.50444803e-02,  -3.89804309e-17,  -1.03943254e-01,
+            -1.89206682e-01,  -2.16236208e-01,  -1.55914881e-01,
+            3.89804309e-17,   2.33872321e-01,   5.04551152e-01,
+            7.56826729e-01,   9.35489284e-01,   1.00000000e+00,
+            9.35489284e-01,   7.56826729e-01,   5.04551152e-01,
+            2.33872321e-01,   3.89804309e-17,  -1.55914881e-01,
+           -2.16236208e-01,  -1.89206682e-01,  -1.03943254e-01,
+           -3.89804309e-17,   8.50444803e-02,   1.26137788e-01,
+            1.16434881e-01,   6.68206631e-02,   3.89804309e-17,
+            -5.84680802e-02,  -8.90384387e-02,  -8.40918587e-02,
+            -4.92362781e-02,  -3.89804309e-17])
+
+    >>> plt.plot(x, np.sinc(x))
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Sinc Function\")
+    Text(0.5, 1.0, 'Sinc Function')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"X\")
+    Text(0.5, 0, 'X')
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]]} sinc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sinc"))))
+
+(def ^{:doc "fmax(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Element-wise maximum of array elements.
+
+Compare two arrays and returns a new array containing the element-wise
+maxima. If one of the elements being compared is a NaN, then the
+non-nan element is returned. If both elements are NaNs then the first
+is returned.  The latter distinction is important for complex NaNs,
+which are defined as at least one of the real or imaginary parts being
+a NaN. The net effect is that NaNs are ignored when possible.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays holding the elements to be compared.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The maximum of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+fmin :
+    Element-wise minimum of two arrays, ignores NaNs.
+maximum :
+    Element-wise maximum of two arrays, propagates NaNs.
+amax :
+    The maximum value of an array along a given axis, propagates NaNs.
+nanmax :
+    The maximum value of an array along a given axis, ignores NaNs.
+
+minimum, amin, nanmin
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+The fmax is equivalent to ``np.where(x1 >= x2, x1, x2)`` when neither
+x1 nor x2 are NaNs, but it is faster and does proper broadcasting.
+
+Examples
+--------
+>>> np.fmax([2, 3, 4], [1, 5, 2])
+array([ 2.,  5.,  4.])
+
+>>> np.fmax(np.eye(2), [0.5, 2])
+array([[ 1. ,  2. ],
+       [ 0.5,  2. ]])
+
+>>> np.fmax([np.nan, 0, np.nan],[0, np.nan, np.nan])
+array([ 0.,  0., nan])" :arglists '[[self & [args {:as kwargs}]]]} fmax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fmax"))))
+
+(def ^{:doc "Return a contiguous flattened array.
+
+    A 1-D array, containing the elements of the input, is returned.  A copy is
+    made only if needed.
+
+    As of NumPy 1.10, the returned array will have the same type as the input
+    array. (for example, a masked array will be returned for a masked array
+    input)
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.  The elements in `a` are read in the order specified by
+        `order`, and packed as a 1-D array.
+    order : {'C','F', 'A', 'K'}, optional
+
+        The elements of `a` are read using this index order. 'C' means
+        to index the elements in row-major, C-style order,
+        with the last axis index changing fastest, back to the first
+        axis index changing slowest.  'F' means to index the elements
+        in column-major, Fortran-style order, with the
+        first index changing fastest, and the last index changing
+        slowest. Note that the 'C' and 'F' options take no account of
+        the memory layout of the underlying array, and only refer to
+        the order of axis indexing.  'A' means to read the elements in
+        Fortran-like index order if `a` is Fortran *contiguous* in
+        memory, C-like order otherwise.  'K' means to read the
+        elements in the order they occur in memory, except for
+        reversing the data when strides are negative.  By default, 'C'
+        index order is used.
+
+    Returns
+    -------
+    y : array_like
+        y is an array of the same subtype as `a`, with shape ``(a.size,)``.
+        Note that matrices are special cased for backward compatibility, if `a`
+        is a matrix, then y is a 1-D ndarray.
+
+    See Also
+    --------
+    ndarray.flat : 1-D iterator over an array.
+    ndarray.flatten : 1-D array copy of the elements of an array
+                      in row-major order.
+    ndarray.reshape : Change the shape of an array without changing its data.
+
+    Notes
+    -----
+    In row-major, C-style order, in two dimensions, the row index
+    varies the slowest, and the column index the quickest.  This can
+    be generalized to multiple dimensions, where row-major order
+    implies that the index along the first axis varies slowest, and
+    the index along the last quickest.  The opposite holds for
+    column-major, Fortran-style index ordering.
+
+    When a view is desired in as many cases as possible, ``arr.reshape(-1)``
+    may be preferable.
+
+    Examples
+    --------
+    It is equivalent to ``reshape(-1, order=order)``.
+
+    >>> x = np.array([[1, 2, 3], [4, 5, 6]])
+    >>> np.ravel(x)
+    array([1, 2, 3, 4, 5, 6])
+
+    >>> x.reshape(-1)
+    array([1, 2, 3, 4, 5, 6])
+
+    >>> np.ravel(x, order='F')
+    array([1, 4, 2, 5, 3, 6])
+
+    When ``order`` is 'A', it will preserve the array's 'C' or 'F' ordering:
+
+    >>> np.ravel(x.T)
+    array([1, 4, 2, 5, 3, 6])
+    >>> np.ravel(x.T, order='A')
+    array([1, 2, 3, 4, 5, 6])
+
+    When ``order`` is 'K', it will preserve orderings that are neither 'C'
+    nor 'F', but won't reverse axes:
+
+    >>> a = np.arange(3)[::-1]; a
+    array([2, 1, 0])
+    >>> a.ravel(order='C')
+    array([2, 1, 0])
+    >>> a.ravel(order='K')
+    array([2, 1, 0])
+
+    >>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); a
+    array([[[ 0,  2,  4],
+            [ 1,  3,  5]],
+           [[ 6,  8, 10],
+            [ 7,  9, 11]]])
+    >>> a.ravel(order='C')
+    array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])
+    >>> a.ravel(order='K')
+    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
+
+    " :arglists '[[& [args {:as kwargs}]]]} ravel (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ravel"))))
+
+(def ^{:doc "
+    Cross-correlation of two 1-dimensional sequences.
+
+    This function computes the correlation as generally defined in signal
+    processing texts::
+
+        c_{av}[k] = sum_n a[n+k] * conj(v[n])
+
+    with a and v sequences being zero-padded where necessary and conj being
+    the conjugate.
+
+    Parameters
+    ----------
+    a, v : array_like
+        Input sequences.
+    mode : {'valid', 'same', 'full'}, optional
+        Refer to the `convolve` docstring.  Note that the default
+        is 'valid', unlike `convolve`, which uses 'full'.
+    old_behavior : bool
+        `old_behavior` was removed in NumPy 1.10. If you need the old
+        behavior, use `multiarray.correlate`.
+
+    Returns
+    -------
+    out : ndarray
+        Discrete cross-correlation of `a` and `v`.
+
+    See Also
+    --------
+    convolve : Discrete, linear convolution of two one-dimensional sequences.
+    multiarray.correlate : Old, no conjugate, version of correlate.
+
+    Notes
+    -----
+    The definition of correlation above is not unique and sometimes correlation
+    may be defined differently. Another common definition is::
+
+        c'_{av}[k] = sum_n a[n] conj(v[n+k])
+
+    which is related to ``c_{av}[k]`` by ``c'_{av}[k] = c_{av}[-k]``.
+
+    Examples
+    --------
+    >>> np.correlate([1, 2, 3], [0, 1, 0.5])
+    array([3.5])
+    >>> np.correlate([1, 2, 3], [0, 1, 0.5], \"same\")
+    array([2. ,  3.5,  3. ])
+    >>> np.correlate([1, 2, 3], [0, 1, 0.5], \"full\")
+    array([0.5,  2. ,  3.5,  3. ,  0. ])
+
+    Using complex sequences:
+
+    >>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full')
+    array([ 0.5-0.5j,  1.0+0.j ,  1.5-1.5j,  3.0-1.j ,  0.0+0.j ])
+
+    Note that you get the time reversed, complex conjugated result
+    when the two input sequences change places, i.e.,
+    ``c_{va}[k] = c^{*}_{av}[-k]``:
+
+    >>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')
+    array([ 0.0+0.j ,  3.0+1.j ,  1.5+1.5j,  1.0+0.j ,  0.5+0.5j])
+
+    " :arglists '[[& [args {:as kwargs}]]]} correlate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "correlate"))))
+
+(def ^{:doc "
+    Return minimum of an array or minimum along an axis, ignoring any NaNs.
+    When all-NaN slices are encountered a ``RuntimeWarning`` is raised and
+    Nan is returned for that slice.
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose minimum is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the minimum is computed. The default is to compute
+        the minimum of the flattened array.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary. See
+        :ref:`ufuncs-output-type` for more details.
+
+        .. versionadded:: 1.8.0
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `min` method
+        of sub-classes of `ndarray`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+        .. versionadded:: 1.8.0
+
+    Returns
+    -------
+    nanmin : ndarray
+        An array with the same shape as `a`, with the specified axis
+        removed.  If `a` is a 0-d array, or if axis is None, an ndarray
+        scalar is returned.  The same dtype as `a` is returned.
+
+    See Also
+    --------
+    nanmax :
+        The maximum value of an array along a given axis, ignoring any NaNs.
+    amin :
+        The minimum value of an array along a given axis, propagating any NaNs.
+    fmin :
+        Element-wise minimum of two arrays, ignoring any NaNs.
+    minimum :
+        Element-wise minimum of two arrays, propagating any NaNs.
+    isnan :
+        Shows which elements are Not a Number (NaN).
+    isfinite:
+        Shows which elements are neither NaN nor infinity.
+
+    amax, fmax, maximum
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+    Positive infinity is treated as a very large number and negative
+    infinity is treated as a very small (i.e. negative) number.
+
+    If the input has a integer type the function is equivalent to np.min.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, np.nan]])
+    >>> np.nanmin(a)
+    1.0
+    >>> np.nanmin(a, axis=0)
+    array([1.,  2.])
+    >>> np.nanmin(a, axis=1)
+    array([1.,  3.])
+
+    When positive infinity and negative infinity are present:
+
+    >>> np.nanmin([1, 2, np.nan, np.inf])
+    1.0
+    >>> np.nanmin([1, 2, np.nan, np.NINF])
+    -inf
+
+    " :arglists '[[& [args {:as kwargs}]]]} nanmin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmin"))))
+
+(def ^{:doc "
+    Find the sum of two polynomials.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide </reference/routines.polynomials>`.
+
+    Returns the polynomial resulting from the sum of two input polynomials.
+    Each input must be either a poly1d object or a 1D sequence of polynomial
+    coefficients, from highest to lowest degree.
+
+    Parameters
+    ----------
+    a1, a2 : array_like or poly1d object
+        Input polynomials.
+
+    Returns
+    -------
+    out : ndarray or poly1d object
+        The sum of the inputs. If either input is a poly1d object, then the
+        output is also a poly1d object. Otherwise, it is a 1D array of
+        polynomial coefficients from highest to lowest degree.
+
+    See Also
+    --------
+    poly1d : A one-dimensional polynomial class.
+    poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
+
+    Examples
+    --------
+    >>> np.polyadd([1, 2], [9, 5, 4])
+    array([9, 6, 6])
+
+    Using poly1d objects:
+
+    >>> p1 = np.poly1d([1, 2])
+    >>> p2 = np.poly1d([9, 5, 4])
+    >>> print(p1)
+    1 x + 2
+    >>> print(p2)
+       2
+    9 x + 5 x + 4
+    >>> print(np.polyadd(p1, p2))
+       2
+    9 x + 6 x + 6
+
+    " :arglists '[[& [args {:as kwargs}]]]} polyadd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyadd"))))
+
+(def ^{:doc "The specification for a module, used for loading.
+
+    A module's spec is the source for information about the module.  For
+    data associated with the module, including source, use the spec's
+    loader.
+
+    `name` is the absolute name of the module.  `loader` is the loader
+    to use when loading the module.  `parent` is the name of the
+    package the module is in.  The parent is derived from the name.
+
+    `is_package` determines if the module is considered a package or
+    not.  On modules this is reflected by the `__path__` attribute.
+
+    `origin` is the specific location used by the loader from which to
+    load the module, if that information is available.  When filename is
+    set, origin will match.
+
+    `has_location` indicates that a spec's \"origin\" reflects a location.
+    When this is True, `__file__` attribute of the module is set.
+
+    `cached` is the location of the cached bytecode file, if any.  It
+    corresponds to the `__cached__` attribute.
+
+    `submodule_search_locations` is the sequence of path entries to
+    search when importing submodules.  If set, is_package should be
+    True--and False otherwise.
+
+    Packages are simply modules that (may) have submodules.  If a spec
+    has a non-None value in `submodule_search_locations`, the import
+    system will consider modules loaded from the spec as packages.
+
+    Only finders (see importlib.abc.MetaPathFinder and
+    importlib.abc.PathEntryFinder) should modify ModuleSpec instances.
+
+    "} __spec__ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "__spec__"))))
+
+(def ^{:doc "arcsinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Inverse hyperbolic sine element-wise.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Array of the same shape as `x`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+`arcsinh` is a multivalued function: for each `x` there are infinitely
+many numbers `z` such that `sinh(z) = x`. The convention is to return the
+`z` whose imaginary part lies in `[-pi/2, pi/2]`.
+
+For real-valued input data types, `arcsinh` always returns real output.
+For each value that cannot be expressed as a real number or infinity, it
+returns ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arccos` is a complex analytical function that
+has branch cuts `[1j, infj]` and `[-1j, -infj]` and is continuous from
+the right on the former and from the left on the latter.
+
+The inverse hyperbolic sine is also known as `asinh` or ``sinh^-1``.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Inverse hyperbolic function\",
+       https://en.wikipedia.org/wiki/Arcsinh
+
+Examples
+--------
+>>> np.arcsinh(np.array([np.e, 10.0]))
+array([ 1.72538256,  2.99822295])" :arglists '[[self & [args {:as kwargs}]]]} arcsinh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arcsinh"))))
+
+(def ^{:doc "
+    A nicer way to build up index tuples for arrays.
+
+    .. note::
+       Use one of the two predefined instances `index_exp` or `s_`
+       rather than directly using `IndexExpression`.
+
+    For any index combination, including slicing and axis insertion,
+    ``a[indices]`` is the same as ``a[np.index_exp[indices]]`` for any
+    array `a`. However, ``np.index_exp[indices]`` can be used anywhere
+    in Python code and returns a tuple of slice objects that can be
+    used in the construction of complex index expressions.
+
+    Parameters
+    ----------
+    maketuple : bool
+        If True, always returns a tuple.
+
+    See Also
+    --------
+    index_exp : Predefined instance that always returns a tuple:
+       `index_exp = IndexExpression(maketuple=True)`.
+    s_ : Predefined instance without tuple conversion:
+       `s_ = IndexExpression(maketuple=False)`.
+
+    Notes
+    -----
+    You can do all this with `slice()` plus a few special objects,
+    but there's a lot to remember and this version is simpler because
+    it uses the standard array indexing syntax.
+
+    Examples
+    --------
+    >>> np.s_[2::2]
+    slice(2, None, 2)
+    >>> np.index_exp[2::2]
+    (slice(2, None, 2),)
+
+    >>> np.array([0, 1, 2, 3, 4])[np.s_[2::2]]
+    array([2, 4])
+
+    "} index_exp (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "index_exp"))))
+
+(def ^{:doc "
+    The warning raised when casting a complex dtype to a real dtype.
+
+    As implemented, casting a complex number to a real discards its imaginary
+    part, but this behavior may not be what the user actually wants.
+
+    " :arglists '[[self & [args {:as kwargs}]]]} ComplexWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ComplexWarning"))))
+
+(def ^{:doc "
+    Determines whether the given object represents a scalar data-type.
+
+    Parameters
+    ----------
+    rep : any
+        If `rep` is an instance of a scalar dtype, True is returned. If not,
+        False is returned.
+
+    Returns
+    -------
+    out : bool
+        Boolean result of check whether `rep` is a scalar dtype.
+
+    See Also
+    --------
+    issubsctype, issubdtype, obj2sctype, sctype2char
+
+    Examples
+    --------
+    >>> np.issctype(np.int32)
+    True
+    >>> np.issctype(list)
+    False
+    >>> np.issctype(1.1)
+    False
+
+    Strings are also a scalar type:
+
+    >>> np.issctype(np.dtype('str'))
+    True
+
+    " :arglists '[[rep]]} issctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issctype"))))
+
+(def ^{:doc "sqrt(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the non-negative square-root of an array, element-wise.
+
+Parameters
+----------
+x : array_like
+    The values whose square-roots are required.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    An array of the same shape as `x`, containing the positive
+    square-root of each element in `x`.  If any element in `x` is
+    complex, a complex array is returned (and the square-roots of
+    negative reals are calculated).  If all of the elements in `x`
+    are real, so is `y`, with negative elements returning ``nan``.
+    If `out` was provided, `y` is a reference to it.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+lib.scimath.sqrt
+    A version which returns complex numbers when given negative reals.
+
+Notes
+-----
+*sqrt* has--consistent with common convention--as its branch cut the
+real \"interval\" [`-inf`, 0), and is continuous from above on it.
+A branch cut is a curve in the complex plane across which a given
+complex function fails to be continuous.
+
+Examples
+--------
+>>> np.sqrt([1,4,9])
+array([ 1.,  2.,  3.])
+
+>>> np.sqrt([4, -1, -3+4J])
+array([ 2.+0.j,  0.+1.j,  1.+2.j])
+
+>>> np.sqrt([4, -1, np.inf])
+array([ 2., nan, inf])" :arglists '[[self & [args {:as kwargs}]]]} sqrt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sqrt"))))
+
+(def ^{:doc "
+    Find the product of two polynomials.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide </reference/routines.polynomials>`.
+
+    Finds the polynomial resulting from the multiplication of the two input
+    polynomials. Each input must be either a poly1d object or a 1D sequence
+    of polynomial coefficients, from highest to lowest degree.
+
+    Parameters
+    ----------
+    a1, a2 : array_like or poly1d object
+        Input polynomials.
+
+    Returns
+    -------
+    out : ndarray or poly1d object
+        The polynomial resulting from the multiplication of the inputs. If
+        either inputs is a poly1d object, then the output is also a poly1d
+        object. Otherwise, it is a 1D array of polynomial coefficients from
+        highest to lowest degree.
+
+    See Also
+    --------
+    poly1d : A one-dimensional polynomial class.
+    poly, polyadd, polyder, polydiv, polyfit, polyint, polysub, polyval
+    convolve : Array convolution. Same output as polymul, but has parameter
+               for overlap mode.
+
+    Examples
+    --------
+    >>> np.polymul([1, 2, 3], [9, 5, 1])
+    array([ 9, 23, 38, 17,  3])
+
+    Using poly1d objects:
+
+    >>> p1 = np.poly1d([1, 2, 3])
+    >>> p2 = np.poly1d([9, 5, 1])
+    >>> print(p1)
+       2
+    1 x + 2 x + 3
+    >>> print(p2)
+       2
+    9 x + 5 x + 1
+    >>> print(np.polymul(p1, p2))
+       4      3      2
+    9 x + 23 x + 38 x + 17 x + 3
+
+    " :arglists '[[& [args {:as kwargs}]]]} polymul (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polymul"))))
+
+(def ^{:doc "empty(shape, dtype=float, order='C', *, like=None)
+
+    Return a new array of given shape and type, without initializing entries.
+
+    Parameters
+    ----------
+    shape : int or tuple of int
+        Shape of the empty array, e.g., ``(2, 3)`` or ``2``.
+    dtype : data-type, optional
+        Desired output data-type for the array, e.g, `numpy.int8`. Default is
+        `numpy.float64`.
+    order : {'C', 'F'}, optional, default: 'C'
+        Whether to store multi-dimensional data in row-major
+        (C-style) or column-major (Fortran-style) order in
+        memory.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of uninitialized (arbitrary) data of the given shape, dtype, and
+        order.  Object arrays will be initialized to None.
+
+    See Also
+    --------
+    empty_like : Return an empty array with shape and type of input.
+    ones : Return a new array setting values to one.
+    zeros : Return a new array setting values to zero.
+    full : Return a new array of given shape filled with value.
+
+
+    Notes
+    -----
+    `empty`, unlike `zeros`, does not set the array values to zero,
+    and may therefore be marginally faster.  On the other hand, it requires
+    the user to manually set all the values in the array, and should be
+    used with caution.
+
+    Examples
+    --------
+    >>> np.empty([2, 2])
+    array([[ -9.74499359e+001,   6.69583040e-309],
+           [  2.13182611e-314,   3.06959433e-309]])         #uninitialized
+
+    >>> np.empty([2, 2], dtype=int)
+    array([[-1073741821, -1067949133],
+           [  496041986,    19249760]])                     #uninitialized" :arglists '[[self & [args {:as kwargs}]]]} empty (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "empty"))))
+
+(def ^{:doc "Any Python object.
+
+    :Character code: ``'O'``" :arglists '[[self & [args {:as kwargs}]]]} object0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "object0"))))
+
+(def ^{:doc "
+    Return the number of dimensions of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.  If it is not already an ndarray, a conversion is
+        attempted.
+
+    Returns
+    -------
+    number_of_dimensions : int
+        The number of dimensions in `a`.  Scalars are zero-dimensional.
+
+    See Also
+    --------
+    ndarray.ndim : equivalent method
+    shape : dimensions of array
+    ndarray.shape : dimensions of array
+
+    Examples
+    --------
+    >>> np.ndim([[1,2,3],[4,5,6]])
+    2
+    >>> np.ndim(np.array([[1,2,3],[4,5,6]]))
+    2
+    >>> np.ndim(1)
+    0
+
+    " :arglists '[[& [args {:as kwargs}]]]} ndim (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ndim"))))
+
+(def ^{:doc "
+    Least squares polynomial fit.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide </reference/routines.polynomials>`.
+
+    Fit a polynomial ``p(x) = p[0] * x**deg + ... + p[deg]`` of degree `deg`
+    to points `(x, y)`. Returns a vector of coefficients `p` that minimises
+    the squared error in the order `deg`, `deg-1`, ... `0`.
+
+    The `Polynomial.fit <numpy.polynomial.polynomial.Polynomial.fit>` class
+    method is recommended for new code as it is more stable numerically. See
+    the documentation of the method for more information.
+
+    Parameters
+    ----------
+    x : array_like, shape (M,)
+        x-coordinates of the M sample points ``(x[i], y[i])``.
+    y : array_like, shape (M,) or (M, K)
+        y-coordinates of the sample points. Several data sets of sample
+        points sharing the same x-coordinates can be fitted at once by
+        passing in a 2D-array that contains one dataset per column.
+    deg : int
+        Degree of the fitting polynomial
+    rcond : float, optional
+        Relative condition number of the fit. Singular values smaller than
+        this relative to the largest singular value will be ignored. The
+        default value is len(x)*eps, where eps is the relative precision of
+        the float type, about 2e-16 in most cases.
+    full : bool, optional
+        Switch determining nature of return value. When it is False (the
+        default) just the coefficients are returned, when True diagnostic
+        information from the singular value decomposition is also returned.
+    w : array_like, shape (M,), optional
+        Weights to apply to the y-coordinates of the sample points. For
+        gaussian uncertainties, use 1/sigma (not 1/sigma**2).
+    cov : bool or str, optional
+        If given and not `False`, return not just the estimate but also its
+        covariance matrix. By default, the covariance are scaled by
+        chi2/dof, where dof = M - (deg + 1), i.e., the weights are presumed 
+        to be unreliable except in a relative sense and everything is scaled 
+        such that the reduced chi2 is unity. This scaling is omitted if 
+        ``cov='unscaled'``, as is relevant for the case that the weights are 
+        1/sigma**2, with sigma known to be a reliable estimate of the 
+        uncertainty.
+
+    Returns
+    -------
+    p : ndarray, shape (deg + 1,) or (deg + 1, K)
+        Polynomial coefficients, highest power first.  If `y` was 2-D, the
+        coefficients for `k`-th data set are in ``p[:,k]``.
+
+    residuals, rank, singular_values, rcond
+        Present only if `full` = True.  Residuals is sum of squared residuals
+        of the least-squares fit, the effective rank of the scaled Vandermonde
+        coefficient matrix, its singular values, and the specified value of
+        `rcond`. For more details, see `linalg.lstsq`.
+
+    V : ndarray, shape (M,M) or (M,M,K)
+        Present only if `full` = False and `cov`=True.  The covariance
+        matrix of the polynomial coefficient estimates.  The diagonal of
+        this matrix are the variance estimates for each coefficient.  If y
+        is a 2-D array, then the covariance matrix for the `k`-th data set
+        are in ``V[:,:,k]``
+
+
+    Warns
+    -----
+    RankWarning
+        The rank of the coefficient matrix in the least-squares fit is
+        deficient. The warning is only raised if `full` = False.
+
+        The warnings can be turned off by
+
+        >>> import warnings
+        >>> warnings.simplefilter('ignore', np.RankWarning)
+
+    See Also
+    --------
+    polyval : Compute polynomial values.
+    linalg.lstsq : Computes a least-squares fit.
+    scipy.interpolate.UnivariateSpline : Computes spline fits.
+
+    Notes
+    -----
+    The solution minimizes the squared error
+
+    .. math ::
+        E = \\sum_{j=0}^k |p(x_j) - y_j|^2
+
+    in the equations::
+
+        x[0]**n * p[0] + ... + x[0] * p[n-1] + p[n] = y[0]
+        x[1]**n * p[0] + ... + x[1] * p[n-1] + p[n] = y[1]
+        ...
+        x[k]**n * p[0] + ... + x[k] * p[n-1] + p[n] = y[k]
+
+    The coefficient matrix of the coefficients `p` is a Vandermonde matrix.
+
+    `polyfit` issues a `RankWarning` when the least-squares fit is badly
+    conditioned. This implies that the best fit is not well-defined due
+    to numerical error. The results may be improved by lowering the polynomial
+    degree or by replacing `x` by `x` - `x`.mean(). The `rcond` parameter
+    can also be set to a value smaller than its default, but the resulting
+    fit may be spurious: including contributions from the small singular
+    values can add numerical noise to the result.
+
+    Note that fitting polynomial coefficients is inherently badly conditioned
+    when the degree of the polynomial is large or the interval of sample points
+    is badly centered. The quality of the fit should always be checked in these
+    cases. When polynomial fits are not satisfactory, splines may be a good
+    alternative.
+
+    References
+    ----------
+    .. [1] Wikipedia, \"Curve fitting\",
+           https://en.wikipedia.org/wiki/Curve_fitting
+    .. [2] Wikipedia, \"Polynomial interpolation\",
+           https://en.wikipedia.org/wiki/Polynomial_interpolation
+
+    Examples
+    --------
+    >>> import warnings
+    >>> x = np.array([0.0, 1.0, 2.0, 3.0,  4.0,  5.0])
+    >>> y = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0])
+    >>> z = np.polyfit(x, y, 3)
+    >>> z
+    array([ 0.08703704, -0.81349206,  1.69312169, -0.03968254]) # may vary
+
+    It is convenient to use `poly1d` objects for dealing with polynomials:
+
+    >>> p = np.poly1d(z)
+    >>> p(0.5)
+    0.6143849206349179 # may vary
+    >>> p(3.5)
+    -0.34732142857143039 # may vary
+    >>> p(10)
+    22.579365079365115 # may vary
+
+    High-order polynomials may oscillate wildly:
+
+    >>> with warnings.catch_warnings():
+    ...     warnings.simplefilter('ignore', np.RankWarning)
+    ...     p30 = np.poly1d(np.polyfit(x, y, 30))
+    ...
+    >>> p30(4)
+    -0.80000000000000204 # may vary
+    >>> p30(5)
+    -0.99999999999999445 # may vary
+    >>> p30(4.5)
+    -0.10547061179440398 # may vary
+
+    Illustration:
+
+    >>> import matplotlib.pyplot as plt
+    >>> xp = np.linspace(-2, 6, 100)
+    >>> _ = plt.plot(x, y, '.', xp, p(xp), '-', xp, p30(xp), '--')
+    >>> plt.ylim(-2,2)
+    (-2, 2)
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]]} polyfit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyfit"))))
+
+(def ^{:doc "A byte string.
+
+    When used in arrays, this type strips trailing null bytes.
+
+    :Character code: ``'S'``
+    :Alias: `numpy.string_`" :arglists '[[self & [args {:as kwargs}]]]} string_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "string_"))))
+
+(def ^{:doc "
+    Construct an array from an index array and a set of arrays to choose from.
+
+    First of all, if confused or uncertain, definitely look at the Examples -
+    in its full generality, this function is less simple than it might
+    seem from the following code description (below ndi =
+    `numpy.lib.index_tricks`):
+
+    ``np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)])``.
+
+    But this omits some subtleties.  Here is a fully general summary:
+
+    Given an \"index\" array (`a`) of integers and a sequence of `n` arrays
+    (`choices`), `a` and each choice array are first broadcast, as necessary,
+    to arrays of a common shape; calling these *Ba* and *Bchoices[i], i =
+    0,...,n-1* we have that, necessarily, ``Ba.shape == Bchoices[i].shape``
+    for each `i`.  Then, a new array with shape ``Ba.shape`` is created as
+    follows:
+
+    * if ``mode=raise`` (the default), then, first of all, each element of
+      `a` (and thus `Ba`) must be in the range `[0, n-1]`; now, suppose that
+      `i` (in that range) is the value at the `(j0, j1, ..., jm)` position
+      in `Ba` - then the value at the same position in the new array is the
+      value in `Bchoices[i]` at that same position;
+
+    * if ``mode=wrap``, values in `a` (and thus `Ba`) may be any (signed)
+      integer; modular arithmetic is used to map integers outside the range
+      `[0, n-1]` back into that range; and then the new array is constructed
+      as above;
+
+    * if ``mode=clip``, values in `a` (and thus `Ba`) may be any (signed)
+      integer; negative integers are mapped to 0; values greater than `n-1`
+      are mapped to `n-1`; and then the new array is constructed as above.
+
+    Parameters
+    ----------
+    a : int array
+        This array must contain integers in `[0, n-1]`, where `n` is the number
+        of choices, unless ``mode=wrap`` or ``mode=clip``, in which cases any
+        integers are permissible.
+    choices : sequence of arrays
+        Choice arrays. `a` and all of the choices must be broadcastable to the
+        same shape.  If `choices` is itself an array (not recommended), then
+        its outermost dimension (i.e., the one corresponding to
+        ``choices.shape[0]``) is taken as defining the \"sequence\".
+    out : array, optional
+        If provided, the result will be inserted into this array. It should
+        be of the appropriate shape and dtype. Note that `out` is always
+        buffered if `mode='raise'`; use other modes for better performance.
+    mode : {'raise' (default), 'wrap', 'clip'}, optional
+        Specifies how indices outside `[0, n-1]` will be treated:
+
+          * 'raise' : an exception is raised
+          * 'wrap' : value becomes value mod `n`
+          * 'clip' : values < 0 are mapped to 0, values > n-1 are mapped to n-1
+
+    Returns
+    -------
+    merged_array : array
+        The merged result.
+
+    Raises
+    ------
+    ValueError: shape mismatch
+        If `a` and each choice array are not all broadcastable to the same
+        shape.
+
+    See Also
+    --------
+    ndarray.choose : equivalent method
+    numpy.take_along_axis : Preferable if `choices` is an array
+
+    Notes
+    -----
+    To reduce the chance of misinterpretation, even though the following
+    \"abuse\" is nominally supported, `choices` should neither be, nor be
+    thought of as, a single array, i.e., the outermost sequence-like container
+    should be either a list or a tuple.
+
+    Examples
+    --------
+
+    >>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],
+    ...   [20, 21, 22, 23], [30, 31, 32, 33]]
+    >>> np.choose([2, 3, 1, 0], choices
+    ... # the first element of the result will be the first element of the
+    ... # third (2+1) \"array\" in choices, namely, 20; the second element
+    ... # will be the second element of the fourth (3+1) choice array, i.e.,
+    ... # 31, etc.
+    ... )
+    array([20, 31, 12,  3])
+    >>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)
+    array([20, 31, 12,  3])
+    >>> # because there are 4 choice arrays
+    >>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)
+    array([20,  1, 12,  3])
+    >>> # i.e., 0
+
+    A couple examples illustrating how choose broadcasts:
+
+    >>> a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]]
+    >>> choices = [-10, 10]
+    >>> np.choose(a, choices)
+    array([[ 10, -10,  10],
+           [-10,  10, -10],
+           [ 10, -10,  10]])
+
+    >>> # With thanks to Anne Archibald
+    >>> a = np.array([0, 1]).reshape((2,1,1))
+    >>> c1 = np.array([1, 2, 3]).reshape((1,3,1))
+    >>> c2 = np.array([-1, -2, -3, -4, -5]).reshape((1,1,5))
+    >>> np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2
+    array([[[ 1,  1,  1,  1,  1],
+            [ 2,  2,  2,  2,  2],
+            [ 3,  3,  3,  3,  3]],
+           [[-1, -2, -3, -4, -5],
+            [-1, -2, -3, -4, -5],
+            [-1, -2, -3, -4, -5]]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} choose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "choose"))))
+
+(def ^{:doc "
+    Return numbers spaced evenly on a log scale.
+
+    In linear space, the sequence starts at ``base ** start``
+    (`base` to the power of `start`) and ends with ``base ** stop``
+    (see `endpoint` below).
+
+    .. versionchanged:: 1.16.0
+        Non-scalar `start` and `stop` are now supported.
+
+    Parameters
+    ----------
+    start : array_like
+        ``base ** start`` is the starting value of the sequence.
+    stop : array_like
+        ``base ** stop`` is the final value of the sequence, unless `endpoint`
+        is False.  In that case, ``num + 1`` values are spaced over the
+        interval in log-space, of which all but the last (a sequence of
+        length `num`) are returned.
+    num : integer, optional
+        Number of samples to generate.  Default is 50.
+    endpoint : boolean, optional
+        If true, `stop` is the last sample. Otherwise, it is not included.
+        Default is True.
+    base : array_like, optional
+        The base of the log space. The step size between the elements in
+        ``ln(samples) / ln(base)`` (or ``log_base(samples)``) is uniform.
+        Default is 10.0.
+    dtype : dtype
+        The type of the output array.  If `dtype` is not given, the data type
+        is inferred from `start` and `stop`. The inferred type will never be
+        an integer; `float` is chosen even if the arguments would produce an
+        array of integers.
+    axis : int, optional
+        The axis in the result to store the samples.  Relevant only if start
+        or stop are array-like.  By default (0), the samples will be along a
+        new axis inserted at the beginning. Use -1 to get an axis at the end.
+
+        .. versionadded:: 1.16.0
+
+
+    Returns
+    -------
+    samples : ndarray
+        `num` samples, equally spaced on a log scale.
+
+    See Also
+    --------
+    arange : Similar to linspace, with the step size specified instead of the
+             number of samples. Note that, when used with a float endpoint, the
+             endpoint may or may not be included.
+    linspace : Similar to logspace, but with the samples uniformly distributed
+               in linear space, instead of log space.
+    geomspace : Similar to logspace, but with endpoints specified directly.
+
+    Notes
+    -----
+    Logspace is equivalent to the code
+
+    >>> y = np.linspace(start, stop, num=num, endpoint=endpoint)
+    ... # doctest: +SKIP
+    >>> power(base, y).astype(dtype)
+    ... # doctest: +SKIP
+
+    Examples
+    --------
+    >>> np.logspace(2.0, 3.0, num=4)
+    array([ 100.        ,  215.443469  ,  464.15888336, 1000.        ])
+    >>> np.logspace(2.0, 3.0, num=4, endpoint=False)
+    array([100.        ,  177.827941  ,  316.22776602,  562.34132519])
+    >>> np.logspace(2.0, 3.0, num=4, base=2.0)
+    array([4.        ,  5.0396842 ,  6.34960421,  8.        ])
+
+    Graphical illustration:
+
+    >>> import matplotlib.pyplot as plt
+    >>> N = 10
+    >>> x1 = np.logspace(0.1, 1, N, endpoint=True)
+    >>> x2 = np.logspace(0.1, 1, N, endpoint=False)
+    >>> y = np.zeros(N)
+    >>> plt.plot(x1, y, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.plot(x2, y + 0.5, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.ylim([-0.5, 1])
+    (-0.5, 1)
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]]} logspace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logspace"))))
+
+(def ^{:doc "logical_not(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the truth value of NOT x element-wise.
+
+Parameters
+----------
+x : array_like
+    Logical NOT is applied to the elements of `x`.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : bool or ndarray of bool
+    Boolean result with the same shape as `x` of the NOT operation
+    on elements of `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+logical_and, logical_or, logical_xor
+
+Examples
+--------
+>>> np.logical_not(3)
+False
+>>> np.logical_not([True, False, 0, 1])
+array([False,  True,  True, False])
+
+>>> x = np.arange(5)
+>>> np.logical_not(x<3)
+array([False, False, False,  True,  True])" :arglists '[[self & [args {:as kwargs}]]]} logical_not (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_not"))))
+
+(def ^{:doc "" :arglists '[[& [args {:as kwargs}]]]} loads (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "loads"))))
+
+(def ^{:doc "
+    bincount(x, weights=None, minlength=0)
+
+    Count number of occurrences of each value in array of non-negative ints.
+
+    The number of bins (of size 1) is one larger than the largest value in
+    `x`. If `minlength` is specified, there will be at least this number
+    of bins in the output array (though it will be longer if necessary,
+    depending on the contents of `x`).
+    Each bin gives the number of occurrences of its index value in `x`.
+    If `weights` is specified the input array is weighted by it, i.e. if a
+    value ``n`` is found at position ``i``, ``out[n] += weight[i]`` instead
+    of ``out[n] += 1``.
+
+    Parameters
+    ----------
+    x : array_like, 1 dimension, nonnegative ints
+        Input array.
+    weights : array_like, optional
+        Weights, array of the same shape as `x`.
+    minlength : int, optional
+        A minimum number of bins for the output array.
+
+        .. versionadded:: 1.6.0
+
+    Returns
+    -------
+    out : ndarray of ints
+        The result of binning the input array.
+        The length of `out` is equal to ``np.amax(x)+1``.
+
+    Raises
+    ------
+    ValueError
+        If the input is not 1-dimensional, or contains elements with negative
+        values, or if `minlength` is negative.
+    TypeError
+        If the type of the input is float or complex.
+
+    See Also
+    --------
+    histogram, digitize, unique
+
+    Examples
+    --------
+    >>> np.bincount(np.arange(5))
+    array([1, 1, 1, 1, 1])
+    >>> np.bincount(np.array([0, 1, 1, 3, 2, 1, 7]))
+    array([1, 3, 1, 1, 0, 0, 0, 1])
+
+    >>> x = np.array([0, 1, 1, 3, 2, 1, 7, 23])
+    >>> np.bincount(x).size == np.amax(x)+1
+    True
+
+    The input array needs to be of integer dtype, otherwise a
+    TypeError is raised:
+
+    >>> np.bincount(np.arange(5, dtype=float))
+    Traceback (most recent call last):
+      ...
+    TypeError: Cannot cast array data from dtype('float64') to dtype('int64')
+    according to the rule 'safe'
+
+    A possible use of ``bincount`` is to perform sums over
+    variable-size chunks of an array, using the ``weights`` keyword.
+
+    >>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights
+    >>> x = np.array([0, 1, 1, 2, 2, 2])
+    >>> np.bincount(x,  weights=w)
+    array([ 0.3,  0.7,  1.1])
+
+    " :arglists '[[& [args {:as kwargs}]]]} bincount (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bincount"))))
+
+(def ^{:doc "
+    Format a floating-point scalar as a decimal string in scientific notation.
+
+    Provides control over rounding, trimming and padding. Uses and assumes
+    IEEE unbiased rounding. Uses the \"Dragon4\" algorithm.
+
+    Parameters
+    ----------
+    x : python float or numpy floating scalar
+        Value to format.
+    precision : non-negative integer or None, optional
+        Maximum number of digits to print. May be None if `unique` is
+        `True`, but must be an integer if unique is `False`.
+    unique : boolean, optional
+        If `True`, use a digit-generation strategy which gives the shortest
+        representation which uniquely identifies the floating-point number from
+        other values of the same type, by judicious rounding. If `precision`
+        was omitted, print all necessary digits, otherwise digit generation is
+        cut off after `precision` digits and the remaining value is rounded.
+        If `False`, digits are generated as if printing an infinite-precision
+        value and stopping after `precision` digits, rounding the remaining
+        value.
+    trim : one of 'k', '.', '0', '-', optional
+        Controls post-processing trimming of trailing digits, as follows:
+
+        * 'k' : keep trailing zeros, keep decimal point (no trimming)
+        * '.' : trim all trailing zeros, leave decimal point
+        * '0' : trim all but the zero before the decimal point. Insert the
+          zero if it is missing.
+        * '-' : trim trailing zeros and any trailing decimal point
+    sign : boolean, optional
+        Whether to show the sign for positive values.
+    pad_left : non-negative integer, optional
+        Pad the left side of the string with whitespace until at least that
+        many characters are to the left of the decimal point.
+    exp_digits : non-negative integer, optional
+        Pad the exponent with zeros until it contains at least this many digits.
+        If omitted, the exponent will be at least 2 digits.
+
+    Returns
+    -------
+    rep : string
+        The string representation of the floating point value
+
+    See Also
+    --------
+    format_float_positional
+
+    Examples
+    --------
+    >>> np.format_float_scientific(np.float32(np.pi))
+    '3.1415927e+00'
+    >>> s = np.float32(1.23e24)
+    >>> np.format_float_scientific(s, unique=False, precision=15)
+    '1.230000071797338e+24'
+    >>> np.format_float_scientific(s, exp_digits=4)
+    '1.23e+0024'
+    " :arglists '[[x & [{precision :precision, unique :unique, trim :trim, sign :sign, pad_left :pad_left, exp_digits :exp_digits}]] [x & [{precision :precision, unique :unique, trim :trim, sign :sign, pad_left :pad_left}]] [x & [{precision :precision, unique :unique, trim :trim, sign :sign}]] [x & [{precision :precision, unique :unique, trim :trim}]] [x & [{precision :precision, unique :unique}]] [x & [{precision :precision}]] [x]]} format_float_scientific (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "format_float_scientific"))))
+
+(def ^{:doc "tan(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute tangent element-wise.
+
+Equivalent to ``np.sin(x)/np.cos(x)`` element-wise.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding tangent values.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+If `out` is provided, the function writes the result into it,
+and returns a reference to `out`.  (See Examples)
+
+References
+----------
+M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
+New York, NY: Dover, 1972.
+
+Examples
+--------
+>>> from math import pi
+>>> np.tan(np.array([-pi,pi/2,pi]))
+array([  1.22460635e-16,   1.63317787e+16,  -1.22460635e-16])
+>>>
+>>> # Example of providing the optional output parameter illustrating
+>>> # that what is returned is a reference to said parameter
+>>> out1 = np.array([0], dtype='d')
+>>> out2 = np.cos([0.1], out1)
+>>> out2 is out1
+True
+>>>
+>>> # Example of ValueError due to provision of shape mis-matched `out`
+>>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
+Traceback (most recent call last):
+  File \"<stdin>\", line 1, in <module>
+ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]]} tan (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tan"))))
+
+(def ^{:doc "Signed integer type, compatible with Python `int` and C ``long``.
+
+    :Character code: ``'l'``
+    :Canonical name: `numpy.int_`
+    :Alias on this platform: `numpy.int64`: 64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``).
+    :Alias on this platform: `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]]} int_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int_"))))
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} __expired_functions__ (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "__expired_functions__")))) 
+
+(def ^{:doc "Construct an ndarray that allows field access using attributes.
+
+    Arrays may have a data-types containing fields, analogous
+    to columns in a spread sheet.  An example is ``[(x, int), (y, float)]``,
+    where each entry in the array is a pair of ``(int, float)``.  Normally,
+    these attributes are accessed using dictionary lookups such as ``arr['x']``
+    and ``arr['y']``.  Record arrays allow the fields to be accessed as members
+    of the array, using ``arr.x`` and ``arr.y``.
+
+    Parameters
+    ----------
+    shape : tuple
+        Shape of output array.
+    dtype : data-type, optional
+        The desired data-type.  By default, the data-type is determined
+        from `formats`, `names`, `titles`, `aligned` and `byteorder`.
+    formats : list of data-types, optional
+        A list containing the data-types for the different columns, e.g.
+        ``['i4', 'f8', 'i4']``.  `formats` does *not* support the new
+        convention of using types directly, i.e. ``(int, float, int)``.
+        Note that `formats` must be a list, not a tuple.
+        Given that `formats` is somewhat limited, we recommend specifying
+        `dtype` instead.
+    names : tuple of str, optional
+        The name of each column, e.g. ``('x', 'y', 'z')``.
+    buf : buffer, optional
+        By default, a new array is created of the given shape and data-type.
+        If `buf` is specified and is an object exposing the buffer interface,
+        the array will use the memory from the existing buffer.  In this case,
+        the `offset` and `strides` keywords are available.
+
+    Other Parameters
+    ----------------
+    titles : tuple of str, optional
+        Aliases for column names.  For example, if `names` were
+        ``('x', 'y', 'z')`` and `titles` is
+        ``('x_coordinate', 'y_coordinate', 'z_coordinate')``, then
+        ``arr['x']`` is equivalent to both ``arr.x`` and ``arr.x_coordinate``.
+    byteorder : {'<', '>', '='}, optional
+        Byte-order for all fields.
+    aligned : bool, optional
+        Align the fields in memory as the C-compiler would.
+    strides : tuple of ints, optional
+        Buffer (`buf`) is interpreted according to these strides (strides
+        define how many bytes each array element, row, column, etc.
+        occupy in memory).
+    offset : int, optional
+        Start reading buffer (`buf`) from this offset onwards.
+    order : {'C', 'F'}, optional
+        Row-major (C-style) or column-major (Fortran-style) order.
+
+    Returns
+    -------
+    rec : recarray
+        Empty array of the given shape and type.
+
+    See Also
+    --------
+    core.records.fromrecords : Construct a record array from data.
+    record : fundamental data-type for `recarray`.
+    format_parser : determine a data-type from formats, names, titles.
+
+    Notes
+    -----
+    This constructor can be compared to ``empty``: it creates a new record
+    array but does not fill it with data.  To create a record array from data,
+    use one of the following methods:
+
+    1. Create a standard ndarray and convert it to a record array,
+       using ``arr.view(np.recarray)``
+    2. Use the `buf` keyword.
+    3. Use `np.rec.fromrecords`.
+
+    Examples
+    --------
+    Create an array with two fields, ``x`` and ``y``:
+
+    >>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', '<f8'), ('y', '<i8')])
+    >>> x
+    array([(1., 2), (3., 4)], dtype=[('x', '<f8'), ('y', '<i8')])
+
+    >>> x['x']
+    array([1., 3.])
+
+    View the array as a record array:
+
+    >>> x = x.view(np.recarray)
+
+    >>> x.x
+    array([1., 3.])
+
+    >>> x.y
+    array([2, 4])
+
+    Create a new, empty record array:
+
+    >>> np.recarray((2,),
+    ... dtype=[('x', int), ('y', float), ('z', int)]) #doctest: +SKIP
+    rec.array([(-1073741821, 1.2249118382103472e-301, 24547520),
+           (3471280, 1.2134086255804012e-316, 0)],
+          dtype=[('x', '<i4'), ('y', '<f8'), ('z', '<i4')])
+
+    " :arglists '[[self & [args {:as kwargs}]]]} recarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "recarray"))))
+
+(def ^{:doc "cos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Cosine element-wise.
+
+Parameters
+----------
+x : array_like
+    Input array in radians.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding cosine values.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+If `out` is provided, the function writes the result into it,
+and returns a reference to `out`.  (See Examples)
+
+References
+----------
+M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
+New York, NY: Dover, 1972.
+
+Examples
+--------
+>>> np.cos(np.array([0, np.pi/2, np.pi]))
+array([  1.00000000e+00,   6.12303177e-17,  -1.00000000e+00])
+>>>
+>>> # Example of providing the optional output parameter
+>>> out1 = np.array([0], dtype='d')
+>>> out2 = np.cos([0.1], out1)
+>>> out2 is out1
+True
+>>>
+>>> # Example of ValueError due to provision of shape mis-matched `out`
+>>> np.cos(np.zeros((3,3)),np.zeros((2,2)))
+Traceback (most recent call last):
+  File \"<stdin>\", line 1, in <module>
+ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]]} cos (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cos"))))
+
+(def ^{:doc "
+    Compute tensor dot product along specified axes.
+
+    Given two tensors, `a` and `b`, and an array_like object containing
+    two array_like objects, ``(a_axes, b_axes)``, sum the products of
+    `a`'s and `b`'s elements (components) over the axes specified by
+    ``a_axes`` and ``b_axes``. The third argument can be a single non-negative
+    integer_like scalar, ``N``; if it is such, then the last ``N`` dimensions
+    of `a` and the first ``N`` dimensions of `b` are summed over.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Tensors to \"dot\".
+
+    axes : int or (2,) array_like
+        * integer_like
+          If an int N, sum over the last N axes of `a` and the first N axes
+          of `b` in order. The sizes of the corresponding axes must match.
+        * (2,) array_like
+          Or, a list of axes to be summed over, first sequence applying to `a`,
+          second to `b`. Both elements array_like must be of the same length.
+
+    Returns
+    -------
+    output : ndarray
+        The tensor dot product of the input.
+
+    See Also
+    --------
+    dot, einsum
+
+    Notes
+    -----
+    Three common use cases are:
+        * ``axes = 0`` : tensor product :math:`a\\otimes b`
+        * ``axes = 1`` : tensor dot product :math:`a\\cdot b`
+        * ``axes = 2`` : (default) tensor double contraction :math:`a:b`
+
+    When `axes` is integer_like, the sequence for evaluation will be: first
+    the -Nth axis in `a` and 0th axis in `b`, and the -1th axis in `a` and
+    Nth axis in `b` last.
+
+    When there is more than one axis to sum over - and they are not the last
+    (first) axes of `a` (`b`) - the argument `axes` should consist of
+    two sequences of the same length, with the first axis to sum over given
+    first in both sequences, the second axis second, and so forth.
+
+    The shape of the result consists of the non-contracted axes of the
+    first tensor, followed by the non-contracted axes of the second.
+
+    Examples
+    --------
+    A \"traditional\" example:
+
+    >>> a = np.arange(60.).reshape(3,4,5)
+    >>> b = np.arange(24.).reshape(4,3,2)
+    >>> c = np.tensordot(a,b, axes=([1,0],[0,1]))
+    >>> c.shape
+    (5, 2)
+    >>> c
+    array([[4400., 4730.],
+           [4532., 4874.],
+           [4664., 5018.],
+           [4796., 5162.],
+           [4928., 5306.]])
+    >>> # A slower but equivalent way of computing the same...
+    >>> d = np.zeros((5,2))
+    >>> for i in range(5):
+    ...   for j in range(2):
+    ...     for k in range(3):
+    ...       for n in range(4):
+    ...         d[i,j] += a[k,n,i] * b[n,k,j]
+    >>> c == d
+    array([[ True,  True],
+           [ True,  True],
+           [ True,  True],
+           [ True,  True],
+           [ True,  True]])
+
+    An extended example taking advantage of the overloading of + and \\*:
+
+    >>> a = np.array(range(1, 9))
+    >>> a.shape = (2, 2, 2)
+    >>> A = np.array(('a', 'b', 'c', 'd'), dtype=object)
+    >>> A.shape = (2, 2)
+    >>> a; A
+    array([[[1, 2],
+            [3, 4]],
+           [[5, 6],
+            [7, 8]]])
+    array([['a', 'b'],
+           ['c', 'd']], dtype=object)
+
+    >>> np.tensordot(a, A) # third argument default is 2 for double-contraction
+    array(['abbcccdddd', 'aaaaabbbbbbcccccccdddddddd'], dtype=object)
+
+    >>> np.tensordot(a, A, 1)
+    array([[['acc', 'bdd'],
+            ['aaacccc', 'bbbdddd']],
+           [['aaaaacccccc', 'bbbbbdddddd'],
+            ['aaaaaaacccccccc', 'bbbbbbbdddddddd']]], dtype=object)
+
+    >>> np.tensordot(a, A, 0) # tensor product (result too long to incl.)
+    array([[[[['a', 'b'],
+              ['c', 'd']],
+              ...
+
+    >>> np.tensordot(a, A, (0, 1))
+    array([[['abbbbb', 'cddddd'],
+            ['aabbbbbb', 'ccdddddd']],
+           [['aaabbbbbbb', 'cccddddddd'],
+            ['aaaabbbbbbbb', 'ccccdddddddd']]], dtype=object)
+
+    >>> np.tensordot(a, A, (2, 1))
+    array([[['abb', 'cdd'],
+            ['aaabbbb', 'cccdddd']],
+           [['aaaaabbbbbb', 'cccccdddddd'],
+            ['aaaaaaabbbbbbbb', 'cccccccdddddddd']]], dtype=object)
+
+    >>> np.tensordot(a, A, ((0, 1), (0, 1)))
+    array(['abbbcccccddddddd', 'aabbbbccccccdddddddd'], dtype=object)
+
+    >>> np.tensordot(a, A, ((2, 1), (1, 0)))
+    array(['acccbbdddd', 'aaaaacccccccbbbbbbdddddddd'], dtype=object)
+
+    " :arglists '[[& [args {:as kwargs}]]]} tensordot (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tensordot"))))
+
+(def ^{:doc "
+    DataSource(destpath='.')
+
+    A generic data source file (file, http, ftp, ...).
+
+    DataSources can be local files or remote files/URLs.  The files may
+    also be compressed or uncompressed. DataSource hides some of the
+    low-level details of downloading the file, allowing you to simply pass
+    in a valid file path (or URL) and obtain a file object.
+
+    Parameters
+    ----------
+    destpath : str or None, optional
+        Path to the directory where the source file gets downloaded to for
+        use.  If `destpath` is None, a temporary directory will be created.
+        The default path is the current directory.
+
+    Notes
+    -----
+    URLs require a scheme string (``http://``) to be used, without it they
+    will fail::
+
+        >>> repos = np.DataSource()
+        >>> repos.exists('www.google.com/index.html')
+        False
+        >>> repos.exists('http://www.google.com/index.html')
+        True
+
+    Temporary directories are deleted when the DataSource is deleted.
+
+    Examples
+    --------
+    ::
+
+        >>> ds = np.DataSource('/home/guido')
+        >>> urlname = 'http://www.google.com/'
+        >>> gfile = ds.open('http://www.google.com/')
+        >>> ds.abspath(urlname)
+        '/home/guido/www.google.com/index.html'
+
+        >>> ds = np.DataSource(None)  # use with temporary file
+        >>> ds.open('/home/guido/foobar.txt')
+        <open file '/home/guido.foobar.txt', mode 'r' at 0x91d4430>
+        >>> ds.abspath('/home/guido/foobar.txt')
+        '/tmp/.../home/guido/foobar.txt'
+
+    " :arglists '[[self & [{destpath :destpath}]] [self]]} DataSource (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "DataSource"))))
+
+(def ^{:doc "
+    Returns the indices that would sort an array.
+
+    Perform an indirect sort along the given axis using the algorithm specified
+    by the `kind` keyword. It returns an array of indices of the same shape as
+    `a` that index data along the given axis in sorted order.
+
+    Parameters
+    ----------
+    a : array_like
+        Array to sort.
+    axis : int or None, optional
+        Axis along which to sort.  The default is -1 (the last axis). If None,
+        the flattened array is used.
+    kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional
+        Sorting algorithm. The default is 'quicksort'. Note that both 'stable'
+        and 'mergesort' use timsort under the covers and, in general, the
+        actual implementation will vary with data type. The 'mergesort' option
+        is retained for backwards compatibility.
+
+        .. versionchanged:: 1.15.0.
+           The 'stable' option was added.
+    order : str or list of str, optional
+        When `a` is an array with fields defined, this argument specifies
+        which fields to compare first, second, etc.  A single field can
+        be specified as a string, and not all fields need be specified,
+        but unspecified fields will still be used, in the order in which
+        they come up in the dtype, to break ties.
+
+    Returns
+    -------
+    index_array : ndarray, int
+        Array of indices that sort `a` along the specified `axis`.
+        If `a` is one-dimensional, ``a[index_array]`` yields a sorted `a`.
+        More generally, ``np.take_along_axis(a, index_array, axis=axis)``
+        always yields the sorted `a`, irrespective of dimensionality.
+
+    See Also
+    --------
+    sort : Describes sorting algorithms used.
+    lexsort : Indirect stable sort with multiple keys.
+    ndarray.sort : Inplace sort.
+    argpartition : Indirect partial sort.
+    take_along_axis : Apply ``index_array`` from argsort
+                      to an array as if by calling sort.
+
+    Notes
+    -----
+    See `sort` for notes on the different sorting algorithms.
+
+    As of NumPy 1.4.0 `argsort` works with real/complex arrays containing
+    nan values. The enhanced sort order is documented in `sort`.
+
+    Examples
+    --------
+    One dimensional array:
+
+    >>> x = np.array([3, 1, 2])
+    >>> np.argsort(x)
+    array([1, 2, 0])
+
+    Two-dimensional array:
+
+    >>> x = np.array([[0, 3], [2, 2]])
+    >>> x
+    array([[0, 3],
+           [2, 2]])
+
+    >>> ind = np.argsort(x, axis=0)  # sorts along first axis (down)
+    >>> ind
+    array([[0, 1],
+           [1, 0]])
+    >>> np.take_along_axis(x, ind, axis=0)  # same as np.sort(x, axis=0)
+    array([[0, 2],
+           [2, 3]])
+
+    >>> ind = np.argsort(x, axis=1)  # sorts along last axis (across)
+    >>> ind
+    array([[0, 1],
+           [0, 1]])
+    >>> np.take_along_axis(x, ind, axis=1)  # same as np.sort(x, axis=1)
+    array([[0, 3],
+           [2, 2]])
+
+    Indices of the sorted elements of a N-dimensional array:
+
+    >>> ind = np.unravel_index(np.argsort(x, axis=None), x.shape)
+    >>> ind
+    (array([0, 1, 1, 0]), array([0, 0, 1, 1]))
+    >>> x[ind]  # same as np.sort(x, axis=None)
+    array([0, 2, 2, 3])
+
+    Sorting with keys:
+
+    >>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])
+    >>> x
+    array([(1, 0), (0, 1)],
+          dtype=[('x', '<i4'), ('y', '<i4')])
+
+    >>> np.argsort(x, order=('x','y'))
+    array([1, 0])
+
+    >>> np.argsort(x, order=('y','x'))
+    array([0, 1])
+
+    " :arglists '[[& [args {:as kwargs}]]]} argsort (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argsort"))))
+
+(def ^{:doc "trunc(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the truncated value of the input, element-wise.
+
+The truncated value of the scalar `x` is the nearest integer `i` which
+is closer to zero than `x` is. In short, the fractional part of the
+signed number `x` is discarded.
+
+Parameters
+----------
+x : array_like
+    Input data.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The truncated value of each element in `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+ceil, floor, rint
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+Examples
+--------
+>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
+>>> np.trunc(a)
+array([-1., -1., -0.,  0.,  1.,  1.,  2.])" :arglists '[[self & [args {:as kwargs}]]]} trunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trunc"))))
+
+(def ^{:doc "
+    Find the intersection of two arrays.
+
+    Return the sorted, unique values that are in both of the input arrays.
+
+    Parameters
+    ----------
+    ar1, ar2 : array_like
+        Input arrays. Will be flattened if not already 1D.
+    assume_unique : bool
+        If True, the input arrays are both assumed to be unique, which
+        can speed up the calculation.  If True but ``ar1`` or ``ar2`` are not
+        unique, incorrect results and out-of-bounds indices could result.
+        Default is False.
+    return_indices : bool
+        If True, the indices which correspond to the intersection of the two
+        arrays are returned. The first instance of a value is used if there are
+        multiple. Default is False.
+
+        .. versionadded:: 1.15.0
+
+    Returns
+    -------
+    intersect1d : ndarray
+        Sorted 1D array of common and unique elements.
+    comm1 : ndarray
+        The indices of the first occurrences of the common values in `ar1`.
+        Only provided if `return_indices` is True.
+    comm2 : ndarray
+        The indices of the first occurrences of the common values in `ar2`.
+        Only provided if `return_indices` is True.
+
+
+    See Also
+    --------
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Examples
+    --------
+    >>> np.intersect1d([1, 3, 4, 3], [3, 1, 2, 1])
+    array([1, 3])
+
+    To intersect more than two arrays, use functools.reduce:
+
+    >>> from functools import reduce
+    >>> reduce(np.intersect1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
+    array([3])
+
+    To return the indices of the values common to the input arrays
+    along with the intersected values:
+
+    >>> x = np.array([1, 1, 2, 3, 4])
+    >>> y = np.array([2, 1, 4, 6])
+    >>> xy, x_ind, y_ind = np.intersect1d(x, y, return_indices=True)
+    >>> x_ind, y_ind
+    (array([0, 2, 4]), array([1, 0, 2]))
+    >>> xy, x[x_ind], y[y_ind]
+    (array([1, 2, 4]), array([1, 2, 4]), array([1, 2, 4]))
+
+    " :arglists '[[& [args {:as kwargs}]]]} intersect1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "intersect1d"))))
+
+(def ^{:doc "Fill the main diagonal of the given array of any dimensionality.
+
+    For an array `a` with ``a.ndim >= 2``, the diagonal is the list of
+    locations with indices ``a[i, ..., i]`` all identical. This function
+    modifies the input array in-place, it does not return a value.
+
+    Parameters
+    ----------
+    a : array, at least 2-D.
+      Array whose diagonal is to be filled, it gets modified in-place.
+
+    val : scalar or array_like
+      Value(s) to write on the diagonal. If `val` is scalar, the value is
+      written along the diagonal. If array-like, the flattened `val` is
+      written along the diagonal, repeating if necessary to fill all
+      diagonal entries.
+
+    wrap : bool
+      For tall matrices in NumPy version up to 1.6.2, the
+      diagonal \"wrapped\" after N columns. You can have this behavior
+      with this option. This affects only tall matrices.
+
+    See also
+    --------
+    diag_indices, diag_indices_from
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    This functionality can be obtained via `diag_indices`, but internally
+    this version uses a much faster implementation that never constructs the
+    indices and uses simple slicing.
+
+    Examples
+    --------
+    >>> a = np.zeros((3, 3), int)
+    >>> np.fill_diagonal(a, 5)
+    >>> a
+    array([[5, 0, 0],
+           [0, 5, 0],
+           [0, 0, 5]])
+
+    The same function can operate on a 4-D array:
+
+    >>> a = np.zeros((3, 3, 3, 3), int)
+    >>> np.fill_diagonal(a, 4)
+
+    We only show a few blocks for clarity:
+
+    >>> a[0, 0]
+    array([[4, 0, 0],
+           [0, 0, 0],
+           [0, 0, 0]])
+    >>> a[1, 1]
+    array([[0, 0, 0],
+           [0, 4, 0],
+           [0, 0, 0]])
+    >>> a[2, 2]
+    array([[0, 0, 0],
+           [0, 0, 0],
+           [0, 0, 4]])
+
+    The wrap option affects only tall matrices:
+
+    >>> # tall matrices no wrap
+    >>> a = np.zeros((5, 3), int)
+    >>> np.fill_diagonal(a, 4)
+    >>> a
+    array([[4, 0, 0],
+           [0, 4, 0],
+           [0, 0, 4],
+           [0, 0, 0],
+           [0, 0, 0]])
+
+    >>> # tall matrices wrap
+    >>> a = np.zeros((5, 3), int)
+    >>> np.fill_diagonal(a, 4, wrap=True)
+    >>> a
+    array([[4, 0, 0],
+           [0, 4, 0],
+           [0, 0, 4],
+           [0, 0, 0],
+           [4, 0, 0]])
+
+    >>> # wide matrices
+    >>> a = np.zeros((3, 5), int)
+    >>> np.fill_diagonal(a, 4, wrap=True)
+    >>> a
+    array([[4, 0, 0, 0, 0],
+           [0, 4, 0, 0, 0],
+           [0, 0, 4, 0, 0]])
+
+    The anti-diagonal can be filled by reversing the order of elements
+    using either `numpy.flipud` or `numpy.fliplr`.
+
+    >>> a = np.zeros((3, 3), int);
+    >>> np.fill_diagonal(np.fliplr(a), [1,2,3])  # Horizontal flip
+    >>> a
+    array([[0, 0, 1],
+           [0, 2, 0],
+           [3, 0, 0]])
+    >>> np.fill_diagonal(np.flipud(a), [1,2,3])  # Vertical flip
+    >>> a
+    array([[0, 0, 3],
+           [0, 2, 0],
+           [1, 0, 0]])
+
+    Note that the order in which the diagonal is filled varies depending
+    on the flip function.
+    " :arglists '[[& [args {:as kwargs}]]]} fill_diagonal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fill_diagonal"))))
+
+(def ^{:doc "
+``numpy.linalg``
+================
+
+The NumPy linear algebra functions rely on BLAS and LAPACK to provide efficient
+low level implementations of standard linear algebra algorithms. Those
+libraries may be provided by NumPy itself using C versions of a subset of their
+reference implementations but, when possible, highly optimized libraries that
+take advantage of specialized processor functionality are preferred. Examples
+of such libraries are OpenBLAS, MKL (TM), and ATLAS. Because those libraries
+are multithreaded and processor dependent, environmental variables and external
+packages such as threadpoolctl may be needed to control the number of threads
+or specify the processor architecture.
+
+- OpenBLAS: https://www.openblas.net/
+- threadpoolctl: https://github.com/joblib/threadpoolctl
+
+Please note that the most-used linear algebra functions in NumPy are present in
+the main ``numpy`` namespace rather than in ``numpy.linalg``.  There are:
+``dot``, ``vdot``, ``inner``, ``outer``, ``matmul``, ``tensordot``, ``einsum``,
+``einsum_path`` and ``kron``.
+
+Functions present in numpy.linalg are listed below.
+
+
+Matrix and vector products
+--------------------------
+
+   multi_dot
+   matrix_power
+
+Decompositions
+--------------
+
+   cholesky
+   qr
+   svd
+
+Matrix eigenvalues
+------------------
+
+   eig
+   eigh
+   eigvals
+   eigvalsh
+
+Norms and other numbers
+-----------------------
+
+   norm
+   cond
+   det
+   matrix_rank
+   slogdet
+
+Solving equations and inverting matrices
+----------------------------------------
+
+   solve
+   tensorsolve
+   lstsq
+   inv
+   pinv
+   tensorinv
+
+Exceptions
+----------
+
+   LinAlgError
+
+"} linalg (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "linalg"))))
+
+(def ^{:doc "
+    Return the indices for the upper-triangle of an (n, m) array.
+
+    Parameters
+    ----------
+    n : int
+        The size of the arrays for which the returned indices will
+        be valid.
+    k : int, optional
+        Diagonal offset (see `triu` for details).
+    m : int, optional
+        .. versionadded:: 1.9.0
+
+        The column dimension of the arrays for which the returned
+        arrays will be valid.
+        By default `m` is taken equal to `n`.
+
+
+    Returns
+    -------
+    inds : tuple, shape(2) of ndarrays, shape(`n`)
+        The indices for the triangle. The returned tuple contains two arrays,
+        each with the indices along one dimension of the array.  Can be used
+        to slice a ndarray of shape(`n`, `n`).
+
+    See also
+    --------
+    tril_indices : similar function, for lower-triangular.
+    mask_indices : generic function accepting an arbitrary mask function.
+    triu, tril
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    Compute two different sets of indices to access 4x4 arrays, one for the
+    upper triangular part starting at the main diagonal, and one starting two
+    diagonals further right:
+
+    >>> iu1 = np.triu_indices(4)
+    >>> iu2 = np.triu_indices(4, 2)
+
+    Here is how they can be used with a sample array:
+
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+
+    Both for indexing:
+
+    >>> a[iu1]
+    array([ 0,  1,  2, ..., 10, 11, 15])
+
+    And for assigning values:
+
+    >>> a[iu1] = -1
+    >>> a
+    array([[-1, -1, -1, -1],
+           [ 4, -1, -1, -1],
+           [ 8,  9, -1, -1],
+           [12, 13, 14, -1]])
+
+    These cover only a small part of the whole array (two diagonals right
+    of the main one):
+
+    >>> a[iu2] = -10
+    >>> a
+    array([[ -1,  -1, -10, -10],
+           [  4,  -1,  -1, -10],
+           [  8,   9,  -1,  -1],
+           [ 12,  13,  14,  -1]])
+
+    " :arglists '[[n & [{k :k, m :m}]] [n & [{k :k}]] [n]]} triu_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "triu_indices"))))
+
+(def ^{:doc "remainder(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return element-wise remainder of division.
+
+Computes the remainder complementary to the `floor_divide` function.  It is
+equivalent to the Python modulus operator``x1 % x2`` and has the same sign
+as the divisor `x2`. The MATLAB function equivalent to ``np.remainder``
+is ``mod``.
+
+.. warning::
+
+    This should not be confused with:
+
+    * Python 3.7's `math.remainder` and C's ``remainder``, which
+      computes the IEEE remainder, which are the complement to
+      ``round(x1 / x2)``.
+    * The MATLAB ``rem`` function and or the C ``%`` operator which is the
+      complement to ``int(x1 / x2)``.
+
+Parameters
+----------
+x1 : array_like
+    Dividend array.
+x2 : array_like
+    Divisor array.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The element-wise remainder of the quotient ``floor_divide(x1, x2)``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+floor_divide : Equivalent of Python ``//`` operator.
+divmod : Simultaneous floor division and remainder.
+fmod : Equivalent of the MATLAB ``rem`` function.
+divide, floor
+
+Notes
+-----
+Returns 0 when `x2` is 0 and both `x1` and `x2` are (arrays of)
+integers.
+``mod`` is an alias of ``remainder``.
+
+Examples
+--------
+>>> np.remainder([4, 7], [2, 3])
+array([0, 1])
+>>> np.remainder(np.arange(7), 5)
+array([0, 1, 2, 3, 4, 0, 1])
+
+The ``%`` operator can be used as a shorthand for ``np.remainder`` on
+ndarrays.
+
+>>> x1 = np.arange(7)
+>>> x1 % 5
+array([0, 1, 2, 3, 4, 0, 1])" :arglists '[[self & [args {:as kwargs}]]]} mod (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mod"))))
+
+(def ^{:doc "
+    Broadcast any number of arrays against each other.
+
+    Parameters
+    ----------
+    `*args` : array_likes
+        The arrays to broadcast.
+
+    subok : bool, optional
+        If True, then sub-classes will be passed-through, otherwise
+        the returned arrays will be forced to be a base-class array (default).
+
+    Returns
+    -------
+    broadcasted : list of arrays
+        These arrays are views on the original arrays.  They are typically
+        not contiguous.  Furthermore, more than one element of a
+        broadcasted array may refer to a single memory location. If you need
+        to write to the arrays, make copies first. While you can set the
+        ``writable`` flag True, writing to a single output value may end up
+        changing more than one location in the output array.
+
+        .. deprecated:: 1.17
+            The output is currently marked so that if written to, a deprecation
+            warning will be emitted. A future version will set the
+            ``writable`` flag False so writing to it will raise an error.
+
+    See Also
+    --------
+    broadcast
+    broadcast_to
+    broadcast_shapes
+
+    Examples
+    --------
+    >>> x = np.array([[1,2,3]])
+    >>> y = np.array([[4],[5]])
+    >>> np.broadcast_arrays(x, y)
+    [array([[1, 2, 3],
+           [1, 2, 3]]), array([[4, 4, 4],
+           [5, 5, 5]])]
+
+    Here is a useful idiom for getting contiguous copies instead of
+    non-contiguous views.
+
+    >>> [np.array(a) for a in np.broadcast_arrays(x, y)]
+    [array([[1, 2, 3],
+           [1, 2, 3]]), array([[4, 4, 4],
+           [5, 5, 5]])]
+
+    " :arglists '[[& [args {:as kwargs}]]]} broadcast_arrays (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "broadcast_arrays"))))
+
+(def ^{:doc "Abstract base class of all integer scalar types." :arglists '[[self & [args {:as kwargs}]]]} integer (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "integer"))))
+
+(def ^{:doc "geterrobj()
+
+    Return the current object that defines floating-point error handling.
+
+    The error object contains all information that defines the error handling
+    behavior in NumPy. `geterrobj` is used internally by the other
+    functions that get and set error handling behavior (`geterr`, `seterr`,
+    `geterrcall`, `seterrcall`).
+
+    Returns
+    -------
+    errobj : list
+        The error object, a list containing three elements:
+        [internal numpy buffer size, error mask, error callback function].
+
+        The error mask is a single integer that holds the treatment information
+        on all four floating point errors. The information for each error type
+        is contained in three bits of the integer. If we print it in base 8, we
+        can see what treatment is set for \"invalid\", \"under\", \"over\", and
+        \"divide\" (in that order). The printed string can be interpreted with
+
+        * 0 : 'ignore'
+        * 1 : 'warn'
+        * 2 : 'raise'
+        * 3 : 'call'
+        * 4 : 'print'
+        * 5 : 'log'
+
+    See Also
+    --------
+    seterrobj, seterr, geterr, seterrcall, geterrcall
+    getbufsize, setbufsize
+
+    Notes
+    -----
+    For complete documentation of the types of floating-point exceptions and
+    treatment options, see `seterr`.
+
+    Examples
+    --------
+    >>> np.geterrobj()  # first get the defaults
+    [8192, 521, None]
+
+    >>> def err_handler(type, flag):
+    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
+    ...
+    >>> old_bufsize = np.setbufsize(20000)
+    >>> old_err = np.seterr(divide='raise')
+    >>> old_handler = np.seterrcall(err_handler)
+    >>> np.geterrobj()
+    [8192, 521, <function err_handler at 0x91dcaac>]
+
+    >>> old_err = np.seterr(all='ignore')
+    >>> np.base_repr(np.geterrobj()[1], 8)
+    '0'
+    >>> old_err = np.seterr(divide='warn', over='log', under='call',
+    ...                     invalid='print')
+    >>> np.base_repr(np.geterrobj()[1], 8)
+    '4351'" :arglists '[[self & [args {:as kwargs}]]]} geterrobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geterrobj"))))
+
+(def ^{:doc "Context manager for setting print options.
+
+    Set print options for the scope of the `with` block, and restore the old
+    options at the end. See `set_printoptions` for the full description of
+    available options.
+
+    Examples
+    --------
+
+    >>> from numpy.testing import assert_equal
+    >>> with np.printoptions(precision=2):
+    ...     np.array([2.0]) / 3
+    array([0.67])
+
+    The `as`-clause of the `with`-statement gives the current print options:
+
+    >>> with np.printoptions(precision=2) as opts:
+    ...      assert_equal(opts, np.get_printoptions())
+
+    See Also
+    --------
+    set_printoptions, get_printoptions
+
+    " :arglists '[[& [args {:as kwds}]]]} printoptions (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "printoptions"))))
+
+(def ^{:doc "Signed integer type, compatible with C ``char``.
+
+    :Character code: ``'b'``
+    :Canonical name: `numpy.byte`
+    :Alias on this platform: `numpy.int8`: 8-bit signed integer (``-128`` to ``127``)." :arglists '[[self & [args {:as kwargs}]]]} int8 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int8"))))
+
+(def ^{:doc "
+    Protected string evaluation.
+
+    Evaluate a string containing a Python literal expression without
+    allowing the execution of arbitrary non-literal code.
+
+    Parameters
+    ----------
+    source : str
+        The string to evaluate.
+
+    Returns
+    -------
+    obj : object
+       The result of evaluating `source`.
+
+    Raises
+    ------
+    SyntaxError
+        If the code has invalid Python syntax, or if it contains
+        non-literal code.
+
+    Examples
+    --------
+    >>> np.safe_eval('1')
+    1
+    >>> np.safe_eval('[1, 2, 3]')
+    [1, 2, 3]
+    >>> np.safe_eval('{\"foo\": (\"bar\", 10.0)}')
+    {'foo': ('bar', 10.0)}
+
+    >>> np.safe_eval('import os')
+    Traceback (most recent call last):
+      ...
+    SyntaxError: invalid syntax
+
+    >>> np.safe_eval('open(\"/home/user/.ssh/id_dsa\").read()')
+    Traceback (most recent call last):
+      ...
+    ValueError: malformed node or string: <_ast.Call object at 0x...>
+
+    " :arglists '[[source]]} safe_eval (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "safe_eval"))))
+
+(def ^{:doc "
+**Note:** almost all functions in the ``numpy.lib`` namespace
+are also present in the main ``numpy`` namespace.  Please use the
+functions as ``np.<funcname>`` where possible.
+
+``numpy.lib`` is mostly a space for implementing functions that don't
+belong in core or in another NumPy submodule with a clear purpose
+(e.g. ``random``, ``fft``, ``linalg``, ``ma``).
+
+Most contains basic functions that are used by several submodules and are
+useful to have in the main name-space.
+
+"} lib (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "lib"))))
+
+(def ^{:doc "promote_types(type1, type2)
+
+    Returns the data type with the smallest size and smallest scalar
+    kind to which both ``type1`` and ``type2`` may be safely cast.
+    The returned data type is always in native byte order.
+
+    This function is symmetric, but rarely associative.
+
+    Parameters
+    ----------
+    type1 : dtype or dtype specifier
+        First data type.
+    type2 : dtype or dtype specifier
+        Second data type.
+
+    Returns
+    -------
+    out : dtype
+        The promoted data type.
+
+    Notes
+    -----
+    .. versionadded:: 1.6.0
+
+    Starting in NumPy 1.9, promote_types function now returns a valid string
+    length when given an integer or float dtype as one argument and a string
+    dtype as another argument. Previously it always returned the input string
+    dtype, even if it wasn't long enough to store the max integer/float value
+    converted to a string.
+
+    See Also
+    --------
+    result_type, dtype, can_cast
+
+    Examples
+    --------
+    >>> np.promote_types('f4', 'f8')
+    dtype('float64')
+
+    >>> np.promote_types('i8', 'f4')
+    dtype('float64')
+
+    >>> np.promote_types('>i8', '<c8')
+    dtype('complex128')
+
+    >>> np.promote_types('i4', 'S8')
+    dtype('S11')
+
+    An example of a non-associative case:
+
+    >>> p = np.promote_types
+    >>> p('S', p('i1', 'u1'))
+    dtype('S6')
+    >>> p(p('S', 'i1'), 'u1')
+    dtype('S4')" :arglists '[[self & [args {:as kwargs}]]]} promote_types (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "promote_types"))))
+
+(def ^{:doc "square(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the element-wise square of the input.
+
+Parameters
+----------
+x : array_like
+    Input data.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Element-wise `x*x`, of the same shape and dtype as `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+numpy.linalg.matrix_power
+sqrt
+power
+
+Examples
+--------
+>>> np.square([-1j, 1])
+array([-1.-0.j,  1.+0.j])" :arglists '[[self & [args {:as kwargs}]]]} square (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "square"))))
+
+(def ^{:doc "Module deprecation warning.
+
+    The nose tester turns ordinary Deprecation warnings into test failures.
+    That makes it hard to deprecate whole modules, because they get
+    imported by default. So this is a special Deprecation warning that the
+    nose tester will let pass without making tests fail.
+
+    " :arglists '[[self & [args {:as kwargs}]]]} ModuleDeprecationWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ModuleDeprecationWarning"))))
+
+(def ^{:doc "
+    may_share_memory(a, b, max_work=None)
+
+    Determine if two arrays might share memory
+
+    A return of True does not necessarily mean that the two arrays
+    share any element.  It just means that they *might*.
+
+    Only the memory bounds of a and b are checked by default.
+
+    Parameters
+    ----------
+    a, b : ndarray
+        Input arrays
+    max_work : int, optional
+        Effort to spend on solving the overlap problem.  See
+        `shares_memory` for details.  Default for ``may_share_memory``
+        is to do a bounds check.
+
+    Returns
+    -------
+    out : bool
+
+    See Also
+    --------
+    shares_memory
+
+    Examples
+    --------
+    >>> np.may_share_memory(np.array([1,2]), np.array([5,8,9]))
+    False
+    >>> x = np.zeros([3, 4])
+    >>> np.may_share_memory(x[:,0], x[:,1])
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]]} may_share_memory (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "may_share_memory"))))
+(def ^{:doc "dict() -> new empty dictionary
+dict(mapping) -> new dictionary initialized from a mapping object's
+    (key, value) pairs
+dict(iterable) -> new dictionary initialized as if via:
+    d = {}
+    for k, v in iterable:
+        d[k] = v
+dict(**kwargs) -> new dictionary initialized with the name=value pairs
+    in the keyword argument list.  For example:  dict(one=1, two=2)"} __builtins__ (as-jvm/generic-python-as-map (py-global-delay (py/get-attr @src-obj* "__builtins__")))) 
+
+(def ^{:doc "
+    Print or write to a file the source code for a NumPy object.
+
+    The source code is only returned for objects written in Python. Many
+    functions and classes are defined in C and will therefore not return
+    useful information.
+
+    Parameters
+    ----------
+    object : numpy object
+        Input object. This can be any object (function, class, module,
+        ...).
+    output : file object, optional
+        If `output` not supplied then source code is printed to screen
+        (sys.stdout).  File object must be created with either write 'w' or
+        append 'a' modes.
+
+    See Also
+    --------
+    lookfor, info
+
+    Examples
+    --------
+    >>> np.source(np.interp)                        #doctest: +SKIP
+    In file: /usr/lib/python2.6/dist-packages/numpy/lib/function_base.py
+    def interp(x, xp, fp, left=None, right=None):
+        \"\"\".... (full docstring printed)\"\"\"
+        if isinstance(x, (float, int, number)):
+            return compiled_interp([x], xp, fp, left, right).item()
+        else:
+            return compiled_interp(x, xp, fp, left, right)
+
+    The source code is only returned for objects written in Python.
+
+    >>> np.source(np.array)                         #doctest: +SKIP
+    Not available for this object.
+
+    " :arglists '[[object & [{output :output}]] [object]]} source (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "source"))))
+
+(def ^{:doc "
+    Interchange two axes of an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis1 : int
+        First axis.
+    axis2 : int
+        Second axis.
+
+    Returns
+    -------
+    a_swapped : ndarray
+        For NumPy >= 1.10.0, if `a` is an ndarray, then a view of `a` is
+        returned; otherwise a new array is created. For earlier NumPy
+        versions a view of `a` is returned only if the order of the
+        axes is changed, otherwise the input array is returned.
+
+    Examples
+    --------
+    >>> x = np.array([[1,2,3]])
+    >>> np.swapaxes(x,0,1)
+    array([[1],
+           [2],
+           [3]])
+
+    >>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])
+    >>> x
+    array([[[0, 1],
+            [2, 3]],
+           [[4, 5],
+            [6, 7]]])
+
+    >>> np.swapaxes(x,0,2)
+    array([[[0, 4],
+            [2, 6]],
+           [[1, 5],
+            [3, 7]]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} swapaxes (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "swapaxes"))))
+
+(def ^{:doc ""} ERR_LOG 5)
+
+(def ^{:doc "
+    Sort a complex array using the real part first, then the imaginary part.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array
+
+    Returns
+    -------
+    out : complex ndarray
+        Always returns a sorted complex array.
+
+    Examples
+    --------
+    >>> np.sort_complex([5, 3, 6, 2, 1])
+    array([1.+0.j, 2.+0.j, 3.+0.j, 5.+0.j, 6.+0.j])
+
+    >>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])
+    array([1.+2.j,  2.-1.j,  3.-3.j,  3.-2.j,  3.+5.j])
+
+    " :arglists '[[& [args {:as kwargs}]]]} sort_complex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sort_complex"))))
+
+(def ^{:doc "less(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the truth value of (x1 < x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+greater, less_equal, greater_equal, equal, not_equal
+
+Examples
+--------
+>>> np.less([1, 2], [2, 2])
+array([ True, False])
+
+The ``<`` operator can be used as a shorthand for ``np.less`` on ndarrays.
+
+>>> a = np.array([1, 2])
+>>> b = np.array([2, 2])
+>>> a < b
+array([ True, False])" :arglists '[[self & [args {:as kwargs}]]]} less (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "less"))))
+
+(def ^{:doc "Abstract base class of all complex number scalar types that are made up of
+    floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} complexfloating (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complexfloating"))))
+
+(def ^{:doc "
+    unpackbits(a, axis=None, count=None, bitorder='big')
+
+    Unpacks elements of a uint8 array into a binary-valued output array.
+
+    Each element of `a` represents a bit-field that should be unpacked
+    into a binary-valued output array. The shape of the output array is
+    either 1-D (if `axis` is ``None``) or the same shape as the input
+    array with unpacking done along the axis specified.
+
+    Parameters
+    ----------
+    a : ndarray, uint8 type
+       Input array.
+    axis : int, optional
+        The dimension over which bit-unpacking is done.
+        ``None`` implies unpacking the flattened array.
+    count : int or None, optional
+        The number of elements to unpack along `axis`, provided as a way
+        of undoing the effect of packing a size that is not a multiple
+        of eight. A non-negative number means to only unpack `count`
+        bits. A negative number means to trim off that many bits from
+        the end. ``None`` means to unpack the entire array (the
+        default). Counts larger than the available number of bits will
+        add zero padding to the output. Negative counts must not
+        exceed the available number of bits.
+
+        .. versionadded:: 1.17.0
+
+    bitorder : {'big', 'little'}, optional
+        The order of the returned bits. 'big' will mimic bin(val),
+        ``3 = 0b00000011 => [0, 0, 0, 0, 0, 0, 1, 1]``, 'little' will reverse
+        the order to ``[1, 1, 0, 0, 0, 0, 0, 0]``.
+        Defaults to 'big'.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    unpacked : ndarray, uint8 type
+       The elements are binary-valued (0 or 1).
+
+    See Also
+    --------
+    packbits : Packs the elements of a binary-valued array into bits in
+               a uint8 array.
+
+    Examples
+    --------
+    >>> a = np.array([[2], [7], [23]], dtype=np.uint8)
+    >>> a
+    array([[ 2],
+           [ 7],
+           [23]], dtype=uint8)
+    >>> b = np.unpackbits(a, axis=1)
+    >>> b
+    array([[0, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)
+    >>> c = np.unpackbits(a, axis=1, count=-3)
+    >>> c
+    array([[0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0],
+           [0, 0, 0, 1, 0]], dtype=uint8)
+
+    >>> p = np.packbits(b, axis=0)
+    >>> np.unpackbits(p, axis=0)
+    array([[0, 0, 0, 0, 0, 0, 1, 0],
+           [0, 0, 0, 0, 0, 1, 1, 1],
+           [0, 0, 0, 1, 0, 1, 1, 1],
+           [0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)
+    >>> np.array_equal(b, np.unpackbits(p, axis=0, count=b.shape[0]))
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]]} unpackbits (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unpackbits"))))
+
+(def ^{:doc "
+    Find the union of two arrays.
+
+    Return the unique, sorted array of values that are in either of the two
+    input arrays.
+
+    Parameters
+    ----------
+    ar1, ar2 : array_like
+        Input arrays. They are flattened if they are not already 1D.
+
+    Returns
+    -------
+    union1d : ndarray
+        Unique, sorted union of the input arrays.
+
+    See Also
+    --------
+    numpy.lib.arraysetops : Module with a number of other functions for
+                            performing set operations on arrays.
+
+    Examples
+    --------
+    >>> np.union1d([-1, 0, 1], [-2, 0, 2])
+    array([-2, -1,  0,  1,  2])
+
+    To find the union of more than two arrays, use functools.reduce:
+
+    >>> from functools import reduce
+    >>> reduce(np.union1d, ([1, 3, 4, 3], [3, 1, 2, 1], [6, 3, 4, 2]))
+    array([1, 2, 3, 4, 6])
+    " :arglists '[[& [args {:as kwargs}]]]} union1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "union1d"))))
+
+(def ^{:doc "
+    Evaluate a piecewise-defined function.
+
+    Given a set of conditions and corresponding functions, evaluate each
+    function on the input data wherever its condition is true.
+
+    Parameters
+    ----------
+    x : ndarray or scalar
+        The input domain.
+    condlist : list of bool arrays or bool scalars
+        Each boolean array corresponds to a function in `funclist`.  Wherever
+        `condlist[i]` is True, `funclist[i](x)` is used as the output value.
+
+        Each boolean array in `condlist` selects a piece of `x`,
+        and should therefore be of the same shape as `x`.
+
+        The length of `condlist` must correspond to that of `funclist`.
+        If one extra function is given, i.e. if
+        ``len(funclist) == len(condlist) + 1``, then that extra function
+        is the default value, used wherever all conditions are false.
+    funclist : list of callables, f(x,*args,**kw), or scalars
+        Each function is evaluated over `x` wherever its corresponding
+        condition is True.  It should take a 1d array as input and give an 1d
+        array or a scalar value as output.  If, instead of a callable,
+        a scalar is provided then a constant function (``lambda x: scalar``) is
+        assumed.
+    args : tuple, optional
+        Any further arguments given to `piecewise` are passed to the functions
+        upon execution, i.e., if called ``piecewise(..., ..., 1, 'a')``, then
+        each function is called as ``f(x, 1, 'a')``.
+    kw : dict, optional
+        Keyword arguments used in calling `piecewise` are passed to the
+        functions upon execution, i.e., if called
+        ``piecewise(..., ..., alpha=1)``, then each function is called as
+        ``f(x, alpha=1)``.
+
+    Returns
+    -------
+    out : ndarray
+        The output is the same shape and type as x and is found by
+        calling the functions in `funclist` on the appropriate portions of `x`,
+        as defined by the boolean arrays in `condlist`.  Portions not covered
+        by any condition have a default value of 0.
+
+
+    See Also
+    --------
+    choose, select, where
+
+    Notes
+    -----
+    This is similar to choose or select, except that functions are
+    evaluated on elements of `x` that satisfy the corresponding condition from
+    `condlist`.
+
+    The result is::
+
+            |--
+            |funclist[0](x[condlist[0]])
+      out = |funclist[1](x[condlist[1]])
+            |...
+            |funclist[n2](x[condlist[n2]])
+            |--
+
+    Examples
+    --------
+    Define the sigma function, which is -1 for ``x < 0`` and +1 for ``x >= 0``.
+
+    >>> x = np.linspace(-2.5, 2.5, 6)
+    >>> np.piecewise(x, [x < 0, x >= 0], [-1, 1])
+    array([-1., -1., -1.,  1.,  1.,  1.])
+
+    Define the absolute value, which is ``-x`` for ``x <0`` and ``x`` for
+    ``x >= 0``.
+
+    >>> np.piecewise(x, [x < 0, x >= 0], [lambda x: -x, lambda x: x])
+    array([2.5,  1.5,  0.5,  0.5,  1.5,  2.5])
+
+    Apply the same function to a scalar value.
+
+    >>> y = -2
+    >>> np.piecewise(y, [y < 0, y >= 0], [lambda x: -x, lambda x: x])
+    array(2)
+
+    " :arglists '[[& [args {:as kwargs}]]]} piecewise (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "piecewise"))))
+
+(def ^{:doc "absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Calculate the absolute value element-wise.
+
+``np.abs`` is a shorthand for this function.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+absolute : ndarray
+    An ndarray containing the absolute value of
+    each element in `x`.  For complex input, ``a + ib``, the
+    absolute value is :math:`\\sqrt{ a^2 + b^2 }`.
+    This is a scalar if `x` is a scalar.
+
+Examples
+--------
+>>> x = np.array([-1.2, 1.2])
+>>> np.absolute(x)
+array([ 1.2,  1.2])
+>>> np.absolute(1.2 + 1j)
+1.5620499351813308
+
+Plot the function over ``[-10, 10]``:
+
+>>> import matplotlib.pyplot as plt
+
+>>> x = np.linspace(start=-10, stop=10, num=101)
+>>> plt.plot(x, np.absolute(x))
+>>> plt.show()
+
+Plot the function over the complex plane:
+
+>>> xx = x + 1j * x[:, np.newaxis]
+>>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')
+>>> plt.show()
+
+The `abs` function can be used as a shorthand for ``np.absolute`` on
+ndarrays.
+
+>>> x = np.array([-1.2, 1.2])
+>>> abs(x)
+array([1.2, 1.2])" :arglists '[[self & [args {:as kwargs}]]]} abs (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "abs"))))
+
+(def ^{:doc "
+    Return the size of the buffer used in ufuncs.
+
+    Returns
+    -------
+    getbufsize : int
+        Size of ufunc buffer in bytes.
+
+    " :arglists '[[]]} getbufsize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "getbufsize"))))
+
+(def ^{:doc "
+    Return the indices for the lower-triangle of arr.
+
+    See `tril_indices` for full details.
+
+    Parameters
+    ----------
+    arr : array_like
+        The indices will be valid for square arrays whose dimensions are
+        the same as arr.
+    k : int, optional
+        Diagonal offset (see `tril` for details).
+
+    See Also
+    --------
+    tril_indices, tril
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    " :arglists '[[& [args {:as kwargs}]]]} tril_indices_from (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tril_indices_from"))))
+
+(def ^{:doc "
+Module defining global singleton classes.
+
+This module raises a RuntimeError if an attempt to reload it is made. In that
+way the identities of the classes defined here are fixed and will remain so
+even if numpy itself is reloaded. In particular, a function like the following
+will still work correctly after numpy is reloaded::
+
+    def foo(arg=np._NoValue):
+        if arg is np._NoValue:
+            ...
+
+That was not the case when the singleton classes were defined in the numpy
+``__init__.py`` file. See gh-7844 for a discussion of the reload problem that
+motivated this module.
+
+"} _globals (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_globals"))))
+
+(def ^{:doc "A unicode string.
+
+    When used in arrays, this type strips trailing null codepoints.
+
+    Unlike the builtin `str`, this supports the :ref:`python:bufferobjects`, exposing its
+    contents as UCS4:
+
+    >>> m = memoryview(np.str_(\"abc\"))
+    >>> m.format
+    '3w'
+    >>> m.tobytes()
+    b'a\\x00\\x00\\x00b\\x00\\x00\\x00c\\x00\\x00\\x00'
+
+    :Character code: ``'U'``
+    :Alias: `numpy.unicode_`" :arglists '[[self & [args {:as kwargs}]]]} Str0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "Str0"))))
+
+(def ^{:doc "conjugate(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the complex conjugate, element-wise.
+
+The complex conjugate of a complex number is obtained by changing the
+sign of its imaginary part.
+
+Parameters
+----------
+x : array_like
+    Input value.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The complex conjugate of `x`, with same dtype as `y`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+`conj` is an alias for `conjugate`:
+
+>>> np.conj is np.conjugate
+True
+
+Examples
+--------
+>>> np.conjugate(1+2j)
+(1-2j)
+
+>>> x = np.eye(2) + 1j * np.eye(2)
+>>> np.conjugate(x)
+array([[ 1.-1.j,  0.-0.j],
+       [ 0.-0.j,  1.-1.j]])" :arglists '[[self & [args {:as kwargs}]]]} conj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "conj"))))
+
+(def ^{:doc "
+    Perform an indirect partition along the given axis using the
+    algorithm specified by the `kind` keyword. It returns an array of
+    indices of the same shape as `a` that index data along the given
+    axis in partitioned order.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array to sort.
+    kth : int or sequence of ints
+        Element index to partition by. The k-th element will be in its
+        final sorted position and all smaller elements will be moved
+        before it and all larger elements behind it. The order all
+        elements in the partitions is undefined. If provided with a
+        sequence of k-th it will partition all of them into their sorted
+        position at once.
+    axis : int or None, optional
+        Axis along which to sort. The default is -1 (the last axis). If
+        None, the flattened array is used.
+    kind : {'introselect'}, optional
+        Selection algorithm. Default is 'introselect'
+    order : str or list of str, optional
+        When `a` is an array with fields defined, this argument
+        specifies which fields to compare first, second, etc. A single
+        field can be specified as a string, and not all fields need be
+        specified, but unspecified fields will still be used, in the
+        order in which they come up in the dtype, to break ties.
+
+    Returns
+    -------
+    index_array : ndarray, int
+        Array of indices that partition `a` along the specified axis.
+        If `a` is one-dimensional, ``a[index_array]`` yields a partitioned `a`.
+        More generally, ``np.take_along_axis(a, index_array, axis=a)`` always
+        yields the partitioned `a`, irrespective of dimensionality.
+
+    See Also
+    --------
+    partition : Describes partition algorithms used.
+    ndarray.partition : Inplace partition.
+    argsort : Full indirect sort.
+    take_along_axis : Apply ``index_array`` from argpartition
+                      to an array as if by calling partition.
+
+    Notes
+    -----
+    See `partition` for notes on the different selection algorithms.
+
+    Examples
+    --------
+    One dimensional array:
+
+    >>> x = np.array([3, 4, 2, 1])
+    >>> x[np.argpartition(x, 3)]
+    array([2, 1, 3, 4])
+    >>> x[np.argpartition(x, (1, 3))]
+    array([1, 2, 3, 4])
+
+    >>> x = [3, 4, 2, 1]
+    >>> np.array(x)[np.argpartition(x, 3)]
+    array([2, 1, 3, 4])
+
+    Multi-dimensional array:
+
+    >>> x = np.array([[3, 4, 2], [1, 3, 1]])
+    >>> index_array = np.argpartition(x, kth=1, axis=-1)
+    >>> np.take_along_axis(x, index_array, axis=-1)  # same as np.partition(x, kth=1)
+    array([[2, 3, 4],
+           [1, 1, 3]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} argpartition (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argpartition"))))
+
+(def ^{:doc "
+    Show libraries in the system on which NumPy was built.
+
+    Print information about various resources (libraries, library
+    directories, include directories, etc.) in the system on which
+    NumPy was built.
+
+    See Also
+    --------
+    get_include : Returns the directory containing NumPy C
+                  header files.
+
+    Notes
+    -----
+    Classes specifying the information to be printed are defined
+    in the `numpy.distutils.system_info` module.
+
+    Information may include:
+
+    * ``language``: language used to write the libraries (mostly
+      C or f77)
+    * ``libraries``: names of libraries found in the system
+    * ``library_dirs``: directories containing the libraries
+    * ``include_dirs``: directories containing library header files
+    * ``src_dirs``: directories containing library source files
+    * ``define_macros``: preprocessor macros used by
+      ``distutils.setup``
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.show_config()
+    blas_opt_info:
+        language = c
+        define_macros = [('HAVE_CBLAS', None)]
+        libraries = ['openblas', 'openblas']
+        library_dirs = ['/usr/local/lib']
+    " :arglists '[[]]} show_config (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "show_config"))))
+
+(def ^{:doc "arange([start,] stop[, step,], dtype=None, *, like=None)
+
+    Return evenly spaced values within a given interval.
+
+    Values are generated within the half-open interval ``[start, stop)``
+    (in other words, the interval including `start` but excluding `stop`).
+    For integer arguments the function is equivalent to the Python built-in
+    `range` function, but returns an ndarray rather than a list.
+
+    When using a non-integer step, such as 0.1, the results will often not
+    be consistent.  It is better to use `numpy.linspace` for these cases.
+
+    Parameters
+    ----------
+    start : integer or real, optional
+        Start of interval.  The interval includes this value.  The default
+        start value is 0.
+    stop : integer or real
+        End of interval.  The interval does not include this value, except
+        in some cases where `step` is not an integer and floating point
+        round-off affects the length of `out`.
+    step : integer or real, optional
+        Spacing between values.  For any output `out`, this is the distance
+        between two adjacent values, ``out[i+1] - out[i]``.  The default
+        step size is 1.  If `step` is specified as a position argument,
+        `start` must also be given.
+    dtype : dtype
+        The type of the output array.  If `dtype` is not given, infer the data
+        type from the other input arguments.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    arange : ndarray
+        Array of evenly spaced values.
+
+        For floating point arguments, the length of the result is
+        ``ceil((stop - start)/step)``.  Because of floating point overflow,
+        this rule may result in the last element of `out` being greater
+        than `stop`.
+
+    See Also
+    --------
+    numpy.linspace : Evenly spaced numbers with careful handling of endpoints.
+    numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.
+    numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
+
+    Examples
+    --------
+    >>> np.arange(3)
+    array([0, 1, 2])
+    >>> np.arange(3.0)
+    array([ 0.,  1.,  2.])
+    >>> np.arange(3,7)
+    array([3, 4, 5, 6])
+    >>> np.arange(3,7,2)
+    array([3, 5])" :arglists '[[self & [args {:as kwargs}]]]} arange (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arange"))))
+
+(def ^{:doc "
+    Generate a Vandermonde matrix.
+
+    The columns of the output matrix are powers of the input vector. The
+    order of the powers is determined by the `increasing` boolean argument.
+    Specifically, when `increasing` is False, the `i`-th output column is
+    the input vector raised element-wise to the power of ``N - i - 1``. Such
+    a matrix with a geometric progression in each row is named for Alexandre-
+    Theophile Vandermonde.
+
+    Parameters
+    ----------
+    x : array_like
+        1-D input array.
+    N : int, optional
+        Number of columns in the output.  If `N` is not specified, a square
+        array is returned (``N = len(x)``).
+    increasing : bool, optional
+        Order of the powers of the columns.  If True, the powers increase
+        from left to right, if False (the default) they are reversed.
+
+        .. versionadded:: 1.9.0
+
+    Returns
+    -------
+    out : ndarray
+        Vandermonde matrix.  If `increasing` is False, the first column is
+        ``x^(N-1)``, the second ``x^(N-2)`` and so forth. If `increasing` is
+        True, the columns are ``x^0, x^1, ..., x^(N-1)``.
+
+    See Also
+    --------
+    polynomial.polynomial.polyvander
+
+    Examples
+    --------
+    >>> x = np.array([1, 2, 3, 5])
+    >>> N = 3
+    >>> np.vander(x, N)
+    array([[ 1,  1,  1],
+           [ 4,  2,  1],
+           [ 9,  3,  1],
+           [25,  5,  1]])
+
+    >>> np.column_stack([x**(N-1-i) for i in range(N)])
+    array([[ 1,  1,  1],
+           [ 4,  2,  1],
+           [ 9,  3,  1],
+           [25,  5,  1]])
+
+    >>> x = np.array([1, 2, 3, 5])
+    >>> np.vander(x)
+    array([[  1,   1,   1,   1],
+           [  8,   4,   2,   1],
+           [ 27,   9,   3,   1],
+           [125,  25,   5,   1]])
+    >>> np.vander(x, increasing=True)
+    array([[  1,   1,   1,   1],
+           [  1,   2,   4,   8],
+           [  1,   3,   9,  27],
+           [  1,   5,  25, 125]])
+
+    The determinant of a square Vandermonde matrix is the product
+    of the differences between the values of the input vector:
+
+    >>> np.linalg.det(np.vander(x))
+    48.000000000000043 # may vary
+    >>> (5-3)*(5-2)*(5-1)*(3-2)*(3-1)*(2-1)
+    48
+
+    " :arglists '[[& [args {:as kwargs}]]]} vander (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vander"))))
+
+(def ^{:doc "expm1(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Calculate ``exp(x) - 1`` for all elements in the array.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Element-wise exponential minus one: ``out = exp(x) - 1``.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+log1p : ``log(1 + x)``, the inverse of expm1.
+
+
+Notes
+-----
+This function provides greater precision than ``exp(x) - 1``
+for small values of ``x``.
+
+Examples
+--------
+The true value of ``exp(1e-10) - 1`` is ``1.00000000005e-10`` to
+about 32 significant digits. This example shows the superiority of
+expm1 in this case.
+
+>>> np.expm1(1e-10)
+1.00000000005e-10
+>>> np.exp(1e-10) - 1
+1.000000082740371e-10" :arglists '[[self & [args {:as kwargs}]]]} expm1 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "expm1"))))
+
+(def ^{:doc "
+    Return the binary representation of the input number as a string.
+
+    For negative numbers, if width is not given, a minus sign is added to the
+    front. If width is given, the two's complement of the number is
+    returned, with respect to that width.
+
+    In a two's-complement system negative numbers are represented by the two's
+    complement of the absolute value. This is the most common method of
+    representing signed integers on computers [1]_. A N-bit two's-complement
+    system can represent every integer in the range
+    :math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
+
+    Parameters
+    ----------
+    num : int
+        Only an integer decimal number can be used.
+    width : int, optional
+        The length of the returned string if `num` is positive, or the length
+        of the two's complement if `num` is negative, provided that `width` is
+        at least a sufficient number of bits for `num` to be represented in the
+        designated form.
+
+        If the `width` value is insufficient, it will be ignored, and `num` will
+        be returned in binary (`num` > 0) or two's complement (`num` < 0) form
+        with its width equal to the minimum number of bits needed to represent
+        the number in the designated form. This behavior is deprecated and will
+        later raise an error.
+
+        .. deprecated:: 1.12.0
+
+    Returns
+    -------
+    bin : str
+        Binary representation of `num` or two's complement of `num`.
+
+    See Also
+    --------
+    base_repr: Return a string representation of a number in the given base
+               system.
+    bin: Python's built-in binary representation generator of an integer.
+
+    Notes
+    -----
+    `binary_repr` is equivalent to using `base_repr` with base 2, but about 25x
+    faster.
+
+    References
+    ----------
+    .. [1] Wikipedia, \"Two's complement\",
+        https://en.wikipedia.org/wiki/Two's_complement
+
+    Examples
+    --------
+    >>> np.binary_repr(3)
+    '11'
+    >>> np.binary_repr(-3)
+    '-11'
+    >>> np.binary_repr(3, width=4)
+    '0011'
+
+    The two's complement is returned when the input number is negative and
+    width is specified:
+
+    >>> np.binary_repr(-3, width=3)
+    '101'
+    >>> np.binary_repr(-3, width=5)
+    '11101'
+
+    " :arglists '[[num & [{width :width}]] [num]]} binary_repr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "binary_repr"))))
+
+(def ^{:doc "Double-precision floating-point number type, compatible with Python `float`
+    and C ``double``.
+
+    :Character code: ``'d'``
+    :Canonical name: `numpy.double`
+    :Alias: `numpy.float_`
+    :Alias on this platform: `numpy.float64`: 64-bit precision floating-point number type: sign bit, 11 bits exponent, 52 bits mantissa." :arglists '[[self & [args {:as kwargs}]]]} double (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "double"))))
+
+(def ^{:doc "
+    Stack arrays in sequence vertically (row wise).
+
+    This is equivalent to concatenation along the first axis after 1-D arrays
+    of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
+    `vsplit`.
+
+    This function makes most sense for arrays with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of ndarrays
+        The arrays must have the same shape along all but the first axis.
+        1-D arrays must have the same length.
+
+    Returns
+    -------
+    stacked : ndarray
+        The array formed by stacking the given arrays, will be at least 2-D.
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays along an existing axis.
+    stack : Join a sequence of arrays along a new axis.
+    block : Assemble an nd-array from nested lists of blocks.
+    hstack : Stack arrays in sequence horizontally (column wise).
+    dstack : Stack arrays in sequence depth wise (along third axis).
+    column_stack : Stack 1-D arrays as columns into a 2-D array.
+    vsplit : Split an array into multiple sub-arrays vertically (row-wise).
+
+    Examples
+    --------
+    >>> a = np.array([1, 2, 3])
+    >>> b = np.array([2, 3, 4])
+    >>> np.vstack((a,b))
+    array([[1, 2, 3],
+           [2, 3, 4]])
+
+    >>> a = np.array([[1], [2], [3]])
+    >>> b = np.array([[2], [3], [4]])
+    >>> np.vstack((a,b))
+    array([[1],
+           [2],
+           [3],
+           [2],
+           [3],
+           [4]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} vstack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "vstack"))))
+
+(def ^{:doc ""} version (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "version"))))
+
+(def ^{:doc "
+    Find the indices of array elements that are non-zero, grouped by element.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+
+    Returns
+    -------
+    index_array : (N, a.ndim) ndarray
+        Indices of elements that are non-zero. Indices are grouped by element.
+        This array will have shape ``(N, a.ndim)`` where ``N`` is the number of
+        non-zero items.
+
+    See Also
+    --------
+    where, nonzero
+
+    Notes
+    -----
+    ``np.argwhere(a)`` is almost the same as ``np.transpose(np.nonzero(a))``,
+    but produces a result of the correct shape for a 0D array.
+
+    The output of ``argwhere`` is not suitable for indexing arrays.
+    For this purpose use ``nonzero(a)`` instead.
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2,3)
+    >>> x
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.argwhere(x>1)
+    array([[0, 2],
+           [1, 0],
+           [1, 1],
+           [1, 2]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} argwhere (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "argwhere"))))
+
+(def ^{:doc "
+    Check whether or not an object can be iterated over.
+
+    Parameters
+    ----------
+    y : object
+      Input object.
+
+    Returns
+    -------
+    b : bool
+      Return ``True`` if the object has an iterator method or is a
+      sequence and ``False`` otherwise.
+
+
+    Examples
+    --------
+    >>> np.iterable([1, 2, 3])
+    True
+    >>> np.iterable(2)
+    False
+
+    " :arglists '[[y]]} iterable (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iterable"))))
+
+(def ^{:doc "add_ufunc_docstring(ufunc, new_docstring)
+
+    Replace the docstring for a ufunc with new_docstring.
+    This method will only work if the current docstring for
+    the ufunc is NULL. (At the C level, i.e. when ufunc->doc is NULL.)
+
+    Parameters
+    ----------
+    ufunc : numpy.ufunc
+        A ufunc whose current doc is NULL.
+    new_docstring : string
+        The new docstring for the ufunc.
+
+    Notes
+    -----
+    This method allocates memory for new_docstring on
+    the heap. Technically this creates a mempory leak, since this
+    memory will not be reclaimed until the end of the program
+    even if the ufunc itself is removed. However this will only
+    be a problem if the user is repeatedly creating ufuncs with
+    no documentation, adding documentation via add_newdoc_ufunc,
+    and then throwing away the ufunc." :arglists '[[self & [args {:as kwargs}]]]} _add_newdoc_ufunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "_add_newdoc_ufunc"))))
+
+(def ^{:doc "
+    Append values to the end of an array.
+
+    Parameters
+    ----------
+    arr : array_like
+        Values are appended to a copy of this array.
+    values : array_like
+        These values are appended to a copy of `arr`.  It must be of the
+        correct shape (the same shape as `arr`, excluding `axis`).  If
+        `axis` is not specified, `values` can be any shape and will be
+        flattened before use.
+    axis : int, optional
+        The axis along which `values` are appended.  If `axis` is not
+        given, both `arr` and `values` are flattened before use.
+
+    Returns
+    -------
+    append : ndarray
+        A copy of `arr` with `values` appended to `axis`.  Note that
+        `append` does not occur in-place: a new array is allocated and
+        filled.  If `axis` is None, `out` is a flattened array.
+
+    See Also
+    --------
+    insert : Insert elements into an array.
+    delete : Delete elements from an array.
+
+    Examples
+    --------
+    >>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]])
+    array([1, 2, 3, ..., 7, 8, 9])
+
+    When `axis` is specified, `values` must have the correct shape.
+
+    >>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)
+    array([[1, 2, 3],
+           [4, 5, 6],
+           [7, 8, 9]])
+    >>> np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)
+    Traceback (most recent call last):
+        ...
+    ValueError: all the input arrays must have same number of dimensions, but
+    the array at index 0 has 2 dimension(s) and the array at index 1 has 1
+    dimension(s)
+
+    " :arglists '[[& [args {:as kwargs}]]]} append (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "append"))))
+
+(def ^{:doc "
+    iinfo(type)
+
+    Machine limits for integer types.
+
+    Attributes
+    ----------
+    bits : int
+        The number of bits occupied by the type.
+    min : int
+        The smallest integer expressible by the type.
+    max : int
+        The largest integer expressible by the type.
+
+    Parameters
+    ----------
+    int_type : integer type, dtype, or instance
+        The kind of integer data type to get information about.
+
+    See Also
+    --------
+    finfo : The equivalent for floating point data types.
+
+    Examples
+    --------
+    With types:
+
+    >>> ii16 = np.iinfo(np.int16)
+    >>> ii16.min
+    -32768
+    >>> ii16.max
+    32767
+    >>> ii32 = np.iinfo(np.int32)
+    >>> ii32.min
+    -2147483648
+    >>> ii32.max
+    2147483647
+
+    With instances:
+
+    >>> ii32 = np.iinfo(np.int32(10))
+    >>> ii32.min
+    -2147483648
+    >>> ii32.max
+    2147483647
+
+    " :arglists '[[self int_type]]} iinfo (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "iinfo"))))
+
+(def ^{:doc "
+    Return an array of ones with the same shape and type as a given array.
+
+    Parameters
+    ----------
+    a : array_like
+        The shape and data-type of `a` define these same attributes of
+        the returned array.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+
+        .. versionadded:: 1.6.0
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible.
+
+        .. versionadded:: 1.6.0
+    subok : bool, optional.
+        If True, then the newly created array will use the sub-class
+        type of `a`, otherwise it will be a base-class array. Defaults
+        to True.
+    shape : int or sequence of ints, optional.
+        Overrides the shape of the result. If order='K' and the number of
+        dimensions is unchanged, will try to keep order, otherwise,
+        order='C' is implied.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of ones with the same shape and type as `a`.
+
+    See Also
+    --------
+    empty_like : Return an empty array with shape and type of input.
+    zeros_like : Return an array of zeros with shape and type of input.
+    full_like : Return a new array with shape of input filled with value.
+    ones : Return a new array setting values to one.
+
+    Examples
+    --------
+    >>> x = np.arange(6)
+    >>> x = x.reshape((2, 3))
+    >>> x
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.ones_like(x)
+    array([[1, 1, 1],
+           [1, 1, 1]])
+
+    >>> y = np.arange(3, dtype=float)
+    >>> y
+    array([0., 1., 2.])
+    >>> np.ones_like(y)
+    array([1.,  1.,  1.])
+
+    " :arglists '[[& [args {:as kwargs}]]]} ones_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ones_like"))))
+
+(def ^{:doc "
+    Return a full array with the same shape and type as a given array.
+
+    Parameters
+    ----------
+    a : array_like
+        The shape and data-type of `a` define these same attributes of
+        the returned array.
+    fill_value : scalar
+        Fill value.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible.
+    subok : bool, optional.
+        If True, then the newly created array will use the sub-class
+        type of `a`, otherwise it will be a base-class array. Defaults
+        to True.
+    shape : int or sequence of ints, optional.
+        Overrides the shape of the result. If order='K' and the number of
+        dimensions is unchanged, will try to keep order, otherwise,
+        order='C' is implied.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of `fill_value` with the same shape and type as `a`.
+
+    See Also
+    --------
+    empty_like : Return an empty array with shape and type of input.
+    ones_like : Return an array of ones with shape and type of input.
+    zeros_like : Return an array of zeros with shape and type of input.
+    full : Return a new array of given shape filled with value.
+
+    Examples
+    --------
+    >>> x = np.arange(6, dtype=int)
+    >>> np.full_like(x, 1)
+    array([1, 1, 1, 1, 1, 1])
+    >>> np.full_like(x, 0.1)
+    array([0, 0, 0, 0, 0, 0])
+    >>> np.full_like(x, 0.1, dtype=np.double)
+    array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
+    >>> np.full_like(x, np.nan, dtype=np.double)
+    array([nan, nan, nan, nan, nan, nan])
+
+    >>> y = np.arange(6, dtype=np.double)
+    >>> np.full_like(y, 0.1)
+    array([0.1, 0.1, 0.1, 0.1, 0.1, 0.1])
+
+    " :arglists '[[& [args {:as kwargs}]]]} full_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "full_like"))))
+
+(def ^{:doc "
+    Convert inputs to arrays with at least one dimension.
+
+    Scalar inputs are converted to 1-dimensional arrays, whilst
+    higher-dimensional inputs are preserved.
+
+    Parameters
+    ----------
+    arys1, arys2, ... : array_like
+        One or more input arrays.
+
+    Returns
+    -------
+    ret : ndarray
+        An array, or list of arrays, each with ``a.ndim >= 1``.
+        Copies are made only if necessary.
+
+    See Also
+    --------
+    atleast_2d, atleast_3d
+
+    Examples
+    --------
+    >>> np.atleast_1d(1.0)
+    array([1.])
+
+    >>> x = np.arange(9.0).reshape(3,3)
+    >>> np.atleast_1d(x)
+    array([[0., 1., 2.],
+           [3., 4., 5.],
+           [6., 7., 8.]])
+    >>> np.atleast_1d(x) is x
+    True
+
+    >>> np.atleast_1d(1, [3, 4])
+    [array([1]), array([3, 4])]
+
+    " :arglists '[[& [args {:as kwargs}]]]} atleast_1d (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "atleast_1d"))))
+
+(def ^{:doc ""} SHIFT_UNDERFLOW 6)
+
+(def ^{:doc "Convert the input to an ndarray, but pass ndarray subclasses through.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data, in any form that can be converted to an array.  This
+        includes scalars, lists, lists of tuples, tuples, tuples of tuples,
+        tuples of lists, and ndarrays.
+    dtype : data-type, optional
+        By default, the data-type is inferred from the input data.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Memory layout.  'A' and 'K' depend on the order of input array a.
+        'C' row-major (C-style), 
+        'F' column-major (Fortran-style) memory representation.
+        'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
+        'K' (keep) preserve input order
+        Defaults to 'C'.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray or an ndarray subclass
+        Array interpretation of `a`.  If `a` is an ndarray or a subclass
+        of ndarray, it is returned as-is and no copy is performed.
+
+    See Also
+    --------
+    asarray : Similar function which always returns ndarrays.
+    ascontiguousarray : Convert input to a contiguous array.
+    asfarray : Convert input to a floating point ndarray.
+    asfortranarray : Convert input to an ndarray with column-major
+                     memory order.
+    asarray_chkfinite : Similar function which checks input for NaNs and
+                        Infs.
+    fromiter : Create an array from an iterator.
+    fromfunction : Construct an array by executing a function on grid
+                   positions.
+
+    Examples
+    --------
+    Convert a list into an array:
+
+    >>> a = [1, 2]
+    >>> np.asanyarray(a)
+    array([1, 2])
+
+    Instances of `ndarray` subclasses are passed through as-is:
+
+    >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
+    >>> np.asanyarray(a) is a
+    True
+
+    " :arglists '[[a & [{dtype :dtype, order :order, like :like}]] [a & [{dtype :dtype, like :like}]] [a & [{like :like}]]]} asanyarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asanyarray"))))
+
+(def ^{:doc "
+    Do a keyword search on docstrings.
+
+    A list of objects that matched the search is displayed,
+    sorted by relevance. All given keywords need to be found in the
+    docstring for it to be returned as a result, but the order does
+    not matter.
+
+    Parameters
+    ----------
+    what : str
+        String containing words to look for.
+    module : str or list, optional
+        Name of module(s) whose docstrings to go through.
+    import_modules : bool, optional
+        Whether to import sub-modules in packages. Default is True.
+    regenerate : bool, optional
+        Whether to re-generate the docstring cache. Default is False.
+    output : file-like, optional
+        File-like object to write the output to. If omitted, use a pager.
+
+    See Also
+    --------
+    source, info
+
+    Notes
+    -----
+    Relevance is determined only roughly, by checking if the keywords occur
+    in the function name, at the start of a docstring, etc.
+
+    Examples
+    --------
+    >>> np.lookfor('binary representation') # doctest: +SKIP
+    Search results for 'binary representation'
+    ------------------------------------------
+    numpy.binary_repr
+        Return the binary representation of the input number as a string.
+    numpy.core.setup_common.long_double_representation
+        Given a binary dump as given by GNU od -b, look for long double
+    numpy.base_repr
+        Return a string representation of a number in the given base system.
+    ...
+
+    " :arglists '[[what & [{module :module, import_modules :import_modules, regenerate :regenerate, output :output}]] [what & [{module :module, import_modules :import_modules, regenerate :regenerate}]] [what & [{module :module, import_modules :import_modules}]] [what & [{module :module}]] [what]]} lookfor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "lookfor"))))
+
+(def ^{:doc "true_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns a true division of the inputs, element-wise.
+
+Instead of the Python traditional 'floor division', this returns a true
+division.  True division adjusts the output type to present the best
+answer, regardless of input types.
+
+Parameters
+----------
+x1 : array_like
+    Dividend array.
+x2 : array_like
+    Divisor array.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+In Python, ``//`` is the floor division operator and ``/`` the
+true division operator.  The ``true_divide(x1, x2)`` function is
+equivalent to true division in Python.
+
+Examples
+--------
+>>> x = np.arange(5)
+>>> np.true_divide(x, 4)
+array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
+
+>>> x/4
+array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
+
+>>> x//4
+array([0, 0, 0, 0, 1])
+
+The ``/`` operator can be used as a shorthand for ``np.true_divide`` on
+ndarrays.
+
+>>> x = np.arange(5)
+>>> x / 4
+array([0.  , 0.25, 0.5 , 0.75, 1.  ])" :arglists '[[self & [args {:as kwargs}]]]} divide (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "divide"))))
+
+(def ^{:doc "
+    Trim the leading and/or trailing zeros from a 1-D array or sequence.
+
+    Parameters
+    ----------
+    filt : 1-D array or sequence
+        Input array.
+    trim : str, optional
+        A string with 'f' representing trim from front and 'b' to trim from
+        back. Default is 'fb', trim zeros from both front and back of the
+        array.
+
+    Returns
+    -------
+    trimmed : 1-D array or sequence
+        The result of trimming the input. The input data type is preserved.
+
+    Examples
+    --------
+    >>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0))
+    >>> np.trim_zeros(a)
+    array([1, 2, 3, 0, 2, 1])
+
+    >>> np.trim_zeros(a, 'b')
+    array([0, 0, 0, ..., 0, 2, 1])
+
+    The input data type is preserved, list/tuple in means list/tuple out.
+
+    >>> np.trim_zeros([0, 1, 2, 0])
+    [1, 2]
+
+    " :arglists '[[& [args {:as kwargs}]]]} trim_zeros (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "trim_zeros"))))
+
+(def ^{:doc "
+    Insert values along the given axis before the given indices.
+
+    Parameters
+    ----------
+    arr : array_like
+        Input array.
+    obj : int, slice or sequence of ints
+        Object that defines the index or indices before which `values` is
+        inserted.
+
+        .. versionadded:: 1.8.0
+
+        Support for multiple insertions when `obj` is a single scalar or a
+        sequence with one element (similar to calling insert multiple
+        times).
+    values : array_like
+        Values to insert into `arr`. If the type of `values` is different
+        from that of `arr`, `values` is converted to the type of `arr`.
+        `values` should be shaped so that ``arr[...,obj,...] = values``
+        is legal.
+    axis : int, optional
+        Axis along which to insert `values`.  If `axis` is None then `arr`
+        is flattened first.
+
+    Returns
+    -------
+    out : ndarray
+        A copy of `arr` with `values` inserted.  Note that `insert`
+        does not occur in-place: a new array is returned. If
+        `axis` is None, `out` is a flattened array.
+
+    See Also
+    --------
+    append : Append elements at the end of an array.
+    concatenate : Join a sequence of arrays along an existing axis.
+    delete : Delete elements from an array.
+
+    Notes
+    -----
+    Note that for higher dimensional inserts `obj=0` behaves very different
+    from `obj=[0]` just like `arr[:,0,:] = values` is different from
+    `arr[:,[0],:] = values`.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 1], [2, 2], [3, 3]])
+    >>> a
+    array([[1, 1],
+           [2, 2],
+           [3, 3]])
+    >>> np.insert(a, 1, 5)
+    array([1, 5, 1, ..., 2, 3, 3])
+    >>> np.insert(a, 1, 5, axis=1)
+    array([[1, 5, 1],
+           [2, 5, 2],
+           [3, 5, 3]])
+
+    Difference between sequence and scalars:
+
+    >>> np.insert(a, [1], [[1],[2],[3]], axis=1)
+    array([[1, 1, 1],
+           [2, 2, 2],
+           [3, 3, 3]])
+    >>> np.array_equal(np.insert(a, 1, [1, 2, 3], axis=1),
+    ...                np.insert(a, [1], [[1],[2],[3]], axis=1))
+    True
+
+    >>> b = a.flatten()
+    >>> b
+    array([1, 1, 2, 2, 3, 3])
+    >>> np.insert(b, [2, 2], [5, 6])
+    array([1, 1, 5, ..., 2, 3, 3])
+
+    >>> np.insert(b, slice(2, 4), [5, 6])
+    array([1, 1, 5, ..., 2, 3, 3])
+
+    >>> np.insert(b, [2, 2], [7.13, False]) # type casting
+    array([1, 1, 7, ..., 2, 3, 3])
+
+    >>> x = np.arange(8).reshape(2, 4)
+    >>> idx = (1, 3)
+    >>> np.insert(x, idx, 999, axis=1)
+    array([[  0, 999,   1,   2, 999,   3],
+           [  4, 999,   5,   6, 999,   7]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} insert (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "insert"))))
+
+(def ^{:doc ""} __version__ "1.20.3")
+
+(def ^{:doc "compare_chararrays(a, b, cmp_op, rstrip)
+
+    Performs element-wise comparison of two string arrays using the
+    comparison operator specified by `cmp_op`.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Arrays to be compared.
+    cmp_op : {\"<\", \"<=\", \"==\", \">=\", \">\", \"!=\"}
+        Type of comparison.
+    rstrip : Boolean
+        If True, the spaces at the end of Strings are removed before the comparison.
+
+    Returns
+    -------
+    out : ndarray
+        The output array of type Boolean with the same shape as a and b.
+
+    Raises
+    ------
+    ValueError
+        If `cmp_op` is not valid.
+    TypeError
+        If at least one of `a` or `b` is a non-string array
+
+    Examples
+    --------
+    >>> a = np.array([\"a\", \"b\", \"cde\"])
+    >>> b = np.array([\"a\", \"a\", \"dec\"])
+    >>> np.compare_chararrays(a, b, \">\", True)
+    array([False,  True, False])" :arglists '[[self & [args {:as kwargs}]]]} compare_chararrays (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "compare_chararrays"))))
+
+(def ^{:doc ""} __git_revision__ "27b98cbe0dd9d2969e9c227e7a2070aa56f41d6d")
+
+(def ^{:doc "
+    Return the string representation of an array.
+
+    Parameters
+    ----------
+    arr : ndarray
+        Input array.
+    max_line_width : int, optional
+        Inserts newlines if text is longer than `max_line_width`.
+        Defaults to ``numpy.get_printoptions()['linewidth']``.
+    precision : int, optional
+        Floating point precision.
+        Defaults to ``numpy.get_printoptions()['precision']``.
+    suppress_small : bool, optional
+        Represent numbers \"very close\" to zero as zero; default is False.
+        Very close is defined by precision: if the precision is 8, e.g.,
+        numbers smaller (in absolute value) than 5e-9 are represented as
+        zero.
+        Defaults to ``numpy.get_printoptions()['suppress']``.
+
+    Returns
+    -------
+    string : str
+      The string representation of an array.
+
+    See Also
+    --------
+    array_str, array2string, set_printoptions
+
+    Examples
+    --------
+    >>> np.array_repr(np.array([1,2]))
+    'array([1, 2])'
+    >>> np.array_repr(np.ma.array([0.]))
+    'MaskedArray([0.])'
+    >>> np.array_repr(np.array([], np.int32))
+    'array([], dtype=int32)'
+
+    >>> x = np.array([1e-6, 4e-7, 2, 3])
+    >>> np.array_repr(x, precision=6, suppress_small=True)
+    'array([0.000001,  0.      ,  2.      ,  3.      ])'
+
+    " :arglists '[[& [args {:as kwargs}]]]} array_repr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_repr"))))
+
+(def ^{:doc "
+    Determine if the first argument is a subclass of the second argument.
+
+    Parameters
+    ----------
+    arg1, arg2 : dtype or dtype specifier
+        Data-types.
+
+    Returns
+    -------
+    out : bool
+        The result.
+
+    See Also
+    --------
+    issctype, issubdtype, obj2sctype
+
+    Examples
+    --------
+    >>> np.issubsctype('S8', str)
+    False
+    >>> np.issubsctype(np.array([1]), int)
+    True
+    >>> np.issubsctype(np.array([1]), float)
+    False
+
+    " :arglists '[[arg1 arg2]]} issubsctype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issubsctype"))))
+
+(def ^{:doc ""} PINF ##Inf)
+(def ^{:doc "Built-in immutable sequence.
+
+If no argument is given, the constructor returns an empty tuple.
+If iterable is specified the tuple is initialized from iterable's items.
+
+If the argument is a tuple, the return value is the same object."} ScalarType (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* "ScalarType")))) 
+
+(def ^{:doc "
+    Stack arrays in sequence depth wise (along third axis).
+
+    This is equivalent to concatenation along the third axis after 2-D arrays
+    of shape `(M,N)` have been reshaped to `(M,N,1)` and 1-D arrays of shape
+    `(N,)` have been reshaped to `(1,N,1)`. Rebuilds arrays divided by
+    `dsplit`.
+
+    This function makes most sense for arrays with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of arrays
+        The arrays must have the same shape along all but the third axis.
+        1-D or 2-D arrays must have the same shape.
+
+    Returns
+    -------
+    stacked : ndarray
+        The array formed by stacking the given arrays, will be at least 3-D.
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays along an existing axis.
+    stack : Join a sequence of arrays along a new axis.
+    block : Assemble an nd-array from nested lists of blocks.
+    vstack : Stack arrays in sequence vertically (row wise).
+    hstack : Stack arrays in sequence horizontally (column wise).
+    column_stack : Stack 1-D arrays as columns into a 2-D array.
+    dsplit : Split array along third axis.
+
+    Examples
+    --------
+    >>> a = np.array((1,2,3))
+    >>> b = np.array((2,3,4))
+    >>> np.dstack((a,b))
+    array([[[1, 2],
+            [2, 3],
+            [3, 4]]])
+
+    >>> a = np.array([[1],[2],[3]])
+    >>> b = np.array([[2],[3],[4]])
+    >>> np.dstack((a,b))
+    array([[[1, 2]],
+           [[2, 3]],
+           [[3, 4]]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} dstack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dstack"))))
+
+(def ^{:doc "
+    `nd_grid` instance which returns an open multi-dimensional \"meshgrid\".
+
+    An instance of `numpy.lib.index_tricks.nd_grid` which returns an open
+    (i.e. not fleshed out) mesh-grid when indexed, so that only one dimension
+    of each returned array is greater than 1.  The dimension and number of the
+    output arrays are equal to the number of indexing dimensions.  If the step
+    length is not a complex number, then the stop is not inclusive.
+
+    However, if the step length is a **complex number** (e.g. 5j), then
+    the integer part of its magnitude is interpreted as specifying the
+    number of points to create between the start and stop values, where
+    the stop value **is inclusive**.
+
+    Returns
+    -------
+    mesh-grid
+        `ndarrays` with only one dimension not equal to 1
+
+    See Also
+    --------
+    np.lib.index_tricks.nd_grid : class of `ogrid` and `mgrid` objects
+    mgrid : like `ogrid` but returns dense (or fleshed out) mesh grids
+    r_ : array concatenator
+
+    Examples
+    --------
+    >>> from numpy import ogrid
+    >>> ogrid[-1:1:5j]
+    array([-1. , -0.5,  0. ,  0.5,  1. ])
+    >>> ogrid[0:5,0:5]
+    [array([[0],
+            [1],
+            [2],
+            [3],
+            [4]]), array([[0, 1, 2, 3, 4]])]
+
+    "} ogrid (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "ogrid"))))
+
+(def ^{:doc "
+    Test element-wise for positive infinity, return result as bool array.
+
+    Parameters
+    ----------
+    x : array_like
+        The input array.
+    out : array_like, optional
+        A location into which the result is stored. If provided, it must have a
+        shape that the input broadcasts to. If not provided or None, a
+        freshly-allocated boolean array is returned.
+
+    Returns
+    -------
+    out : ndarray
+        A boolean array with the same dimensions as the input.
+        If second argument is not supplied then a boolean array is returned
+        with values True where the corresponding element of the input is
+        positive infinity and values False where the element of the input is
+        not positive infinity.
+
+        If a second argument is supplied the result is stored there. If the
+        type of that array is a numeric type the result is represented as zeros
+        and ones, if the type is boolean then as False and True.
+        The return value `out` is then a reference to that array.
+
+    See Also
+    --------
+    isinf, isneginf, isfinite, isnan
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754).
+
+    Errors result if the second argument is also supplied when x is a scalar
+    input, if first and second arguments have different shapes, or if the
+    first argument has complex values
+
+    Examples
+    --------
+    >>> np.isposinf(np.PINF)
+    True
+    >>> np.isposinf(np.inf)
+    True
+    >>> np.isposinf(np.NINF)
+    False
+    >>> np.isposinf([-np.inf, 0., np.inf])
+    array([False, False,  True])
+
+    >>> x = np.array([-np.inf, 0., np.inf])
+    >>> y = np.array([2, 2, 2])
+    >>> np.isposinf(x, y)
+    array([0, 0, 1])
+    >>> y
+    array([0, 0, 1])
+
+    " :arglists '[[& [args {:as kwargs}]]]} isposinf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isposinf"))))
+
+(def ^{:doc "exp2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Calculate `2**p` for all `p` in the input array.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Element-wise 2 to the power `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+power
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+
+
+Examples
+--------
+>>> np.exp2([2, 3])
+array([ 4.,  8.])" :arglists '[[self & [args {:as kwargs}]]]} exp2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "exp2"))))
+
+(def ^{:doc "A byte string.
+
+    When used in arrays, this type strips trailing null bytes.
+
+    :Character code: ``'S'``
+    :Alias: `numpy.string_`" :arglists '[[self & [args {:as kwargs}]]]} Bytes0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "Bytes0"))))
+
+(def ^{:doc "
+    Roll array elements along a given axis.
+
+    Elements that roll beyond the last position are re-introduced at
+    the first.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    shift : int or tuple of ints
+        The number of places by which elements are shifted.  If a tuple,
+        then `axis` must be a tuple of the same size, and each of the
+        given axes is shifted by the corresponding number.  If an int
+        while `axis` is a tuple of ints, then the same value is used for
+        all given axes.
+    axis : int or tuple of ints, optional
+        Axis or axes along which elements are shifted.  By default, the
+        array is flattened before shifting, after which the original
+        shape is restored.
+
+    Returns
+    -------
+    res : ndarray
+        Output array, with the same shape as `a`.
+
+    See Also
+    --------
+    rollaxis : Roll the specified axis backwards, until it lies in a
+               given position.
+
+    Notes
+    -----
+    .. versionadded:: 1.12.0
+
+    Supports rolling over multiple dimensions simultaneously.
+
+    Examples
+    --------
+    >>> x = np.arange(10)
+    >>> np.roll(x, 2)
+    array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
+    >>> np.roll(x, -2)
+    array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])
+
+    >>> x2 = np.reshape(x, (2,5))
+    >>> x2
+    array([[0, 1, 2, 3, 4],
+           [5, 6, 7, 8, 9]])
+    >>> np.roll(x2, 1)
+    array([[9, 0, 1, 2, 3],
+           [4, 5, 6, 7, 8]])
+    >>> np.roll(x2, -1)
+    array([[1, 2, 3, 4, 5],
+           [6, 7, 8, 9, 0]])
+    >>> np.roll(x2, 1, axis=0)
+    array([[5, 6, 7, 8, 9],
+           [0, 1, 2, 3, 4]])
+    >>> np.roll(x2, -1, axis=0)
+    array([[5, 6, 7, 8, 9],
+           [0, 1, 2, 3, 4]])
+    >>> np.roll(x2, 1, axis=1)
+    array([[4, 0, 1, 2, 3],
+           [9, 5, 6, 7, 8]])
+    >>> np.roll(x2, -1, axis=1)
+    array([[1, 2, 3, 4, 0],
+           [6, 7, 8, 9, 5]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} roll (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "roll"))))
+
+(def ^{:doc ""} WRAP 1)
+
+(def ^{:doc "Convert the input to an array.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data, in any form that can be converted to an array.  This
+        includes lists, lists of tuples, tuples, tuples of tuples, tuples
+        of lists and ndarrays.
+    dtype : data-type, optional
+        By default, the data-type is inferred from the input data.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Memory layout.  'A' and 'K' depend on the order of input array a.
+        'C' row-major (C-style), 
+        'F' column-major (Fortran-style) memory representation.
+        'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
+        'K' (keep) preserve input order
+        Defaults to 'C'.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        Array interpretation of `a`.  No copy is performed if the input
+        is already an ndarray with matching dtype and order.  If `a` is a
+        subclass of ndarray, a base class ndarray is returned.
+
+    See Also
+    --------
+    asanyarray : Similar function which passes through subclasses.
+    ascontiguousarray : Convert input to a contiguous array.
+    asfarray : Convert input to a floating point ndarray.
+    asfortranarray : Convert input to an ndarray with column-major
+                     memory order.
+    asarray_chkfinite : Similar function which checks input for NaNs and Infs.
+    fromiter : Create an array from an iterator.
+    fromfunction : Construct an array by executing a function on grid
+                   positions.
+
+    Examples
+    --------
+    Convert a list into an array:
+
+    >>> a = [1, 2]
+    >>> np.asarray(a)
+    array([1, 2])
+
+    Existing arrays are not copied:
+
+    >>> a = np.array([1, 2])
+    >>> np.asarray(a) is a
+    True
+
+    If `dtype` is set, array is copied only if dtype does not match:
+
+    >>> a = np.array([1, 2], dtype=np.float32)
+    >>> np.asarray(a, dtype=np.float32) is a
+    True
+    >>> np.asarray(a, dtype=np.float64) is a
+    False
+
+    Contrary to `asanyarray`, ndarray subclasses are not passed through:
+
+    >>> issubclass(np.recarray, np.ndarray)
+    True
+    >>> a = np.array([(1.0, 2), (3.0, 4)], dtype='f4,i4').view(np.recarray)
+    >>> np.asarray(a) is a
+    False
+    >>> np.asanyarray(a) is a
+    True
+
+    " :arglists '[[a & [{dtype :dtype, order :order, like :like}]] [a & [{dtype :dtype, like :like}]] [a & [{like :like}]]]} asarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asarray"))))
+
+(def ^{:doc "_fastCopyAndTranspose(a)" :arglists '[[self & [args {:as kwargs}]]]} fastCopyAndTranspose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fastCopyAndTranspose"))))
+
+(def ^{:doc ""} oldnumeric "removed")
+
+(def ^{:doc "
+    Returns a boolean array where two arrays are element-wise equal within a
+    tolerance.
+
+    The tolerance values are positive, typically very small numbers.  The
+    relative difference (`rtol` * abs(`b`)) and the absolute difference
+    `atol` are added together to compare against the absolute difference
+    between `a` and `b`.
+
+    .. warning:: The default `atol` is not appropriate for comparing numbers
+                 that are much smaller than one (see Notes).
+
+    Parameters
+    ----------
+    a, b : array_like
+        Input arrays to compare.
+    rtol : float
+        The relative tolerance parameter (see Notes).
+    atol : float
+        The absolute tolerance parameter (see Notes).
+    equal_nan : bool
+        Whether to compare NaN's as equal.  If True, NaN's in `a` will be
+        considered equal to NaN's in `b` in the output array.
+
+    Returns
+    -------
+    y : array_like
+        Returns a boolean array of where `a` and `b` are equal within the
+        given tolerance. If both `a` and `b` are scalars, returns a single
+        boolean value.
+
+    See Also
+    --------
+    allclose
+    math.isclose
+
+    Notes
+    -----
+    .. versionadded:: 1.7.0
+
+    For finite values, isclose uses the following equation to test whether
+    two floating point values are equivalent.
+
+     absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
+
+    Unlike the built-in `math.isclose`, the above equation is not symmetric
+    in `a` and `b` -- it assumes `b` is the reference value -- so that
+    `isclose(a, b)` might be different from `isclose(b, a)`. Furthermore,
+    the default value of atol is not zero, and is used to determine what
+    small values should be considered close to zero. The default value is
+    appropriate for expected values of order unity: if the expected values
+    are significantly smaller than one, it can result in false positives.
+    `atol` should be carefully selected for the use case at hand. A zero value
+    for `atol` will result in `False` if either `a` or `b` is zero.
+
+    `isclose` is not defined for non-numeric data types.
+
+    Examples
+    --------
+    >>> np.isclose([1e10,1e-7], [1.00001e10,1e-8])
+    array([ True, False])
+    >>> np.isclose([1e10,1e-8], [1.00001e10,1e-9])
+    array([ True, True])
+    >>> np.isclose([1e10,1e-8], [1.0001e10,1e-9])
+    array([False,  True])
+    >>> np.isclose([1.0, np.nan], [1.0, np.nan])
+    array([ True, False])
+    >>> np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
+    array([ True, True])
+    >>> np.isclose([1e-8, 1e-7], [0.0, 0.0])
+    array([ True, False])
+    >>> np.isclose([1e-100, 1e-7], [0.0, 0.0], atol=0.0)
+    array([False, False])
+    >>> np.isclose([1e-10, 1e-10], [1e-20, 0.0])
+    array([ True,  True])
+    >>> np.isclose([1e-10, 1e-10], [1e-20, 0.999999e-10], atol=0.0)
+    array([False,  True])
+    " :arglists '[[& [args {:as kwargs}]]]} isclose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isclose"))))
+
+(def ^{:doc "invert(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute bit-wise inversion, or bit-wise NOT, element-wise.
+
+Computes the bit-wise NOT of the underlying binary representation of
+the integers in the input arrays. This ufunc implements the C/Python
+operator ``~``.
+
+For signed integer inputs, the two's complement is returned.  In a
+two's-complement system negative numbers are represented by the two's
+complement of the absolute value. This is the most common method of
+representing signed integers on computers [1]_. A N-bit
+two's-complement system can represent every integer in the range
+:math:`-2^{N-1}` to :math:`+2^{N-1}-1`.
+
+Parameters
+----------
+x : array_like
+    Only integer and boolean types are handled.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Result.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+bitwise_and, bitwise_or, bitwise_xor
+logical_not
+binary_repr :
+    Return the binary representation of the input number as a string.
+
+Notes
+-----
+`bitwise_not` is an alias for `invert`:
+
+>>> np.bitwise_not is np.invert
+True
+
+References
+----------
+.. [1] Wikipedia, \"Two's complement\",
+    https://en.wikipedia.org/wiki/Two's_complement
+
+Examples
+--------
+We've seen that 13 is represented by ``00001101``.
+The invert or bit-wise NOT of 13 is then:
+
+>>> x = np.invert(np.array(13, dtype=np.uint8))
+>>> x
+242
+>>> np.binary_repr(x, width=8)
+'11110010'
+
+The result depends on the bit-width:
+
+>>> x = np.invert(np.array(13, dtype=np.uint16))
+>>> x
+65522
+>>> np.binary_repr(x, width=16)
+'1111111111110010'
+
+When using signed integer types the result is the two's complement of
+the result for the unsigned type:
+
+>>> np.invert(np.array([13], dtype=np.int8))
+array([-14], dtype=int8)
+>>> np.binary_repr(-14, width=8)
+'11110010'
+
+Booleans are accepted as well:
+
+>>> np.invert(np.array([True, False]))
+array([False,  True])
+
+The ``~`` operator can be used as a shorthand for ``np.invert`` on
+ndarrays.
+
+>>> x1 = np.array([True, False])
+>>> ~x1
+array([False,  True])" :arglists '[[self & [args {:as kwargs}]]]} bitwise_not (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_not"))))
+
+(def ^{:doc "Signed integer type, compatible with Python `int` and C ``long``.
+
+    :Character code: ``'l'``
+    :Canonical name: `numpy.int_`
+    :Alias on this platform: `numpy.int64`: 64-bit signed integer (``-9_223_372_036_854_775_808`` to ``9_223_372_036_854_775_807``).
+    :Alias on this platform: `numpy.intp`: Signed integer large enough to fit pointer, compatible with C ``intptr_t``." :arglists '[[self & [args {:as kwargs}]]]} int0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "int0"))))
+
+(def ^{:doc "ldexp(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns x1 * 2**x2, element-wise.
+
+The mantissas `x1` and twos exponents `x2` are used to construct
+floating point numbers ``x1 * 2**x2``.
+
+Parameters
+----------
+x1 : array_like
+    Array of multipliers.
+x2 : array_like, int
+    Array of twos exponents.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray or scalar
+    The result of ``x1 * 2**x2``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+frexp : Return (y1, y2) from ``x = y1 * 2**y2``, inverse to `ldexp`.
+
+Notes
+-----
+Complex dtypes are not supported, they will raise a TypeError.
+
+`ldexp` is useful as the inverse of `frexp`, if used by itself it is
+more clear to simply use the expression ``x1 * 2**x2``.
+
+Examples
+--------
+>>> np.ldexp(5, np.arange(4))
+array([ 5., 10., 20., 40.], dtype=float16)
+
+>>> x = np.arange(6)
+>>> np.ldexp(*np.frexp(x))
+array([ 0.,  1.,  2.,  3.,  4.,  5.])" :arglists '[[self & [args {:as kwargs}]]]} ldexp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ldexp"))))
+
+(def ^{:doc "
+    Evenly round to the given number of decimals.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    decimals : int, optional
+        Number of decimal places to round to (default: 0).  If
+        decimals is negative, it specifies the number of positions to
+        the left of the decimal point.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output, but the type of the output
+        values will be cast if necessary. See :ref:`ufuncs-output-type` for more
+        details.
+
+    Returns
+    -------
+    rounded_array : ndarray
+        An array of the same type as `a`, containing the rounded values.
+        Unless `out` was specified, a new array is created.  A reference to
+        the result is returned.
+
+        The real and imaginary parts of complex numbers are rounded
+        separately.  The result of rounding a float is a float.
+
+    See Also
+    --------
+    ndarray.round : equivalent method
+
+    ceil, fix, floor, rint, trunc
+
+
+    Notes
+    -----
+    For values exactly halfway between rounded decimal values, NumPy
+    rounds to the nearest even value. Thus 1.5 and 2.5 round to 2.0,
+    -0.5 and 0.5 round to 0.0, etc.
+
+    ``np.around`` uses a fast but sometimes inexact algorithm to round
+    floating-point datatypes. For positive `decimals` it is equivalent to
+    ``np.true_divide(np.rint(a * 10**decimals), 10**decimals)``, which has
+    error due to the inexact representation of decimal fractions in the IEEE
+    floating point standard [1]_ and errors introduced when scaling by powers
+    of ten. For instance, note the extra \"1\" in the following:
+
+        >>> np.round(56294995342131.5, 3)
+        56294995342131.51
+
+    If your goal is to print such values with a fixed number of decimals, it is
+    preferable to use numpy's float printing routines to limit the number of
+    printed decimals:
+
+        >>> np.format_float_positional(56294995342131.5, precision=3)
+        '56294995342131.5'
+
+    The float printing routines use an accurate but much more computationally
+    demanding algorithm to compute the number of digits after the decimal
+    point.
+
+    Alternatively, Python's builtin `round` function uses a more accurate
+    but slower algorithm for 64-bit floating point values:
+
+        >>> round(56294995342131.5, 3)
+        56294995342131.5
+        >>> np.round(16.055, 2), round(16.055, 2)  # equals 16.0549999999999997
+        (16.06, 16.05)
+
+
+    References
+    ----------
+    .. [1] \"Lecture Notes on the Status of IEEE 754\", William Kahan,
+           https://people.eecs.berkeley.edu/~wkahan/ieee754status/IEEE754.PDF
+    .. [2] \"How Futile are Mindless Assessments of
+           Roundoff in Floating-Point Computation?\", William Kahan,
+           https://people.eecs.berkeley.edu/~wkahan/Mindless.pdf
+
+    Examples
+    --------
+    >>> np.around([0.37, 1.64])
+    array([0.,  2.])
+    >>> np.around([0.37, 1.64], decimals=1)
+    array([0.4,  1.6])
+    >>> np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value
+    array([0.,  2.,  2.,  4.,  4.])
+    >>> np.around([1,2,3,11], decimals=1) # ndarray of ints is returned
+    array([ 1,  2,  3, 11])
+    >>> np.around([1,2,3,11], decimals=-1)
+    array([ 0,  0,  0, 10])
+
+    " :arglists '[[& [args {:as kwargs}]]]} around (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "around"))))
+
+(def ^{:doc "
+    Returns the discrete, linear convolution of two one-dimensional sequences.
+
+    The convolution operator is often seen in signal processing, where it
+    models the effect of a linear time-invariant system on a signal [1]_.  In
+    probability theory, the sum of two independent random variables is
+    distributed according to the convolution of their individual
+    distributions.
+
+    If `v` is longer than `a`, the arrays are swapped before computation.
+
+    Parameters
+    ----------
+    a : (N,) array_like
+        First one-dimensional input array.
+    v : (M,) array_like
+        Second one-dimensional input array.
+    mode : {'full', 'valid', 'same'}, optional
+        'full':
+          By default, mode is 'full'.  This returns the convolution
+          at each point of overlap, with an output shape of (N+M-1,). At
+          the end-points of the convolution, the signals do not overlap
+          completely, and boundary effects may be seen.
+
+        'same':
+          Mode 'same' returns output of length ``max(M, N)``.  Boundary
+          effects are still visible.
+
+        'valid':
+          Mode 'valid' returns output of length
+          ``max(M, N) - min(M, N) + 1``.  The convolution product is only given
+          for points where the signals overlap completely.  Values outside
+          the signal boundary have no effect.
+
+    Returns
+    -------
+    out : ndarray
+        Discrete, linear convolution of `a` and `v`.
+
+    See Also
+    --------
+    scipy.signal.fftconvolve : Convolve two arrays using the Fast Fourier
+                               Transform.
+    scipy.linalg.toeplitz : Used to construct the convolution operator.
+    polymul : Polynomial multiplication. Same output as convolve, but also
+              accepts poly1d objects as input.
+
+    Notes
+    -----
+    The discrete convolution operation is defined as
+
+    .. math:: (a * v)[n] = \\sum_{m = -\\infty}^{\\infty} a[m] v[n - m]
+
+    It can be shown that a convolution :math:`x(t) * y(t)` in time/space
+    is equivalent to the multiplication :math:`X(f) Y(f)` in the Fourier
+    domain, after appropriate padding (padding is necessary to prevent
+    circular convolution).  Since multiplication is more efficient (faster)
+    than convolution, the function `scipy.signal.fftconvolve` exploits the
+    FFT to calculate the convolution of large data-sets.
+
+    References
+    ----------
+    .. [1] Wikipedia, \"Convolution\",
+        https://en.wikipedia.org/wiki/Convolution
+
+    Examples
+    --------
+    Note how the convolution operator flips the second array
+    before \"sliding\" the two across one another:
+
+    >>> np.convolve([1, 2, 3], [0, 1, 0.5])
+    array([0. , 1. , 2.5, 4. , 1.5])
+
+    Only return the middle values of the convolution.
+    Contains boundary effects, where zeros are taken
+    into account:
+
+    >>> np.convolve([1,2,3],[0,1,0.5], 'same')
+    array([1. ,  2.5,  4. ])
+
+    The two arrays are of the same length, so there
+    is only one position where they completely overlap:
+
+    >>> np.convolve([1,2,3],[0,1,0.5], 'valid')
+    array([2.5])
+
+    " :arglists '[[& [args {:as kwargs}]]]} convolve (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "convolve"))))
+
+(def ^{:doc "
+    Round an array to the given number of decimals.
+
+    See Also
+    --------
+    around : equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]]} round_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "round_"))))
+
+(def ^{:doc "add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Add arguments element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    The arrays to be added.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+add : ndarray or scalar
+    The sum of `x1` and `x2`, element-wise.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+Equivalent to `x1` + `x2` in terms of array broadcasting.
+
+Examples
+--------
+>>> np.add(1.0, 4.0)
+5.0
+>>> x1 = np.arange(9.0).reshape((3, 3))
+>>> x2 = np.arange(3.0)
+>>> np.add(x1, x2)
+array([[  0.,   2.,   4.],
+       [  3.,   5.,   7.],
+       [  6.,   8.,  10.]])
+
+The ``+`` operator can be used as a shorthand for ``np.add`` on ndarrays.
+
+>>> x1 = np.arange(9.0).reshape((3, 3))
+>>> x2 = np.arange(3.0)
+>>> x1 + x2
+array([[ 0.,  2.,  4.],
+       [ 3.,  5.,  7.],
+       [ 6.,  8., 10.]])" :arglists '[[self & [args {:as kwargs}]]]} add (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add"))))
+
+(def ^{:doc "
+    Return a string representation of a number in the given base system.
+
+    Parameters
+    ----------
+    number : int
+        The value to convert. Positive and negative values are handled.
+    base : int, optional
+        Convert `number` to the `base` number system. The valid range is 2-36,
+        the default value is 2.
+    padding : int, optional
+        Number of zeros padded on the left. Default is 0 (no padding).
+
+    Returns
+    -------
+    out : str
+        String representation of `number` in `base` system.
+
+    See Also
+    --------
+    binary_repr : Faster version of `base_repr` for base 2.
+
+    Examples
+    --------
+    >>> np.base_repr(5)
+    '101'
+    >>> np.base_repr(6, 5)
+    '11'
+    >>> np.base_repr(7, base=5, padding=3)
+    '00012'
+
+    >>> np.base_repr(10, base=16)
+    'A'
+    >>> np.base_repr(32, base=16)
+    '20'
+
+    " :arglists '[[number & [{base :base, padding :padding}]] [number & [{base :base}]] [number]]} base_repr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "base_repr"))))
+
+(def ^{:doc "
+    Load ASCII data stored in a text file and return a masked array.
+
+    .. deprecated:: 1.17
+        np.mafromtxt is a deprecated alias of `genfromtxt` which
+        overwrites the ``usemask`` argument with `True` even when
+        explicitly called as ``mafromtxt(..., usemask=False)``.
+        Use `genfromtxt` instead.
+
+    Parameters
+    ----------
+    fname, kwargs : For a description of input parameters, see `genfromtxt`.
+
+    See Also
+    --------
+    numpy.genfromtxt : generic function to load ASCII data.
+
+    " :arglists '[[fname & [{:as kwargs}]]]} mafromtxt (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "mafromtxt"))))
+
+(def ^{:doc "
+    Compute the standard deviation along the specified axis, while
+    ignoring NaNs.
+
+    Returns the standard deviation, a measure of the spread of a
+    distribution, of the non-NaN array elements. The standard deviation is
+    computed for the flattened array by default, otherwise over the
+    specified axis.
+
+    For all-NaN slices or slices with zero degrees of freedom, NaN is
+    returned and a `RuntimeWarning` is raised.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Calculate the standard deviation of the non-NaN values.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the standard deviation is computed. The default is
+        to compute the standard deviation of the flattened array.
+    dtype : dtype, optional
+        Type to use in computing the standard deviation. For arrays of
+        integer type the default is float64, for arrays of float types it
+        is the same as the array type.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must have
+        the same shape as the expected output but the type (of the
+        calculated values) will be cast if necessary.
+    ddof : int, optional
+        Means Delta Degrees of Freedom.  The divisor used in calculations
+        is ``N - ddof``, where ``N`` represents the number of non-NaN
+        elements.  By default `ddof` is zero.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If this value is anything but the default it is passed through
+        as-is to the relevant functions of the sub-classes.  If these
+        functions do not have a `keepdims` kwarg, a RuntimeError will
+        be raised.
+
+    Returns
+    -------
+    standard_deviation : ndarray, see dtype parameter above.
+        If `out` is None, return a new array containing the standard
+        deviation, otherwise return a reference to the output array. If
+        ddof is >= the number of non-NaN elements in a slice or the slice
+        contains only NaNs, then the result for that slice is NaN.
+
+    See Also
+    --------
+    var, mean, std
+    nanvar, nanmean
+    :ref:`ufuncs-output-type`
+
+    Notes
+    -----
+    The standard deviation is the square root of the average of the squared
+    deviations from the mean: ``std = sqrt(mean(abs(x - x.mean())**2))``.
+
+    The average squared deviation is normally calculated as
+    ``x.sum() / N``, where ``N = len(x)``.  If, however, `ddof` is
+    specified, the divisor ``N - ddof`` is used instead. In standard
+    statistical practice, ``ddof=1`` provides an unbiased estimator of the
+    variance of the infinite population. ``ddof=0`` provides a maximum
+    likelihood estimate of the variance for normally distributed variables.
+    The standard deviation computed in this function is the square root of
+    the estimated variance, so even with ``ddof=1``, it will not be an
+    unbiased estimate of the standard deviation per se.
+
+    Note that, for complex numbers, `std` takes the absolute value before
+    squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the *std* is computed using the same
+    precision the input has. Depending on the input data, this can cause
+    the results to be inaccurate, especially for float32 (see example
+    below).  Specifying a higher-accuracy accumulator using the `dtype`
+    keyword can alleviate this issue.
+
+    Examples
+    --------
+    >>> a = np.array([[1, np.nan], [3, 4]])
+    >>> np.nanstd(a)
+    1.247219128924647
+    >>> np.nanstd(a, axis=0)
+    array([1., 0.])
+    >>> np.nanstd(a, axis=1)
+    array([0.,  0.5]) # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]]} nanstd (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanstd"))))
+
+(def ^{:doc "Single-precision floating-point number type, compatible with C ``float``.
+
+    :Character code: ``'f'``
+    :Canonical name: `numpy.single`
+    :Alias on this platform: `numpy.float32`: 32-bit-precision floating-point number type: sign bit, 8 bits exponent, 23 bits mantissa." :arglists '[[self & [args {:as kwargs}]]]} single (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "single"))))
+
+(def ^{:doc "
+    inner(a, b)
+
+    Inner product of two arrays.
+
+    Ordinary inner product of vectors for 1-D arrays (without complex
+    conjugation), in higher dimensions a sum product over the last axes.
+
+    Parameters
+    ----------
+    a, b : array_like
+        If `a` and `b` are nonscalar, their last dimensions must match.
+
+    Returns
+    -------
+    out : ndarray
+        `out.shape = a.shape[:-1] + b.shape[:-1]`
+
+    Raises
+    ------
+    ValueError
+        If the last dimension of `a` and `b` has different size.
+
+    See Also
+    --------
+    tensordot : Sum products over arbitrary axes.
+    dot : Generalised matrix product, using second last dimension of `b`.
+    einsum : Einstein summation convention.
+
+    Notes
+    -----
+    For vectors (1-D arrays) it computes the ordinary inner-product::
+
+        np.inner(a, b) = sum(a[:]*b[:])
+
+    More generally, if `ndim(a) = r > 0` and `ndim(b) = s > 0`::
+
+        np.inner(a, b) = np.tensordot(a, b, axes=(-1,-1))
+
+    or explicitly::
+
+        np.inner(a, b)[i0,...,ir-1,j0,...,js-1]
+             = sum(a[i0,...,ir-1,:]*b[j0,...,js-1,:])
+
+    In addition `a` or `b` may be scalars, in which case::
+
+       np.inner(a,b) = a*b
+
+    Examples
+    --------
+    Ordinary inner product for vectors:
+
+    >>> a = np.array([1,2,3])
+    >>> b = np.array([0,1,0])
+    >>> np.inner(a, b)
+    2
+
+    A multidimensional example:
+
+    >>> a = np.arange(24).reshape((2,3,4))
+    >>> b = np.arange(4)
+    >>> np.inner(a, b)
+    array([[ 14,  38,  62],
+           [ 86, 110, 134]])
+
+    An example where `b` is a scalar:
+
+    >>> np.inner(np.eye(2), 7)
+    array([[7., 0.],
+           [0., 7.]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} inner (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "inner"))))
+
+(def ^{:doc "
+    Stack 1-D arrays as columns into a 2-D array.
+
+    Take a sequence of 1-D arrays and stack them as columns
+    to make a single 2-D array. 2-D arrays are stacked as-is,
+    just like with `hstack`.  1-D arrays are turned into 2-D columns
+    first.
+
+    Parameters
+    ----------
+    tup : sequence of 1-D or 2-D arrays.
+        Arrays to stack. All of them must have the same first dimension.
+
+    Returns
+    -------
+    stacked : 2-D array
+        The array formed by stacking the given arrays.
+
+    See Also
+    --------
+    stack, hstack, vstack, concatenate
+
+    Examples
+    --------
+    >>> a = np.array((1,2,3))
+    >>> b = np.array((2,3,4))
+    >>> np.column_stack((a,b))
+    array([[1, 2],
+           [2, 3],
+           [3, 4]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} column_stack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "column_stack"))))
+
+(def ^{:doc "
+    Estimate a covariance matrix, given data and weights.
+
+    Covariance indicates the level to which two variables vary together.
+    If we examine N-dimensional samples, :math:`X = [x_1, x_2, ... x_N]^T`,
+    then the covariance matrix element :math:`C_{ij}` is the covariance of
+    :math:`x_i` and :math:`x_j`. The element :math:`C_{ii}` is the variance
+    of :math:`x_i`.
+
+    See the notes for an outline of the algorithm.
+
+    Parameters
+    ----------
+    m : array_like
+        A 1-D or 2-D array containing multiple variables and observations.
+        Each row of `m` represents a variable, and each column a single
+        observation of all those variables. Also see `rowvar` below.
+    y : array_like, optional
+        An additional set of variables and observations. `y` has the same form
+        as that of `m`.
+    rowvar : bool, optional
+        If `rowvar` is True (default), then each row represents a
+        variable, with observations in the columns. Otherwise, the relationship
+        is transposed: each column represents a variable, while the rows
+        contain observations.
+    bias : bool, optional
+        Default normalization (False) is by ``(N - 1)``, where ``N`` is the
+        number of observations given (unbiased estimate). If `bias` is True,
+        then normalization is by ``N``. These values can be overridden by using
+        the keyword ``ddof`` in numpy versions >= 1.5.
+    ddof : int, optional
+        If not ``None`` the default value implied by `bias` is overridden.
+        Note that ``ddof=1`` will return the unbiased estimate, even if both
+        `fweights` and `aweights` are specified, and ``ddof=0`` will return
+        the simple average. See the notes for the details. The default value
+        is ``None``.
+
+        .. versionadded:: 1.5
+    fweights : array_like, int, optional
+        1-D array of integer frequency weights; the number of times each
+        observation vector should be repeated.
+
+        .. versionadded:: 1.10
+    aweights : array_like, optional
+        1-D array of observation vector weights. These relative weights are
+        typically large for observations considered \"important\" and smaller for
+        observations considered less \"important\". If ``ddof=0`` the array of
+        weights can be used to assign probabilities to observation vectors.
+
+        .. versionadded:: 1.10
+    dtype : data-type, optional
+        Data-type of the result. By default, the return data-type will have
+        at least `numpy.float64` precision.
+
+        .. versionadded:: 1.20
+
+    Returns
+    -------
+    out : ndarray
+        The covariance matrix of the variables.
+
+    See Also
+    --------
+    corrcoef : Normalized covariance matrix
+
+    Notes
+    -----
+    Assume that the observations are in the columns of the observation
+    array `m` and let ``f = fweights`` and ``a = aweights`` for brevity. The
+    steps to compute the weighted covariance are as follows::
+
+        >>> m = np.arange(10, dtype=np.float64)
+        >>> f = np.arange(10) * 2
+        >>> a = np.arange(10) ** 2.
+        >>> ddof = 1
+        >>> w = f * a
+        >>> v1 = np.sum(w)
+        >>> v2 = np.sum(w * a)
+        >>> m -= np.sum(m * w, axis=None, keepdims=True) / v1
+        >>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)
+
+    Note that when ``a == 1``, the normalization factor
+    ``v1 / (v1**2 - ddof * v2)`` goes over to ``1 / (np.sum(f) - ddof)``
+    as it should.
+
+    Examples
+    --------
+    Consider two variables, :math:`x_0` and :math:`x_1`, which
+    correlate perfectly, but in opposite directions:
+
+    >>> x = np.array([[0, 2], [1, 1], [2, 0]]).T
+    >>> x
+    array([[0, 1, 2],
+           [2, 1, 0]])
+
+    Note how :math:`x_0` increases while :math:`x_1` decreases. The covariance
+    matrix shows this clearly:
+
+    >>> np.cov(x)
+    array([[ 1., -1.],
+           [-1.,  1.]])
+
+    Note that element :math:`C_{0,1}`, which shows the correlation between
+    :math:`x_0` and :math:`x_1`, is negative.
+
+    Further, note how `x` and `y` are combined:
+
+    >>> x = [-2.1, -1,  4.3]
+    >>> y = [3,  1.1,  0.12]
+    >>> X = np.stack((x, y), axis=0)
+    >>> np.cov(X)
+    array([[11.71      , -4.286     ], # may vary
+           [-4.286     ,  2.144133]])
+    >>> np.cov(x, y)
+    array([[11.71      , -4.286     ], # may vary
+           [-4.286     ,  2.144133]])
+    >>> np.cov(x)
+    array(11.71)
+
+    " :arglists '[[& [args {:as kwargs}]]]} cov (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cov"))))
+
+(def ^{:doc "
+    Return the current callback function used on floating-point errors.
+
+    When the error handling for a floating-point error (one of \"divide\",
+    \"over\", \"under\", or \"invalid\") is set to 'call' or 'log', the function
+    that is called or the log instance that is written to is returned by
+    `geterrcall`. This function or log instance has been set with
+    `seterrcall`.
+
+    Returns
+    -------
+    errobj : callable, log instance or None
+        The current error handler. If no handler was set through `seterrcall`,
+        ``None`` is returned.
+
+    See Also
+    --------
+    seterrcall, seterr, geterr
+
+    Notes
+    -----
+    For complete documentation of the types of floating-point exceptions and
+    treatment options, see `seterr`.
+
+    Examples
+    --------
+    >>> np.geterrcall()  # we did not yet set a handler, returns None
+
+    >>> oldsettings = np.seterr(all='call')
+    >>> def err_handler(type, flag):
+    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
+    >>> oldhandler = np.seterrcall(err_handler)
+    >>> np.array([1, 2, 3]) / 0.0
+    Floating point error (divide by zero), with flag 1
+    array([inf, inf, inf])
+
+    >>> cur_handler = np.geterrcall()
+    >>> cur_handler is err_handler
+    True
+
+    " :arglists '[[]]} geterrcall (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geterrcall"))))
+
+(def ^{:doc "signbit(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns element-wise True where signbit is set (less than zero).
+
+Parameters
+----------
+x : array_like
+    The input value(s).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+result : ndarray of bool
+    Output array, or reference to `out` if that was supplied.
+    This is a scalar if `x` is a scalar.
+
+Examples
+--------
+>>> np.signbit(-1.2)
+True
+>>> np.signbit(np.array([1, -2.3, 2.1]))
+array([False,  True, False])" :arglists '[[self & [args {:as kwargs}]]]} signbit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "signbit"))))
+
+(def ^{:doc "
+    Return the maximum of an array or maximum along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to operate.  By default, flattened input is
+        used.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, the maximum is selected over multiple axes,
+        instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternative output array in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+        See :ref:`ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `amax` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    initial : scalar, optional
+        The minimum value of an output element. Must be present to allow
+        computation on empty slice. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to compare for the maximum. See `~numpy.ufunc.reduce`
+        for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    amax : ndarray or scalar
+        Maximum of `a`. If `axis` is None, the result is a scalar value.
+        If `axis` is given, the result is an array of dimension
+        ``a.ndim - 1``.
+
+    See Also
+    --------
+    amin :
+        The minimum value of an array along a given axis, propagating any NaNs.
+    nanmax :
+        The maximum value of an array along a given axis, ignoring any NaNs.
+    maximum :
+        Element-wise maximum of two arrays, propagating any NaNs.
+    fmax :
+        Element-wise maximum of two arrays, ignoring any NaNs.
+    argmax :
+        Return the indices of the maximum values.
+
+    nanmin, minimum, fmin
+
+    Notes
+    -----
+    NaN values are propagated, that is if at least one item is NaN, the
+    corresponding max value will be NaN as well. To ignore NaN values
+    (MATLAB behavior), please use nanmax.
+
+    Don't use `amax` for element-wise comparison of 2 arrays; when
+    ``a.shape[0]`` is 2, ``maximum(a[0], a[1])`` is faster than
+    ``amax(a, axis=0)``.
+
+    Examples
+    --------
+    >>> a = np.arange(4).reshape((2,2))
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> np.amax(a)           # Maximum of the flattened array
+    3
+    >>> np.amax(a, axis=0)   # Maxima along the first axis
+    array([2, 3])
+    >>> np.amax(a, axis=1)   # Maxima along the second axis
+    array([1, 3])
+    >>> np.amax(a, where=[False, True], initial=-1, axis=0)
+    array([-1,  3])
+    >>> b = np.arange(5, dtype=float)
+    >>> b[2] = np.NaN
+    >>> np.amax(b)
+    nan
+    >>> np.amax(b, where=~np.isnan(b), initial=-1)
+    4.0
+    >>> np.nanmax(b)
+    4.0
+
+    You can use an initial value to compute the maximum of an empty slice, or
+    to initialize it to a different value:
+
+    >>> np.max([[-50], [10]], axis=-1, initial=0)
+    array([ 0, 10])
+
+    Notice that the initial value is used as one of the elements for which the
+    maximum is determined, unlike for the default argument Python's max
+    function, which is only used for empty iterables.
+
+    >>> np.max([5], initial=6)
+    6
+    >>> max([5], default=6)
+    5
+    " :arglists '[[& [args {:as kwargs}]]]} amax (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "amax"))))
+
+(def ^{:doc "
+    Test whether all array elements along a given axis evaluate to True.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which a logical AND reduction is performed.
+        The default (``axis=None``) is to perform a logical AND over all
+        the dimensions of the input array. `axis` may be negative, in
+        which case it counts from the last to the first axis.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, a reduction is performed on multiple
+        axes, instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternate output array in which to place the result.
+        It must have the same shape as the expected output and its
+        type is preserved (e.g., if ``dtype(out)`` is float, the result
+        will consist of 0.0's and 1.0's). See :ref:`ufuncs-output-type` for more
+        details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `all` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    where : array_like of bool, optional
+        Elements to include in checking for all `True` values.
+        See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    all : ndarray, bool
+        A new boolean or array is returned unless `out` is specified,
+        in which case a reference to `out` is returned.
+
+    See Also
+    --------
+    ndarray.all : equivalent method
+
+    any : Test whether any element along a given axis evaluates to True.
+
+    Notes
+    -----
+    Not a Number (NaN), positive infinity and negative infinity
+    evaluate to `True` because these are not equal to zero.
+
+    Examples
+    --------
+    >>> np.all([[True,False],[True,True]])
+    False
+
+    >>> np.all([[True,False],[True,True]], axis=0)
+    array([ True, False])
+
+    >>> np.all([-1, 4, 5])
+    True
+
+    >>> np.all([1.0, np.nan])
+    True
+
+    >>> np.all([[True, True], [False, True]], where=[[True], [False]])
+    True
+
+    >>> o=np.array(False)
+    >>> z=np.all([-1, 4, 5], out=o)
+    >>> id(z), id(o), z
+    (28293632, 28293632, array(True)) # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]]} all (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "all"))))
+
+(def ^{:doc "This module provides access to some objects used or maintained by the
+interpreter and to functions that interact strongly with the interpreter.
+
+Dynamic objects:
+
+argv -- command line arguments; argv[0] is the script pathname if known
+path -- module search path; path[0] is the script directory, else ''
+modules -- dictionary of loaded modules
+
+displayhook -- called to show results in an interactive session
+excepthook -- called to handle any uncaught exception other than SystemExit
+  To customize printing in an interactive session or to install a custom
+  top-level exception handler, assign other functions to replace these.
+
+stdin -- standard input file object; used by input()
+stdout -- standard output file object; used by print()
+stderr -- standard error object; used for error messages
+  By assigning other file objects (or objects that behave like files)
+  to these, it is possible to redirect all of the interpreter's I/O.
+
+last_type -- type of last uncaught exception
+last_value -- value of last uncaught exception
+last_traceback -- traceback of last uncaught exception
+  These three are only available in an interactive session after a
+  traceback has been printed.
+
+Static objects:
+
+builtin_module_names -- tuple of module names built into this interpreter
+copyright -- copyright notice pertaining to this interpreter
+exec_prefix -- prefix used to find the machine-specific Python library
+executable -- absolute path of the executable binary of the Python interpreter
+float_info -- a named tuple with information about the float implementation.
+float_repr_style -- string indicating the style of repr() output for floats
+hash_info -- a named tuple with information about the hash algorithm.
+hexversion -- version information encoded as a single integer
+implementation -- Python implementation information.
+int_info -- a named tuple with information about the int implementation.
+maxsize -- the largest supported length of containers.
+maxunicode -- the value of the largest Unicode code point
+platform -- platform identifier
+prefix -- prefix used to find the Python library
+thread_info -- a named tuple with information about the thread implementation.
+version -- the version of this interpreter as a string
+version_info -- version information as a named tuple
+__stdin__ -- the original stdin; don't touch!
+__stdout__ -- the original stdout; don't touch!
+__stderr__ -- the original stderr; don't touch!
+__displayhook__ -- the original displayhook; don't touch!
+__excepthook__ -- the original excepthook; don't touch!
+
+Functions:
+
+displayhook() -- print an object to the screen, and save it in builtins._
+excepthook() -- print an exception and its traceback to sys.stderr
+exc_info() -- return thread-safe information about the current exception
+exit() -- exit the interpreter by raising SystemExit
+getdlopenflags() -- returns flags to be used for dlopen() calls
+getprofile() -- get the global profiling function
+getrefcount() -- return the reference count for an object (plus one :-)
+getrecursionlimit() -- return the max recursion depth for the interpreter
+getsizeof() -- return the size of an object in bytes
+gettrace() -- get the global debug tracing function
+setdlopenflags() -- set the flags to be used for dlopen() calls
+setprofile() -- set the global profiling function
+setrecursionlimit() -- set the max recursion depth for the interpreter
+settrace() -- set the global debug tracing function
+"} sys (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "sys"))))
+
+(def ^{:doc "true_divide(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns a true division of the inputs, element-wise.
+
+Instead of the Python traditional 'floor division', this returns a true
+division.  True division adjusts the output type to present the best
+answer, regardless of input types.
+
+Parameters
+----------
+x1 : array_like
+    Dividend array.
+x2 : array_like
+    Divisor array.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Notes
+-----
+In Python, ``//`` is the floor division operator and ``/`` the
+true division operator.  The ``true_divide(x1, x2)`` function is
+equivalent to true division in Python.
+
+Examples
+--------
+>>> x = np.arange(5)
+>>> np.true_divide(x, 4)
+array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
+
+>>> x/4
+array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ])
+
+>>> x//4
+array([0, 0, 0, 0, 1])
+
+The ``/`` operator can be used as a shorthand for ``np.true_divide`` on
+ndarrays.
+
+>>> x = np.arange(5)
+>>> x / 4
+array([0.  , 0.25, 0.5 , 0.75, 1.  ])" :arglists '[[self & [args {:as kwargs}]]]} true_divide (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "true_divide"))))
+
+(def ^{:doc ""} NZERO -0.0)
+
+(def ^{:doc "
+    Broadcast the input shapes into a single shape.
+
+    :ref:`Learn more about broadcasting here <basics.broadcasting>`.
+
+    .. versionadded:: 1.20.0
+
+    Parameters
+    ----------
+    `*args` : tuples of ints, or ints
+        The shapes to be broadcast against each other.
+
+    Returns
+    -------
+    tuple
+        Broadcasted shape.
+
+    Raises
+    ------
+    ValueError
+        If the shapes are not compatible and cannot be broadcast according
+        to NumPy's broadcasting rules.
+
+    See Also
+    --------
+    broadcast
+    broadcast_arrays
+    broadcast_to
+
+    Examples
+    --------
+    >>> np.broadcast_shapes((1, 2), (3, 1), (3, 2))
+    (3, 2)
+
+    >>> np.broadcast_shapes((6, 7), (5, 6, 1), (7,), (5, 1, 7))
+    (5, 6, 7)
+    " :arglists '[[& [args]]]} broadcast_shapes (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "broadcast_shapes"))))
+
+(def ^{:doc ""} FPE_INVALID 8)
+
+(def ^{:doc "
+    Return the Hanning window.
+
+    The Hanning window is a taper formed by using a weighted cosine.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+
+    Returns
+    -------
+    out : ndarray, shape(M,)
+        The window, with the maximum value normalized to one (the value
+        one appears only if `M` is odd).
+
+    See Also
+    --------
+    bartlett, blackman, hamming, kaiser
+
+    Notes
+    -----
+    The Hanning window is defined as
+
+    .. math::  w(n) = 0.5 - 0.5cos\\left(\\frac{2\\pi{n}}{M-1}\\right)
+               \\qquad 0 \\leq n \\leq M-1
+
+    The Hanning was named for Julius von Hann, an Austrian meteorologist.
+    It is also known as the Cosine Bell. Some authors prefer that it be
+    called a Hann window, to help avoid confusion with the very similar
+    Hamming window.
+
+    Most references to the Hanning window come from the signal processing
+    literature, where it is used as one of many windowing functions for
+    smoothing values.  It is also known as an apodization (which means
+    \"removing the foot\", i.e. smoothing discontinuities at the beginning
+    and end of the sampled signal) or tapering function.
+
+    References
+    ----------
+    .. [1] Blackman, R.B. and Tukey, J.W., (1958) The measurement of power
+           spectra, Dover Publications, New York.
+    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\",
+           The University of Alberta Press, 1975, pp. 106-108.
+    .. [3] Wikipedia, \"Window function\",
+           https://en.wikipedia.org/wiki/Window_function
+    .. [4] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
+           \"Numerical Recipes\", Cambridge University Press, 1986, page 425.
+
+    Examples
+    --------
+    >>> np.hanning(12)
+    array([0.        , 0.07937323, 0.29229249, 0.57115742, 0.82743037,
+           0.97974649, 0.97974649, 0.82743037, 0.57115742, 0.29229249,
+           0.07937323, 0.        ])
+
+    Plot the window and its frequency response:
+
+    >>> import matplotlib.pyplot as plt
+    >>> from numpy.fft import fft, fftshift
+    >>> window = np.hanning(51)
+    >>> plt.plot(window)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Hann window\")
+    Text(0.5, 1.0, 'Hann window')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"Sample\")
+    Text(0.5, 0, 'Sample')
+    >>> plt.show()
+
+    >>> plt.figure()
+    <Figure size 640x480 with 0 Axes>
+    >>> A = fft(window, 2048) / 25.5
+    >>> mag = np.abs(fftshift(A))
+    >>> freq = np.linspace(-0.5, 0.5, len(A))
+    >>> with np.errstate(divide='ignore', invalid='ignore'):
+    ...     response = 20 * np.log10(mag)
+    ...
+    >>> response = np.clip(response, -100, 100)
+    >>> plt.plot(freq, response)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Frequency response of the Hann window\")
+    Text(0.5, 1.0, 'Frequency response of the Hann window')
+    >>> plt.ylabel(\"Magnitude [dB]\")
+    Text(0, 0.5, 'Magnitude [dB]')
+    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
+    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
+    >>> plt.axis('tight')
+    ...
+    >>> plt.show()
+
+    " :arglists '[[M]]} hanning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hanning"))))
+
+(def ^{:doc "Python part of the warnings subsystem."} warnings (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "warnings"))))
+
+(def ^{:doc "Unsigned integer type, compatible with C ``unsigned int``.
+
+    :Character code: ``'I'``
+    :Canonical name: `numpy.uintc`
+    :Alias on this platform: `numpy.uint32`: 32-bit unsigned integer (``0`` to ``4_294_967_295``)." :arglists '[[self & [args {:as kwargs}]]]} uintc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uintc"))))
+
+(def ^{:doc "
+    Return a new array with the specified shape.
+
+    If the new array is larger than the original array, then the new
+    array is filled with repeated copies of `a`.  Note that this behavior
+    is different from a.resize(new_shape) which fills with zeros instead
+    of repeated copies of `a`.
+
+    Parameters
+    ----------
+    a : array_like
+        Array to be resized.
+
+    new_shape : int or tuple of int
+        Shape of resized array.
+
+    Returns
+    -------
+    reshaped_array : ndarray
+        The new array is formed from the data in the old array, repeated
+        if necessary to fill out the required number of elements.  The
+        data are repeated in the order that they are stored in memory.
+
+    See Also
+    --------
+    np.reshape : Reshape an array without changing the total size.
+    np.pad : Enlarge and pad an array.
+    np.repeat: Repeat elements of an array.
+    ndarray.resize : resize an array in-place.
+
+    Notes
+    -----
+    When the total size of the array does not change `~numpy.reshape` should
+    be used.  In most other cases either indexing (to reduce the size)
+    or padding (to increase the size) may be a more appropriate solution.
+
+    Warning: This functionality does **not** consider axes separately,
+    i.e. it does not apply interpolation/extrapolation.
+    It fills the return array with the required number of elements, taken
+    from `a` as they are laid out in memory, disregarding strides and axes.
+    (This is in case the new shape is smaller. For larger, see above.)
+    This functionality is therefore not suitable to resize images,
+    or data where each axis represents a separate and distinct entity.
+
+    Examples
+    --------
+    >>> a=np.array([[0,1],[2,3]])
+    >>> np.resize(a,(2,3))
+    array([[0, 1, 2],
+           [3, 0, 1]])
+    >>> np.resize(a,(1,4))
+    array([[0, 1, 2, 3]])
+    >>> np.resize(a,(2,4))
+    array([[0, 1, 2, 3],
+           [0, 1, 2, 3]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} resize (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "resize"))))
+
+(def ^{:doc "
+    Return the number of elements along a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : int, optional
+        Axis along which the elements are counted.  By default, give
+        the total number of elements.
+
+    Returns
+    -------
+    element_count : int
+        Number of elements along the specified axis.
+
+    See Also
+    --------
+    shape : dimensions of array
+    ndarray.shape : dimensions of array
+    ndarray.size : number of elements in array
+
+    Examples
+    --------
+    >>> a = np.array([[1,2,3],[4,5,6]])
+    >>> np.size(a)
+    6
+    >>> np.size(a,1)
+    3
+    >>> np.size(a,0)
+    2
+
+    " :arglists '[[& [args {:as kwargs}]]]} size (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "size"))))
+
+(def ^{:doc "Abstract base class of all unsigned integer scalar types." :arglists '[[self & [args {:as kwargs}]]]} unsignedinteger (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "unsignedinteger"))))
+
+(def ^{:doc "float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+First array elements raised to powers from second array, element-wise.
+
+Raise each base in `x1` to the positionally-corresponding power in `x2`.
+`x1` and `x2` must be broadcastable to the same shape. This differs from
+the power function in that integers, float16, and float32  are promoted to
+floats with a minimum precision of float64 so that the result is always
+inexact.  The intent is that the function will return a usable result for
+negative powers and seldom overflow for positive powers.
+
+.. versionadded:: 1.12.0
+
+Parameters
+----------
+x1 : array_like
+    The bases.
+x2 : array_like
+    The exponents.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The bases in `x1` raised to the exponents in `x2`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+power : power function that preserves type
+
+Examples
+--------
+Cube each element in a list.
+
+>>> x1 = range(6)
+>>> x1
+[0, 1, 2, 3, 4, 5]
+>>> np.float_power(x1, 3)
+array([   0.,    1.,    8.,   27.,   64.,  125.])
+
+Raise the bases to different exponents.
+
+>>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
+>>> np.float_power(x1, x2)
+array([  0.,   1.,   8.,  27.,  16.,   5.])
+
+The effect of broadcasting.
+
+>>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
+>>> x2
+array([[1, 2, 3, 3, 2, 1],
+       [1, 2, 3, 3, 2, 1]])
+>>> np.float_power(x1, x2)
+array([[  0.,   1.,   8.,  27.,  16.,   5.],
+       [  0.,   1.,   8.,  27.,  16.,   5.]])" :arglists '[[self & [args {:as kwargs}]]]} float_power (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "float_power"))))
+
+(def ^{:doc "logical_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the truth value of x1 XOR x2, element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Logical XOR is applied to the elements of `x1` and `x2`.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : bool or ndarray of bool
+    Boolean result of the logical XOR operation applied to the elements
+    of `x1` and `x2`; the shape is determined by broadcasting.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_and, logical_or, logical_not, bitwise_xor
+
+Examples
+--------
+>>> np.logical_xor(True, False)
+True
+>>> np.logical_xor([True, True, False, False], [True, False, True, False])
+array([False,  True,  True, False])
+
+>>> x = np.arange(5)
+>>> np.logical_xor(x < 1, x > 3)
+array([ True, False, False, False,  True])
+
+Simple example showing support of broadcasting
+
+>>> np.logical_xor(0, np.eye(2))
+array([[ True, False],
+       [False,  True]])" :arglists '[[self & [args {:as kwargs}]]]} logical_xor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logical_xor"))))
+
+(def ^{:doc "
+    Set a Python function to be used when pretty printing arrays.
+
+    Parameters
+    ----------
+    f : function or None
+        Function to be used to pretty print arrays. The function should expect
+        a single array argument and return a string of the representation of
+        the array. If None, the function is reset to the default NumPy function
+        to print arrays.
+    repr : bool, optional
+        If True (default), the function for pretty printing (``__repr__``)
+        is set, if False the function that returns the default string
+        representation (``__str__``) is set.
+
+    See Also
+    --------
+    set_printoptions, get_printoptions
+
+    Examples
+    --------
+    >>> def pprint(arr):
+    ...     return 'HA! - What are you going to do now?'
+    ...
+    >>> np.set_string_function(pprint)
+    >>> a = np.arange(10)
+    >>> a
+    HA! - What are you going to do now?
+    >>> _ = a
+    >>> # [0 1 2 3 4 5 6 7 8 9]
+
+    We can reset the function to the default:
+
+    >>> np.set_string_function(None)
+    >>> a
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+    `repr` affects either pretty printing or normal string representation.
+    Note that ``__repr__`` is still affected by setting ``__str__``
+    because the width of each array element in the returned string becomes
+    equal to the length of the result of ``__str__()``.
+
+    >>> x = np.arange(4)
+    >>> np.set_string_function(lambda x:'random', repr=False)
+    >>> x.__str__()
+    'random'
+    >>> x.__repr__()
+    'array([0, 1, 2, 3])'
+
+    " :arglists '[[f & [{repr :repr}]] [f]]} set_string_function (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "set_string_function"))))
+
+(def ^{:doc "
+    Returns True if two arrays are element-wise equal within a tolerance.
+
+    The tolerance values are positive, typically very small numbers.  The
+    relative difference (`rtol` * abs(`b`)) and the absolute difference
+    `atol` are added together to compare against the absolute difference
+    between `a` and `b`.
+
+    NaNs are treated as equal if they are in the same place and if
+    ``equal_nan=True``.  Infs are treated as equal if they are in the same
+    place and of the same sign in both arrays.
+
+    Parameters
+    ----------
+    a, b : array_like
+        Input arrays to compare.
+    rtol : float
+        The relative tolerance parameter (see Notes).
+    atol : float
+        The absolute tolerance parameter (see Notes).
+    equal_nan : bool
+        Whether to compare NaN's as equal.  If True, NaN's in `a` will be
+        considered equal to NaN's in `b` in the output array.
+
+        .. versionadded:: 1.10.0
+
+    Returns
+    -------
+    allclose : bool
+        Returns True if the two arrays are equal within the given
+        tolerance; False otherwise.
+
+    See Also
+    --------
+    isclose, all, any, equal
+
+    Notes
+    -----
+    If the following equation is element-wise True, then allclose returns
+    True.
+
+     absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))
+
+    The above equation is not symmetric in `a` and `b`, so that
+    ``allclose(a, b)`` might be different from ``allclose(b, a)`` in
+    some rare cases.
+
+    The comparison of `a` and `b` uses standard broadcasting, which
+    means that `a` and `b` need not have the same shape in order for
+    ``allclose(a, b)`` to evaluate to True.  The same is true for
+    `equal` but not `array_equal`.
+
+    `allclose` is not defined for non-numeric data types.
+
+    Examples
+    --------
+    >>> np.allclose([1e10,1e-7], [1.00001e10,1e-8])
+    False
+    >>> np.allclose([1e10,1e-8], [1.00001e10,1e-9])
+    True
+    >>> np.allclose([1e10,1e-8], [1.0001e10,1e-9])
+    False
+    >>> np.allclose([1.0, np.nan], [1.0, np.nan])
+    False
+    >>> np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]]} allclose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "allclose"))))
+
+(def ^{:doc ""} Inf ##Inf)
+
+(def ^{:doc "
+    Return the cumulative product over the given axis.
+
+    See Also
+    --------
+    cumprod : equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]]} cumproduct (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cumproduct"))))
+
+(def ^{:doc "
+    Return the minimum of an array or minimum along an axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data.
+    axis : None or int or tuple of ints, optional
+        Axis or axes along which to operate.  By default, flattened input is
+        used.
+
+        .. versionadded:: 1.7.0
+
+        If this is a tuple of ints, the minimum is selected over multiple axes,
+        instead of a single axis or all the axes as before.
+    out : ndarray, optional
+        Alternative output array in which to place the result.  Must
+        be of the same shape and buffer length as the expected output.
+        See :ref:`ufuncs-output-type` for more details.
+
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the input array.
+
+        If the default value is passed, then `keepdims` will not be
+        passed through to the `amin` method of sub-classes of
+        `ndarray`, however any non-default value will be.  If the
+        sub-class' method does not implement `keepdims` any
+        exceptions will be raised.
+
+    initial : scalar, optional
+        The maximum value of an output element. Must be present to allow
+        computation on empty slice. See `~numpy.ufunc.reduce` for details.
+
+        .. versionadded:: 1.15.0
+
+    where : array_like of bool, optional
+        Elements to compare for the minimum. See `~numpy.ufunc.reduce`
+        for details.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    amin : ndarray or scalar
+        Minimum of `a`. If `axis` is None, the result is a scalar value.
+        If `axis` is given, the result is an array of dimension
+        ``a.ndim - 1``.
+
+    See Also
+    --------
+    amax :
+        The maximum value of an array along a given axis, propagating any NaNs.
+    nanmin :
+        The minimum value of an array along a given axis, ignoring any NaNs.
+    minimum :
+        Element-wise minimum of two arrays, propagating any NaNs.
+    fmin :
+        Element-wise minimum of two arrays, ignoring any NaNs.
+    argmin :
+        Return the indices of the minimum values.
+
+    nanmax, maximum, fmax
+
+    Notes
+    -----
+    NaN values are propagated, that is if at least one item is NaN, the
+    corresponding min value will be NaN as well. To ignore NaN values
+    (MATLAB behavior), please use nanmin.
+
+    Don't use `amin` for element-wise comparison of 2 arrays; when
+    ``a.shape[0]`` is 2, ``minimum(a[0], a[1])`` is faster than
+    ``amin(a, axis=0)``.
+
+    Examples
+    --------
+    >>> a = np.arange(4).reshape((2,2))
+    >>> a
+    array([[0, 1],
+           [2, 3]])
+    >>> np.amin(a)           # Minimum of the flattened array
+    0
+    >>> np.amin(a, axis=0)   # Minima along the first axis
+    array([0, 1])
+    >>> np.amin(a, axis=1)   # Minima along the second axis
+    array([0, 2])
+    >>> np.amin(a, where=[False, True], initial=10, axis=0)
+    array([10,  1])
+
+    >>> b = np.arange(5, dtype=float)
+    >>> b[2] = np.NaN
+    >>> np.amin(b)
+    nan
+    >>> np.amin(b, where=~np.isnan(b), initial=10)
+    0.0
+    >>> np.nanmin(b)
+    0.0
+
+    >>> np.min([[-50], [10]], axis=-1, initial=0)
+    array([-50,   0])
+
+    Notice that the initial value is used as one of the elements for which the
+    minimum is determined, unlike for the default argument Python's max
+    function, which is only used for empty iterables.
+
+    Notice that this isn't the same as Python's ``default`` argument.
+
+    >>> np.min([6], initial=5)
+    5
+    >>> min([6], default=5)
+    6
+    " :arglists '[[& [args {:as kwargs}]]]} amin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "amin"))))
+
+(def ^{:doc "
+    Replace NaN with zero and infinity with large finite numbers (default
+    behaviour) or with the numbers defined by the user using the `nan`, 
+    `posinf` and/or `neginf` keywords.
+
+    If `x` is inexact, NaN is replaced by zero or by the user defined value in
+    `nan` keyword, infinity is replaced by the largest finite floating point 
+    values representable by ``x.dtype`` or by the user defined value in 
+    `posinf` keyword and -infinity is replaced by the most negative finite 
+    floating point values representable by ``x.dtype`` or by the user defined 
+    value in `neginf` keyword.
+
+    For complex dtypes, the above is applied to each of the real and
+    imaginary components of `x` separately.
+
+    If `x` is not inexact, then no replacements are made.
+
+    Parameters
+    ----------
+    x : scalar or array_like
+        Input data.
+    copy : bool, optional
+        Whether to create a copy of `x` (True) or to replace values
+        in-place (False). The in-place operation only occurs if
+        casting to an array does not require a copy.
+        Default is True.
+        
+        .. versionadded:: 1.13
+    nan : int, float, optional
+        Value to be used to fill NaN values. If no value is passed 
+        then NaN values will be replaced with 0.0.
+        
+        .. versionadded:: 1.17
+    posinf : int, float, optional
+        Value to be used to fill positive infinity values. If no value is 
+        passed then positive infinity values will be replaced with a very
+        large number.
+        
+        .. versionadded:: 1.17
+    neginf : int, float, optional
+        Value to be used to fill negative infinity values. If no value is 
+        passed then negative infinity values will be replaced with a very
+        small (or negative) number.
+        
+        .. versionadded:: 1.17
+
+        
+
+    Returns
+    -------
+    out : ndarray
+        `x`, with the non-finite values replaced. If `copy` is False, this may
+        be `x` itself.
+
+    See Also
+    --------
+    isinf : Shows which elements are positive or negative infinity.
+    isneginf : Shows which elements are negative infinity.
+    isposinf : Shows which elements are positive infinity.
+    isnan : Shows which elements are Not a Number (NaN).
+    isfinite : Shows which elements are finite (not NaN, not infinity)
+
+    Notes
+    -----
+    NumPy uses the IEEE Standard for Binary Floating-Point for Arithmetic
+    (IEEE 754). This means that Not a Number is not equivalent to infinity.
+
+    Examples
+    --------
+    >>> np.nan_to_num(np.inf)
+    1.7976931348623157e+308
+    >>> np.nan_to_num(-np.inf)
+    -1.7976931348623157e+308
+    >>> np.nan_to_num(np.nan)
+    0.0
+    >>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])
+    >>> np.nan_to_num(x)
+    array([ 1.79769313e+308, -1.79769313e+308,  0.00000000e+000, # may vary
+           -1.28000000e+002,  1.28000000e+002])
+    >>> np.nan_to_num(x, nan=-9999, posinf=33333333, neginf=33333333)
+    array([ 3.3333333e+07,  3.3333333e+07, -9.9990000e+03, 
+           -1.2800000e+02,  1.2800000e+02])
+    >>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])
+    array([  1.79769313e+308,  -1.79769313e+308,   0.00000000e+000, # may vary
+         -1.28000000e+002,   1.28000000e+002])
+    >>> np.nan_to_num(y)
+    array([  1.79769313e+308 +0.00000000e+000j, # may vary
+             0.00000000e+000 +0.00000000e+000j,
+             0.00000000e+000 +1.79769313e+308j])
+    >>> np.nan_to_num(y, nan=111111, posinf=222222)
+    array([222222.+111111.j, 111111.     +0.j, 111111.+222222.j])
+    " :arglists '[[& [args {:as kwargs}]]]} nan_to_num (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nan_to_num"))))
+
+(def ^{:doc "
+    Return the indices to access the main diagonal of an array.
+
+    This returns a tuple of indices that can be used to access the main
+    diagonal of an array `a` with ``a.ndim >= 2`` dimensions and shape
+    (n, n, ..., n). For ``a.ndim = 2`` this is the usual diagonal, for
+    ``a.ndim > 2`` this is the set of indices to access ``a[i, i, ..., i]``
+    for ``i = [0..n-1]``.
+
+    Parameters
+    ----------
+    n : int
+      The size, along each dimension, of the arrays for which the returned
+      indices can be used.
+
+    ndim : int, optional
+      The number of dimensions.
+
+    See Also
+    --------
+    diag_indices_from
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    Create a set of indices to access the diagonal of a (4, 4) array:
+
+    >>> di = np.diag_indices(4)
+    >>> di
+    (array([0, 1, 2, 3]), array([0, 1, 2, 3]))
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+    >>> a[di] = 100
+    >>> a
+    array([[100,   1,   2,   3],
+           [  4, 100,   6,   7],
+           [  8,   9, 100,  11],
+           [ 12,  13,  14, 100]])
+
+    Now, we create indices to manipulate a 3-D array:
+
+    >>> d3 = np.diag_indices(2, 3)
+    >>> d3
+    (array([0, 1]), array([0, 1]), array([0, 1]))
+
+    And use it to set the diagonal of an array of zeros to 1:
+
+    >>> a = np.zeros((2, 2, 2), dtype=int)
+    >>> a[d3] = 1
+    >>> a
+    array([[[1, 0],
+            [0, 0]],
+           [[0, 0],
+            [0, 1]]])
+
+    " :arglists '[[n & [{ndim :ndim}]] [n]]} diag_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diag_indices"))))
+
+(def ^{:doc "
+    Check whether some values are true.
+
+    Refer to `any` for full documentation.
+
+    See Also
+    --------
+    any : equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]]} sometrue (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sometrue"))))
+
+(def ^{:doc "A unicode string.
+
+    When used in arrays, this type strips trailing null codepoints.
+
+    Unlike the builtin `str`, this supports the :ref:`python:bufferobjects`, exposing its
+    contents as UCS4:
+
+    >>> m = memoryview(np.str_(\"abc\"))
+    >>> m.format
+    '3w'
+    >>> m.tobytes()
+    b'a\\x00\\x00\\x00b\\x00\\x00\\x00c\\x00\\x00\\x00'
+
+    :Character code: ``'U'``
+    :Alias: `numpy.unicode_`" :arglists '[[self & [args {:as kwargs}]]]} str_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "str_"))))
+
+(def ^{:doc "Complex number type composed of two single-precision floating-point
+    numbers.
+
+    :Character code: ``'F'``
+    :Canonical name: `numpy.csingle`
+    :Alias: `numpy.singlecomplex`
+    :Alias on this platform: `numpy.complex64`: Complex number type composed of 2 32-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} singlecomplex (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "singlecomplex"))))
+
+(def ^{:doc "
+    Return the current print options.
+
+    Returns
+    -------
+    print_opts : dict
+        Dictionary of current print options with keys
+
+          - precision : int
+          - threshold : int
+          - edgeitems : int
+          - linewidth : int
+          - suppress : bool
+          - nanstr : str
+          - infstr : str
+          - formatter : dict of callables
+          - sign : str
+
+        For a full description of these options, see `set_printoptions`.
+
+    See Also
+    --------
+    set_printoptions, printoptions, set_string_function
+
+    " :arglists '[[]]} get_printoptions (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "get_printoptions"))))
+
+(def ^{:doc "sinh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Hyperbolic sine, element-wise.
+
+Equivalent to ``1/2 * (np.exp(x) - np.exp(-x))`` or
+``-1j * np.sin(1j*x)``.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding hyperbolic sine values.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+If `out` is provided, the function writes the result into it,
+and returns a reference to `out`.  (See Examples)
+
+References
+----------
+M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
+New York, NY: Dover, 1972, pg. 83.
+
+Examples
+--------
+>>> np.sinh(0)
+0.0
+>>> np.sinh(np.pi*1j/2)
+1j
+>>> np.sinh(np.pi*1j) # (exact value is 0)
+1.2246063538223773e-016j
+>>> # Discrepancy due to vagaries of floating point arithmetic.
+
+>>> # Example of providing the optional output parameter
+>>> out1 = np.array([0], dtype='d')
+>>> out2 = np.sinh([0.1], out1)
+>>> out2 is out1
+True
+
+>>> # Example of ValueError due to provision of shape mis-matched `out`
+>>> np.sinh(np.zeros((3,3)),np.zeros((2,2)))
+Traceback (most recent call last):
+  File \"<stdin>\", line 1, in <module>
+ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]]} sinh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sinh"))))
+
+(def ^{:doc "
+    Return the indices for the upper-triangle of arr.
+
+    See `triu_indices` for full details.
+
+    Parameters
+    ----------
+    arr : ndarray, shape(N, N)
+        The indices will be valid for square arrays.
+    k : int, optional
+        Diagonal offset (see `triu` for details).
+
+    Returns
+    -------
+    triu_indices_from : tuple, shape(2) of ndarray, shape(N)
+        Indices for the upper-triangle of `arr`.
+
+    See Also
+    --------
+    triu_indices, triu
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    " :arglists '[[& [args {:as kwargs}]]]} triu_indices_from (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "triu_indices_from"))))
+
+(def ^{:doc ""} __doc__ "
+NumPy
+=====
+
+Provides
+  1. An array object of arbitrary homogeneous items
+  2. Fast mathematical operations over arrays
+  3. Linear Algebra, Fourier Transforms, Random Number Generation
+
+How to use the documentation
+----------------------------
+Documentation is available in two forms: docstrings provided
+with the code, and a loose standing reference guide, available from
+`the NumPy homepage <https://www.scipy.org>`_.
+
+We recommend exploring the docstrings using
+`IPython <https://ipython.org>`_, an advanced Python shell with
+TAB-completion and introspection capabilities.  See below for further
+instructions.
+
+The docstring examples assume that `numpy` has been imported as `np`::
+
+  >>> import numpy as np
+
+Code snippets are indicated by three greater-than signs::
+
+  >>> x = 42
+  >>> x = x + 1
+
+Use the built-in ``help`` function to view a function's docstring::
+
+  >>> help(np.sort)
+  ... # doctest: +SKIP
+
+For some objects, ``np.info(obj)`` may provide additional help.  This is
+particularly true if you see the line \"Help on ufunc object:\" at the top
+of the help() page.  Ufuncs are implemented in C, not Python, for speed.
+The native Python help() does not know how to view their help, but our
+np.info() function does.
+
+To search for documents containing a keyword, do::
+
+  >>> np.lookfor('keyword')
+  ... # doctest: +SKIP
+
+General-purpose documents like a glossary and help on the basic concepts
+of numpy are available under the ``doc`` sub-module::
+
+  >>> from numpy import doc
+  >>> help(doc)
+  ... # doctest: +SKIP
+
+Available subpackages
+---------------------
+doc
+    Topical documentation on broadcasting, indexing, etc.
+lib
+    Basic functions used by several sub-packages.
+random
+    Core Random Tools
+linalg
+    Core Linear Algebra Tools
+fft
+    Core FFT routines
+polynomial
+    Polynomial tools
+testing
+    NumPy testing tools
+f2py
+    Fortran to Python Interface Generator.
+distutils
+    Enhancements to distutils with support for
+    Fortran compilers support and more.
+
+Utilities
+---------
+test
+    Run numpy unittests
+show_config
+    Show numpy build configuration
+dual
+    Overwrite certain functions with high-performance SciPy tools.
+    Note: `numpy.dual` is deprecated.  Use the functions from NumPy or Scipy
+    directly instead of importing them from `numpy.dual`.
+matlib
+    Make everything matrices.
+__version__
+    NumPy version string
+
+Viewing documentation using IPython
+-----------------------------------
+Start IPython with the NumPy profile (``ipython -p numpy``), which will
+import `numpy` under the alias `np`.  Then, use the ``cpaste`` command to
+paste examples into the shell.  To see which functions are available in
+`numpy`, type ``np.<TAB>`` (where ``<TAB>`` refers to the TAB key), or use
+``np.*cos*?<ENTER>`` (where ``<ENTER>`` refers to the ENTER key) to narrow
+down the list.  To view the docstring for a function, use
+``np.cos?<ENTER>`` (to view the docstring) and ``np.cos??<ENTER>`` (to view
+the source code).
+
+Copies vs. in-place operation
+-----------------------------
+Most of the functions in `numpy` return a copy of the array argument
+(e.g., `np.sort`).  In-place versions of these functions are often
+available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.
+Exceptions to this rule are documented.
+
+")
+
+(def ^{:doc "
+    Rotate an array by 90 degrees in the plane specified by axes.
+
+    Rotation direction is from the first towards the second axis.
+
+    Parameters
+    ----------
+    m : array_like
+        Array of two or more dimensions.
+    k : integer
+        Number of times the array is rotated by 90 degrees.
+    axes: (2,) array_like
+        The array is rotated in the plane defined by the axes.
+        Axes must be different.
+
+        .. versionadded:: 1.12.0
+
+    Returns
+    -------
+    y : ndarray
+        A rotated view of `m`.
+
+    See Also
+    --------
+    flip : Reverse the order of elements in an array along the given axis.
+    fliplr : Flip an array horizontally.
+    flipud : Flip an array vertically.
+
+    Notes
+    -----
+    rot90(m, k=1, axes=(1,0)) is the reverse of rot90(m, k=1, axes=(0,1))
+    rot90(m, k=1, axes=(1,0)) is equivalent to rot90(m, k=-1, axes=(0,1))
+
+    Examples
+    --------
+    >>> m = np.array([[1,2],[3,4]], int)
+    >>> m
+    array([[1, 2],
+           [3, 4]])
+    >>> np.rot90(m)
+    array([[2, 4],
+           [1, 3]])
+    >>> np.rot90(m, 2)
+    array([[4, 3],
+           [2, 1]])
+    >>> m = np.arange(8).reshape((2,2,2))
+    >>> np.rot90(m, 1, (1,2))
+    array([[[1, 3],
+            [0, 2]],
+           [[5, 7],
+            [4, 6]]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} rot90 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rot90"))))
+
+(def ^{:doc "
+    Split array into multiple sub-arrays along the 3rd axis (depth).
+
+    Please refer to the `split` documentation.  `dsplit` is equivalent
+    to `split` with ``axis=2``, the array is always split along the third
+    axis provided the array dimension is greater than or equal to 3.
+
+    See Also
+    --------
+    split : Split an array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> x = np.arange(16.0).reshape(2, 2, 4)
+    >>> x
+    array([[[ 0.,   1.,   2.,   3.],
+            [ 4.,   5.,   6.,   7.]],
+           [[ 8.,   9.,  10.,  11.],
+            [12.,  13.,  14.,  15.]]])
+    >>> np.dsplit(x, 2)
+    [array([[[ 0.,  1.],
+            [ 4.,  5.]],
+           [[ 8.,  9.],
+            [12., 13.]]]), array([[[ 2.,  3.],
+            [ 6.,  7.]],
+           [[10., 11.],
+            [14., 15.]]])]
+    >>> np.dsplit(x, np.array([3, 6]))
+    [array([[[ 0.,   1.,   2.],
+            [ 4.,   5.,   6.]],
+           [[ 8.,   9.,  10.],
+            [12.,  13.,  14.]]]),
+     array([[[ 3.],
+            [ 7.]],
+           [[11.],
+            [15.]]]),
+    array([], shape=(2, 2, 0), dtype=float64)]
+    " :arglists '[[& [args {:as kwargs}]]]} dsplit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dsplit"))))
+
+(def ^{:doc "equal(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return (x1 == x2) element-wise.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input arrays.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array, element-wise comparison of `x1` and `x2`.
+    Typically of type bool, unless ``dtype=object`` is passed.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+not_equal, greater_equal, less_equal, greater, less
+
+Examples
+--------
+>>> np.equal([0, 1, 3], np.arange(3))
+array([ True,  True, False])
+
+What is compared are values, not types. So an int (1) and an array of
+length one can evaluate as True:
+
+>>> np.equal(1, np.ones(1))
+array([ True])
+
+The ``==`` operator can be used as a shorthand for ``np.equal`` on
+ndarrays.
+
+>>> a = np.array([2, 4, 6])
+>>> b = np.array([2, 4, 2])
+>>> a == b
+array([ True,  True, False])" :arglists '[[self & [args {:as kwargs}]]]} equal (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "equal"))))
+
+(def ^{:doc ""} CLIP 0)
+
+(def ^{:doc "Broadcast an array to a new shape.
+
+    Parameters
+    ----------
+    array : array_like
+        The array to broadcast.
+    shape : tuple
+        The shape of the desired array.
+    subok : bool, optional
+        If True, then sub-classes will be passed-through, otherwise
+        the returned array will be forced to be a base-class array (default).
+
+    Returns
+    -------
+    broadcast : array
+        A readonly view on the original array with the given shape. It is
+        typically not contiguous. Furthermore, more than one element of a
+        broadcasted array may refer to a single memory location.
+
+    Raises
+    ------
+    ValueError
+        If the array is not compatible with the new shape according to NumPy's
+        broadcasting rules.
+
+    See Also
+    --------
+    broadcast
+    broadcast_arrays
+    broadcast_shapes
+
+    Notes
+    -----
+    .. versionadded:: 1.10.0
+
+    Examples
+    --------
+    >>> x = np.array([1, 2, 3])
+    >>> np.broadcast_to(x, (3, 3))
+    array([[1, 2, 3],
+           [1, 2, 3],
+           [1, 2, 3]])
+    " :arglists '[[& [args {:as kwargs}]]]} broadcast_to (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "broadcast_to"))))
+
+(def ^{:doc "
+    einsum(subscripts, *operands, out=None, dtype=None, order='K',
+           casting='safe', optimize=False)
+
+    Evaluates the Einstein summation convention on the operands.
+
+    Using the Einstein summation convention, many common multi-dimensional,
+    linear algebraic array operations can be represented in a simple fashion.
+    In *implicit* mode `einsum` computes these values.
+
+    In *explicit* mode, `einsum` provides further flexibility to compute
+    other array operations that might not be considered classical Einstein
+    summation operations, by disabling, or forcing summation over specified
+    subscript labels.
+
+    See the notes and examples for clarification.
+
+    Parameters
+    ----------
+    subscripts : str
+        Specifies the subscripts for summation as comma separated list of
+        subscript labels. An implicit (classical Einstein summation)
+        calculation is performed unless the explicit indicator '->' is
+        included as well as subscript labels of the precise output form.
+    operands : list of array_like
+        These are the arrays for the operation.
+    out : ndarray, optional
+        If provided, the calculation is done into this array.
+    dtype : {data-type, None}, optional
+        If provided, forces the calculation to use the data type specified.
+        Note that you may have to also give a more liberal `casting`
+        parameter to allow the conversions. Default is None.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Controls the memory layout of the output. 'C' means it should
+        be C contiguous. 'F' means it should be Fortran contiguous,
+        'A' means it should be 'F' if the inputs are all 'F', 'C' otherwise.
+        'K' means it should be as close to the layout as the inputs as
+        is possible, including arbitrarily permuted axes.
+        Default is 'K'.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur.  Setting this to
+        'unsafe' is not recommended, as it can adversely affect accumulations.
+
+          * 'no' means the data types should not be cast at all.
+          * 'equiv' means only byte-order changes are allowed.
+          * 'safe' means only casts which can preserve values are allowed.
+          * 'same_kind' means only safe casts or casts within a kind,
+            like float64 to float32, are allowed.
+          * 'unsafe' means any data conversions may be done.
+
+        Default is 'safe'.
+    optimize : {False, True, 'greedy', 'optimal'}, optional
+        Controls if intermediate optimization should occur. No optimization
+        will occur if False and True will default to the 'greedy' algorithm.
+        Also accepts an explicit contraction list from the ``np.einsum_path``
+        function. See ``np.einsum_path`` for more details. Defaults to False.
+
+    Returns
+    -------
+    output : ndarray
+        The calculation based on the Einstein summation convention.
+
+    See Also
+    --------
+    einsum_path, dot, inner, outer, tensordot, linalg.multi_dot
+
+    einops:
+        similar verbose interface is provided by
+        `einops <https://github.com/arogozhnikov/einops>`_ package to cover
+        additional operations: transpose, reshape/flatten, repeat/tile,
+        squeeze/unsqueeze and reductions.
+
+    opt_einsum:
+        `opt_einsum <https://optimized-einsum.readthedocs.io/en/stable/>`_
+        optimizes contraction order for einsum-like expressions
+        in backend-agnostic manner.
+
+    Notes
+    -----
+    .. versionadded:: 1.6.0
+
+    The Einstein summation convention can be used to compute
+    many multi-dimensional, linear algebraic array operations. `einsum`
+    provides a succinct way of representing these.
+
+    A non-exhaustive list of these operations,
+    which can be computed by `einsum`, is shown below along with examples:
+
+    * Trace of an array, :py:func:`numpy.trace`.
+    * Return a diagonal, :py:func:`numpy.diag`.
+    * Array axis summations, :py:func:`numpy.sum`.
+    * Transpositions and permutations, :py:func:`numpy.transpose`.
+    * Matrix multiplication and dot product, :py:func:`numpy.matmul` :py:func:`numpy.dot`.
+    * Vector inner and outer products, :py:func:`numpy.inner` :py:func:`numpy.outer`.
+    * Broadcasting, element-wise and scalar multiplication, :py:func:`numpy.multiply`.
+    * Tensor contractions, :py:func:`numpy.tensordot`.
+    * Chained array operations, in efficient calculation order, :py:func:`numpy.einsum_path`.
+
+    The subscripts string is a comma-separated list of subscript labels,
+    where each label refers to a dimension of the corresponding operand.
+    Whenever a label is repeated it is summed, so ``np.einsum('i,i', a, b)``
+    is equivalent to :py:func:`np.inner(a,b) <numpy.inner>`. If a label
+    appears only once, it is not summed, so ``np.einsum('i', a)`` produces a
+    view of ``a`` with no changes. A further example ``np.einsum('ij,jk', a, b)``
+    describes traditional matrix multiplication and is equivalent to
+    :py:func:`np.matmul(a,b) <numpy.matmul>`. Repeated subscript labels in one
+    operand take the diagonal. For example, ``np.einsum('ii', a)`` is equivalent
+    to :py:func:`np.trace(a) <numpy.trace>`.
+
+    In *implicit mode*, the chosen subscripts are important
+    since the axes of the output are reordered alphabetically.  This
+    means that ``np.einsum('ij', a)`` doesn't affect a 2D array, while
+    ``np.einsum('ji', a)`` takes its transpose. Additionally,
+    ``np.einsum('ij,jk', a, b)`` returns a matrix multiplication, while,
+    ``np.einsum('ij,jh', a, b)`` returns the transpose of the
+    multiplication since subscript 'h' precedes subscript 'i'.
+
+    In *explicit mode* the output can be directly controlled by
+    specifying output subscript labels.  This requires the
+    identifier '->' as well as the list of output subscript labels.
+    This feature increases the flexibility of the function since
+    summing can be disabled or forced when required. The call
+    ``np.einsum('i->', a)`` is like :py:func:`np.sum(a, axis=-1) <numpy.sum>`,
+    and ``np.einsum('ii->i', a)`` is like :py:func:`np.diag(a) <numpy.diag>`.
+    The difference is that `einsum` does not allow broadcasting by default.
+    Additionally ``np.einsum('ij,jh->ih', a, b)`` directly specifies the
+    order of the output subscript labels and therefore returns matrix
+    multiplication, unlike the example above in implicit mode.
+
+    To enable and control broadcasting, use an ellipsis.  Default
+    NumPy-style broadcasting is done by adding an ellipsis
+    to the left of each term, like ``np.einsum('...ii->...i', a)``.
+    To take the trace along the first and last axes,
+    you can do ``np.einsum('i...i', a)``, or to do a matrix-matrix
+    product with the left-most indices instead of rightmost, one can do
+    ``np.einsum('ij...,jk...->ik...', a, b)``.
+
+    When there is only one operand, no axes are summed, and no output
+    parameter is provided, a view into the operand is returned instead
+    of a new array.  Thus, taking the diagonal as ``np.einsum('ii->i', a)``
+    produces a view (changed in version 1.10.0).
+
+    `einsum` also provides an alternative way to provide the subscripts
+    and operands as ``einsum(op0, sublist0, op1, sublist1, ..., [sublistout])``.
+    If the output shape is not provided in this format `einsum` will be
+    calculated in implicit mode, otherwise it will be performed explicitly.
+    The examples below have corresponding `einsum` calls with the two
+    parameter methods.
+
+    .. versionadded:: 1.10.0
+
+    Views returned from einsum are now writeable whenever the input array
+    is writeable. For example, ``np.einsum('ijk...->kji...', a)`` will now
+    have the same effect as :py:func:`np.swapaxes(a, 0, 2) <numpy.swapaxes>`
+    and ``np.einsum('ii->i', a)`` will return a writeable view of the diagonal
+    of a 2D array.
+
+    .. versionadded:: 1.12.0
+
+    Added the ``optimize`` argument which will optimize the contraction order
+    of an einsum expression. For a contraction with three or more operands this
+    can greatly increase the computational efficiency at the cost of a larger
+    memory footprint during computation.
+
+    Typically a 'greedy' algorithm is applied which empirical tests have shown
+    returns the optimal path in the majority of cases. In some cases 'optimal'
+    will return the superlative path through a more expensive, exhaustive search.
+    For iterative calculations it may be advisable to calculate the optimal path
+    once and reuse that path by supplying it as an argument. An example is given
+    below.
+
+    See :py:func:`numpy.einsum_path` for more details.
+
+    Examples
+    --------
+    >>> a = np.arange(25).reshape(5,5)
+    >>> b = np.arange(5)
+    >>> c = np.arange(6).reshape(2,3)
+
+    Trace of a matrix:
+
+    >>> np.einsum('ii', a)
+    60
+    >>> np.einsum(a, [0,0])
+    60
+    >>> np.trace(a)
+    60
+
+    Extract the diagonal (requires explicit form):
+
+    >>> np.einsum('ii->i', a)
+    array([ 0,  6, 12, 18, 24])
+    >>> np.einsum(a, [0,0], [0])
+    array([ 0,  6, 12, 18, 24])
+    >>> np.diag(a)
+    array([ 0,  6, 12, 18, 24])
+
+    Sum over an axis (requires explicit form):
+
+    >>> np.einsum('ij->i', a)
+    array([ 10,  35,  60,  85, 110])
+    >>> np.einsum(a, [0,1], [0])
+    array([ 10,  35,  60,  85, 110])
+    >>> np.sum(a, axis=1)
+    array([ 10,  35,  60,  85, 110])
+
+    For higher dimensional arrays summing a single axis can be done with ellipsis:
+
+    >>> np.einsum('...j->...', a)
+    array([ 10,  35,  60,  85, 110])
+    >>> np.einsum(a, [Ellipsis,1], [Ellipsis])
+    array([ 10,  35,  60,  85, 110])
+
+    Compute a matrix transpose, or reorder any number of axes:
+
+    >>> np.einsum('ji', c)
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+    >>> np.einsum('ij->ji', c)
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+    >>> np.einsum(c, [1,0])
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+    >>> np.transpose(c)
+    array([[0, 3],
+           [1, 4],
+           [2, 5]])
+
+    Vector inner products:
+
+    >>> np.einsum('i,i', b, b)
+    30
+    >>> np.einsum(b, [0], b, [0])
+    30
+    >>> np.inner(b,b)
+    30
+
+    Matrix vector multiplication:
+
+    >>> np.einsum('ij,j', a, b)
+    array([ 30,  80, 130, 180, 230])
+    >>> np.einsum(a, [0,1], b, [1])
+    array([ 30,  80, 130, 180, 230])
+    >>> np.dot(a, b)
+    array([ 30,  80, 130, 180, 230])
+    >>> np.einsum('...j,j', a, b)
+    array([ 30,  80, 130, 180, 230])
+
+    Broadcasting and scalar multiplication:
+
+    >>> np.einsum('..., ...', 3, c)
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+    >>> np.einsum(',ij', 3, c)
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+    >>> np.einsum(3, [Ellipsis], c, [Ellipsis])
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+    >>> np.multiply(3, c)
+    array([[ 0,  3,  6],
+           [ 9, 12, 15]])
+
+    Vector outer product:
+
+    >>> np.einsum('i,j', np.arange(2)+1, b)
+    array([[0, 1, 2, 3, 4],
+           [0, 2, 4, 6, 8]])
+    >>> np.einsum(np.arange(2)+1, [0], b, [1])
+    array([[0, 1, 2, 3, 4],
+           [0, 2, 4, 6, 8]])
+    >>> np.outer(np.arange(2)+1, b)
+    array([[0, 1, 2, 3, 4],
+           [0, 2, 4, 6, 8]])
+
+    Tensor contraction:
+
+    >>> a = np.arange(60.).reshape(3,4,5)
+    >>> b = np.arange(24.).reshape(4,3,2)
+    >>> np.einsum('ijk,jil->kl', a, b)
+    array([[4400., 4730.],
+           [4532., 4874.],
+           [4664., 5018.],
+           [4796., 5162.],
+           [4928., 5306.]])
+    >>> np.einsum(a, [0,1,2], b, [1,0,3], [2,3])
+    array([[4400., 4730.],
+           [4532., 4874.],
+           [4664., 5018.],
+           [4796., 5162.],
+           [4928., 5306.]])
+    >>> np.tensordot(a,b, axes=([1,0],[0,1]))
+    array([[4400., 4730.],
+           [4532., 4874.],
+           [4664., 5018.],
+           [4796., 5162.],
+           [4928., 5306.]])
+
+    Writeable returned arrays (since version 1.10.0):
+
+    >>> a = np.zeros((3, 3))
+    >>> np.einsum('ii->i', a)[:] = 1
+    >>> a
+    array([[1., 0., 0.],
+           [0., 1., 0.],
+           [0., 0., 1.]])
+
+    Example of ellipsis use:
+
+    >>> a = np.arange(6).reshape((3,2))
+    >>> b = np.arange(12).reshape((4,3))
+    >>> np.einsum('ki,jk->ij', a, b)
+    array([[10, 28, 46, 64],
+           [13, 40, 67, 94]])
+    >>> np.einsum('ki,...k->i...', a, b)
+    array([[10, 28, 46, 64],
+           [13, 40, 67, 94]])
+    >>> np.einsum('k...,jk', a, b)
+    array([[10, 28, 46, 64],
+           [13, 40, 67, 94]])
+
+    Chained array operations. For more complicated contractions, speed ups
+    might be achieved by repeatedly computing a 'greedy' path or pre-computing the
+    'optimal' path and repeatedly applying it, using an
+    `einsum_path` insertion (since version 1.12.0). Performance improvements can be
+    particularly significant with larger arrays:
+
+    >>> a = np.ones(64).reshape(2,4,8)
+
+    Basic `einsum`: ~1520ms  (benchmarked on 3.1GHz Intel i5.)
+
+    >>> for iteration in range(500):
+    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a)
+
+    Sub-optimal `einsum` (due to repeated path calculation time): ~330ms
+
+    >>> for iteration in range(500):
+    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')
+
+    Greedy `einsum` (faster optimal path approximation): ~160ms
+
+    >>> for iteration in range(500):
+    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='greedy')
+
+    Optimal `einsum` (best usage pattern in some use cases): ~110ms
+
+    >>> path = np.einsum_path('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize='optimal')[0]
+    >>> for iteration in range(500):
+    ...     _ = np.einsum('ijk,ilm,njm,nlk,abc->',a,a,a,a,a, optimize=path)
+
+    " :arglists '[[& [args {:as kwargs}]]]} einsum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "einsum"))))
+
+(def ^{:doc ""} numarray "removed")
+
+(def ^{:doc "A byte string.
+
+    When used in arrays, this type strips trailing null bytes.
+
+    :Character code: ``'S'``
+    :Alias: `numpy.string_`" :arglists '[[self & [args {:as kwargs}]]]} bytes0 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bytes0"))))
+
+(def ^{:doc ""} little_endian true)
+
+(def ^{:doc "Visible deprecation warning.
+
+    By default, python will not show deprecation warnings, so this class
+    can be used when a very visible warning is helpful, for example because
+    the usage is most likely a user bug.
+
+    " :arglists '[[self & [args {:as kwargs}]]]} VisibleDeprecationWarning (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "VisibleDeprecationWarning"))))
+
+(def ^{:doc " Axis supplied was invalid. " :arglists '[[self axis & [{ndim :ndim, msg_prefix :msg_prefix}]] [self axis & [{ndim :ndim}]] [self axis]]} AxisError (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "AxisError"))))
+
+(def ^{:doc "
+    Apply a function to 1-D slices along the given axis.
+
+    Execute `func1d(a, *args, **kwargs)` where `func1d` operates on 1-D arrays
+    and `a` is a 1-D slice of `arr` along `axis`.
+
+    This is equivalent to (but faster than) the following use of `ndindex` and
+    `s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices::
+
+        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                f = func1d(arr[ii + s_[:,] + kk])
+                Nj = f.shape
+                for jj in ndindex(Nj):
+                    out[ii + jj + kk] = f[jj]
+
+    Equivalently, eliminating the inner loop, this can be expressed as::
+
+        Ni, Nk = a.shape[:axis], a.shape[axis+1:]
+        for ii in ndindex(Ni):
+            for kk in ndindex(Nk):
+                out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])
+
+    Parameters
+    ----------
+    func1d : function (M,) -> (Nj...)
+        This function should accept 1-D arrays. It is applied to 1-D
+        slices of `arr` along the specified axis.
+    axis : integer
+        Axis along which `arr` is sliced.
+    arr : ndarray (Ni..., M, Nk...)
+        Input array.
+    args : any
+        Additional arguments to `func1d`.
+    kwargs : any
+        Additional named arguments to `func1d`.
+
+        .. versionadded:: 1.9.0
+
+
+    Returns
+    -------
+    out : ndarray  (Ni..., Nj..., Nk...)
+        The output array. The shape of `out` is identical to the shape of
+        `arr`, except along the `axis` dimension. This axis is removed, and
+        replaced with new dimensions equal to the shape of the return value
+        of `func1d`. So if `func1d` returns a scalar `out` will have one
+        fewer dimensions than `arr`.
+
+    See Also
+    --------
+    apply_over_axes : Apply a function repeatedly over multiple axes.
+
+    Examples
+    --------
+    >>> def my_func(a):
+    ...     \"\"\"Average first and last element of a 1-D array\"\"\"
+    ...     return (a[0] + a[-1]) * 0.5
+    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
+    >>> np.apply_along_axis(my_func, 0, b)
+    array([4., 5., 6.])
+    >>> np.apply_along_axis(my_func, 1, b)
+    array([2.,  5.,  8.])
+
+    For a function that returns a 1D array, the number of dimensions in
+    `outarr` is the same as `arr`.
+
+    >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])
+    >>> np.apply_along_axis(sorted, 1, b)
+    array([[1, 7, 8],
+           [3, 4, 9],
+           [2, 5, 6]])
+
+    For a function that returns a higher dimensional array, those dimensions
+    are inserted in place of the `axis` dimension.
+
+    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
+    >>> np.apply_along_axis(np.diag, -1, b)
+    array([[[1, 0, 0],
+            [0, 2, 0],
+            [0, 0, 3]],
+           [[4, 0, 0],
+            [0, 5, 0],
+            [0, 0, 6]],
+           [[7, 0, 0],
+            [0, 8, 0],
+            [0, 0, 9]]])
+    " :arglists '[[& [args {:as kwargs}]]]} apply_along_axis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "apply_along_axis"))))
+
+(def ^{:doc "nextafter(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the next floating-point value after x1 towards x2, element-wise.
+
+Parameters
+----------
+x1 : array_like
+    Values to find the next representable value of.
+x2 : array_like
+    The direction where to look for the next representable value of `x1`.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    The next representable values of `x1` in the direction of `x2`.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+Examples
+--------
+>>> eps = np.finfo(np.float64).eps
+>>> np.nextafter(1, 2) == eps + 1
+True
+>>> np.nextafter([1, 2], [2, 1]) == [eps + 1, 2 - eps]
+array([ True,  True])" :arglists '[[self & [args {:as kwargs}]]]} nextafter (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nextafter"))))
+
+(def ^{:doc "
+    Return the cumulative sum of the elements along a given axis.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int, optional
+        Axis along which the cumulative sum is computed. The default
+        (None) is to compute the cumsum over the flattened array.
+    dtype : dtype, optional
+        Type of the returned array and of the accumulator in which the
+        elements are summed.  If `dtype` is not specified, it defaults
+        to the dtype of `a`, unless `a` has an integer dtype with a
+        precision less than that of the default platform integer.  In
+        that case, the default platform integer is used.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output
+        but the type will be cast if necessary. See :ref:`ufuncs-output-type` for
+        more details.
+
+    Returns
+    -------
+    cumsum_along_axis : ndarray.
+        A new array holding the result is returned unless `out` is
+        specified, in which case a reference to `out` is returned. The
+        result has the same size as `a`, and the same shape as `a` if
+        `axis` is not None or `a` is a 1-d array.
+
+
+    See Also
+    --------
+    sum : Sum array elements.
+
+    trapz : Integration of array values using the composite trapezoidal rule.
+
+    diff :  Calculate the n-th discrete difference along given axis.
+
+    Notes
+    -----
+    Arithmetic is modular when using integer types, and no error is
+    raised on overflow.
+
+    Examples
+    --------
+    >>> a = np.array([[1,2,3], [4,5,6]])
+    >>> a
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> np.cumsum(a)
+    array([ 1,  3,  6, 10, 15, 21])
+    >>> np.cumsum(a, dtype=float)     # specifies type of output value(s)
+    array([  1.,   3.,   6.,  10.,  15.,  21.])
+
+    >>> np.cumsum(a,axis=0)      # sum over rows for each of the 3 columns
+    array([[1, 2, 3],
+           [5, 7, 9]])
+    >>> np.cumsum(a,axis=1)      # sum over columns for each of the 2 rows
+    array([[ 1,  3,  6],
+           [ 4,  9, 15]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} cumsum (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cumsum"))))
+
+(def ^{:doc "
+    Return the Bartlett window.
+
+    The Bartlett window is very similar to a triangular window, except
+    that the end points are at zero.  It is often used in signal
+    processing for tapering a signal, without generating too much
+    ripple in the frequency domain.
+
+    Parameters
+    ----------
+    M : int
+        Number of points in the output window. If zero or less, an
+        empty array is returned.
+
+    Returns
+    -------
+    out : array
+        The triangular window, with the maximum value normalized to one
+        (the value one appears only if the number of samples is odd), with
+        the first and last samples equal to zero.
+
+    See Also
+    --------
+    blackman, hamming, hanning, kaiser
+
+    Notes
+    -----
+    The Bartlett window is defined as
+
+    .. math:: w(n) = \\frac{2}{M-1} \\left(
+              \\frac{M-1}{2} - \\left|n - \\frac{M-1}{2}\\right|
+              \\right)
+
+    Most references to the Bartlett window come from the signal
+    processing literature, where it is used as one of many windowing
+    functions for smoothing values.  Note that convolution with this
+    window produces linear interpolation.  It is also known as an
+    apodization (which means\"removing the foot\", i.e. smoothing
+    discontinuities at the beginning and end of the sampled signal) or
+    tapering function. The fourier transform of the Bartlett is the product
+    of two sinc functions.
+    Note the excellent discussion in Kanasewich.
+
+    References
+    ----------
+    .. [1] M.S. Bartlett, \"Periodogram Analysis and Continuous Spectra\",
+           Biometrika 37, 1-16, 1950.
+    .. [2] E.R. Kanasewich, \"Time Sequence Analysis in Geophysics\",
+           The University of Alberta Press, 1975, pp. 109-110.
+    .. [3] A.V. Oppenheim and R.W. Schafer, \"Discrete-Time Signal
+           Processing\", Prentice-Hall, 1999, pp. 468-471.
+    .. [4] Wikipedia, \"Window function\",
+           https://en.wikipedia.org/wiki/Window_function
+    .. [5] W.H. Press,  B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling,
+           \"Numerical Recipes\", Cambridge University Press, 1986, page 429.
+
+    Examples
+    --------
+    >>> import matplotlib.pyplot as plt
+    >>> np.bartlett(12)
+    array([ 0.        ,  0.18181818,  0.36363636,  0.54545455,  0.72727273, # may vary
+            0.90909091,  0.90909091,  0.72727273,  0.54545455,  0.36363636,
+            0.18181818,  0.        ])
+
+    Plot the window and its frequency response (requires SciPy and matplotlib):
+
+    >>> from numpy.fft import fft, fftshift
+    >>> window = np.bartlett(51)
+    >>> plt.plot(window)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Bartlett window\")
+    Text(0.5, 1.0, 'Bartlett window')
+    >>> plt.ylabel(\"Amplitude\")
+    Text(0, 0.5, 'Amplitude')
+    >>> plt.xlabel(\"Sample\")
+    Text(0.5, 0, 'Sample')
+    >>> plt.show()
+
+    >>> plt.figure()
+    <Figure size 640x480 with 0 Axes>
+    >>> A = fft(window, 2048) / 25.5
+    >>> mag = np.abs(fftshift(A))
+    >>> freq = np.linspace(-0.5, 0.5, len(A))
+    >>> with np.errstate(divide='ignore', invalid='ignore'):
+    ...     response = 20 * np.log10(mag)
+    ...
+    >>> response = np.clip(response, -100, 100)
+    >>> plt.plot(freq, response)
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.title(\"Frequency response of Bartlett window\")
+    Text(0.5, 1.0, 'Frequency response of Bartlett window')
+    >>> plt.ylabel(\"Magnitude [dB]\")
+    Text(0, 0.5, 'Magnitude [dB]')
+    >>> plt.xlabel(\"Normalized frequency [cycles per sample]\")
+    Text(0.5, 0, 'Normalized frequency [cycles per sample]')
+    >>> _ = plt.axis('tight')
+    >>> plt.show()
+
+    " :arglists '[[M]]} bartlett (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bartlett"))))
+
+(def ^{:doc "Boolean type (True or False), stored as a byte.
+
+    .. warning::
+
+       The :class:`bool_` type is not a subclass of the :class:`int_` type
+       (the :class:`bool_` is not even a number type). This is different
+       than Python's default implementation of :class:`bool` as a
+       sub-class of :class:`int`.
+
+    :Character code: ``'?'``
+    :Alias: `numpy.bool8`" :arglists '[[self & [args {:as kwargs}]]]} bool8 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bool8"))))
+
+(def ^{:doc "
+    Compute the arithmetic mean along the specified axis, ignoring NaNs.
+
+    Returns the average of the array elements.  The average is taken over
+    the flattened array by default, otherwise over the specified axis.
+    `float64` intermediate and return values are used for integer inputs.
+
+    For all-NaN slices, NaN is returned and a `RuntimeWarning` is raised.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose mean is desired. If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the means are computed. The default is to compute
+        the mean of the flattened array.
+    dtype : data-type, optional
+        Type to use in computing the mean.  For integer inputs, the default
+        is `float64`; for inexact inputs, it is the same as the input
+        dtype.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  The default
+        is ``None``; if provided, it must have the same shape as the
+        expected output, but the type will be cast if necessary. See
+        :ref:`ufuncs-output-type` for more details.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If the value is anything but the default, then
+        `keepdims` will be passed through to the `mean` or `sum` methods
+        of sub-classes of `ndarray`.  If the sub-classes methods
+        does not implement `keepdims` any exceptions will be raised.
+
+    Returns
+    -------
+    m : ndarray, see dtype parameter above
+        If `out=None`, returns a new array containing the mean values,
+        otherwise a reference to the output array is returned. Nan is
+        returned for slices that contain only NaNs.
+
+    See Also
+    --------
+    average : Weighted average
+    mean : Arithmetic mean taken while not ignoring NaNs
+    var, nanvar
+
+    Notes
+    -----
+    The arithmetic mean is the sum of the non-NaN elements along the axis
+    divided by the number of non-NaN elements.
+
+    Note that for floating-point input, the mean is computed using the same
+    precision the input has.  Depending on the input data, this can cause
+    the results to be inaccurate, especially for `float32`.  Specifying a
+    higher-precision accumulator using the `dtype` keyword can alleviate
+    this issue.
+
+    Examples
+    --------
+    >>> a = np.array([[1, np.nan], [3, 4]])
+    >>> np.nanmean(a)
+    2.6666666666666665
+    >>> np.nanmean(a, axis=0)
+    array([2.,  4.])
+    >>> np.nanmean(a, axis=1)
+    array([1.,  3.5]) # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]]} nanmean (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmean"))))
+
+(def ^{:doc "" :arglists '[[self & [args {:as kwargs}]]]} dtype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "dtype"))))
+
+(def ^{:doc "
+    Return numbers spaced evenly on a log scale (a geometric progression).
+
+    This is similar to `logspace`, but with endpoints specified directly.
+    Each output sample is a constant multiple of the previous.
+
+    .. versionchanged:: 1.16.0
+        Non-scalar `start` and `stop` are now supported.
+
+    Parameters
+    ----------
+    start : array_like
+        The starting value of the sequence.
+    stop : array_like
+        The final value of the sequence, unless `endpoint` is False.
+        In that case, ``num + 1`` values are spaced over the
+        interval in log-space, of which all but the last (a sequence of
+        length `num`) are returned.
+    num : integer, optional
+        Number of samples to generate.  Default is 50.
+    endpoint : boolean, optional
+        If true, `stop` is the last sample. Otherwise, it is not included.
+        Default is True.
+    dtype : dtype
+        The type of the output array.  If `dtype` is not given, the data type
+        is inferred from `start` and `stop`. The inferred dtype will never be
+        an integer; `float` is chosen even if the arguments would produce an
+        array of integers.
+    axis : int, optional
+        The axis in the result to store the samples.  Relevant only if start
+        or stop are array-like.  By default (0), the samples will be along a
+        new axis inserted at the beginning. Use -1 to get an axis at the end.
+
+        .. versionadded:: 1.16.0
+
+    Returns
+    -------
+    samples : ndarray
+        `num` samples, equally spaced on a log scale.
+
+    See Also
+    --------
+    logspace : Similar to geomspace, but with endpoints specified using log
+               and base.
+    linspace : Similar to geomspace, but with arithmetic instead of geometric
+               progression.
+    arange : Similar to linspace, with the step size specified instead of the
+             number of samples.
+
+    Notes
+    -----
+    If the inputs or dtype are complex, the output will follow a logarithmic
+    spiral in the complex plane.  (There are an infinite number of spirals
+    passing through two points; the output will follow the shortest such path.)
+
+    Examples
+    --------
+    >>> np.geomspace(1, 1000, num=4)
+    array([    1.,    10.,   100.,  1000.])
+    >>> np.geomspace(1, 1000, num=3, endpoint=False)
+    array([   1.,   10.,  100.])
+    >>> np.geomspace(1, 1000, num=4, endpoint=False)
+    array([   1.        ,    5.62341325,   31.6227766 ,  177.827941  ])
+    >>> np.geomspace(1, 256, num=9)
+    array([   1.,    2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.])
+
+    Note that the above may not produce exact integers:
+
+    >>> np.geomspace(1, 256, num=9, dtype=int)
+    array([  1,   2,   4,   7,  16,  32,  63, 127, 256])
+    >>> np.around(np.geomspace(1, 256, num=9)).astype(int)
+    array([  1,   2,   4,   8,  16,  32,  64, 128, 256])
+
+    Negative, decreasing, and complex inputs are allowed:
+
+    >>> np.geomspace(1000, 1, num=4)
+    array([1000.,  100.,   10.,    1.])
+    >>> np.geomspace(-1000, -1, num=4)
+    array([-1000.,  -100.,   -10.,    -1.])
+    >>> np.geomspace(1j, 1000j, num=4)  # Straight line
+    array([0.   +1.j, 0.  +10.j, 0. +100.j, 0.+1000.j])
+    >>> np.geomspace(-1+0j, 1+0j, num=5)  # Circle
+    array([-1.00000000e+00+1.22464680e-16j, -7.07106781e-01+7.07106781e-01j,
+            6.12323400e-17+1.00000000e+00j,  7.07106781e-01+7.07106781e-01j,
+            1.00000000e+00+0.00000000e+00j])
+
+    Graphical illustration of ``endpoint`` parameter:
+
+    >>> import matplotlib.pyplot as plt
+    >>> N = 10
+    >>> y = np.zeros(N)
+    >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=True), y + 1, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.semilogx(np.geomspace(1, 1000, N, endpoint=False), y + 2, 'o')
+    [<matplotlib.lines.Line2D object at 0x...>]
+    >>> plt.axis([0.5, 2000, 0, 3])
+    [0.5, 2000, 0, 3]
+    >>> plt.grid(True, color='0.7', linestyle='-', which='both', axis='both')
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]]} geomspace (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "geomspace"))))
+
+(def ^{:doc "
+    Round an array to the given number of decimals.
+
+    See Also
+    --------
+    around : equivalent function; see for details.
+    " :arglists '[[& [args {:as kwargs}]]]} round (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "round"))))
+
+(def ^{:doc "Unsigned integer type, compatible with C ``unsigned long``.
+
+    :Character code: ``'L'``
+    :Canonical name: `numpy.uint`
+    :Alias on this platform: `numpy.uint64`: 64-bit unsigned integer (``0`` to ``18_446_744_073_709_551_615``).
+    :Alias on this platform: `numpy.uintp`: Unsigned integer large enough to fit pointer, compatible with C ``uintptr_t``." :arglists '[[self & [args {:as kwargs}]]]} uintp (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "uintp"))))
+
+(def ^{:doc "Unsigned integer type, compatible with C ``unsigned char``.
+
+    :Character code: ``'B'``
+    :Canonical name: `numpy.ubyte`
+    :Alias on this platform: `numpy.uint8`: 8-bit unsigned integer (``0`` to ``255``)." :arglists '[[self & [args {:as kwargs}]]]} ubyte (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ubyte"))))
+
+(def ^{:doc "
+    Upper triangle of an array.
+
+    Return a copy of an array with the elements below the `k`-th diagonal
+    zeroed.
+
+    Please refer to the documentation for `tril` for further details.
+
+    See Also
+    --------
+    tril : lower triangle of an array
+
+    Examples
+    --------
+    >>> np.triu([[1,2,3],[4,5,6],[7,8,9],[10,11,12]], -1)
+    array([[ 1,  2,  3],
+           [ 4,  5,  6],
+           [ 0,  8,  9],
+           [ 0,  0, 12]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} triu (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "triu"))))
+
+(def ^{:doc "
+    Create a two-dimensional array with the flattened input as a diagonal.
+
+    Parameters
+    ----------
+    v : array_like
+        Input data, which is flattened and set as the `k`-th
+        diagonal of the output.
+    k : int, optional
+        Diagonal to set; 0, the default, corresponds to the \"main\" diagonal,
+        a positive (negative) `k` giving the number of the diagonal above
+        (below) the main.
+
+    Returns
+    -------
+    out : ndarray
+        The 2-D output array.
+
+    See Also
+    --------
+    diag : MATLAB work-alike for 1-D and 2-D arrays.
+    diagonal : Return specified diagonals.
+    trace : Sum along diagonals.
+
+    Examples
+    --------
+    >>> np.diagflat([[1,2], [3,4]])
+    array([[1, 0, 0, 0],
+           [0, 2, 0, 0],
+           [0, 0, 3, 0],
+           [0, 0, 0, 4]])
+
+    >>> np.diagflat([1,2], 1)
+    array([[0, 1, 0],
+           [0, 0, 2],
+           [0, 0, 0]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} diagflat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "diagflat"))))
+
+(def ^{:doc "Any Python object.
+
+    :Character code: ``'O'``" :arglists '[[self & [args {:as kwargs}]]]} object_ (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "object_"))))
+
+(def ^{:doc "
+    Return True if x is a not complex type or an array of complex numbers.
+
+    The type of the input is checked, not the value. So even if the input
+    has an imaginary part equal to zero, `isrealobj` evaluates to False
+    if the data type is complex.
+
+    Parameters
+    ----------
+    x : any
+        The input can be of any type and shape.
+
+    Returns
+    -------
+    y : bool
+        The return value, False if `x` is of a complex type.
+
+    See Also
+    --------
+    iscomplexobj, isreal
+
+    Examples
+    --------
+    >>> np.isrealobj(1)
+    True
+    >>> np.isrealobj(1+0j)
+    False
+    >>> np.isrealobj([3, 1+0j, True])
+    False
+
+    " :arglists '[[& [args {:as kwargs}]]]} isrealobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "isrealobj"))))
+
+(def ^{:doc ""} __name__ "numpy")
+
+(def ^{:doc "
+Record Arrays
+=============
+Record arrays expose the fields of structured arrays as properties.
+
+Most commonly, ndarrays contain elements of a single type, e.g. floats,
+integers, bools etc.  However, it is possible for elements to be combinations
+of these using structured types, such as::
+
+  >>> a = np.array([(1, 2.0), (1, 2.0)], dtype=[('x', np.int64), ('y', np.float64)])
+  >>> a
+  array([(1, 2.), (1, 2.)], dtype=[('x', '<i8'), ('y', '<f8')])
+
+Here, each element consists of two fields: x (and int), and y (a float).
+This is known as a structured array.  The different fields are analogous
+to columns in a spread-sheet.  The different fields can be accessed as
+one would a dictionary::
+
+  >>> a['x']
+  array([1, 1])
+
+  >>> a['y']
+  array([2., 2.])
+
+Record arrays allow us to access fields as properties::
+
+  >>> ar = np.rec.array(a)
+
+  >>> ar.x
+  array([1, 1])
+
+  >>> ar.y
+  array([2., 2.])
+
+"} rec (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "rec"))))
+
+(def ^{:doc ""} euler_gamma 0.5772156649015329)
+
+(def ^{:doc "Complex number type composed of two double-precision floating-point
+    numbers, compatible with Python `complex`.
+
+    :Character code: ``'D'``
+    :Canonical name: `numpy.cdouble`
+    :Alias: `numpy.cfloat`
+    :Alias: `numpy.complex_`
+    :Alias on this platform: `numpy.complex128`: Complex number type composed of 2 64-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} cfloat (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "cfloat"))))
+
+(def ^{:doc "
+    Stack arrays in sequence horizontally (column wise).
+
+    This is equivalent to concatenation along the second axis, except for 1-D
+    arrays where it concatenates along the first axis. Rebuilds arrays divided
+    by `hsplit`.
+
+    This function makes most sense for arrays with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of ndarrays
+        The arrays must have the same shape along all but the second axis,
+        except 1-D arrays which can be any length.
+
+    Returns
+    -------
+    stacked : ndarray
+        The array formed by stacking the given arrays.
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays along an existing axis.
+    stack : Join a sequence of arrays along a new axis.
+    block : Assemble an nd-array from nested lists of blocks.
+    vstack : Stack arrays in sequence vertically (row wise).
+    dstack : Stack arrays in sequence depth wise (along third axis).
+    column_stack : Stack 1-D arrays as columns into a 2-D array.
+    hsplit : Split an array into multiple sub-arrays horizontally (column-wise).
+
+    Examples
+    --------
+    >>> a = np.array((1,2,3))
+    >>> b = np.array((2,3,4))
+    >>> np.hstack((a,b))
+    array([1, 2, 3, 2, 3, 4])
+    >>> a = np.array([[1],[2],[3]])
+    >>> b = np.array([[2],[3],[4]])
+    >>> np.hstack((a,b))
+    array([[1, 2],
+           [2, 3],
+           [3, 4]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} hstack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hstack"))))
+
+(def ^{:doc "
+    Base object for a dictionary for look-up with any alias for an array dtype.
+
+    Instances of `_typedict` can not be used as dictionaries directly,
+    first they have to be populated.
+
+    "} nbytes (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "nbytes"))))
+
+(def ^{:doc "
+    Compute the median along the specified axis, while ignoring NaNs.
+
+    Returns the median of the array elements.
+
+    .. versionadded:: 1.9.0
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : {int, sequence of int, None}, optional
+        Axis or axes along which the medians are computed. The default
+        is to compute the median along a flattened version of the array.
+        A sequence of axes is supported since version 1.9.0.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+       If True, then allow use of memory of input array `a` for
+       calculations. The input array will be modified by the call to
+       `median`. This will save memory when you do not need to preserve
+       the contents of the input array. Treat the input as undefined,
+       but it will probably be fully or partially sorted. Default is
+       False. If `overwrite_input` is ``True`` and `a` is not already an
+       `ndarray`, an error will be raised.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+        If this is anything but the default value it will be passed
+        through (in the special case of an empty array) to the
+        `mean` function of the underlying array.  If the array is
+        a sub-class and `mean` does not have the kwarg `keepdims` this
+        will raise a RuntimeError.
+
+    Returns
+    -------
+    median : ndarray
+        A new array holding the result. If the input contains integers
+        or floats smaller than ``float64``, then the output data-type is
+        ``np.float64``.  Otherwise, the data-type of the output is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean, median, percentile
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the median of ``V`` is the
+    middle value of a sorted copy of ``V``, ``V_sorted`` - i.e.,
+    ``V_sorted[(N-1)/2]``, when ``N`` is odd and the average of the two
+    middle values of ``V_sorted`` when ``N`` is even.
+
+    Examples
+    --------
+    >>> a = np.array([[10.0, 7, 4], [3, 2, 1]])
+    >>> a[0, 1] = np.nan
+    >>> a
+    array([[10., nan,  4.],
+           [ 3.,  2.,  1.]])
+    >>> np.median(a)
+    nan
+    >>> np.nanmedian(a)
+    3.0
+    >>> np.nanmedian(a, axis=0)
+    array([6.5, 2. , 2.5])
+    >>> np.median(a, axis=1)
+    array([nan,  2.])
+    >>> b = a.copy()
+    >>> np.nanmedian(b, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a==b)
+    >>> b = a.copy()
+    >>> np.nanmedian(b, axis=None, overwrite_input=True)
+    3.0
+    >>> assert not np.all(a==b)
+
+    " :arglists '[[& [args {:as kwargs}]]]} nanmedian (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanmedian"))))
+
+(def ^{:doc "sign(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Returns an element-wise indication of the sign of a number.
+
+The `sign` function returns ``-1 if x < 0, 0 if x==0, 1 if x > 0``.  nan
+is returned for nan inputs.
+
+For complex inputs, the `sign` function returns
+``sign(x.real) + 0j if x.real != 0 else sign(x.imag) + 0j``.
+
+complex(nan, 0) is returned for complex nan inputs.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The sign of `x`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+There is more than one definition of sign in common use for complex
+numbers.  The definition used here is equivalent to :math:`x/\\sqrt{x*x}`
+which is different from a common alternative, :math:`x/|x|`.
+
+Examples
+--------
+>>> np.sign([-5., 4.5])
+array([-1.,  1.])
+>>> np.sign(0)
+0
+>>> np.sign(5-2j)
+(1+0j)" :arglists '[[self & [args {:as kwargs}]]]} sign (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "sign"))))
+
+(def ^{:doc "
+Discrete Fourier Transform (:mod:`numpy.fft`)
+=============================================
+
+.. currentmodule:: numpy.fft
+
+The SciPy module `scipy.fft` is a more comprehensive superset
+of ``numpy.fft``, which includes only a basic set of routines.
+
+Standard FFTs
+-------------
+
+.. autosummary::
+   :toctree: generated/
+
+   fft       Discrete Fourier transform.
+   ifft      Inverse discrete Fourier transform.
+   fft2      Discrete Fourier transform in two dimensions.
+   ifft2     Inverse discrete Fourier transform in two dimensions.
+   fftn      Discrete Fourier transform in N-dimensions.
+   ifftn     Inverse discrete Fourier transform in N dimensions.
+
+Real FFTs
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+   rfft      Real discrete Fourier transform.
+   irfft     Inverse real discrete Fourier transform.
+   rfft2     Real discrete Fourier transform in two dimensions.
+   irfft2    Inverse real discrete Fourier transform in two dimensions.
+   rfftn     Real discrete Fourier transform in N dimensions.
+   irfftn    Inverse real discrete Fourier transform in N dimensions.
+
+Hermitian FFTs
+--------------
+
+.. autosummary::
+   :toctree: generated/
+
+   hfft      Hermitian discrete Fourier transform.
+   ihfft     Inverse Hermitian discrete Fourier transform.
+
+Helper routines
+---------------
+
+.. autosummary::
+   :toctree: generated/
+
+   fftfreq   Discrete Fourier Transform sample frequencies.
+   rfftfreq  DFT sample frequencies (for usage with rfft, irfft).
+   fftshift  Shift zero-frequency component to center of spectrum.
+   ifftshift Inverse of fftshift.
+
+
+Background information
+----------------------
+
+Fourier analysis is fundamentally a method for expressing a function as a
+sum of periodic components, and for recovering the function from those
+components.  When both the function and its Fourier transform are
+replaced with discretized counterparts, it is called the discrete Fourier
+transform (DFT).  The DFT has become a mainstay of numerical computing in
+part because of a very fast algorithm for computing it, called the Fast
+Fourier Transform (FFT), which was known to Gauss (1805) and was brought
+to light in its current form by Cooley and Tukey [CT]_.  Press et al. [NR]_
+provide an accessible introduction to Fourier analysis and its
+applications.
+
+Because the discrete Fourier transform separates its input into
+components that contribute at discrete frequencies, it has a great number
+of applications in digital signal processing, e.g., for filtering, and in
+this context the discretized input to the transform is customarily
+referred to as a *signal*, which exists in the *time domain*.  The output
+is called a *spectrum* or *transform* and exists in the *frequency
+domain*.
+
+Implementation details
+----------------------
+
+There are many ways to define the DFT, varying in the sign of the
+exponent, normalization, etc.  In this implementation, the DFT is defined
+as
+
+.. math::
+   A_k =  \\sum_{m=0}^{n-1} a_m \\exp\\left\\{-2\\pi i{mk \\over n}\\right\\}
+   \\qquad k = 0,\\ldots,n-1.
+
+The DFT is in general defined for complex inputs and outputs, and a
+single-frequency component at linear frequency :math:`f` is
+represented by a complex exponential
+:math:`a_m = \\exp\\{2\\pi i\\,f m\\Delta t\\}`, where :math:`\\Delta t`
+is the sampling interval.
+
+The values in the result follow so-called \"standard\" order: If ``A =
+fft(a, n)``, then ``A[0]`` contains the zero-frequency term (the sum of
+the signal), which is always purely real for real inputs. Then ``A[1:n/2]``
+contains the positive-frequency terms, and ``A[n/2+1:]`` contains the
+negative-frequency terms, in order of decreasingly negative frequency.
+For an even number of input points, ``A[n/2]`` represents both positive and
+negative Nyquist frequency, and is also purely real for real input.  For
+an odd number of input points, ``A[(n-1)/2]`` contains the largest positive
+frequency, while ``A[(n+1)/2]`` contains the largest negative frequency.
+The routine ``np.fft.fftfreq(n)`` returns an array giving the frequencies
+of corresponding elements in the output.  The routine
+``np.fft.fftshift(A)`` shifts transforms and their frequencies to put the
+zero-frequency components in the middle, and ``np.fft.ifftshift(A)`` undoes
+that shift.
+
+When the input `a` is a time-domain signal and ``A = fft(a)``, ``np.abs(A)``
+is its amplitude spectrum and ``np.abs(A)**2`` is its power spectrum.
+The phase spectrum is obtained by ``np.angle(A)``.
+
+The inverse DFT is defined as
+
+.. math::
+   a_m = \\frac{1}{n}\\sum_{k=0}^{n-1}A_k\\exp\\left\\{2\\pi i{mk\\over n}\\right\\}
+   \\qquad m = 0,\\ldots,n-1.
+
+It differs from the forward transform by the sign of the exponential
+argument and the default normalization by :math:`1/n`.
+
+Type Promotion
+--------------
+
+`numpy.fft` promotes ``float32`` and ``complex64`` arrays to ``float64`` and
+``complex128`` arrays respectively. For an FFT implementation that does not
+promote input arrays, see `scipy.fftpack`.
+
+Normalization
+-------------
+
+The argument ``norm`` indicates which direction of the pair of direct/inverse
+transforms is scaled and with what normalization factor.
+The default normalization (``\"backward\"``) has the direct (forward) transforms
+unscaled and the inverse (backward) transforms scaled by :math:`1/n`. It is
+possible to obtain unitary transforms by setting the keyword argument ``norm``
+to ``\"ortho\"`` so that both direct and inverse transforms are scaled by
+:math:`1/\\sqrt{n}`. Finally, setting the keyword argument ``norm`` to
+``\"forward\"`` has the direct transforms scaled by :math:`1/n` and the inverse
+transforms unscaled (i.e. exactly opposite to the default ``\"backward\"``).
+`None` is an alias of the default option ``\"backward\"`` for backward
+compatibility.
+
+Real and Hermitian transforms
+-----------------------------
+
+When the input is purely real, its transform is Hermitian, i.e., the
+component at frequency :math:`f_k` is the complex conjugate of the
+component at frequency :math:`-f_k`, which means that for real
+inputs there is no information in the negative frequency components that
+is not already available from the positive frequency components.
+The family of `rfft` functions is
+designed to operate on real inputs, and exploits this symmetry by
+computing only the positive frequency components, up to and including the
+Nyquist frequency.  Thus, ``n`` input points produce ``n/2+1`` complex
+output points.  The inverses of this family assumes the same symmetry of
+its input, and for an output of ``n`` points uses ``n/2+1`` input points.
+
+Correspondingly, when the spectrum is purely real, the signal is
+Hermitian.  The `hfft` family of functions exploits this symmetry by
+using ``n/2+1`` complex points in the input (time) domain for ``n`` real
+points in the frequency domain.
+
+In higher dimensions, FFTs are used, e.g., for image analysis and
+filtering.  The computational efficiency of the FFT means that it can
+also be a faster way to compute large convolutions, using the property
+that a convolution in the time domain is equivalent to a point-by-point
+multiplication in the frequency domain.
+
+Higher dimensions
+-----------------
+
+In two dimensions, the DFT is defined as
+
+.. math::
+   A_{kl} =  \\sum_{m=0}^{M-1} \\sum_{n=0}^{N-1}
+   a_{mn}\\exp\\left\\{-2\\pi i \\left({mk\\over M}+{nl\\over N}\\right)\\right\\}
+   \\qquad k = 0, \\ldots, M-1;\\quad l = 0, \\ldots, N-1,
+
+which extends in the obvious way to higher dimensions, and the inverses
+in higher dimensions also extend in the same way.
+
+References
+----------
+
+.. [CT] Cooley, James W., and John W. Tukey, 1965, \"An algorithm for the
+        machine calculation of complex Fourier series,\" *Math. Comput.*
+        19: 297-301.
+
+.. [NR] Press, W., Teukolsky, S., Vetterline, W.T., and Flannery, B.P.,
+        2007, *Numerical Recipes: The Art of Scientific Computing*, ch.
+        12-13.  Cambridge Univ. Press, Cambridge, UK.
+
+Examples
+--------
+
+For examples, see the various functions.
+
+"} fft (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "fft"))))
+
+(def ^{:doc "
+    finfo(dtype)
+
+    Machine limits for floating point types.
+
+    Attributes
+    ----------
+    bits : int
+        The number of bits occupied by the type.
+    eps : float
+        The difference between 1.0 and the next smallest representable float
+        larger than 1.0. For example, for 64-bit binary floats in the IEEE-754
+        standard, ``eps = 2**-52``, approximately 2.22e-16.
+    epsneg : float
+        The difference between 1.0 and the next smallest representable float
+        less than 1.0. For example, for 64-bit binary floats in the IEEE-754
+        standard, ``epsneg = 2**-53``, approximately 1.11e-16.
+    iexp : int
+        The number of bits in the exponent portion of the floating point
+        representation.
+    machar : MachAr
+        The object which calculated these parameters and holds more
+        detailed information.
+    machep : int
+        The exponent that yields `eps`.
+    max : floating point number of the appropriate type
+        The largest representable number.
+    maxexp : int
+        The smallest positive power of the base (2) that causes overflow.
+    min : floating point number of the appropriate type
+        The smallest representable number, typically ``-max``.
+    minexp : int
+        The most negative power of the base (2) consistent with there
+        being no leading 0's in the mantissa.
+    negep : int
+        The exponent that yields `epsneg`.
+    nexp : int
+        The number of bits in the exponent including its sign and bias.
+    nmant : int
+        The number of bits in the mantissa.
+    precision : int
+        The approximate number of decimal digits to which this kind of
+        float is precise.
+    resolution : floating point number of the appropriate type
+        The approximate decimal resolution of this type, i.e.,
+        ``10**-precision``.
+    tiny : float
+        The smallest positive floating point number with full precision
+        (see Notes).
+
+    Parameters
+    ----------
+    dtype : float, dtype, or instance
+        Kind of floating point data-type about which to get information.
+
+    See Also
+    --------
+    MachAr : The implementation of the tests that produce this information.
+    iinfo : The equivalent for integer data types.
+    spacing : The distance between a value and the nearest adjacent number
+    nextafter : The next floating point value after x1 towards x2
+
+    Notes
+    -----
+    For developers of NumPy: do not instantiate this at the module level.
+    The initial calculation of these parameters is expensive and negatively
+    impacts import times.  These objects are cached, so calling ``finfo()``
+    repeatedly inside your functions is not a problem.
+
+    Note that ``tiny`` is not actually the smallest positive representable
+    value in a NumPy floating point type. As in the IEEE-754 standard [1]_,
+    NumPy floating point types make use of subnormal numbers to fill the
+    gap between 0 and ``tiny``. However, subnormal numbers may have
+    significantly reduced precision [2]_.
+    
+    References
+    ----------
+    .. [1] IEEE Standard for Floating-Point Arithmetic, IEEE Std 754-2008,
+           pp.1-70, 2008, http://www.doi.org/10.1109/IEEESTD.2008.4610935
+    .. [2] Wikipedia, \"Denormal Numbers\",
+           https://en.wikipedia.org/wiki/Denormal_number
+    " :arglists '[[self & [args {:as kwargs}]]]} finfo (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "finfo"))))
+
+(def ^{:doc "
+    Returns True if first argument is a typecode lower/equal in type hierarchy.
+
+    This is like the builtin :func:`issubclass`, but for `dtype`\\ s.
+
+    Parameters
+    ----------
+    arg1, arg2 : dtype_like
+        `dtype` or object coercible to one
+
+    Returns
+    -------
+    out : bool
+
+    See Also
+    --------
+    :ref:`arrays.scalars` : Overview of the numpy type hierarchy.
+    issubsctype, issubclass_
+
+    Examples
+    --------
+    `issubdtype` can be used to check the type of arrays:
+
+    >>> ints = np.array([1, 2, 3], dtype=np.int32)
+    >>> np.issubdtype(ints.dtype, np.integer)
+    True
+    >>> np.issubdtype(ints.dtype, np.floating)
+    False
+
+    >>> floats = np.array([1, 2, 3], dtype=np.float32)
+    >>> np.issubdtype(floats.dtype, np.integer)
+    False
+    >>> np.issubdtype(floats.dtype, np.floating)
+    True
+
+    Similar types of different sizes are not subdtypes of each other:
+
+    >>> np.issubdtype(np.float64, np.float32)
+    False
+    >>> np.issubdtype(np.float32, np.float64)
+    False
+
+    but both are subtypes of `floating`:
+
+    >>> np.issubdtype(np.float64, np.floating)
+    True
+    >>> np.issubdtype(np.float32, np.floating)
+    True
+
+    For convenience, dtype-like objects are allowed too:
+
+    >>> np.issubdtype('S1', np.string_)
+    True
+    >>> np.issubdtype('i4', np.signedinteger)
+    True
+
+    " :arglists '[[arg1 arg2]]} issubdtype (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "issubdtype"))))
+
+(def ^{:doc "array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0,
+          like=None)
+
+    Create an array.
+
+    Parameters
+    ----------
+    object : array_like
+        An array, any object exposing the array interface, an object whose
+        __array__ method returns an array, or any (nested) sequence.
+    dtype : data-type, optional
+        The desired data-type for the array.  If not given, then the type will
+        be determined as the minimum type required to hold the objects in the
+        sequence.
+    copy : bool, optional
+        If true (default), then the object is copied.  Otherwise, a copy will
+        only be made if __array__ returns a copy, if obj is a nested sequence,
+        or if a copy is needed to satisfy any of the other requirements
+        (`dtype`, `order`, etc.).
+    order : {'K', 'A', 'C', 'F'}, optional
+        Specify the memory layout of the array. If object is not an array, the
+        newly created array will be in C order (row major) unless 'F' is
+        specified, in which case it will be in Fortran order (column major).
+        If object is an array the following holds.
+
+        ===== ========= ===================================================
+        order  no copy                     copy=True
+        ===== ========= ===================================================
+        'K'   unchanged F & C order preserved, otherwise most similar order
+        'A'   unchanged F order if input is F and not C, otherwise C order
+        'C'   C order   C order
+        'F'   F order   F order
+        ===== ========= ===================================================
+
+        When ``copy=False`` and a copy is made for other reasons, the result is
+        the same as if ``copy=True``, with some exceptions for `A`, see the
+        Notes section. The default order is 'K'.
+    subok : bool, optional
+        If True, then sub-classes will be passed-through, otherwise
+        the returned array will be forced to be a base-class array (default).
+    ndmin : int, optional
+        Specifies the minimum number of dimensions that the resulting
+        array should have.  Ones will be pre-pended to the shape as
+        needed to meet this requirement.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        An array object satisfying the specified requirements.
+
+    See Also
+    --------
+    empty_like : Return an empty array with shape and type of input.
+    ones_like : Return an array of ones with shape and type of input.
+    zeros_like : Return an array of zeros with shape and type of input.
+    full_like : Return a new array with shape of input filled with value.
+    empty : Return a new uninitialized array.
+    ones : Return a new array setting values to one.
+    zeros : Return a new array setting values to zero.
+    full : Return a new array of given shape filled with value.
+
+
+    Notes
+    -----
+    When order is 'A' and `object` is an array in neither 'C' nor 'F' order,
+    and a copy is forced by a change in dtype, then the order of the result is
+    not necessarily 'C' as expected. This is likely a bug.
+
+    Examples
+    --------
+    >>> np.array([1, 2, 3])
+    array([1, 2, 3])
+
+    Upcasting:
+
+    >>> np.array([1, 2, 3.0])
+    array([ 1.,  2.,  3.])
+
+    More than one dimension:
+
+    >>> np.array([[1, 2], [3, 4]])
+    array([[1, 2],
+           [3, 4]])
+
+    Minimum dimensions 2:
+
+    >>> np.array([1, 2, 3], ndmin=2)
+    array([[1, 2, 3]])
+
+    Type provided:
+
+    >>> np.array([1, 2, 3], dtype=complex)
+    array([ 1.+0.j,  2.+0.j,  3.+0.j])
+
+    Data-type consisting of more than one element:
+
+    >>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
+    >>> x['a']
+    array([1, 3])
+
+    Creating an array from sub-classes:
+
+    >>> np.array(np.mat('1 2; 3 4'))
+    array([[1, 2],
+           [3, 4]])
+
+    >>> np.array(np.mat('1 2; 3 4'), subok=True)
+    matrix([[1, 2],
+            [3, 4]])" :arglists '[[self & [args {:as kwargs}]]]} array (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array"))))
+
+(def ^{:doc "logaddexp2(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Logarithm of the sum of exponentiations of the inputs in base-2.
+
+Calculates ``log2(2**x1 + 2**x2)``. This function is useful in machine
+learning when the calculated probabilities of events may be so small as
+to exceed the range of normal floating point numbers.  In such cases
+the base-2 logarithm of the calculated probability can be used instead.
+This function allows adding probabilities stored in such a fashion.
+
+Parameters
+----------
+x1, x2 : array_like
+    Input values.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+result : ndarray
+    Base-2 logarithm of ``2**x1 + 2**x2``.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logaddexp: Logarithm of the sum of exponentiations of the inputs.
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+Examples
+--------
+>>> prob1 = np.log2(1e-50)
+>>> prob2 = np.log2(2.5e-50)
+>>> prob12 = np.logaddexp2(prob1, prob2)
+>>> prob1, prob2, prob12
+(-166.09640474436813, -164.77447664948076, -164.28904982231052)
+>>> 2**prob12
+3.4999999999999914e-50" :arglists '[[self & [args {:as kwargs}]]]} logaddexp2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "logaddexp2"))))
+
+(def ^{:doc "
+    Reverse or permute the axes of an array; returns the modified array.
+
+    For an array a with two axes, transpose(a) gives the matrix transpose.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axes : tuple or list of ints, optional
+        If specified, it must be a tuple or list which contains a permutation of
+        [0,1,..,N-1] where N is the number of axes of a.  The i'th axis of the
+        returned array will correspond to the axis numbered ``axes[i]`` of the
+        input.  If not specified, defaults to ``range(a.ndim)[::-1]``, which
+        reverses the order of the axes.
+
+    Returns
+    -------
+    p : ndarray
+        `a` with its axes permuted.  A view is returned whenever
+        possible.
+
+    See Also
+    --------
+    moveaxis
+    argsort
+
+    Notes
+    -----
+    Use `transpose(a, argsort(axes))` to invert the transposition of tensors
+    when using the `axes` keyword argument.
+
+    Transposing a 1-D array returns an unchanged view of the original array.
+
+    Examples
+    --------
+    >>> x = np.arange(4).reshape((2,2))
+    >>> x
+    array([[0, 1],
+           [2, 3]])
+
+    >>> np.transpose(x)
+    array([[0, 2],
+           [1, 3]])
+
+    >>> x = np.ones((1, 2, 3))
+    >>> np.transpose(x, (1, 0, 2)).shape
+    (2, 1, 3)
+
+    >>> x = np.ones((2, 3, 4, 5))
+    >>> np.transpose(x).shape
+    (5, 4, 3, 2)
+
+    " :arglists '[[& [args {:as kwargs}]]]} transpose (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "transpose"))))
+
+(def ^{:doc "
+    Return the indices for the lower-triangle of an (n, m) array.
+
+    Parameters
+    ----------
+    n : int
+        The row dimension of the arrays for which the returned
+        indices will be valid.
+    k : int, optional
+        Diagonal offset (see `tril` for details).
+    m : int, optional
+        .. versionadded:: 1.9.0
+
+        The column dimension of the arrays for which the returned
+        arrays will be valid.
+        By default `m` is taken equal to `n`.
+
+
+    Returns
+    -------
+    inds : tuple of arrays
+        The indices for the triangle. The returned tuple contains two arrays,
+        each with the indices along one dimension of the array.
+
+    See also
+    --------
+    triu_indices : similar function, for upper-triangular.
+    mask_indices : generic function accepting an arbitrary mask function.
+    tril, triu
+
+    Notes
+    -----
+    .. versionadded:: 1.4.0
+
+    Examples
+    --------
+    Compute two different sets of indices to access 4x4 arrays, one for the
+    lower triangular part starting at the main diagonal, and one starting two
+    diagonals further right:
+
+    >>> il1 = np.tril_indices(4)
+    >>> il2 = np.tril_indices(4, 2)
+
+    Here is how they can be used with a sample array:
+
+    >>> a = np.arange(16).reshape(4, 4)
+    >>> a
+    array([[ 0,  1,  2,  3],
+           [ 4,  5,  6,  7],
+           [ 8,  9, 10, 11],
+           [12, 13, 14, 15]])
+
+    Both for indexing:
+
+    >>> a[il1]
+    array([ 0,  4,  5, ..., 13, 14, 15])
+
+    And for assigning values:
+
+    >>> a[il1] = -1
+    >>> a
+    array([[-1,  1,  2,  3],
+           [-1, -1,  6,  7],
+           [-1, -1, -1, 11],
+           [-1, -1, -1, -1]])
+
+    These cover almost the whole array (two diagonals right of the main one):
+
+    >>> a[il2] = -10
+    >>> a
+    array([[-10, -10, -10,   3],
+           [-10, -10, -10, -10],
+           [-10, -10, -10, -10],
+           [-10, -10, -10, -10]])
+
+    " :arglists '[[n & [{k :k, m :m}]] [n & [{k :k}]] [n]]} tril_indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tril_indices"))))
+
+(def ^{:doc "Convert the input to an array, checking for NaNs or Infs.
+
+    Parameters
+    ----------
+    a : array_like
+        Input data, in any form that can be converted to an array.  This
+        includes lists, lists of tuples, tuples, tuples of tuples, tuples
+        of lists and ndarrays.  Success requires no NaNs or Infs.
+    dtype : data-type, optional
+        By default, the data-type is inferred from the input data.
+    order : {'C', 'F', 'A', 'K'}, optional
+        Memory layout.  'A' and 'K' depend on the order of input array a.
+        'C' row-major (C-style),
+        'F' column-major (Fortran-style) memory representation.
+        'A' (any) means 'F' if `a` is Fortran contiguous, 'C' otherwise
+        'K' (keep) preserve input order
+        Defaults to 'C'.
+
+    Returns
+    -------
+    out : ndarray
+        Array interpretation of `a`.  No copy is performed if the input
+        is already an ndarray.  If `a` is a subclass of ndarray, a base
+        class ndarray is returned.
+
+    Raises
+    ------
+    ValueError
+        Raises ValueError if `a` contains NaN (Not a Number) or Inf (Infinity).
+
+    See Also
+    --------
+    asarray : Create and array.
+    asanyarray : Similar function which passes through subclasses.
+    ascontiguousarray : Convert input to a contiguous array.
+    asfarray : Convert input to a floating point ndarray.
+    asfortranarray : Convert input to an ndarray with column-major
+                     memory order.
+    fromiter : Create an array from an iterator.
+    fromfunction : Construct an array by executing a function on grid
+                   positions.
+
+    Examples
+    --------
+    Convert a list into an array.  If all elements are finite
+    ``asarray_chkfinite`` is identical to ``asarray``.
+
+    >>> a = [1, 2]
+    >>> np.asarray_chkfinite(a, dtype=float)
+    array([1., 2.])
+
+    Raises ValueError if array_like contains Nans or Infs.
+
+    >>> a = [1, 2, np.inf]
+    >>> try:
+    ...     np.asarray_chkfinite(a)
+    ... except ValueError:
+    ...     print('ValueError')
+    ...
+    ValueError
+
+    " :arglists '[[a & [{dtype :dtype, order :order}]] [a & [{dtype :dtype}]] [a]]} asarray_chkfinite (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "asarray_chkfinite"))))
+
+(def ^{:doc "arccos(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Trigonometric inverse cosine, element-wise.
+
+The inverse of `cos` so that, if ``y = cos(x)``, then ``x = arccos(y)``.
+
+Parameters
+----------
+x : array_like
+    `x`-coordinate on the unit circle.
+    For real arguments, the domain is [-1, 1].
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+angle : ndarray
+    The angle of the ray intersecting the unit circle at the given
+    `x`-coordinate in radians [0, pi].
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+cos, arctan, arcsin, emath.arccos
+
+Notes
+-----
+`arccos` is a multivalued function: for each `x` there are infinitely
+many numbers `z` such that `cos(z) = x`. The convention is to return
+the angle `z` whose real part lies in `[0, pi]`.
+
+For real-valued input data types, `arccos` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arccos` is a complex analytic function that
+has branch cuts `[-inf, -1]` and `[1, inf]` and is continuous from
+above on the former and from below on the latter.
+
+The inverse `cos` is also known as `acos` or cos^-1.
+
+References
+----------
+M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+10th printing, 1964, pp. 79. http://www.math.sfu.ca/~cbm/aands/
+
+Examples
+--------
+We expect the arccos of 1 to be 0, and of -1 to be pi:
+
+>>> np.arccos([1, -1])
+array([ 0.        ,  3.14159265])
+
+Plot arccos:
+
+>>> import matplotlib.pyplot as plt
+>>> x = np.linspace(-1, 1, num=100)
+>>> plt.plot(x, np.arccos(x))
+>>> plt.axis('tight')
+>>> plt.show()" :arglists '[[self & [args {:as kwargs}]]]} arccos (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arccos"))))
+
+(def ^{:doc "
+    A nicer way to build up index tuples for arrays.
+
+    .. note::
+       Use one of the two predefined instances `index_exp` or `s_`
+       rather than directly using `IndexExpression`.
+
+    For any index combination, including slicing and axis insertion,
+    ``a[indices]`` is the same as ``a[np.index_exp[indices]]`` for any
+    array `a`. However, ``np.index_exp[indices]`` can be used anywhere
+    in Python code and returns a tuple of slice objects that can be
+    used in the construction of complex index expressions.
+
+    Parameters
+    ----------
+    maketuple : bool
+        If True, always returns a tuple.
+
+    See Also
+    --------
+    index_exp : Predefined instance that always returns a tuple:
+       `index_exp = IndexExpression(maketuple=True)`.
+    s_ : Predefined instance without tuple conversion:
+       `s_ = IndexExpression(maketuple=False)`.
+
+    Notes
+    -----
+    You can do all this with `slice()` plus a few special objects,
+    but there's a lot to remember and this version is simpler because
+    it uses the standard array indexing syntax.
+
+    Examples
+    --------
+    >>> np.s_[2::2]
+    slice(2, None, 2)
+    >>> np.index_exp[2::2]
+    (slice(2, None, 2),)
+
+    >>> np.array([0, 1, 2, 3, 4])[np.s_[2::2]]
+    array([2, 4])
+
+    "} s_ (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "s_"))))
+
+(def ^{:doc "
+Contains the core of NumPy: ndarray, ufuncs, dtypes, etc.
+
+Please note that this module is private.  All functions and objects
+are available in the main ``numpy`` namespace - use that instead.
+
+"} core (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "core"))))
+
+(def ^{:doc "Complex number type composed of two single-precision floating-point
+    numbers.
+
+    :Character code: ``'F'``
+    :Canonical name: `numpy.csingle`
+    :Alias: `numpy.singlecomplex`
+    :Alias on this platform: `numpy.complex64`: Complex number type composed of 2 32-bit-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} complex64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex64"))))
+
+(def ^{:doc "arccosh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Inverse hyperbolic cosine, element-wise.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+arccosh : ndarray
+    Array of the same shape as `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+
+cosh, arcsinh, sinh, arctanh, tanh
+
+Notes
+-----
+`arccosh` is a multivalued function: for each `x` there are infinitely
+many numbers `z` such that `cosh(z) = x`. The convention is to return the
+`z` whose imaginary part lies in `[-pi, pi]` and the real part in
+``[0, inf]``.
+
+For real-valued input data types, `arccosh` always returns real output.
+For each value that cannot be expressed as a real number or infinity, it
+yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arccosh` is a complex analytical function that
+has a branch cut `[-inf, 1]` and is continuous from above on it.
+
+References
+----------
+.. [1] M. Abramowitz and I.A. Stegun, \"Handbook of Mathematical Functions\",
+       10th printing, 1964, pp. 86. http://www.math.sfu.ca/~cbm/aands/
+.. [2] Wikipedia, \"Inverse hyperbolic function\",
+       https://en.wikipedia.org/wiki/Arccosh
+
+Examples
+--------
+>>> np.arccosh([np.e, 10.0])
+array([ 1.65745445,  2.99322285])
+>>> np.arccosh(1)
+0.0" :arglists '[[self & [args {:as kwargs}]]]} arccosh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arccosh"))))
+
+(def ^{:doc "Built-in mutable sequence.
+
+If no argument is given, the constructor creates a new empty list.
+The argument must be an iterable if specified."} _financial_names (as-jvm/generic-python-as-list (py-global-delay (py/get-attr @src-obj* "_financial_names")))) 
+
+(def ^{:doc "
+    Apply a function repeatedly over multiple axes.
+
+    `func` is called as `res = func(a, axis)`, where `axis` is the first
+    element of `axes`.  The result `res` of the function call must have
+    either the same dimensions as `a` or one less dimension.  If `res`
+    has one less dimension than `a`, a dimension is inserted before
+    `axis`.  The call to `func` is then repeated for each axis in `axes`,
+    with `res` as the first argument.
+
+    Parameters
+    ----------
+    func : function
+        This function must take two arguments, `func(a, axis)`.
+    a : array_like
+        Input array.
+    axes : array_like
+        Axes over which `func` is applied; the elements must be integers.
+
+    Returns
+    -------
+    apply_over_axis : ndarray
+        The output array.  The number of dimensions is the same as `a`,
+        but the shape can be different.  This depends on whether `func`
+        changes the shape of its output with respect to its input.
+
+    See Also
+    --------
+    apply_along_axis :
+        Apply a function to 1-D slices of an array along the given axis.
+
+    Notes
+    -----
+    This function is equivalent to tuple axis arguments to reorderable ufuncs
+    with keepdims=True. Tuple axis arguments to ufuncs have been available since
+    version 1.7.0.
+
+    Examples
+    --------
+    >>> a = np.arange(24).reshape(2,3,4)
+    >>> a
+    array([[[ 0,  1,  2,  3],
+            [ 4,  5,  6,  7],
+            [ 8,  9, 10, 11]],
+           [[12, 13, 14, 15],
+            [16, 17, 18, 19],
+            [20, 21, 22, 23]]])
+
+    Sum over axes 0 and 2. The result has same number of dimensions
+    as the original array:
+
+    >>> np.apply_over_axes(np.sum, a, [0,2])
+    array([[[ 60],
+            [ 92],
+            [124]]])
+
+    Tuple axis arguments to ufuncs are equivalent:
+
+    >>> np.sum(a, axis=(0,2), keepdims=True)
+    array([[[ 60],
+            [ 92],
+            [124]]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} apply_over_axes (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "apply_over_axes"))))
+
+(def ^{:doc "tanh(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute hyperbolic tangent element-wise.
+
+Equivalent to ``np.sinh(x)/np.cosh(x)`` or ``-1j * np.tan(1j*x)``.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding hyperbolic tangent values.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+If `out` is provided, the function writes the result into it,
+and returns a reference to `out`.  (See Examples)
+
+References
+----------
+.. [1] M. Abramowitz and I. A. Stegun, Handbook of Mathematical Functions.
+       New York, NY: Dover, 1972, pg. 83.
+       http://www.math.sfu.ca/~cbm/aands/
+
+.. [2] Wikipedia, \"Hyperbolic function\",
+       https://en.wikipedia.org/wiki/Hyperbolic_function
+
+Examples
+--------
+>>> np.tanh((0, np.pi*1j, np.pi*1j/2))
+array([ 0. +0.00000000e+00j,  0. -1.22460635e-16j,  0. +1.63317787e+16j])
+
+>>> # Example of providing the optional output parameter illustrating
+>>> # that what is returned is a reference to said parameter
+>>> out1 = np.array([0], dtype='d')
+>>> out2 = np.tanh([0.1], out1)
+>>> out2 is out1
+True
+
+>>> # Example of ValueError due to provision of shape mis-matched `out`
+>>> np.tanh(np.zeros((3,3)),np.zeros((2,2)))
+Traceback (most recent call last):
+  File \"<stdin>\", line 1, in <module>
+ValueError: operands could not be broadcast together with shapes (3,3) (2,2)" :arglists '[[self & [args {:as kwargs}]]]} tanh (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tanh"))))
+
+(def ^{:doc "frompyfunc(func, nin, nout, *[, identity])
+
+    Takes an arbitrary Python function and returns a NumPy ufunc.
+
+    Can be used, for example, to add broadcasting to a built-in Python
+    function (see Examples section).
+
+    Parameters
+    ----------
+    func : Python function object
+        An arbitrary Python function.
+    nin : int
+        The number of input arguments.
+    nout : int
+        The number of objects returned by `func`.
+    identity : object, optional
+        The value to use for the `~numpy.ufunc.identity` attribute of the resulting
+        object. If specified, this is equivalent to setting the underlying
+        C ``identity`` field to ``PyUFunc_IdentityValue``.
+        If omitted, the identity is set to ``PyUFunc_None``. Note that this is
+        _not_ equivalent to setting the identity to ``None``, which implies the
+        operation is reorderable.
+
+    Returns
+    -------
+    out : ufunc
+        Returns a NumPy universal function (``ufunc``) object.
+
+    See Also
+    --------
+    vectorize : Evaluates pyfunc over input arrays using broadcasting rules of numpy.
+
+    Notes
+    -----
+    The returned ufunc always returns PyObject arrays.
+
+    Examples
+    --------
+    Use frompyfunc to add broadcasting to the Python function ``oct``:
+
+    >>> oct_array = np.frompyfunc(oct, 1, 1)
+    >>> oct_array(np.array((10, 30, 100)))
+    array(['0o12', '0o36', '0o144'], dtype=object)
+    >>> np.array((oct(10), oct(30), oct(100))) # for comparison
+    array(['0o12', '0o36', '0o144'], dtype='<U5')" :arglists '[[self & [args {:as kwargs}]]]} frompyfunc (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "frompyfunc"))))
+
+(def ^{:doc "Complex number type composed of two extended-precision floating-point
+    numbers.
+
+    :Character code: ``'G'``
+    :Canonical name: `numpy.clongdouble`
+    :Alias: `numpy.clongfloat`
+    :Alias: `numpy.longcomplex`
+    :Alias on this platform: `numpy.complex256`: Complex number type composed of 2 128-bit extended-precision floating-point numbers." :arglists '[[self & [args {:as kwargs}]]]} complex256 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "complex256"))))
+
+(def ^{:doc ""} MAXDIMS 32)
+
+(def ^{:doc "
+    Expand the shape of an array.
+
+    Insert a new axis that will appear at the `axis` position in the expanded
+    array shape.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    axis : int or tuple of ints
+        Position in the expanded axes where the new axis (or axes) is placed.
+
+        .. deprecated:: 1.13.0
+            Passing an axis where ``axis > a.ndim`` will be treated as
+            ``axis == a.ndim``, and passing ``axis < -a.ndim - 1`` will
+            be treated as ``axis == 0``. This behavior is deprecated.
+
+        .. versionchanged:: 1.18.0
+            A tuple of axes is now supported.  Out of range axes as
+            described above are now forbidden and raise an `AxisError`.
+
+    Returns
+    -------
+    result : ndarray
+        View of `a` with the number of dimensions increased.
+
+    See Also
+    --------
+    squeeze : The inverse operation, removing singleton dimensions
+    reshape : Insert, remove, and combine dimensions, and resize existing ones
+    doc.indexing, atleast_1d, atleast_2d, atleast_3d
+
+    Examples
+    --------
+    >>> x = np.array([1, 2])
+    >>> x.shape
+    (2,)
+
+    The following is equivalent to ``x[np.newaxis, :]`` or ``x[np.newaxis]``:
+
+    >>> y = np.expand_dims(x, axis=0)
+    >>> y
+    array([[1, 2]])
+    >>> y.shape
+    (1, 2)
+
+    The following is equivalent to ``x[:, np.newaxis]``:
+
+    >>> y = np.expand_dims(x, axis=1)
+    >>> y
+    array([[1],
+           [2]])
+    >>> y.shape
+    (2, 1)
+
+    ``axis`` may also be a tuple:
+
+    >>> y = np.expand_dims(x, axis=(0, 1))
+    >>> y
+    array([[[1, 2]]])
+
+    >>> y = np.expand_dims(x, axis=(2, 0))
+    >>> y
+    array([[[1],
+            [2]]])
+
+    Note that some examples may use ``None`` instead of ``np.newaxis``.  These
+    are the same objects:
+
+    >>> np.newaxis is None
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]]} expand_dims (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "expand_dims"))))
+
+(def ^{:doc "
+    Flip array in the left/right direction.
+
+    Flip the entries in each row in the left/right direction.
+    Columns are preserved, but appear in a different order than before.
+
+    Parameters
+    ----------
+    m : array_like
+        Input array, must be at least 2-D.
+
+    Returns
+    -------
+    f : ndarray
+        A view of `m` with the columns reversed.  Since a view
+        is returned, this operation is :math:`\\mathcal O(1)`.
+
+    See Also
+    --------
+    flipud : Flip array in the up/down direction.
+    rot90 : Rotate array counterclockwise.
+
+    Notes
+    -----
+    Equivalent to m[:,::-1]. Requires the array to be at least 2-D.
+
+    Examples
+    --------
+    >>> A = np.diag([1.,2.,3.])
+    >>> A
+    array([[1.,  0.,  0.],
+           [0.,  2.,  0.],
+           [0.,  0.,  3.]])
+    >>> np.fliplr(A)
+    array([[0.,  0.,  1.],
+           [0.,  2.,  0.],
+           [3.,  0.,  0.]])
+
+    >>> A = np.random.randn(2,3,5)
+    >>> np.all(np.fliplr(A) == A[:,::-1,...])
+    True
+
+    " :arglists '[[& [args {:as kwargs}]]]} fliplr (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "fliplr"))))
+
+(def ^{:doc "
+    An array with ones at and below the given diagonal and zeros elsewhere.
+
+    Parameters
+    ----------
+    N : int
+        Number of rows in the array.
+    M : int, optional
+        Number of columns in the array.
+        By default, `M` is taken equal to `N`.
+    k : int, optional
+        The sub-diagonal at and below which the array is filled.
+        `k` = 0 is the main diagonal, while `k` < 0 is below it,
+        and `k` > 0 is above.  The default is 0.
+    dtype : dtype, optional
+        Data type of the returned array.  The default is float.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    tri : ndarray of shape (N, M)
+        Array with its lower triangle filled with ones and zero elsewhere;
+        in other words ``T[i,j] == 1`` for ``j <= i + k``, 0 otherwise.
+
+    Examples
+    --------
+    >>> np.tri(3, 5, 2, dtype=int)
+    array([[1, 1, 1, 0, 0],
+           [1, 1, 1, 1, 0],
+           [1, 1, 1, 1, 1]])
+
+    >>> np.tri(3, 5, -1)
+    array([[0.,  0.,  0.,  0.,  0.],
+           [1.,  0.,  0.,  0.,  0.],
+           [1.,  1.,  0.,  0.,  0.]])
+
+    " :arglists '[[N & [{M :M, k :k, dtype :dtype, like :like}]] [N & [{M :M, k :k, like :like}]] [N & [{M :M, like :like}]] [N & [{like :like}]]]} tri (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "tri"))))
+
+(def ^{:doc "absolute(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Calculate the absolute value element-wise.
+
+``np.abs`` is a shorthand for this function.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+absolute : ndarray
+    An ndarray containing the absolute value of
+    each element in `x`.  For complex input, ``a + ib``, the
+    absolute value is :math:`\\sqrt{ a^2 + b^2 }`.
+    This is a scalar if `x` is a scalar.
+
+Examples
+--------
+>>> x = np.array([-1.2, 1.2])
+>>> np.absolute(x)
+array([ 1.2,  1.2])
+>>> np.absolute(1.2 + 1j)
+1.5620499351813308
+
+Plot the function over ``[-10, 10]``:
+
+>>> import matplotlib.pyplot as plt
+
+>>> x = np.linspace(start=-10, stop=10, num=101)
+>>> plt.plot(x, np.absolute(x))
+>>> plt.show()
+
+Plot the function over the complex plane:
+
+>>> xx = x + 1j * x[:, np.newaxis]
+>>> plt.imshow(np.abs(xx), extent=[-10, 10, -10, 10], cmap='gray')
+>>> plt.show()
+
+The `abs` function can be used as a shorthand for ``np.absolute`` on
+ndarrays.
+
+>>> x = np.array([-1.2, 1.2])
+>>> abs(x)
+array([1.2, 1.2])" :arglists '[[self & [args {:as kwargs}]]]} absolute (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "absolute"))))
+
+(def ^{:doc "
+    Split an array into multiple sub-arrays horizontally (column-wise).
+
+    Please refer to the `split` documentation.  `hsplit` is equivalent
+    to `split` with ``axis=1``, the array is always split along the second
+    axis regardless of the array dimension.
+
+    See Also
+    --------
+    split : Split an array into multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> x = np.arange(16.0).reshape(4, 4)
+    >>> x
+    array([[ 0.,   1.,   2.,   3.],
+           [ 4.,   5.,   6.,   7.],
+           [ 8.,   9.,  10.,  11.],
+           [12.,  13.,  14.,  15.]])
+    >>> np.hsplit(x, 2)
+    [array([[  0.,   1.],
+           [  4.,   5.],
+           [  8.,   9.],
+           [12.,  13.]]),
+     array([[  2.,   3.],
+           [  6.,   7.],
+           [10.,  11.],
+           [14.,  15.]])]
+    >>> np.hsplit(x, np.array([3, 6]))
+    [array([[ 0.,   1.,   2.],
+           [ 4.,   5.,   6.],
+           [ 8.,   9.,  10.],
+           [12.,  13.,  14.]]),
+     array([[ 3.],
+           [ 7.],
+           [11.],
+           [15.]]),
+     array([], shape=(4, 0), dtype=float64)]
+
+    With a higher dimensional array the split is still along the second axis.
+
+    >>> x = np.arange(8.0).reshape(2, 2, 2)
+    >>> x
+    array([[[0.,  1.],
+            [2.,  3.]],
+           [[4.,  5.],
+            [6.,  7.]]])
+    >>> np.hsplit(x, 2)
+    [array([[[0.,  1.]],
+           [[4.,  5.]]]),
+     array([[[2.,  3.]],
+           [[6.,  7.]]])]
+
+    " :arglists '[[& [args {:as kwargs}]]]} hsplit (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "hsplit"))))
+
+(def ^{:doc "Signed integer type, compatible with C ``char``.
+
+    :Character code: ``'b'``
+    :Canonical name: `numpy.byte`
+    :Alias on this platform: `numpy.int8`: 8-bit signed integer (``-128`` to ``127``)." :arglists '[[self & [args {:as kwargs}]]]} byte (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "byte"))))
+
+(def ^{:doc "seterrobj(errobj)
+
+    Set the object that defines floating-point error handling.
+
+    The error object contains all information that defines the error handling
+    behavior in NumPy. `seterrobj` is used internally by the other
+    functions that set error handling behavior (`seterr`, `seterrcall`).
+
+    Parameters
+    ----------
+    errobj : list
+        The error object, a list containing three elements:
+        [internal numpy buffer size, error mask, error callback function].
+
+        The error mask is a single integer that holds the treatment information
+        on all four floating point errors. The information for each error type
+        is contained in three bits of the integer. If we print it in base 8, we
+        can see what treatment is set for \"invalid\", \"under\", \"over\", and
+        \"divide\" (in that order). The printed string can be interpreted with
+
+        * 0 : 'ignore'
+        * 1 : 'warn'
+        * 2 : 'raise'
+        * 3 : 'call'
+        * 4 : 'print'
+        * 5 : 'log'
+
+    See Also
+    --------
+    geterrobj, seterr, geterr, seterrcall, geterrcall
+    getbufsize, setbufsize
+
+    Notes
+    -----
+    For complete documentation of the types of floating-point exceptions and
+    treatment options, see `seterr`.
+
+    Examples
+    --------
+    >>> old_errobj = np.geterrobj()  # first get the defaults
+    >>> old_errobj
+    [8192, 521, None]
+
+    >>> def err_handler(type, flag):
+    ...     print(\"Floating point error (%s), with flag %s\" % (type, flag))
+    ...
+    >>> new_errobj = [20000, 12, err_handler]
+    >>> np.seterrobj(new_errobj)
+    >>> np.base_repr(12, 8)  # int for divide=4 ('print') and over=1 ('warn')
+    '14'
+    >>> np.geterr()
+    {'over': 'warn', 'divide': 'print', 'invalid': 'ignore', 'under': 'ignore'}
+    >>> np.geterrcall() is err_handler
+    True" :arglists '[[self & [args {:as kwargs}]]]} seterrobj (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "seterrobj"))))
+
+(def ^{:doc "log2(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Base-2 logarithm of `x`.
+
+Parameters
+----------
+x : array_like
+    Input values.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    Base-2 logarithm of `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+log, log10, log1p, emath.log2
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+Logarithm is a multivalued function: for each `x` there is an infinite
+number of `z` such that `2**z = x`. The convention is to return the `z`
+whose imaginary part lies in `[-pi, pi]`.
+
+For real-valued input data types, `log2` always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `log2` is a complex analytical function that
+has a branch cut `[-inf, 0]` and is continuous from above on it. `log2`
+handles the floating-point negative zero as an infinitesimal negative
+number, conforming to the C99 standard.
+
+Examples
+--------
+>>> x = np.array([0, 1, 2, 2**4])
+>>> np.log2(x)
+array([-Inf,   0.,   1.,   4.])
+
+>>> xi = np.array([0+1.j, 1, 2+0.j, 4.j])
+>>> np.log2(xi)
+array([ 0.+2.26618007j,  0.+0.j        ,  1.+0.j        ,  2.+2.26618007j])" :arglists '[[self & [args {:as kwargs}]]]} log2 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "log2"))))
+
+(def ^{:doc "left_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Shift the bits of an integer to the left.
+
+Bits are shifted to the left by appending `x2` 0s at the right of `x1`.
+Since the internal representation of numbers is in binary format, this
+operation is equivalent to multiplying `x1` by ``2**x2``.
+
+Parameters
+----------
+x1 : array_like of integer type
+    Input values.
+x2 : array_like of integer type
+    Number of zeros to append to `x1`. Has to be non-negative.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : array of integer type
+    Return `x1` with bits shifted `x2` times to the left.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+right_shift : Shift the bits of an integer to the right.
+binary_repr : Return the binary representation of the input number
+    as a string.
+
+Examples
+--------
+>>> np.binary_repr(5)
+'101'
+>>> np.left_shift(5, 2)
+20
+>>> np.binary_repr(20)
+'10100'
+
+>>> np.left_shift(5, [1,2,3])
+array([10, 20, 40])
+
+Note that the dtype of the second argument may change the dtype of the
+result and can lead to unexpected results in some cases (see
+:ref:`Casting Rules <ufuncs.casting>`):
+
+>>> a = np.left_shift(np.uint8(255), 1) # Expect 254
+>>> print(a, type(a)) # Unexpected result due to upcasting
+510 <class 'numpy.int64'>
+>>> b = np.left_shift(np.uint8(255), np.uint8(1))
+>>> print(b, type(b))
+254 <class 'numpy.uint8'>
+
+The ``<<`` operator can be used as a shorthand for ``np.left_shift`` on
+ndarrays.
+
+>>> x1 = 5
+>>> x2 = np.array([1, 2, 3])
+>>> x1 << x2
+array([10, 20, 40])" :arglists '[[self & [args {:as kwargs}]]]} left_shift (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "left_shift"))))
+
+(def ^{:doc "
+    Return a contiguous array (ndim >= 1) in memory (C order).
+
+    Parameters
+    ----------
+    a : array_like
+        Input array.
+    dtype : str or dtype object, optional
+        Data-type of returned array.
+    like : array_like
+        Reference object to allow the creation of arrays which are not
+        NumPy arrays. If an array-like passed in as ``like`` supports
+        the ``__array_function__`` protocol, the result will be defined
+        by it. In this case, it ensures the creation of an array object
+        compatible with that passed in via this argument.
+
+        .. note::
+            The ``like`` keyword is an experimental feature pending on
+            acceptance of :ref:`NEP 35 <NEP35>`.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    out : ndarray
+        Contiguous array of same shape and content as `a`, with type `dtype`
+        if specified.
+
+    See Also
+    --------
+    asfortranarray : Convert input to an ndarray with column-major
+                     memory order.
+    require : Return an ndarray that satisfies requirements.
+    ndarray.flags : Information about the memory layout of the array.
+
+    Examples
+    --------
+    >>> x = np.arange(6).reshape(2,3)
+    >>> np.ascontiguousarray(x, dtype=np.float32)
+    array([[0., 1., 2.],
+           [3., 4., 5.]], dtype=float32)
+    >>> x.flags['C_CONTIGUOUS']
+    True
+
+    Note: This function returns an array with at least one-dimension (1-d) 
+    so it will not preserve 0-d arrays.  
+
+    " :arglists '[[a & [{dtype :dtype, like :like}]] [a & [{like :like}]]]} ascontiguousarray (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "ascontiguousarray"))))
+
+(def ^{:doc "
+    Stack arrays in sequence vertically (row wise).
+
+    This is equivalent to concatenation along the first axis after 1-D arrays
+    of shape `(N,)` have been reshaped to `(1,N)`. Rebuilds arrays divided by
+    `vsplit`.
+
+    This function makes most sense for arrays with up to 3 dimensions. For
+    instance, for pixel-data with a height (first axis), width (second axis),
+    and r/g/b channels (third axis). The functions `concatenate`, `stack` and
+    `block` provide more general stacking and concatenation operations.
+
+    Parameters
+    ----------
+    tup : sequence of ndarrays
+        The arrays must have the same shape along all but the first axis.
+        1-D arrays must have the same length.
+
+    Returns
+    -------
+    stacked : ndarray
+        The array formed by stacking the given arrays, will be at least 2-D.
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays along an existing axis.
+    stack : Join a sequence of arrays along a new axis.
+    block : Assemble an nd-array from nested lists of blocks.
+    hstack : Stack arrays in sequence horizontally (column wise).
+    dstack : Stack arrays in sequence depth wise (along third axis).
+    column_stack : Stack 1-D arrays as columns into a 2-D array.
+    vsplit : Split an array into multiple sub-arrays vertically (row-wise).
+
+    Examples
+    --------
+    >>> a = np.array([1, 2, 3])
+    >>> b = np.array([2, 3, 4])
+    >>> np.vstack((a,b))
+    array([[1, 2, 3],
+           [2, 3, 4]])
+
+    >>> a = np.array([[1], [2], [3]])
+    >>> b = np.array([[2], [3], [4]])
+    >>> np.vstack((a,b))
+    array([[1],
+           [2],
+           [3],
+           [2],
+           [3],
+           [4]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} row_stack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "row_stack"))))
+
+(def ^{:doc "Save several arrays into a single file in uncompressed ``.npz`` format.
+
+    If arguments are passed in with no keywords, the corresponding variable
+    names, in the ``.npz`` file, are 'arr_0', 'arr_1', etc. If keyword
+    arguments are given, the corresponding variable names, in the ``.npz``
+    file will match the keyword names.
+
+    Parameters
+    ----------
+    file : str or file
+        Either the filename (string) or an open file (file-like object)
+        where the data will be saved. If file is a string or a Path, the
+        ``.npz`` extension will be appended to the filename if it is not
+        already there.
+    args : Arguments, optional
+        Arrays to save to the file. Since it is not possible for Python to
+        know the names of the arrays outside `savez`, the arrays will be saved
+        with names \"arr_0\", \"arr_1\", and so on. These arguments can be any
+        expression.
+    kwds : Keyword arguments, optional
+        Arrays to save to the file. Arrays will be saved in the file with the
+        keyword names.
+
+    Returns
+    -------
+    None
+
+    See Also
+    --------
+    save : Save a single array to a binary file in NumPy format.
+    savetxt : Save an array to a file as plain text.
+    savez_compressed : Save several arrays into a compressed ``.npz`` archive
+
+    Notes
+    -----
+    The ``.npz`` file format is a zipped archive of files named after the
+    variables they contain.  The archive is not compressed and each file
+    in the archive contains one variable in ``.npy`` format. For a
+    description of the ``.npy`` format, see :py:mod:`numpy.lib.format`.
+
+    When opening the saved ``.npz`` file with `load` a `NpzFile` object is
+    returned. This is a dictionary-like object which can be queried for
+    its list of arrays (with the ``.files`` attribute), and for the arrays
+    themselves.
+
+    When saving dictionaries, the dictionary keys become filenames
+    inside the ZIP archive. Therefore, keys should be valid filenames.
+    E.g., avoid keys that begin with ``/`` or contain ``.``.
+
+    Examples
+    --------
+    >>> from tempfile import TemporaryFile
+    >>> outfile = TemporaryFile()
+    >>> x = np.arange(10)
+    >>> y = np.sin(x)
+
+    Using `savez` with \\*args, the arrays are saved with default names.
+
+    >>> np.savez(outfile, x, y)
+    >>> _ = outfile.seek(0) # Only needed here to simulate closing & reopening file
+    >>> npzfile = np.load(outfile)
+    >>> npzfile.files
+    ['arr_0', 'arr_1']
+    >>> npzfile['arr_0']
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+    Using `savez` with \\**kwds, the arrays are saved with the keyword names.
+
+    >>> outfile = TemporaryFile()
+    >>> np.savez(outfile, x=x, y=y)
+    >>> _ = outfile.seek(0)
+    >>> npzfile = np.load(outfile)
+    >>> sorted(npzfile.files)
+    ['x', 'y']
+    >>> npzfile['x']
+    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    " :arglists '[[& [args {:as kwargs}]]]} savez (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "savez"))))
+
+(def ^{:doc "
+    Return a description for the given data type code.
+
+    Parameters
+    ----------
+    char : str
+        Data type code.
+
+    Returns
+    -------
+    out : str
+        Description of the input data type code.
+
+    See Also
+    --------
+    dtype, typecodes
+
+    Examples
+    --------
+    >>> typechars = ['S1', '?', 'B', 'D', 'G', 'F', 'I', 'H', 'L', 'O', 'Q',
+    ...              'S', 'U', 'V', 'b', 'd', 'g', 'f', 'i', 'h', 'l', 'q']
+    >>> for typechar in typechars:
+    ...     print(typechar, ' : ', np.typename(typechar))
+    ...
+    S1  :  character
+    ?  :  bool
+    B  :  unsigned char
+    D  :  complex double precision
+    G  :  complex long double precision
+    F  :  complex single precision
+    I  :  unsigned integer
+    H  :  unsigned short
+    L  :  unsigned long integer
+    O  :  object
+    Q  :  unsigned long long integer
+    S  :  string
+    U  :  unicode
+    V  :  void
+    b  :  signed char
+    d  :  double precision
+    g  :  long precision
+    f  :  single precision
+    i  :  integer
+    h  :  short
+    l  :  long integer
+    q  :  long long integer
+
+    " :arglists '[[char]]} typename (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "typename"))))
+
+(def ^{:doc "
+    Pytest test runner.
+
+    A test function is typically added to a package's __init__.py like so::
+
+      from numpy._pytesttester import PytestTester
+      test = PytestTester(__name__).test
+      del PytestTester
+
+    Calling this test function finds and runs all tests associated with the
+    module and all its sub-modules.
+
+    Attributes
+    ----------
+    module_name : str
+        Full path to the package to test.
+
+    Parameters
+    ----------
+    module_name : module name
+        The name of the module to test.
+
+    Notes
+    -----
+    Unlike the previous ``nose``-based implementation, this class is not
+    publicly exposed as it performs some ``numpy``-specific warning
+    suppression.
+
+    " :arglists '[[self module_name]]} test (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "test"))))
+
+(def ^{:doc ""} __package__ "numpy")
+
+(def ^{:doc "
+    Returns True if input arrays are shape consistent and all elements equal.
+
+    Shape consistent means they are either the same shape, or one input array
+    can be broadcasted to create the same shape as the other one.
+
+    Parameters
+    ----------
+    a1, a2 : array_like
+        Input arrays.
+
+    Returns
+    -------
+    out : bool
+        True if equivalent, False otherwise.
+
+    Examples
+    --------
+    >>> np.array_equiv([1, 2], [1, 2])
+    True
+    >>> np.array_equiv([1, 2], [1, 3])
+    False
+
+    Showing the shape equivalence:
+
+    >>> np.array_equiv([1, 2], [[1, 2], [1, 2]])
+    True
+    >>> np.array_equiv([1, 2], [[1, 2, 1, 2], [1, 2, 1, 2]])
+    False
+
+    >>> np.array_equiv([1, 2], [[1, 2], [1, 3]])
+    False
+
+    " :arglists '[[& [args {:as kwargs}]]]} array_equiv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "array_equiv"))))
+
+(def ^{:doc "
+    Join a sequence of arrays along a new axis.
+
+    The ``axis`` parameter specifies the index of the new axis in the
+    dimensions of the result. For example, if ``axis=0`` it will be the first
+    dimension and if ``axis=-1`` it will be the last dimension.
+
+    .. versionadded:: 1.10.0
+
+    Parameters
+    ----------
+    arrays : sequence of array_like
+        Each array must have the same shape.
+
+    axis : int, optional
+        The axis in the result array along which the input arrays are stacked.
+
+    out : ndarray, optional
+        If provided, the destination to place the result. The shape must be
+        correct, matching that of what stack would have returned if no
+        out argument were specified.
+
+    Returns
+    -------
+    stacked : ndarray
+        The stacked array has one more dimension than the input arrays.
+
+    See Also
+    --------
+    concatenate : Join a sequence of arrays along an existing axis.
+    block : Assemble an nd-array from nested lists of blocks.
+    split : Split array into a list of multiple sub-arrays of equal size.
+
+    Examples
+    --------
+    >>> arrays = [np.random.randn(3, 4) for _ in range(10)]
+    >>> np.stack(arrays, axis=0).shape
+    (10, 3, 4)
+
+    >>> np.stack(arrays, axis=1).shape
+    (3, 10, 4)
+
+    >>> np.stack(arrays, axis=2).shape
+    (3, 4, 10)
+
+    >>> a = np.array([1, 2, 3])
+    >>> b = np.array([2, 3, 4])
+    >>> np.stack((a, b))
+    array([[1, 2, 3],
+           [2, 3, 4]])
+
+    >>> np.stack((a, b), axis=-1)
+    array([[1, 2],
+           [2, 3],
+           [3, 4]])
+
+    " :arglists '[[& [args {:as kwargs}]]]} stack (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "stack"))))
+
+(def ^{:doc "right_shift(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Shift the bits of an integer to the right.
+
+Bits are shifted to the right `x2`.  Because the internal
+representation of numbers is in binary format, this operation is
+equivalent to dividing `x1` by ``2**x2``.
+
+Parameters
+----------
+x1 : array_like, int
+    Input values.
+x2 : array_like, int
+    Number of bits to remove at the right of `x1`.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray, int
+    Return `x1` with bits shifted `x2` times to the right.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+left_shift : Shift the bits of an integer to the left.
+binary_repr : Return the binary representation of the input number
+    as a string.
+
+Examples
+--------
+>>> np.binary_repr(10)
+'1010'
+>>> np.right_shift(10, 1)
+5
+>>> np.binary_repr(5)
+'101'
+
+>>> np.right_shift(10, [1,2,3])
+array([5, 2, 1])
+
+The ``>>`` operator can be used as a shorthand for ``np.right_shift`` on
+ndarrays.
+
+>>> x1 = 10
+>>> x2 = np.array([1,2,3])
+>>> x1 >> x2
+array([5, 2, 1])" :arglists '[[self & [args {:as kwargs}]]]} right_shift (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "right_shift"))))
+
+(def ^{:doc "
+    Compute the variance along the specified axis, while ignoring NaNs.
+
+    Returns the variance of the array elements, a measure of the spread of
+    a distribution.  The variance is computed for the flattened array by
+    default, otherwise over the specified axis.
+
+    For all-NaN slices or slices with zero degrees of freedom, NaN is
+    returned and a `RuntimeWarning` is raised.
+
+    .. versionadded:: 1.8.0
+
+    Parameters
+    ----------
+    a : array_like
+        Array containing numbers whose variance is desired.  If `a` is not an
+        array, a conversion is attempted.
+    axis : {int, tuple of int, None}, optional
+        Axis or axes along which the variance is computed.  The default is to compute
+        the variance of the flattened array.
+    dtype : data-type, optional
+        Type to use in computing the variance.  For arrays of integer type
+        the default is `float64`; for arrays of float types it is the same as
+        the array type.
+    out : ndarray, optional
+        Alternate output array in which to place the result.  It must have
+        the same shape as the expected output, but the type is cast if
+        necessary.
+    ddof : int, optional
+        \"Delta Degrees of Freedom\": the divisor used in the calculation is
+        ``N - ddof``, where ``N`` represents the number of non-NaN
+        elements. By default `ddof` is zero.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `a`.
+
+
+    Returns
+    -------
+    variance : ndarray, see dtype parameter above
+        If `out` is None, return a new array containing the variance,
+        otherwise return a reference to the output array. If ddof is >= the
+        number of non-NaN elements in a slice or the slice contains only
+        NaNs, then the result for that slice is NaN.
+
+    See Also
+    --------
+    std : Standard deviation
+    mean : Average
+    var : Variance while not ignoring NaNs
+    nanstd, nanmean
+    :ref:`ufuncs-output-type`
+
+    Notes
+    -----
+    The variance is the average of the squared deviations from the mean,
+    i.e.,  ``var = mean(abs(x - x.mean())**2)``.
+
+    The mean is normally calculated as ``x.sum() / N``, where ``N = len(x)``.
+    If, however, `ddof` is specified, the divisor ``N - ddof`` is used
+    instead.  In standard statistical practice, ``ddof=1`` provides an
+    unbiased estimator of the variance of a hypothetical infinite
+    population.  ``ddof=0`` provides a maximum likelihood estimate of the
+    variance for normally distributed variables.
+
+    Note that for complex numbers, the absolute value is taken before
+    squaring, so that the result is always real and nonnegative.
+
+    For floating-point input, the variance is computed using the same
+    precision the input has.  Depending on the input data, this can cause
+    the results to be inaccurate, especially for `float32` (see example
+    below).  Specifying a higher-accuracy accumulator using the ``dtype``
+    keyword can alleviate this issue.
+
+    For this function to work on sub-classes of ndarray, they must define
+    `sum` with the kwarg `keepdims`
+
+    Examples
+    --------
+    >>> a = np.array([[1, np.nan], [3, 4]])
+    >>> np.nanvar(a)
+    1.5555555555555554
+    >>> np.nanvar(a, axis=0)
+    array([1.,  0.])
+    >>> np.nanvar(a, axis=1)
+    array([0.,  0.25])  # may vary
+
+    " :arglists '[[& [args {:as kwargs}]]]} nanvar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "nanvar"))))
+
+(def ^{:doc "
+A sub-package for efficiently dealing with polynomials.
+
+Within the documentation for this sub-package, a \"finite power series,\"
+i.e., a polynomial (also referred to simply as a \"series\") is represented
+by a 1-D numpy array of the polynomial's coefficients, ordered from lowest
+order term to highest.  For example, array([1,2,3]) represents
+``P_0 + 2*P_1 + 3*P_2``, where P_n is the n-th order basis polynomial
+applicable to the specific module in question, e.g., `polynomial` (which
+\"wraps\" the \"standard\" basis) or `chebyshev`.  For optimal performance,
+all operations on polynomials, including evaluation at an argument, are
+implemented as operations on the coefficients.  Additional (module-specific)
+information can be found in the docstring for the module of interest.
+
+This package provides *convenience classes* for each of six different kinds
+of polynomials:
+
+         ============    ================
+         **Name**        **Provides**
+         ============    ================
+         Polynomial      Power series
+         Chebyshev       Chebyshev series
+         Legendre        Legendre series
+         Laguerre        Laguerre series
+         Hermite         Hermite series
+         HermiteE        HermiteE series
+         ============    ================
+
+These *convenience classes* provide a consistent interface for creating,
+manipulating, and fitting data with polynomials of different bases.
+The convenience classes are the preferred interface for the `~numpy.polynomial`
+package, and are available from the `numpy.polynomial` namespace.
+This eliminates the need to
+navigate to the corresponding submodules, e.g. ``np.polynomial.Polynomial``
+or ``np.polynomial.Chebyshev`` instead of
+``np.polynomial.polynomial.Polynomial`` or 
+``np.polynomial.chebyshev.Chebyshev``, respectively.
+The classes provide a more consistent and concise interface than the
+type-specific functions defined in the submodules for each type of polynomial.
+For example, to fit a Chebyshev polynomial with degree ``1`` to data given
+by arrays ``xdata`` and ``ydata``, the 
+`~chebyshev.Chebyshev.fit` class method::
+
+    >>> from numpy.polynomial import Chebyshev
+    >>> c = Chebyshev.fit(xdata, ydata, deg=1)
+
+is preferred over the `chebyshev.chebfit` function from the 
+`numpy.polynomial.chebyshev` module::
+
+    >>> from numpy.polynomial.chebyshev import chebfit
+    >>> c = chebfit(xdata, ydata, deg=1)
+
+See :doc:`routines.polynomials.classes` for more details.
+
+Convenience Classes
+===================
+
+The following lists the various constants and methods common to all of
+the classes representing the various kinds of polynomials. In the following,
+the term ``Poly`` represents any one of the convenience classes (e.g.
+``Polynomial``, ``Chebyshev``, ``Hermite``, etc.) while the lowercase ``p``
+represents an **instance** of a polynomial class.
+
+Constants
+---------
+
+- ``Poly.domain``     -- Default domain
+- ``Poly.window``     -- Default window
+- ``Poly.basis_name`` -- String used to represent the basis
+- ``Poly.maxpower``   -- Maximum value ``n`` such that ``p**n`` is allowed
+- ``Poly.nickname``   -- String used in printing
+
+Creation
+--------
+
+Methods for creating polynomial instances.
+
+- ``Poly.basis(degree)``    -- Basis polynomial of given degree
+- ``Poly.identity()``       -- ``p`` where ``p(x) = x`` for all ``x``
+- ``Poly.fit(x, y, deg)``   -- ``p`` of degree ``deg`` with coefficients 
+  determined by the least-squares fit to the data ``x``, ``y``
+- ``Poly.fromroots(roots)`` -- ``p`` with specified roots
+- ``p.copy()``              -- Create a copy of ``p``
+
+Conversion
+----------
+
+Methods for converting a polynomial instance of one kind to another.
+
+- ``p.cast(Poly)``    -- Convert ``p`` to instance of kind ``Poly``
+- ``p.convert(Poly)`` -- Convert ``p`` to instance of kind ``Poly`` or map
+  between ``domain`` and ``window``
+
+Calculus
+--------
+- ``p.deriv()`` -- Take the derivative of ``p``
+- ``p.integ()`` -- Integrate ``p``
+
+Validation
+----------
+- ``Poly.has_samecoef(p1, p2)``   -- Check if coefficients match
+- ``Poly.has_samedomain(p1, p2)`` -- Check if domains match
+- ``Poly.has_sametype(p1, p2)``   -- Check if types match
+- ``Poly.has_samewindow(p1, p2)`` -- Check if windows match
+
+Misc
+----
+- ``p.linspace()`` -- Return ``x, p(x)`` at equally-spaced points in ``domain``
+- ``p.mapparms()`` -- Return the parameters for the linear mapping between
+  ``domain`` and ``window``.
+- ``p.roots()``    -- Return the roots of `p`.
+- ``p.trim()``     -- Remove trailing coefficients.
+- ``p.cutdeg(degree)`` -- Truncate p to given degree
+- ``p.truncate(size)`` -- Truncate p to given size
+
+"} polynomial (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "polynomial"))))
+
+(def ^{:doc "
+    Return the derivative of the specified order of a polynomial.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide </reference/routines.polynomials>`.
+
+    Parameters
+    ----------
+    p : poly1d or sequence
+        Polynomial to differentiate.
+        A sequence is interpreted as polynomial coefficients, see `poly1d`.
+    m : int, optional
+        Order of differentiation (default: 1)
+
+    Returns
+    -------
+    der : poly1d
+        A new polynomial representing the derivative.
+
+    See Also
+    --------
+    polyint : Anti-derivative of a polynomial.
+    poly1d : Class for one-dimensional polynomials.
+
+    Examples
+    --------
+    The derivative of the polynomial :math:`x^3 + x^2 + x^1 + 1` is:
+
+    >>> p = np.poly1d([1,1,1,1])
+    >>> p2 = np.polyder(p)
+    >>> p2
+    poly1d([3, 2, 1])
+
+    which evaluates to:
+
+    >>> p2(2.)
+    17.0
+
+    We can verify this, approximating the derivative with
+    ``(f(x + h) - f(x))/h``:
+
+    >>> (p(2. + 0.001) - p(2.)) / 0.001
+    17.007000999997857
+
+    The fourth-order derivative of a 3rd-order polynomial is zero:
+
+    >>> np.polyder(p, 2)
+    poly1d([6, 2])
+    >>> np.polyder(p, 3)
+    poly1d([6])
+    >>> np.polyder(p, 4)
+    poly1d([0])
+
+    " :arglists '[[& [args {:as kwargs}]]]} polyder (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polyder"))))
+
+(def ^{:doc "
+    Move axes of an array to new positions.
+
+    Other axes remain in their original order.
+
+    .. versionadded:: 1.11.0
+
+    Parameters
+    ----------
+    a : np.ndarray
+        The array whose axes should be reordered.
+    source : int or sequence of int
+        Original positions of the axes to move. These must be unique.
+    destination : int or sequence of int
+        Destination positions for each of the original axes. These must also be
+        unique.
+
+    Returns
+    -------
+    result : np.ndarray
+        Array with moved axes. This array is a view of the input array.
+
+    See Also
+    --------
+    transpose: Permute the dimensions of an array.
+    swapaxes: Interchange two axes of an array.
+
+    Examples
+    --------
+
+    >>> x = np.zeros((3, 4, 5))
+    >>> np.moveaxis(x, 0, -1).shape
+    (4, 5, 3)
+    >>> np.moveaxis(x, -1, 0).shape
+    (5, 3, 4)
+
+    These all achieve the same result:
+
+    >>> np.transpose(x).shape
+    (5, 4, 3)
+    >>> np.swapaxes(x, 0, -1).shape
+    (5, 4, 3)
+    >>> np.moveaxis(x, [0, 1], [-1, -2]).shape
+    (5, 4, 3)
+    >>> np.moveaxis(x, [0, 1, 2], [-1, -2, -3]).shape
+    (5, 4, 3)
+
+    " :arglists '[[& [args {:as kwargs}]]]} moveaxis (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "moveaxis"))))
+
+(def ^{:doc "
+    concatenate((a1, a2, ...), axis=0, out=None, dtype=None, casting=\"same_kind\")
+
+    Join a sequence of arrays along an existing axis.
+
+    Parameters
+    ----------
+    a1, a2, ... : sequence of array_like
+        The arrays must have the same shape, except in the dimension
+        corresponding to `axis` (the first, by default).
+    axis : int, optional
+        The axis along which the arrays will be joined.  If axis is None,
+        arrays are flattened before use.  Default is 0.
+    out : ndarray, optional
+        If provided, the destination to place the result. The shape must be
+        correct, matching that of what concatenate would have returned if no
+        out argument were specified.
+    dtype : str or dtype
+        If provided, the destination array will have this dtype. Cannot be
+        provided together with `out`.
+
+        .. versionadded:: 1.20.0
+
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur. Defaults to 'same_kind'.
+
+        .. versionadded:: 1.20.0
+
+    Returns
+    -------
+    res : ndarray
+        The concatenated array.
+
+    See Also
+    --------
+    ma.concatenate : Concatenate function that preserves input masks.
+    array_split : Split an array into multiple sub-arrays of equal or
+                  near-equal size.
+    split : Split array into a list of multiple sub-arrays of equal size.
+    hsplit : Split array into multiple sub-arrays horizontally (column wise).
+    vsplit : Split array into multiple sub-arrays vertically (row wise).
+    dsplit : Split array into multiple sub-arrays along the 3rd axis (depth).
+    stack : Stack a sequence of arrays along a new axis.
+    block : Assemble arrays from blocks.
+    hstack : Stack arrays in sequence horizontally (column wise).
+    vstack : Stack arrays in sequence vertically (row wise).
+    dstack : Stack arrays in sequence depth wise (along third dimension).
+    column_stack : Stack 1-D arrays as columns into a 2-D array.
+
+    Notes
+    -----
+    When one or more of the arrays to be concatenated is a MaskedArray,
+    this function will return a MaskedArray object instead of an ndarray,
+    but the input masks are *not* preserved. In cases where a MaskedArray
+    is expected as input, use the ma.concatenate function from the masked
+    array module instead.
+
+    Examples
+    --------
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> b = np.array([[5, 6]])
+    >>> np.concatenate((a, b), axis=0)
+    array([[1, 2],
+           [3, 4],
+           [5, 6]])
+    >>> np.concatenate((a, b.T), axis=1)
+    array([[1, 2, 5],
+           [3, 4, 6]])
+    >>> np.concatenate((a, b), axis=None)
+    array([1, 2, 3, 4, 5, 6])
+
+    This function will not preserve masking of MaskedArray inputs.
+
+    >>> a = np.ma.arange(3)
+    >>> a[1] = np.ma.masked
+    >>> b = np.arange(2, 5)
+    >>> a
+    masked_array(data=[0, --, 2],
+                 mask=[False,  True, False],
+           fill_value=999999)
+    >>> b
+    array([2, 3, 4])
+    >>> np.concatenate([a, b])
+    masked_array(data=[0, 1, 2, 2, 3, 4],
+                 mask=False,
+           fill_value=999999)
+    >>> np.ma.concatenate([a, b])
+    masked_array(data=[0, --, 2, 2, 3, 4],
+                 mask=[False,  True, False, False, False, False],
+           fill_value=999999)
+
+    " :arglists '[[& [args {:as kwargs}]]]} concatenate (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "concatenate"))))
+
+(def ^{:doc "
+    Return an array of zeros with the same shape and type as a given array.
+
+    Parameters
+    ----------
+    a : array_like
+        The shape and data-type of `a` define these same attributes of
+        the returned array.
+    dtype : data-type, optional
+        Overrides the data type of the result.
+
+        .. versionadded:: 1.6.0
+    order : {'C', 'F', 'A', or 'K'}, optional
+        Overrides the memory layout of the result. 'C' means C-order,
+        'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
+        'C' otherwise. 'K' means match the layout of `a` as closely
+        as possible.
+
+        .. versionadded:: 1.6.0
+    subok : bool, optional.
+        If True, then the newly created array will use the sub-class
+        type of `a`, otherwise it will be a base-class array. Defaults
+        to True.
+    shape : int or sequence of ints, optional.
+        Overrides the shape of the result. If order='K' and the number of
+        dimensions is unchanged, will try to keep order, otherwise,
+        order='C' is implied.
+
+        .. versionadded:: 1.17.0
+
+    Returns
+    -------
+    out : ndarray
+        Array of zeros with the same shape and type as `a`.
+
+    See Also
+    --------
+    empty_like : Return an empty array with shape and type of input.
+    ones_like : Return an array of ones with shape and type of input.
+    full_like : Return a new array with shape of input filled with value.
+    zeros : Return a new array setting values to zero.
+
+    Examples
+    --------
+    >>> x = np.arange(6)
+    >>> x = x.reshape((2, 3))
+    >>> x
+    array([[0, 1, 2],
+           [3, 4, 5]])
+    >>> np.zeros_like(x)
+    array([[0, 0, 0],
+           [0, 0, 0]])
+
+    >>> y = np.arange(3, dtype=float)
+    >>> y
+    array([0., 1., 2.])
+    >>> np.zeros_like(y)
+    array([0.,  0.,  0.])
+
+    " :arglists '[[& [args {:as kwargs}]]]} zeros_like (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "zeros_like"))))
+
+(def ^{:doc "rint(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Round elements of the array to the nearest integer.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Output array is same shape and type as `x`.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+ceil, floor, trunc
+
+Examples
+--------
+>>> a = np.array([-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0])
+>>> np.rint(a)
+array([-2., -2., -0.,  0.,  2.,  2.,  2.])" :arglists '[[self & [args {:as kwargs}]]]} rint (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "rint"))))
+
+(def ^{:doc "arcsin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Inverse sine, element-wise.
+
+Parameters
+----------
+x : array_like
+    `y`-coordinate on the unit circle.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+angle : ndarray
+    The inverse sine of each element in `x`, in radians and in the
+    closed interval ``[-pi/2, pi/2]``.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+sin, cos, arccos, tan, arctan, arctan2, emath.arcsin
+
+Notes
+-----
+`arcsin` is a multivalued function: for each `x` there are infinitely
+many numbers `z` such that :math:`sin(z) = x`.  The convention is to
+return the angle `z` whose real part lies in [-pi/2, pi/2].
+
+For real-valued input data types, *arcsin* always returns real output.
+For each value that cannot be expressed as a real number or infinity,
+it yields ``nan`` and sets the `invalid` floating point error flag.
+
+For complex-valued input, `arcsin` is a complex analytic function that
+has, by convention, the branch cuts [-inf, -1] and [1, inf]  and is
+continuous from above on the former and from below on the latter.
+
+The inverse sine is also known as `asin` or sin^{-1}.
+
+References
+----------
+Abramowitz, M. and Stegun, I. A., *Handbook of Mathematical Functions*,
+10th printing, New York: Dover, 1964, pp. 79ff.
+http://www.math.sfu.ca/~cbm/aands/
+
+Examples
+--------
+>>> np.arcsin(1)     # pi/2
+1.5707963267948966
+>>> np.arcsin(-1)    # -pi/2
+-1.5707963267948966
+>>> np.arcsin(0)
+0.0" :arglists '[[self & [args {:as kwargs}]]]} arcsin (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "arcsin"))))
+
+(def ^{:doc "
+    Returns pointers to the end-points of an array.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input array. It must conform to the Python-side of the array
+        interface.
+
+    Returns
+    -------
+    (low, high) : tuple of 2 integers
+        The first integer is the first byte of the array, the second
+        integer is just past the last byte of the array.  If `a` is not
+        contiguous it will not use every byte between the (`low`, `high`)
+        values.
+
+    Examples
+    --------
+    >>> I = np.eye(2, dtype='f'); I.dtype
+    dtype('float32')
+    >>> low, high = np.byte_bounds(I)
+    >>> high - low == I.size*I.itemsize
+    True
+    >>> I = np.eye(2); I.dtype
+    dtype('float64')
+    >>> low, high = np.byte_bounds(I)
+    >>> high - low == I.size*I.itemsize
+    True
+
+    " :arglists '[[a]]} byte_bounds (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "byte_bounds"))))
+
+(def ^{:doc "
+    Return an array representing the indices of a grid.
+
+    Compute an array where the subarrays contain index values 0, 1, ...
+    varying only along the corresponding axis.
+
+    Parameters
+    ----------
+    dimensions : sequence of ints
+        The shape of the grid.
+    dtype : dtype, optional
+        Data type of the result.
+    sparse : boolean, optional
+        Return a sparse representation of the grid instead of a dense
+        representation. Default is False.
+
+        .. versionadded:: 1.17
+
+    Returns
+    -------
+    grid : one ndarray or tuple of ndarrays
+        If sparse is False:
+            Returns one array of grid indices,
+            ``grid.shape = (len(dimensions),) + tuple(dimensions)``.
+        If sparse is True:
+            Returns a tuple of arrays, with
+            ``grid[i].shape = (1, ..., 1, dimensions[i], 1, ..., 1)`` with
+            dimensions[i] in the ith place
+
+    See Also
+    --------
+    mgrid, ogrid, meshgrid
+
+    Notes
+    -----
+    The output shape in the dense case is obtained by prepending the number
+    of dimensions in front of the tuple of dimensions, i.e. if `dimensions`
+    is a tuple ``(r0, ..., rN-1)`` of length ``N``, the output shape is
+    ``(N, r0, ..., rN-1)``.
+
+    The subarrays ``grid[k]`` contains the N-D array of indices along the
+    ``k-th`` axis. Explicitly::
+
+        grid[k, i0, i1, ..., iN-1] = ik
+
+    Examples
+    --------
+    >>> grid = np.indices((2, 3))
+    >>> grid.shape
+    (2, 2, 3)
+    >>> grid[0]        # row indices
+    array([[0, 0, 0],
+           [1, 1, 1]])
+    >>> grid[1]        # column indices
+    array([[0, 1, 2],
+           [0, 1, 2]])
+
+    The indices can be used as an index into an array.
+
+    >>> x = np.arange(20).reshape(5, 4)
+    >>> row, col = np.indices((2, 3))
+    >>> x[row, col]
+    array([[0, 1, 2],
+           [4, 5, 6]])
+
+    Note that it would be more straightforward in the above example to
+    extract the required elements directly with ``x[:2, :3]``.
+
+    If sparse is set to true, the grid will be returned in a sparse
+    representation.
+
+    >>> i, j = np.indices((2, 3), sparse=True)
+    >>> i.shape
+    (2, 1)
+    >>> j.shape
+    (1, 3)
+    >>> i        # row indices
+    array([[0],
+           [1]])
+    >>> j        # column indices
+    array([[0, 1, 2]])
+
+    " :arglists '[[dimensions & [{dtype :dtype, sparse :sparse}]] [dimensions & [{dtype :dtype}]] [dimensions]]} indices (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "indices"))))
+
+(def ^{:doc "
+    Return coordinate matrices from coordinate vectors.
+
+    Make N-D coordinate arrays for vectorized evaluations of
+    N-D scalar/vector fields over N-D grids, given
+    one-dimensional coordinate arrays x1, x2,..., xn.
+
+    .. versionchanged:: 1.9
+       1-D and 0-D cases are allowed.
+
+    Parameters
+    ----------
+    x1, x2,..., xn : array_like
+        1-D arrays representing the coordinates of a grid.
+    indexing : {'xy', 'ij'}, optional
+        Cartesian ('xy', default) or matrix ('ij') indexing of output.
+        See Notes for more details.
+
+        .. versionadded:: 1.7.0
+    sparse : bool, optional
+        If True a sparse grid is returned in order to conserve memory.
+        Default is False.
+
+        .. versionadded:: 1.7.0
+    copy : bool, optional
+        If False, a view into the original arrays are returned in order to
+        conserve memory.  Default is True.  Please note that
+        ``sparse=False, copy=False`` will likely return non-contiguous
+        arrays.  Furthermore, more than one element of a broadcast array
+        may refer to a single memory location.  If you need to write to the
+        arrays, make copies first.
+
+        .. versionadded:: 1.7.0
+
+    Returns
+    -------
+    X1, X2,..., XN : ndarray
+        For vectors `x1`, `x2`,..., 'xn' with lengths ``Ni=len(xi)`` ,
+        return ``(N1, N2, N3,...Nn)`` shaped arrays if indexing='ij'
+        or ``(N2, N1, N3,...Nn)`` shaped arrays if indexing='xy'
+        with the elements of `xi` repeated to fill the matrix along
+        the first dimension for `x1`, the second for `x2` and so on.
+
+    Notes
+    -----
+    This function supports both indexing conventions through the indexing
+    keyword argument.  Giving the string 'ij' returns a meshgrid with
+    matrix indexing, while 'xy' returns a meshgrid with Cartesian indexing.
+    In the 2-D case with inputs of length M and N, the outputs are of shape
+    (N, M) for 'xy' indexing and (M, N) for 'ij' indexing.  In the 3-D case
+    with inputs of length M, N and P, outputs are of shape (N, M, P) for
+    'xy' indexing and (M, N, P) for 'ij' indexing.  The difference is
+    illustrated by the following code snippet::
+
+        xv, yv = np.meshgrid(x, y, sparse=False, indexing='ij')
+        for i in range(nx):
+            for j in range(ny):
+                # treat xv[i,j], yv[i,j]
+
+        xv, yv = np.meshgrid(x, y, sparse=False, indexing='xy')
+        for i in range(nx):
+            for j in range(ny):
+                # treat xv[j,i], yv[j,i]
+
+    In the 1-D and 0-D case, the indexing and sparse keywords have no effect.
+
+    See Also
+    --------
+    mgrid : Construct a multi-dimensional \"meshgrid\" using indexing notation.
+    ogrid : Construct an open multi-dimensional \"meshgrid\" using indexing 
+            notation.
+
+    Examples
+    --------
+    >>> nx, ny = (3, 2)
+    >>> x = np.linspace(0, 1, nx)
+    >>> y = np.linspace(0, 1, ny)
+    >>> xv, yv = np.meshgrid(x, y)
+    >>> xv
+    array([[0. , 0.5, 1. ],
+           [0. , 0.5, 1. ]])
+    >>> yv
+    array([[0.,  0.,  0.],
+           [1.,  1.,  1.]])
+    >>> xv, yv = np.meshgrid(x, y, sparse=True)  # make sparse output arrays
+    >>> xv
+    array([[0. ,  0.5,  1. ]])
+    >>> yv
+    array([[0.],
+           [1.]])
+
+    `meshgrid` is very useful to evaluate functions on a grid.
+
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.arange(-5, 5, 0.1)
+    >>> y = np.arange(-5, 5, 0.1)
+    >>> xx, yy = np.meshgrid(x, y, sparse=True)
+    >>> z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2)
+    >>> h = plt.contourf(x,y,z)
+    >>> plt.show()
+
+    " :arglists '[[& [args {:as kwargs}]]]} meshgrid (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "meshgrid"))))
+
+(def ^{:doc "A datetime stored as a 64-bit integer, counting from ``1970-01-01T00:00:00``.
+
+    >>> np.datetime64(10, 'Y')
+    numpy.datetime64('1980')
+    >>> np.datetime64(10, 'D')
+    numpy.datetime64('1970-01-11')
+    
+    See :ref:`arrays.datetime` for more information.
+
+    :Character code: ``'M'``" :arglists '[[self & [args {:as kwargs}]]]} datetime64 (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "datetime64"))))
+
+(def ^{:doc "
+    copyto(dst, src, casting='same_kind', where=True)
+
+    Copies values from one array to another, broadcasting as necessary.
+
+    Raises a TypeError if the `casting` rule is violated, and if
+    `where` is provided, it selects which elements to copy.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    dst : ndarray
+        The array into which values are copied.
+    src : array_like
+        The array from which values are copied.
+    casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
+        Controls what kind of data casting may occur when copying.
+
+          * 'no' means the data types should not be cast at all.
+          * 'equiv' means only byte-order changes are allowed.
+          * 'safe' means only casts which can preserve values are allowed.
+          * 'same_kind' means only safe casts or casts within a kind,
+            like float64 to float32, are allowed.
+          * 'unsafe' means any data conversions may be done.
+    where : array_like of bool, optional
+        A boolean array which is broadcasted to match the dimensions
+        of `dst`, and selects elements to copy from `src` to `dst`
+        wherever it contains the value True.
+    " :arglists '[[& [args {:as kwargs}]]]} copyto (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "copyto"))))
+
+(def ^{:doc "
+    Returns the quotient and remainder of polynomial division.
+
+    .. note::
+       This forms part of the old polynomial API. Since version 1.4, the
+       new polynomial API defined in `numpy.polynomial` is preferred.
+       A summary of the differences can be found in the
+       :doc:`transition guide </reference/routines.polynomials>`.
+
+    The input arrays are the coefficients (including any coefficients
+    equal to zero) of the \"numerator\" (dividend) and \"denominator\"
+    (divisor) polynomials, respectively.
+
+    Parameters
+    ----------
+    u : array_like or poly1d
+        Dividend polynomial's coefficients.
+
+    v : array_like or poly1d
+        Divisor polynomial's coefficients.
+
+    Returns
+    -------
+    q : ndarray
+        Coefficients, including those equal to zero, of the quotient.
+    r : ndarray
+        Coefficients, including those equal to zero, of the remainder.
+
+    See Also
+    --------
+    poly, polyadd, polyder, polydiv, polyfit, polyint, polymul, polysub
+    polyval
+
+    Notes
+    -----
+    Both `u` and `v` must be 0-d or 1-d (ndim = 0 or 1), but `u.ndim` need
+    not equal `v.ndim`. In other words, all four possible combinations -
+    ``u.ndim = v.ndim = 0``, ``u.ndim = v.ndim = 1``,
+    ``u.ndim = 1, v.ndim = 0``, and ``u.ndim = 0, v.ndim = 1`` - work.
+
+    Examples
+    --------
+    .. math:: \\frac{3x^2 + 5x + 2}{2x + 1} = 1.5x + 1.75, remainder 0.25
+
+    >>> x = np.array([3.0, 5.0, 2.0])
+    >>> y = np.array([2.0, 1.0])
+    >>> np.polydiv(x, y)
+    (array([1.5 , 1.75]), array([0.25]))
+
+    " :arglists '[[& [args {:as kwargs}]]]} polydiv (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "polydiv"))))
+
+(def ^{:doc ""} ERR_PRINT 4)
+
+(def ^{:doc "modf(x[, out1, out2], / [, out=(None, None)], *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Return the fractional and integral parts of an array, element-wise.
+
+The fractional and integral parts are negative if the given number is
+negative.
+
+Parameters
+----------
+x : array_like
+    Input array.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y1 : ndarray
+    Fractional part of `x`.
+    This is a scalar if `x` is a scalar.
+y2 : ndarray
+    Integral part of `x`.
+    This is a scalar if `x` is a scalar.
+
+Notes
+-----
+For integer input the return values are floats.
+
+See Also
+--------
+divmod : ``divmod(x, 1)`` is equivalent to ``modf`` with the return values
+         switched, except it always has a positive remainder.
+
+Examples
+--------
+>>> np.modf([0, 3.5])
+(array([ 0. ,  0.5]), array([ 0.,  3.]))
+>>> np.modf(-0.5)
+(-0.5, -0)" :arglists '[[self & [args {:as kwargs}]]]} modf (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "modf"))))
+
+(def ^{:doc "busdaycalendar(weekmask='1111100', holidays=None)
+
+    A business day calendar object that efficiently stores information
+    defining valid days for the busday family of functions.
+
+    The default valid days are Monday through Friday (\"business days\").
+    A busdaycalendar object can be specified with any set of weekly
+    valid days, plus an optional \"holiday\" dates that always will be invalid.
+
+    Once a busdaycalendar object is created, the weekmask and holidays
+    cannot be modified.
+
+    .. versionadded:: 1.7.0
+
+    Parameters
+    ----------
+    weekmask : str or array_like of bool, optional
+        A seven-element array indicating which of Monday through Sunday are
+        valid days. May be specified as a length-seven list or array, like
+        [1,1,1,1,1,0,0]; a length-seven string, like '1111100'; or a string
+        like \"Mon Tue Wed Thu Fri\", made up of 3-character abbreviations for
+        weekdays, optionally separated by white space. Valid abbreviations
+        are: Mon Tue Wed Thu Fri Sat Sun
+    holidays : array_like of datetime64[D], optional
+        An array of dates to consider as invalid dates, no matter which
+        weekday they fall upon.  Holiday dates may be specified in any
+        order, and NaT (not-a-time) dates are ignored.  This list is
+        saved in a normalized form that is suited for fast calculations
+        of valid days.
+
+    Returns
+    -------
+    out : busdaycalendar
+        A business day calendar object containing the specified
+        weekmask and holidays values.
+
+    See Also
+    --------
+    is_busday : Returns a boolean array indicating valid days.
+    busday_offset : Applies an offset counted in valid days.
+    busday_count : Counts how many valid days are in a half-open date range.
+
+    Attributes
+    ----------
+    Note: once a busdaycalendar object is created, you cannot modify the
+    weekmask or holidays.  The attributes return copies of internal data.
+    weekmask : (copy) seven-element array of bool
+    holidays : (copy) sorted array of datetime64[D]
+
+    Examples
+    --------
+    >>> # Some important days in July
+    ... bdd = np.busdaycalendar(
+    ...             holidays=['2011-07-01', '2011-07-04', '2011-07-17'])
+    >>> # Default is Monday to Friday weekdays
+    ... bdd.weekmask
+    array([ True,  True,  True,  True,  True, False, False])
+    >>> # Any holidays already on the weekend are removed
+    ... bdd.holidays
+    array(['2011-07-01', '2011-07-04'], dtype='datetime64[D]')" :arglists '[[self & [args {:as kwargs}]]]} busdaycalendar (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "busdaycalendar"))))
+
+(def ^{:doc "deg2rad(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Convert angles from degrees to radians.
+
+Parameters
+----------
+x : array_like
+    Angles in degrees.
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+y : ndarray
+    The corresponding angle in radians.
+    This is a scalar if `x` is a scalar.
+
+See Also
+--------
+rad2deg : Convert angles from radians to degrees.
+unwrap : Remove large jumps in angle by wrapping.
+
+Notes
+-----
+.. versionadded:: 1.3.0
+
+``deg2rad(x)`` is ``x * pi / 180``.
+
+Examples
+--------
+>>> np.deg2rad(180)
+3.1415926535897931" :arglists '[[self & [args {:as kwargs}]]]} deg2rad (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "deg2rad"))))
+
+(def ^{:doc ""} FPE_UNDERFLOW 4)
+
+(def ^{:doc "Signed integer type, compatible with C ``long long``.
+
+    :Character code: ``'q'``" :arglists '[[self & [args {:as kwargs}]]]} longlong (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "longlong"))))
+
+(def ^{:doc " Distributor init file
+
+Distributors: you can add custom code here to support particular distributions
+of numpy.
+
+For example, this is a good place to put any checks for hardware requirements.
+
+The numpy standard source distribution will not put code in this file, so you
+can safely replace this file with your own version.
+"} _distributor_init (as-jvm/generic-pyobject (py-global-delay (py/get-attr @src-obj* "_distributor_init"))))
+
+(def ^{:doc "add_docstring(obj, docstring)
+
+    Add a docstring to a built-in obj if possible.
+    If the obj already has a docstring raise a RuntimeError
+    If this routine does not know how to add a docstring to the object
+    raise a TypeError" :arglists '[[self & [args {:as kwargs}]]]} add_docstring (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "add_docstring"))))
+
+(def ^{:doc "
+    Compute the median along the specified axis.
+
+    Returns the median of the array elements.
+
+    Parameters
+    ----------
+    a : array_like
+        Input array or object that can be converted to an array.
+    axis : {int, sequence of int, None}, optional
+        Axis or axes along which the medians are computed. The default
+        is to compute the median along a flattened version of the array.
+        A sequence of axes is supported since version 1.9.0.
+    out : ndarray, optional
+        Alternative output array in which to place the result. It must
+        have the same shape and buffer length as the expected output,
+        but the type (of the output) will be cast if necessary.
+    overwrite_input : bool, optional
+       If True, then allow use of memory of input array `a` for
+       calculations. The input array will be modified by the call to
+       `median`. This will save memory when you do not need to preserve
+       the contents of the input array. Treat the input as undefined,
+       but it will probably be fully or partially sorted. Default is
+       False. If `overwrite_input` is ``True`` and `a` is not already an
+       `ndarray`, an error will be raised.
+    keepdims : bool, optional
+        If this is set to True, the axes which are reduced are left
+        in the result as dimensions with size one. With this option,
+        the result will broadcast correctly against the original `arr`.
+
+        .. versionadded:: 1.9.0
+
+    Returns
+    -------
+    median : ndarray
+        A new array holding the result. If the input contains integers
+        or floats smaller than ``float64``, then the output data-type is
+        ``np.float64``.  Otherwise, the data-type of the output is the
+        same as that of the input. If `out` is specified, that array is
+        returned instead.
+
+    See Also
+    --------
+    mean, percentile
+
+    Notes
+    -----
+    Given a vector ``V`` of length ``N``, the median of ``V`` is the
+    middle value of a sorted copy of ``V``, ``V_sorted`` - i
+    e., ``V_sorted[(N-1)/2]``, when ``N`` is odd, and the average of the
+    two middle values of ``V_sorted`` when ``N`` is even.
+
+    Examples
+    --------
+    >>> a = np.array([[10, 7, 4], [3, 2, 1]])
+    >>> a
+    array([[10,  7,  4],
+           [ 3,  2,  1]])
+    >>> np.median(a)
+    3.5
+    >>> np.median(a, axis=0)
+    array([6.5, 4.5, 2.5])
+    >>> np.median(a, axis=1)
+    array([7.,  2.])
+    >>> m = np.median(a, axis=0)
+    >>> out = np.zeros_like(m)
+    >>> np.median(a, axis=0, out=m)
+    array([6.5,  4.5,  2.5])
+    >>> m
+    array([6.5,  4.5,  2.5])
+    >>> b = a.copy()
+    >>> np.median(b, axis=1, overwrite_input=True)
+    array([7.,  2.])
+    >>> assert not np.all(a==b)
+    >>> b = a.copy()
+    >>> np.median(b, axis=None, overwrite_input=True)
+    3.5
+    >>> assert not np.all(a==b)
+
+    " :arglists '[[& [args {:as kwargs}]]]} median (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "median"))))
+
+(def ^{:doc "bitwise_xor(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])
+
+Compute the bit-wise XOR of two arrays element-wise.
+
+Computes the bit-wise XOR of the underlying binary representation of
+the integers in the input arrays. This ufunc implements the C/Python
+operator ``^``.
+
+Parameters
+----------
+x1, x2 : array_like
+    Only integer and boolean types are handled.
+    If ``x1.shape != x2.shape``, they must be broadcastable to a common
+    shape (which becomes the shape of the output).
+out : ndarray, None, or tuple of ndarray and None, optional
+    A location into which the result is stored. If provided, it must have
+    a shape that the inputs broadcast to. If not provided or None,
+    a freshly-allocated array is returned. A tuple (possible only as a
+    keyword argument) must have length equal to the number of outputs.
+where : array_like, optional
+    This condition is broadcast over the input. At locations where the
+    condition is True, the `out` array will be set to the ufunc result.
+    Elsewhere, the `out` array will retain its original value.
+    Note that if an uninitialized `out` array is created via the default
+    ``out=None``, locations within it where the condition is False will
+    remain uninitialized.
+**kwargs
+    For other keyword-only arguments, see the
+    :ref:`ufunc docs <ufuncs.kwargs>`.
+
+Returns
+-------
+out : ndarray or scalar
+    Result.
+    This is a scalar if both `x1` and `x2` are scalars.
+
+See Also
+--------
+logical_xor
+bitwise_and
+bitwise_or
+binary_repr :
+    Return the binary representation of the input number as a string.
+
+Examples
+--------
+The number 13 is represented by ``00001101``. Likewise, 17 is
+represented by ``00010001``.  The bit-wise XOR of 13 and 17 is
+therefore ``00011100``, or 28:
+
+>>> np.bitwise_xor(13, 17)
+28
+>>> np.binary_repr(28)
+'11100'
+
+>>> np.bitwise_xor(31, 5)
+26
+>>> np.bitwise_xor([31,3], 5)
+array([26,  6])
+
+>>> np.bitwise_xor([31,3], [5,6])
+array([26,  5])
+>>> np.bitwise_xor([True, True], [False, True])
+array([ True, False])
+
+The ``^`` operator can be used as a shorthand for ``np.bitwise_xor`` on
+ndarrays.
+
+>>> x1 = np.array([True, True])
+>>> x2 = np.array([False, True])
+>>> x1 ^ x2
+array([ True, False])" :arglists '[[self & [args {:as kwargs}]]]} bitwise_xor (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* "bitwise_xor"))))
\ No newline at end of file
diff --git a/deps.edn b/deps.edn
index 71a3ed8..94e82dd 100644
--- a/deps.edn
+++ b/deps.edn
@@ -46,7 +46,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.016"
+                        :version "2.017"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
@@ -57,5 +57,10 @@
             :exec-args {:installer :remote
                         :sign-releases? true
                         :artifact "target/libpython-clj.jar"}}
+           :install
+           {:replace-deps {slipset/deps-deploy {:mvn/version "0.1.5"}}
+            :exec-fn deps-deploy.deps-deploy/deploy
+            :exec-args {:installer :local
+                        :artifact "target/libpython-clj.jar"}}
 
            }}
diff --git a/docs/Usage.html b/docs/Usage.html
index 2187315..ad9c594 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/design.html b/docs/design.html
index 83fa1ba..1a7e3dc 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Design Notes</h1>
 <h2>Key Design Points</h2>
 <h3>Code Organization</h3>
 <p>There are 3 rough sections of code:</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index caec9b5..7858b2d 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index 0115214..d372a7b 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 9e9b4f1..f7d5c3b 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.016</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+<html><head><meta charset="UTF-8" /><title> 2.017</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index c76503d..aa9fc24 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
@@ -41,4 +41,4 @@
         (.add 2))
 [1, 2]
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/codegen.clj#L102">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/codegen.clj#L101">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 1b47156..ada71f9 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index d55f122..5a75f96 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index c8b3297..b76dd0e 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 654904e..dca9b2d 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 3bc1ba6..2c459d9 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index d96d169..40774bc 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index bdb5bc4..247b2cb 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index ba12a2f..583cf0d 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,6 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.016</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>
diff --git a/scripts/install b/scripts/install
new file mode 100755
index 0000000..d440eb1
--- /dev/null
+++ b/scripts/install
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+set -e
+
+clj -X:depstar
+clj -X:install
\ No newline at end of file
diff --git a/src/libpython_clj2/codegen.clj b/src/libpython_clj2/codegen.clj
index f03197e..af4b4cf 100644
--- a/src/libpython_clj2/codegen.clj
+++ b/src/libpython_clj2/codegen.clj
@@ -56,13 +56,12 @@
   (.write writer
           (format "
 
-(def %s (as-jvm/generic-callable-pyobject (py-global-delay (py/get-attr @src-obj* \"%s\"))))
-(alter-meta! #'%s assoc :doc \"%s\" :arglists '%s)"
+(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
-                  (get-docs v)
-                  (:arglists v))))
+                  clj-name)))
 
 (defn- output-module-generic
   [^Writer writer clj-name k v vv]
diff --git a/src/libpython_clj2/python/bridge_as_jvm.clj b/src/libpython_clj2/python/bridge_as_jvm.clj
index 49e446f..84eb351 100644
--- a/src/libpython_clj2/python/bridge_as_jvm.clj
+++ b/src/libpython_clj2/python/bridge_as_jvm.clj
@@ -250,90 +250,89 @@
                     fn-name)))))
 
 
-(defn make-dict-att-map
+(defn- make-dict-att-map-delay
   [pyobj* attnames]
-  (let [dict-atts (set attnames)
-        gc-ctx (pygc/gc-context)]
-    (->> (py-proto/dir @pyobj*)
-         (filter dict-atts)
-         (map (juxt identity #(delay
-                                (pygc/with-gc-context gc-ctx
-                                  (py-proto/get-attr @pyobj* %)))))
-         (into {}))))
+  (delay
+    (let [dict-atts (set attnames)
+          gc-ctx (pygc/gc-context)]
+      (->> (py-proto/dir @pyobj*)
+           (filter dict-atts)
+           (map (juxt identity #(delay (pygc/with-gc-context gc-ctx
+                                         (py-proto/get-attr @pyobj* %)))))
+           (into {})))))
 
 
 (defn make-instance-pycall
   [pyobj* attnames]
-  (let [dict-att-map (make-dict-att-map pyobj* attnames)]
+  (let [dict-att-map* (make-dict-att-map-delay pyobj* attnames)]
     (fn [fn-name & args]
-      (py-ffi/with-gil (call-impl-fn fn-name dict-att-map args)))))
+      (py-ffi/with-gil (call-impl-fn fn-name @dict-att-map* args)))))
 
 
 
 (defn generic-python-as-map
   [pyobj*]
-  (with-gil
-    (let [py-call
-          (make-instance-pycall
-           pyobj*
-           #{"__len__" "__getitem__" "__setitem__" "__iter__" "__contains__"
-             "__eq__" "__hash__" "clear" "keys" "values" "__delitem__"})]
-      (bridge-pyobject
-       pyobj*
-       Map
-       (clear [item] (py-call "clear"))
-       (containsKey [item k] (boolean (py-call "__contains__" k)))
-       (entrySet
-        [this]
-        (py-ffi/with-gil
-          (->> (.iterator this)
-               iterator-seq
-               set)))
-       (get [this obj-key]
-            ;;Specifically return nil to match java map expectations
-            ;;and thus allow destructuring.
-            (when (py-call "__contains__" obj-key)
-              (py-call "__getitem__" obj-key)))
-       (getOrDefault [item obj-key obj-default-value]
-                     (if (.containsKey item obj-key)
-                       (.get item obj-key)
-                       obj-default-value))
-       (isEmpty [this] (= 0 (.size this)))
-       (keySet [this] (->> (py-call "keys")
-                           set))
-       (put [this k v]
-            (py-call "__setitem__" k v))
-
-       (remove [this k]
-               (py-call "__delitem__" k))
-
-       (size [this]
-             (int (py-call "__len__")))
-       (values [this]
-               (py-ffi/with-gil
-                 (-> (py-call "values")
-                     (vec))))
-       Iterable
-       (iterator
-        [this]
-        (let [mapentry-seq
-              (->> (python->jvm-iterator @pyobj* nil)
-                   iterator-seq
-                   (map (fn [pyobj-key]
-                          (with-gil
-                            (let [k (py-base/as-jvm pyobj-key)
-                                  v (.get this pyobj-key)
-                                  retval
-                                  (MapEntry. k v)]
-                              retval)))))]
-
-          (.iterator ^Iterable mapentry-seq)))
-       IFn
-       (invoke [this arg] (.getOrDefault this arg nil))
-       (applyTo [this arglist]
-                (let [arglist (vec arglist)]
-                  (case (count arglist)
-                    1 (.get this (first arglist)))))))))
+  (let [py-call
+        (make-instance-pycall
+         pyobj*
+         #{"__len__" "__getitem__" "__setitem__" "__iter__" "__contains__"
+           "__eq__" "__hash__" "clear" "keys" "values" "__delitem__"})]
+    (bridge-pyobject
+     pyobj*
+     Map
+     (clear [item] (py-call "clear"))
+     (containsKey [item k] (boolean (py-call "__contains__" k)))
+     (entrySet
+      [this]
+      (py-ffi/with-gil
+        (->> (.iterator this)
+             iterator-seq
+             set)))
+     (get [this obj-key]
+          ;;Specifically return nil to match java map expectations
+          ;;and thus allow destructuring.
+          (when (py-call "__contains__" obj-key)
+            (py-call "__getitem__" obj-key)))
+     (getOrDefault [item obj-key obj-default-value]
+                   (if (.containsKey item obj-key)
+                     (.get item obj-key)
+                     obj-default-value))
+     (isEmpty [this] (= 0 (.size this)))
+     (keySet [this] (->> (py-call "keys")
+                         set))
+     (put [this k v]
+          (py-call "__setitem__" k v))
+
+     (remove [this k]
+             (py-call "__delitem__" k))
+
+     (size [this]
+           (int (py-call "__len__")))
+     (values [this]
+             (py-ffi/with-gil
+               (-> (py-call "values")
+                   (vec))))
+     Iterable
+     (iterator
+      [this]
+      (let [mapentry-seq
+            (->> (python->jvm-iterator @pyobj* nil)
+                 iterator-seq
+                 (map (fn [pyobj-key]
+                        (with-gil
+                          (let [k (py-base/as-jvm pyobj-key)
+                                v (.get this pyobj-key)
+                                retval
+                                (MapEntry. k v)]
+                            retval)))))]
+
+        (.iterator ^Iterable mapentry-seq)))
+     IFn
+     (invoke [this arg] (.getOrDefault this arg nil))
+     (applyTo [this arglist]
+              (let [arglist (vec arglist)]
+                (case (count arglist)
+                  1 (.get this (first arglist))))))))
 
 
 (defmethod py-proto/pyobject-as-jvm :dict
@@ -343,34 +342,33 @@
 
 (defn generic-python-as-list
   [pyobj*]
-  (with-gil
-    (let [py-call (make-instance-pycall
-                  pyobj*
-                  #{"__len__" "__getitem__" "__setitem__" "__iter__" "__contains__"
-                    "__eq__" "__hash__" "clear" "insert" "pop" "append"
-                    "__delitem__" "sort"})]
-      (bridge-pyobject
-       pyobj*
-       ObjectBuffer
-       (lsize [reader]
-              (long (py-call "__len__")))
-       (readObject [reader idx]
-             (py-call "__getitem__" idx))
-       (sort [reader obj-com]
-             (when-not (= nil obj-com)
-               (throw (ex-info "Python lists do not support comparators" {})))
-             (py-call "sort"))
-       (writeObject [writer idx value]
-              (py-call "__setitem__" idx value))
-       (remove [writer ^int idx]
-               (py-call "__delitem__" idx)
-               true)
-       (add [mutable idx value]
-            (py-call "insert" idx value)
-            true)
-       (add [mutable value]
-            (.add mutable (.size mutable) value)
-            true)))))
+  (let [py-call (make-instance-pycall
+                 pyobj*
+                 #{"__len__" "__getitem__" "__setitem__" "__iter__" "__contains__"
+                   "__eq__" "__hash__" "clear" "insert" "pop" "append"
+                   "__delitem__" "sort"})]
+    (bridge-pyobject
+     pyobj*
+     ObjectBuffer
+     (lsize [reader]
+            (long (py-call "__len__")))
+     (readObject [reader idx]
+                 (py-call "__getitem__" idx))
+     (sort [reader obj-com]
+           (when-not (= nil obj-com)
+             (throw (ex-info "Python lists do not support comparators" {})))
+           (py-call "sort"))
+     (writeObject [writer idx value]
+                  (py-call "__setitem__" idx value))
+     (remove [writer ^int idx]
+             (py-call "__delitem__" idx)
+             true)
+     (add [mutable idx value]
+          (py-call "insert" idx value)
+          true)
+     (add [mutable value]
+          (.add mutable (.size mutable) value)
+          true))))
 
 
 (defmethod py-proto/pyobject-as-jvm :list

From 354784c79ffa20be723efb5c913a4c2de69255df Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 3 Feb 2022 15:44:21 -0700
Subject: [PATCH 397/456] Adding compile/run example steps

---
 codegen-test/scripts/compile | 6 ++++++
 codegen-test/scripts/run     | 4 ++++
 2 files changed, 10 insertions(+)
 create mode 100755 codegen-test/scripts/compile
 create mode 100755 codegen-test/scripts/run

diff --git a/codegen-test/scripts/compile b/codegen-test/scripts/compile
new file mode 100755
index 0000000..0c15659
--- /dev/null
+++ b/codegen-test/scripts/compile
@@ -0,0 +1,6 @@
+#!/bin/bash
+
+
+
+clj -e "(require '[code.codegen :as cg])(cg/codegen)(println \"compilation successful\")\
+(shutdown-agents)"
diff --git a/codegen-test/scripts/run b/codegen-test/scripts/run
new file mode 100755
index 0000000..3c477ac
--- /dev/null
+++ b/codegen-test/scripts/run
@@ -0,0 +1,4 @@
+#!/bin/bash
+
+clj -e "(compile 'code.main)"
+java -cp "$(clj -Spath):classes" code.main
\ No newline at end of file

From 4e9f0b326e5273eddcf0b3faaf3dcf3d2439fbdf Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 10 Feb 2022 07:48:16 -0700
Subject: [PATCH 398/456] Release 2.18 - google analytics tracking for
 documentation

---
 deps.edn                                 | 12 ++++++++++--
 docs/Usage.html                          |  6 +++++-
 docs/design.html                         |  6 +++++-
 docs/embedded.html                       |  6 +++++-
 docs/environments.html                   |  6 +++++-
 docs/index.html                          |  6 +++++-
 docs/libpython-clj2.codegen.html         |  6 +++++-
 docs/libpython-clj2.embedded.html        |  6 +++++-
 docs/libpython-clj2.java-api.html        |  6 +++++-
 docs/libpython-clj2.python.html          |  6 +++++-
 docs/libpython-clj2.python.np-array.html |  6 +++++-
 docs/libpython-clj2.require.html         |  6 +++++-
 docs/new-to-clojure.html                 |  6 +++++-
 docs/scopes-and-gc.html                  |  6 +++++-
 docs/slicing.html                        |  6 +++++-
 15 files changed, 80 insertions(+), 16 deletions(-)

diff --git a/deps.edn b/deps.edn
index 94e82dd..4a6255c 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "8.062"}
+        cnuernber/dtype-next {:mvn/version "9.009"}
         net.java.dev.jna/jna {:mvn/version "5.10.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
@@ -21,6 +21,14 @@
             :exec-args {:arg-paths [[:aliases :depstar :exec-args]]
                         :description "Python bindings for Clojure"
                         :metadata {:doc/format :markdown}
+                        :google-analytics "G-LN7PG6FJ2D"
+                        :html {:transforms [[:head] [:append [:script {:async true
+                                                                       :src "https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"}]]
+                                            [:head] [:append [:script "window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');"]]]}
                         :themes [:rdash]
                         :source-paths ["src"]
                         :output-path "docs"
@@ -46,7 +54,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.017"
+                        :version "2.018"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index ad9c594..06904e3 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Usage</h1>
+<html><head><meta charset="UTF-8" /><title>Usage</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/design.html b/docs/design.html
index 1a7e3dc..3a7305f 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Design Notes</h1>
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Design Notes</h1>
 <h2>Key Design Points</h2>
 <h3>Code Organization</h3>
 <p>There are 3 rough sections of code:</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 7858b2d..4b061bf 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+<html><head><meta charset="UTF-8" /><title>Embedding Clojure In Python</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index d372a7b..1940ce5 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Python Environments</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+<html><head><meta charset="UTF-8" /><title>Python Environments</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index f7d5c3b..b312981 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.017</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+<html><head><meta charset="UTF-8" /><title> 2.018</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index aa9fc24..e2d1e51 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.codegen documentation</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index ada71f9..d9c2852 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.embedded documentation</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 5a75f96..6eecfbb 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.java-api documentation</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index b76dd0e..06ee885 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python documentation</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index dca9b2d..aa1f78e 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.np-array documentation</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 2c459d9..40e53a9 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.require documentation</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 40774bc..84c8019 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+<html><head><meta charset="UTF-8" /><title>So Many Parenthesis!</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 247b2cb..a59a732 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+<html><head><meta charset="UTF-8" /><title>Scopes And Garbage Collection</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index 583cf0d..c19e8b6 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -1,6 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.017</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+<html><head><meta charset="UTF-8" /><title>Slicing And Slices</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>

From 517bdb02fc5bac4914c91fdb4a3934bb8d31aca3 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 12 Feb 2022 12:39:24 -0700
Subject: [PATCH 399/456] Adding proper title.

---
 deps.edn                                 | 1 +
 docs/Usage.html                          | 2 +-
 docs/design.html                         | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 4 ++--
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.java-api.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 15 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/deps.edn b/deps.edn
index 4a6255c..5511b60 100644
--- a/deps.edn
+++ b/deps.edn
@@ -19,6 +19,7 @@
                          com.cnuernber/codox {:mvn/version "1.001"}}
             :exec-fn codox.main/-main
             :exec-args {:arg-paths [[:aliases :depstar :exec-args]]
+                        :name "libpython-clj"
                         :description "Python bindings for Clojure"
                         :metadata {:doc/format :markdown}
                         :google-analytics "G-LN7PG6FJ2D"
diff --git a/docs/Usage.html b/docs/Usage.html
index 06904e3..22f48f3 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/design.html b/docs/design.html
index 3a7305f..22df427 100644
--- a/docs/design.html
+++ b/docs/design.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Design Notes</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Design Notes</h1>
 <h2>Key Design Points</h2>
 <h3>Code Organization</h3>
 <p>There are 3 rough sections of code:</p>
diff --git a/docs/embedded.html b/docs/embedded.html
index 4b061bf..4df7cfc 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index 1940ce5..8a5c446 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index b312981..5c0786f 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title> 2.018</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.018</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index e2d1e51..99edbb3 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index d9c2852..554709e 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 6eecfbb..ab57a22 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 06ee885..9a358eb 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index aa1f78e..c07b45a 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 40e53a9..3b3fa6d 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 84c8019..8c251b9 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index a59a732..f4eda52 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index c19e8b6..434416a 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name"></span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>

From 60e034bf68ec44e4feddf10bbcedee57bbeb62c5 Mon Sep 17 00:00:00 2001
From: Richie Kirchofer <88050994+rkirchofer@users.noreply.github.com>
Date: Thu, 17 Feb 2022 16:55:20 -0500
Subject: [PATCH 400/456] update require. (#197)

Is this old? I had to make some changes.
---
 topics/Usage.md | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/topics/Usage.md b/topics/Usage.md
index bad4c37..86fc08f 100644
--- a/topics/Usage.md
+++ b/topics/Usage.md
@@ -40,17 +40,15 @@ Python installation instructions [here](https://docs.python-guide.org/starting/i
 ```clojure
 user>
 
-user> (require '[libpython-clj.python
-                 :refer [as-python as-jvm
-                         ->python ->jvm
-                         get-attr call-attr call-attr-kw
-                         get-item att-type-map
-                         call call-kw initialize!
-                         as-numpy as-tensor ->numpy
-                         run-simple-string
-                         add-module module-dict
-                         import-module
-                         python-type]])
+user> (require [libpython-clj2.python
+          :refer [as-python as-jvm
+                  ->python ->jvm
+                  get-attr call-attr call-attr-kw
+                  get-item initialize!
+                  run-simple-string
+                  add-module module-dict
+                  import-module
+                  python-type]])
 nil
 
 ; Mac and Linux

From 6b353902a4a7038ff87640c7a7924cbf05290054 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 26 Feb 2022 12:40:00 -0700
Subject: [PATCH 401/456] Removing out of date document.

---
 docs/Usage.html                          |   4 +-
 docs/design.html                         | 144 -------------------
 docs/embedded.html                       |   2 +-
 docs/environments.html                   |   2 +-
 docs/index.html                          |   2 +-
 docs/libpython-clj2.codegen.html         |   2 +-
 docs/libpython-clj2.embedded.html        |   2 +-
 docs/libpython-clj2.java-api.html        |   2 +-
 docs/libpython-clj2.python.html          |   2 +-
 docs/libpython-clj2.python.np-array.html |   2 +-
 docs/libpython-clj2.require.html         |   2 +-
 docs/new-to-clojure.html                 |   2 +-
 docs/scopes-and-gc.html                  |   2 +-
 docs/slicing.html                        |   2 +-
 topics/Usage.md                          |   2 +-
 topics/design.md                         | 171 -----------------------
 16 files changed, 15 insertions(+), 330 deletions(-)
 delete mode 100644 docs/design.html
 delete mode 100644 topics/design.md

diff --git a/docs/Usage.html b/docs/Usage.html
index 22f48f3..a87ade9 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>Usage</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Usage</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/design.html b/docs/design.html
deleted file mode 100644
index 22df427..0000000
--- a/docs/design.html
+++ /dev/null
@@ -1,144 +0,0 @@
-<!DOCTYPE html PUBLIC ""
-    "">
-<html><head><meta charset="UTF-8" /><title>LibPython-CLJ Design Notes</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
-  function gtag(){dataLayer.push(arguments);}
-  gtag('js', new Date());
-
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1  current"><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Design Notes</h1>
-<h2>Key Design Points</h2>
-<h3>Code Organization</h3>
-<p>There are 3 rough sections of code:</p>
-<ol>
-<li>
-<p>A JNA layer which is a 1-1 mapping most of the C API with no changes and full
-documentation.  The docstrings on the functions match the documentation if you lookup
-the 3.7 API documentation.  Users must manually manage the GIL when using this API
-layer.</p>
-</li>
-<li>
-<p>An API implementation layer which knows about things like interpreters and type
-symbol tables.  Users must know how to manipulate the GIL and how the two garbage
-collectors work with each other to add to this layer.</p>
-</li>
-<li>
-<p>A public API layer.  Details like managing the GIL or messing with garbage collection
-in general do not leak out to this layer.</p>
-</li>
-</ol>
-<h3>Interpreters</h3>
-<p>Interpreters are global objects.  After initialize!, there is a main interpreter which
-is used automatically from any thread.  Access to the interpreters relies on thread
-local variables and interpreter locking so you can do things like:</p>
-<pre><code class="language-clojure">(with-interpreter interpreter
-  some code)
-</code></pre>
-<p>You don't have to do this, however.  If you don't care what context you run in you can
-just use the public API which under the covers simple does:</p>
-<pre><code class="language-clojure">(with-gil
-  some code)
-</code></pre>
-<p>This type of thing grabs the GIL if it hasn't already been claimed by the current thread
-and off you go.  When the code is finished, it saves the interpreter thread state back
-into a global atom and thus releases the GIL.  Interpreters have both shared and
-per-interpreter state named <code>:shared-state</code> and <code>:interpreter-state</code> respectively.
-Shared state would be the global type symbol table.  Interpreter state contains things
-like a map of objects to their per-interpreter python bridging class.</p>
-<p>If the interpreter isn't specified it uses the main interpreter.  The simplest way to
-ensure you have the gil is <code>with-gil</code>.  You may also use <code>(ensure-bound-interpreter)</code> if
-you wish to penalize users for using a function incorrectly.  This returns the
-interpreter currently bound to this thread or throws.</p>
-<h3>Garbage Collection</h3>
-<p>The system uses the <a href="https://github.com/techascent/tech.resource">tech.resource</a>
-library to attach a GC hook to appropriate java object
-that releases the associated python object if the java object goes out of scope.
-Bridges use a similar technique to unregister the bridge on destruction of their python
-counterpart.  There should be no need for manual addref/release calls in any user code
-aside from potentially (and damn rarely) a <code>(System/gc)</code> call.</p>
-<h3>Copying Vs. Bridging</h3>
-<p>Objects either in python or in java may be either copied or bridged into the other
-ecosystem.  Bridging allows sharing complex and potentially changing datastructures
-while copying allows a cleaner partitioning of concerns and frees both garbage
-collection systems to act more independently.  Numeric buffers that have a direct
-representation as a C-ptr (the datatype native-buffer type) have a zero-copy pathway via
-numpy.  If you want access to object functionality that object needs to be bridged; so
-for example if you want to call numpy functions then you need to bridge that object.
-Tensors are always represented in python as numpy objects using zero-copy where possible
-in all cases.</p>
-<h3>Bridging</h3>
-<p>Python Callables implement <code>clojure.lang.IFn</code> along with a python specific interface so
-in general you can call them like any other function but you also can use keyword
-arguments if you know you are dealing with a python function.  Python dicts implement
-<code>java.util.Map</code> and <code>clojure.lang.IFn</code> and lists are <code>java.util.List</code>,
-<code>java.util.RandomAccess</code>, and <code>clojure.lang.IFn</code>.  This allows fluid manipulation of
-the datastructures (even mutation) from both languages.</p>
-<p>You can create a python function from a clojure function with create-function.  You can
-create a new bridge type by implementing the <code>libpython_clj.jna.JVMBridge</code> interface:</p>
-<pre><code class="language-java">public interface JVMBridge extends AutoCloseable
-{
-  public Pointer getAttr(String name);
-  public void setAttr(String name, Pointer val);
-  public String[] dir();
-  public Object interpreter();
-  public Object wrappedObject();
-  // Called from python when the python mirror is deleted.
-  // This had better not throw anything.
-  public default void close() {}
-}
-</code></pre>
-<p>If all you want to do is override the attribute map that is simple.  Here is the bridge
-for java.util.Map:</p>
-<pre><code class="language-clojure">(defn jvm-map-&gt;python
-  ^Pointer [^Map jvm-data]
-  (with-gil
-    (let [att-map
-          {"__contains__" (jvm-fn-&gt;python #(.containsKey jvm-data %))
-           "__eq__" (jvm-fn-&gt;python #(.equals jvm-data %))
-           "__getitem__" (jvm-fn-&gt;python #(.get jvm-data %))
-           "__setitem__" (jvm-fn-&gt;python #(.put jvm-data %1 %2))
-           "__hash__" (jvm-fn-&gt;python #(.hashCode jvm-data))
-           "__iter__" (jvm-fn-&gt;python #(.iterator ^Iterable jvm-data))
-           "__len__" (jvm-fn-&gt;python #(.size jvm-data))
-           "__str__" (jvm-fn-&gt;python #(.toString jvm-data))
-           "clear" (jvm-fn-&gt;python #(.clear jvm-data))
-           "keys" (jvm-fn-&gt;python #(seq (.keySet jvm-data)))
-           "values" (jvm-fn-&gt;python #(seq (.values jvm-data)))
-           "pop" (jvm-fn-&gt;python #(.remove jvm-data %))}]
-      (create-bridge-from-att-map jvm-data att-map))))
-</code></pre>
-<h3>IO</h3>
-<p><code>sys.stdout</code> and <code>sys.stderr</code> are redirected to <code>*out*</code> and <code>*err*</code> respectively.
-This rerouting is done using a bridge that is then set as <code>sys.stdout</code> or <code>sys.stderr</code>:</p>
-<pre><code class="language-clojure">(defn create-var-writer
-  "Returns an unregistered bridge"
-  ^Pointer [writer-var]
-  (with-gil
-    (create-bridge-from-att-map
-     writer-var
-     {"write" (-&gt;python (fn [&amp; args]
-                          (.write ^Writer @writer-var (str (first args)))))
-      "flush" (-&gt;python (fn [&amp; args]))
-      "isatty" (-&gt;python (fn [&amp; args]
-                           (libpy/Py_False)))
-      })))
-
-(defn setup-std-writer
-  [writer-var sys-mod-attname]
-  (with-gil
-    (let [sys-module (import-module "sys")
-          std-out-writer (get-or-create-var-writer writer-var)]
-      (py-proto/set-attr! sys-module sys-mod-attname std-out-writer)
-      :ok)))
-
-
-(defn initialize!
-  [&amp; {:keys [program-name no-io-redirect?]}]
-  (when-not @pyinterp/*main-interpreter*
-    (pyinterp/initialize! program-name)
-    ;;setup bridge mechansim and io redirection
-    (pyinterop/register-bridge-type!)
-    (when-not no-io-redirect?
-      (pyinterop/setup-std-writer #'*err* "stderr")
-      (pyinterop/setup-std-writer #'*out* "stdout")))
-  :ok)
-</code></pre>
-</div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/embedded.html b/docs/embedded.html
index 4df7cfc..b2361f1 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index 8a5c446..db6809f 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 5c0786f..66a40ed 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">Usage</a></li><li><a href="design.html">LibPython-CLJ Design Notes</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 99edbb3..3e675b8 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 554709e..e8fea9d 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index ab57a22..4715d86 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 9a358eb..14dee0e 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index c07b45a..6c4c716 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 3b3fa6d..f5f00ec 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 8c251b9..8824144 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index f4eda52..6698963 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index 434416a..dff495c 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>Usage</span></div></a></li><li class="depth-1 "><a href="design.html"><div class="inner"><span>LibPython-CLJ Design Notes</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>
diff --git a/topics/Usage.md b/topics/Usage.md
index bad4c37..f89419d 100644
--- a/topics/Usage.md
+++ b/topics/Usage.md
@@ -1,4 +1,4 @@
-# Usage
+# LibPython-CLJ Usage
 
 
 Python objects are essentially two dictionaries, one for 'attributes' and one for
diff --git a/topics/design.md b/topics/design.md
deleted file mode 100644
index 19b14d3..0000000
--- a/topics/design.md
+++ /dev/null
@@ -1,171 +0,0 @@
-# LibPython-CLJ Design Notes
-
-
-## Key Design Points
-
-
-### Code Organization
-
-
-There are 3 rough sections of code:
-1. A JNA layer which is a 1-1 mapping most of the C API with no changes and full
-   documentation.  The docstrings on the functions match the documentation if you lookup
-   the 3.7 API documentation.  Users must manually manage the GIL when using this API
-   layer.
-
-2. An API implementation layer which knows about things like interpreters and type
-   symbol tables.  Users must know how to manipulate the GIL and how the two garbage
-   collectors work with each other to add to this layer.
-
-3. A public API layer.  Details like managing the GIL or messing with garbage collection
-   in general do not leak out to this layer.
-
-
-
-### Interpreters
-
-Interpreters are global objects.  After initialize!, there is a main interpreter which
-is used automatically from any thread.  Access to the interpreters relies on thread
-local variables and interpreter locking so you can do things like:
-
-```clojure
-(with-interpreter interpreter
-  some code)
-```
-
-You don't have to do this, however.  If you don't care what context you run in you can
-just use the public API which under the covers simple does:
-
-
-```clojure
-(with-gil
-  some code)
-```
-
-This type of thing grabs the GIL if it hasn't already been claimed by the current thread
-and off you go.  When the code is finished, it saves the interpreter thread state back
-into a global atom and thus releases the GIL.  Interpreters have both shared and
-per-interpreter state named `:shared-state` and `:interpreter-state` respectively.
-Shared state would be the global type symbol table.  Interpreter state contains things
-like a map of objects to their per-interpreter python bridging class.
-
-If the interpreter isn't specified it uses the main interpreter.  The simplest way to
-ensure you have the gil is `with-gil`.  You may also use `(ensure-bound-interpreter)` if
-you wish to penalize users for using a function incorrectly.  This returns the
-interpreter currently bound to this thread or throws.
-
-
-### Garbage Collection
-
-The system uses the [tech.resource](https://github.com/techascent/tech.resource) 
-library to attach a GC hook to appropriate java object
-that releases the associated python object if the java object goes out of scope.
-Bridges use a similar technique to unregister the bridge on destruction of their python
-counterpart.  There should be no need for manual addref/release calls in any user code
-aside from potentially (and damn rarely) a `(System/gc)` call.
-
-
-### Copying Vs. Bridging
-
-
-Objects either in python or in java may be either copied or bridged into the other
-ecosystem.  Bridging allows sharing complex and potentially changing datastructures
-while copying allows a cleaner partitioning of concerns and frees both garbage
-collection systems to act more independently.  Numeric buffers that have a direct
-representation as a C-ptr (the datatype native-buffer type) have a zero-copy pathway via
-numpy.  If you want access to object functionality that object needs to be bridged; so
-for example if you want to call numpy functions then you need to bridge that object.
-Tensors are always represented in python as numpy objects using zero-copy where possible
-in all cases.
-
-
-### Bridging
-
-
-Python Callables implement `clojure.lang.IFn` along with a python specific interface so
-in general you can call them like any other function but you also can use keyword
-arguments if you know you are dealing with a python function.  Python dicts implement
-`java.util.Map` and `clojure.lang.IFn` and lists are `java.util.List`,
-`java.util.RandomAccess`, and `clojure.lang.IFn`.  This allows fluid manipulation of
-the datastructures (even mutation) from both languages.
-
-You can create a python function from a clojure function with create-function.  You can
-create a new bridge type by implementing the `libpython_clj.jna.JVMBridge` interface:
-
-```java
-public interface JVMBridge extends AutoCloseable
-{
-  public Pointer getAttr(String name);
-  public void setAttr(String name, Pointer val);
-  public String[] dir();
-  public Object interpreter();
-  public Object wrappedObject();
-  // Called from python when the python mirror is deleted.
-  // This had better not throw anything.
-  public default void close() {}
-}
-```
-
-If all you want to do is override the attribute map that is simple.  Here is the bridge
-for java.util.Map:
-
-```clojure
-(defn jvm-map->python
-  ^Pointer [^Map jvm-data]
-  (with-gil
-    (let [att-map
-          {"__contains__" (jvm-fn->python #(.containsKey jvm-data %))
-           "__eq__" (jvm-fn->python #(.equals jvm-data %))
-           "__getitem__" (jvm-fn->python #(.get jvm-data %))
-           "__setitem__" (jvm-fn->python #(.put jvm-data %1 %2))
-           "__hash__" (jvm-fn->python #(.hashCode jvm-data))
-           "__iter__" (jvm-fn->python #(.iterator ^Iterable jvm-data))
-           "__len__" (jvm-fn->python #(.size jvm-data))
-           "__str__" (jvm-fn->python #(.toString jvm-data))
-           "clear" (jvm-fn->python #(.clear jvm-data))
-           "keys" (jvm-fn->python #(seq (.keySet jvm-data)))
-           "values" (jvm-fn->python #(seq (.values jvm-data)))
-           "pop" (jvm-fn->python #(.remove jvm-data %))}]
-      (create-bridge-from-att-map jvm-data att-map))))
-```
-
-
-### IO
-
-`sys.stdout` and `sys.stderr` are redirected to `*out*` and `*err*` respectively.
-This rerouting is done using a bridge that is then set as `sys.stdout` or `sys.stderr`:
-
-```clojure
-(defn create-var-writer
-  "Returns an unregistered bridge"
-  ^Pointer [writer-var]
-  (with-gil
-    (create-bridge-from-att-map
-     writer-var
-     {"write" (->python (fn [& args]
-                          (.write ^Writer @writer-var (str (first args)))))
-      "flush" (->python (fn [& args]))
-      "isatty" (->python (fn [& args]
-                           (libpy/Py_False)))
-      })))
-
-(defn setup-std-writer
-  [writer-var sys-mod-attname]
-  (with-gil
-    (let [sys-module (import-module "sys")
-          std-out-writer (get-or-create-var-writer writer-var)]
-      (py-proto/set-attr! sys-module sys-mod-attname std-out-writer)
-      :ok)))
-
-
-(defn initialize!
-  [& {:keys [program-name no-io-redirect?]}]
-  (when-not @pyinterp/*main-interpreter*
-    (pyinterp/initialize! program-name)
-    ;;setup bridge mechansim and io redirection
-    (pyinterop/register-bridge-type!)
-    (when-not no-io-redirect?
-      (pyinterop/setup-std-writer #'*err* "stderr")
-      (pyinterop/setup-std-writer #'*out* "stdout")))
-  :ok)
-```

From ceb4e5e9a4d38c5189ca558886f5f32c3aba0772 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 4 Mar 2022 09:08:21 -0700
Subject: [PATCH 402/456] Updates trying to enable pregeneration of all
 required classes.

---
 .gitignore                        |  3 ++-
 deps.edn                          |  4 ++--
 docs/Usage.html                   | 20 +++++++---------
 src/libpython_clj2/python/ffi.clj | 39 +++++++++++++++++--------------
 4 files changed, 35 insertions(+), 31 deletions(-)

diff --git a/.gitignore b/.gitignore
index 1ccfa12..6bd4f64 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,4 +19,5 @@ a.out
 /.idea
 *.iml
 .lsp
-.clj-kondo
\ No newline at end of file
+.clj-kondo
+pregen-ffi-test
\ No newline at end of file
diff --git a/deps.edn b/deps.edn
index 5511b60..f1d3c1a 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "9.009"}
+        cnuernber/dtype-next {:mvn/version "9.015"}
         net.java.dev.jna/jna {:mvn/version "5.10.0"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
@@ -55,7 +55,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.018"
+                        :version "2.019-SNAPSHOT"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index a87ade9..73f016b 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -28,17 +28,15 @@ <h4>MacOSX</h4>
 <h3>Initialize python</h3>
 <pre><code class="language-clojure">user&gt;
 
-user&gt; (require '[libpython-clj.python
-                 :refer [as-python as-jvm
-                         -&gt;python -&gt;jvm
-                         get-attr call-attr call-attr-kw
-                         get-item att-type-map
-                         call call-kw initialize!
-                         as-numpy as-tensor -&gt;numpy
-                         run-simple-string
-                         add-module module-dict
-                         import-module
-                         python-type]])
+user&gt; (require [libpython-clj2.python
+          :refer [as-python as-jvm
+                  -&gt;python -&gt;jvm
+                  get-attr call-attr call-attr-kw
+                  get-item initialize!
+                  run-simple-string
+                  add-module module-dict
+                  import-module
+                  python-type]])
 nil
 
 ; Mac and Linux
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index 3aecbba..773d1f9 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -303,18 +303,22 @@ Each call must be matched with PyGILState_Release"}
                           :doc "Mark a python function as being an instance method."}
    })
 
+(defn define-library!
+  [python-lib-classname]
+  (dt-ffi/define-library
+    python-library-fns
+    ["_Py_NoneStruct"
+     "_Py_FalseStruct"
+     "_Py_TrueStruct"
+     "PyType_Type"
+     "PyExc_StopIteration"
+     "PyRange_Type"
+     "PyExc_Exception"]
+    {:classname python-lib-classname}))
+
+
+(def python-lib-def* (delay (define-library! nil)))
 
-(def python-lib-def* (delay (dt-ffi/define-library
-                              python-library-fns
-                              ["_Py_NoneStruct"
-                               "_Py_FalseStruct"
-                               "_Py_TrueStruct"
-                               "PyType_Type"
-                               "PyExc_StopIteration"
-                               "PyRange_Type"
-                               "PyExc_Exception"]
-                              nil
-                              )))
 (defonce pyobject-struct-type*
   (delay (dt-struct/define-datatype!
            :pyobject [{:name :ob_refcnt :datatype (ffi-size-t/size-t-type)}
@@ -345,19 +349,19 @@ Each call must be matched with PyGILState_Release"}
 
 
 (defn reset-library!
-  []
+  [& [library-definition]]
   (when @library-path*
-    (reset! library* (dt-ffi/instantiate-library @python-lib-def*
+    (reset! library* (dt-ffi/instantiate-library (or library-definition @python-lib-def*)
                                                  (:libpath @library-path*)))))
 
 
 (defn set-library!
-  [libpath]
+  [libpath & [library-definition]]
   (when @library*
     (log/warnf "Python library is being reinitialized to (%s).  Is this what you want?"
                libpath))
   (reset! library-path* {:libpath libpath})
-  (reset-library!))
+  (reset-library! library-definition))
 
 ;;Useful for repling around - this regenerates the library function bindings
 (reset-library!)
@@ -572,11 +576,12 @@ Each call must be matched with PyGILState_Release"}
 
 
 (defn initialize!
-  [libpath python-home & [{:keys [signals? program-name python-home]
+  [libpath python-home & [{:keys [signals? program-name python-home
+                                  library-definition]
                            :or {signals? true
                                 program-name ""}
                            :as opts}]]
-  (set-library! libpath)
+  (set-library! libpath library-definition)
   (when-not (= 1 (Py_IsInitialized))
     (log/debug "Initializing Python C Layer")
     ;;platform specific encoding

From 9a4536006e43905632ff7c8dcc27aa00e10bd2df Mon Sep 17 00:00:00 2001
From: shaun <shaunewilliams@gmail.com>
Date: Mon, 25 Apr 2022 13:19:56 -0500
Subject: [PATCH 403/456] Fix set-item! docstring (#203)

---
 src/libpython_clj2/python.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index d23d331..9409a09 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -232,7 +232,7 @@ user> (py/py. np linspace 2 3 :num 10)
 
 
 (defn set-item!
-  "Get an item from a python object using  __setitem__"
+  "Set an item on a python object using  __setitem__"
   [pyobj item-name item-val]
   (with-gil (py-proto/set-item! pyobj item-name item-val))
   pyobj)

From 91c7ca0895102cb918ff8c24a67ea668acc54543 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 3 Sep 2022 11:35:24 -0600
Subject: [PATCH 404/456] Adding pickle example to usage doc

---
 topics/Usage.md | 94 ++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 85 insertions(+), 9 deletions(-)

diff --git a/topics/Usage.md b/topics/Usage.md
index fe4b132..2e4ef37 100644
--- a/topics/Usage.md
+++ b/topics/Usage.md
@@ -75,7 +75,7 @@ INFO: Reference thread starting
 
 This dynamically finds the python shared library and loads it using output from
 the python3 executable on your system.  For information about how that works,
-please checkout the code 
+please checkout the code
 [here](https://github.com/cnuernber/libpython-clj/blob/master/src/libpython_clj/python/interpreter.clj#L30).
 
 
@@ -308,28 +308,28 @@ user> (py/$.. numpy random shuffle)
 
 ##### New sugar (fixme)
 
-`libpython-clj` offers syntactic forms similar to those offered by 
-Clojure for interacting with Python classes and objects. 
+`libpython-clj` offers syntactic forms similar to those offered by
+Clojure for interacting with Python classes and objects.
 
 **Class/object methods**
 Where in Clojure you would use `(. obj method arg1 arg2 ... argN)`,
-you can use `(py. pyobj method arg1 arg2 ... argN)`.  
+you can use `(py. pyobj method arg1 arg2 ... argN)`.
 
 In Python, this is equivalent to `pyobj.method(arg1, arg2, ..., argN)`.
 Concrete examples are shown below.
 
 **Class/object attributes**
-Where in Clojure you would use `(.- obj attr)`, you can use 
+Where in Clojure you would use `(.- obj attr)`, you can use
 `(py.- pyobj attr)`.
 
-In Python, this is equivalent to `pyobj.attr`. 
+In Python, this is equivalent to `pyobj.attr`.
 Concrete examples shown below.
 
 **Nested attribute access**
 To achieve a chain of method/attribute access, use the `py..` for.
 
-```clojure 
-(py.. (requests/get "http://www.google.com") 
+```clojure
+(py.. (requests/get "http://www.google.com")
       -content
       (decode "latin-1"))
 ```
@@ -337,7 +337,7 @@ To achieve a chain of method/attribute access, use the `py..` for.
 
 **Examples**
 
-```clojure 
+```clojure
 user=> (require '[libpython-clj.python :as py :refer [py. py.. py.-]])
 nil
 user=> (require '[libpython-clj.require :refer [require-python]])
@@ -418,3 +418,79 @@ please refer to the datatype library [documentation](https://github.com/techasce
 
 Just keep in mind, careless usage of zero copy is going to cause spooky action at a
     distance.
+
+
+### Pickle
+
+Speaking of numpy, you can pickle python objects and transform the result via numpy and dtype
+to a java byte array and back:
+
+
+```clojure
+user> (require '[libpython-clj2.python :as py])
+nil
+user> (py/initialize!)
+Sep 03, 2022 11:23:34 AM clojure.tools.logging$eval5948$fn__5951 invoke
+INFO: Detecting startup info
+Sep 03, 2022 11:23:34 AM clojure.tools.logging$eval5948$fn__5951 invoke
+INFO: Startup info {:lib-version "3.9", :java-library-path-addendum "/home/chrisn/miniconda3/lib", :exec-prefix "/home/chrisn/miniconda3", :executable "/home/chrisn/miniconda3/bin/python3", :libnames ("python3.9m" "python3.9"), :prefix "/home/chrisn/miniconda3", :base-prefix "/home/chrisn/miniconda3", :libname "python3.9m", :base-exec-prefix "/home/chrisn/miniconda3", :python-home "/home/chrisn/miniconda3", :version [3 9 1], :platform "linux"}
+Sep 03, 2022 11:23:34 AM clojure.tools.logging$eval5948$fn__5951 invoke
+INFO: Prefixing java library path: /home/chrisn/miniconda3/lib
+Sep 03, 2022 11:23:35 AM clojure.tools.logging$eval5948$fn__5951 invoke
+INFO: Loading python library: python3.9
+Sep 03, 2022 11:23:35 AM clojure.tools.logging$eval5948$fn__5951 invoke
+INFO: Reference thread starting
+:ok
+user> (def data (py/->python {:a 1 :b 2}))
+#'user/data
+user> (def pickle (py/import-module "pickle"))
+#'user/pickle
+user> (def bdata (py/py. pickle dumps data))
+#'user/bdata
+user> bdata
+b'\x80\x04\x95\x11\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x01a\x94K\x01\x8c\x01b\x94K\x02u.'
+user> (def np (py/import-module "numpy"))
+#'user/np
+user> (py/py. np frombuffer bdata :dtype "int8")
+[-128    4 -107   17    0    0    0    0    0    0    0  125 -108   40
+ -116    1   97 -108   75    1 -116    1   98 -108   75    2  117   46]
+user> (require '[libpython-clj2.python.np-array])
+nil
+user> (def ary (py/py. np frombuffer bdata :dtype "int8"))
+#'user/ary
+user> (py/->jvm ary)
+#tech.v3.tensor<int8>[28]
+[-128 4 -107 17 0 0 0 0 0 0 0 125 -108 40 -116 1 97 -108 75 1 -116 1 98 -108 75 2 117 46]
+user> (require '[tech.v3.datatype :as dt])
+nil
+user> (dt/->byte-array *2)
+[-128, 4, -107, 17, 0, 0, 0, 0, 0, 0, 0, 125, -108, 40, -116, 1, 97, -108, 75, 1,
+ -116, 1, 98, -108, 75, 2, 117, 46]
+user> (require '[tech.v3.tensor :as dtt])
+nil
+user> (dtt/as-tensor *2)
+nil
+user> (def bdata *3)
+#'user/bdata
+user> bdata
+[-128, 4, -107, 17, 0, 0, 0, 0, 0, 0, 0, 125, -108, 40, -116, 1, 97, -108, 75, 1,
+ -116, 1, 98, -108, 75, 2, 117, 46]
+user> (type bdata)
+[B
+user> (def tens (dtt/reshape bdata [(dt/ecount bdata)]))
+#'user/tens
+user> (def pdata (py/->python tens))
+#'user/pdata
+user> pdata
+[-128    4 -107   17    0    0    0    0    0    0    0  125 -108   40
+ -116    1   97 -108   75    1 -116    1   98 -108   75    2  117   46]
+user> (py/python-type *1)
+:ndarray
+user> (def py-ary *2)
+#'user/py-ary
+user> (def py-bytes (py/py. py-ary tobytes))
+#'user/py-bytes
+user> (py/py. pickle loads py-bytes)
+{'a': 1, 'b': 2}
+user>
+```

From c0ca0f6e84c3bdff3e7159e128085eff2838951c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 3 Sep 2022 11:37:09 -0600
Subject: [PATCH 405/456] Updating docs to include pickle example in usage.

---
 docs/Usage.html                          | 74 +++++++++++++++++++++++-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  4 +-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        |  2 +-
 docs/libpython-clj2.python.html          |  2 +-
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 13 files changed, 85 insertions(+), 15 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index 73f016b..b8e4c8b 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
@@ -270,7 +270,7 @@ <h5>New sugar (fixme)</h5>
 Concrete examples shown below.</p>
 <p><strong>Nested attribute access</strong>
 To achieve a chain of method/attribute access, use the <code>py..</code> for.</p>
-<pre><code class="language-clojure">(py.. (requests/get "http://www.google.com") 
+<pre><code class="language-clojure">(py.. (requests/get "http://www.google.com")
       -content
       (decode "latin-1"))
 </code></pre>
@@ -348,4 +348,74 @@ <h3>Numpy</h3>
 please refer to the datatype library <a href="https://github.com/techascent/tech.datatype/tree/master/docs">documentation</a>.</p>
 <p>Just keep in mind, careless usage of zero copy is going to cause spooky action at a
 distance.</p>
+<h3>Pickle</h3>
+<p>Speaking of numpy, you can pickle python objects and transform the result via numpy and dtype
+to a java byte array and back:</p>
+<pre><code class="language-clojure">user&gt; (require '[libpython-clj2.python :as py])
+nil
+user&gt; (py/initialize!)
+Sep 03, 2022 11:23:34 AM clojure.tools.logging$eval5948$fn__5951 invoke
+INFO: Detecting startup info
+Sep 03, 2022 11:23:34 AM clojure.tools.logging$eval5948$fn__5951 invoke
+INFO: Startup info {:lib-version "3.9", :java-library-path-addendum "/home/chrisn/miniconda3/lib", :exec-prefix "/home/chrisn/miniconda3", :executable "/home/chrisn/miniconda3/bin/python3", :libnames ("python3.9m" "python3.9"), :prefix "/home/chrisn/miniconda3", :base-prefix "/home/chrisn/miniconda3", :libname "python3.9m", :base-exec-prefix "/home/chrisn/miniconda3", :python-home "/home/chrisn/miniconda3", :version [3 9 1], :platform "linux"}
+Sep 03, 2022 11:23:34 AM clojure.tools.logging$eval5948$fn__5951 invoke
+INFO: Prefixing java library path: /home/chrisn/miniconda3/lib
+Sep 03, 2022 11:23:35 AM clojure.tools.logging$eval5948$fn__5951 invoke
+INFO: Loading python library: python3.9
+Sep 03, 2022 11:23:35 AM clojure.tools.logging$eval5948$fn__5951 invoke
+INFO: Reference thread starting
+:ok
+user&gt; (def data (py/-&gt;python {:a 1 :b 2}))
+#'user/data
+user&gt; (def pickle (py/import-module "pickle"))
+#'user/pickle
+user&gt; (def bdata (py/py. pickle dumps data))
+#'user/bdata
+user&gt; bdata
+b'\x80\x04\x95\x11\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x01a\x94K\x01\x8c\x01b\x94K\x02u.'
+user&gt; (def np (py/import-module "numpy"))
+#'user/np
+user&gt; (py/py. np frombuffer bdata :dtype "int8")
+[-128    4 -107   17    0    0    0    0    0    0    0  125 -108   40
+ -116    1   97 -108   75    1 -116    1   98 -108   75    2  117   46]
+user&gt; (require '[libpython-clj2.python.np-array])
+nil
+user&gt; (def ary (py/py. np frombuffer bdata :dtype "int8"))
+#'user/ary
+user&gt; (py/-&gt;jvm ary)
+#tech.v3.tensor&lt;int8&gt;[28]
+[-128 4 -107 17 0 0 0 0 0 0 0 125 -108 40 -116 1 97 -108 75 1 -116 1 98 -108 75 2 117 46]
+user&gt; (require '[tech.v3.datatype :as dt])
+nil
+user&gt; (dt/-&gt;byte-array *2)
+[-128, 4, -107, 17, 0, 0, 0, 0, 0, 0, 0, 125, -108, 40, -116, 1, 97, -108, 75, 1,
+ -116, 1, 98, -108, 75, 2, 117, 46]
+user&gt; (require '[tech.v3.tensor :as dtt])
+nil
+user&gt; (dtt/as-tensor *2)
+nil
+user&gt; (def bdata *3)
+#'user/bdata
+user&gt; bdata
+[-128, 4, -107, 17, 0, 0, 0, 0, 0, 0, 0, 125, -108, 40, -116, 1, 97, -108, 75, 1,
+ -116, 1, 98, -108, 75, 2, 117, 46]
+user&gt; (type bdata)
+[B
+user&gt; (def tens (dtt/reshape bdata [(dt/ecount bdata)]))
+#'user/tens
+user&gt; (def pdata (py/-&gt;python tens))
+#'user/pdata
+user&gt; pdata
+[-128    4 -107   17    0    0    0    0    0    0    0  125 -108   40
+ -116    1   97 -108   75    1 -116    1   98 -108   75    2  117   46]
+user&gt; (py/python-type *1)
+:ndarray
+user&gt; (def py-ary *2)
+#'user/py-ary
+user&gt; (def py-bytes (py/py. py-ary tobytes))
+#'user/py-bytes
+user&gt; (py/py. pickle loads py-bytes)
+{'a': 1, 'b': 2}
+user&gt;
+</code></pre>
 </div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/embedded.html b/docs/embedded.html
index b2361f1..e69bd7b 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index db6809f..f49e805 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 66a40ed..de5dc64 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.018</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.019-SNAPSHOT</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 3e675b8..14834c7 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index e8fea9d..2f47f51 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 4715d86..89fdeb8 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 14dee0e..117e6c9 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 6c4c716..aa66d0b 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index f5f00ec..658ec92 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 8824144..8fb56dd 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 6698963..a9aeddd 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index dff495c..f093f57 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>

From d37f06c48b75365f5dcb0dc2896cc9c3daabf89a Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Mon, 12 Sep 2022 21:17:30 +0200
Subject: [PATCH 406/456] Various fixes to the Usage.md (#214)

* added missing quote

* varias fixes in the Usage.md

Most where still referring to < 2.0 API
---
 topics/Usage.md | 113 +++++++++++++++---------------------------------
 1 file changed, 36 insertions(+), 77 deletions(-)

diff --git a/topics/Usage.md b/topics/Usage.md
index 2e4ef37..db1ecc1 100644
--- a/topics/Usage.md
+++ b/topics/Usage.md
@@ -36,19 +36,19 @@ Python installation instructions [here](https://docs.python-guide.org/starting/i
 
 
 ### Initialize python
-
 ```clojure
-user>
+user> (require '[libpython-clj2.python
+                 :refer [as-python as-jvm
+                         ->python ->jvm
+                         get-attr call-attr call-attr-kw
+                         get-item initialize!
+                         run-simple-string
+                         add-module module-dict
+                         import-module
+                         python-type
+                         dir]
+                 :as py])
 
-user> (require [libpython-clj2.python
-          :refer [as-python as-jvm
-                  ->python ->jvm
-                  get-attr call-attr call-attr-kw
-                  get-item initialize!
-                  run-simple-string
-                  add-module module-dict
-                  import-module
-                  python-type]])
 nil
 
 ; Mac and Linux
@@ -158,70 +158,27 @@ user> (get-attr ones-ary "shape")
 user> (vec (get-attr ones-ary "shape"))
 [2 3]
 
-user> (att-type-map ones-ary)
-{"T" :ndarray,
- "__abs__" :method-wrapper,
- "__add__" :method-wrapper,
- "__and__" :method-wrapper,
- "__array__" :builtin-function-or-method,
- "__array_finalize__" :none-type,
- "__array_function__" :builtin-function-or-method,
- "__array_interface__" :dict,
- "__array_prepare__" :builtin-function-or-method,
- "__array_priority__" :float,
- "__array_struct__" :py-capsule,
- "__array_ufunc__" :builtin-function-or-method,
- "__array_wrap__" :builtin-function-or-method,
- "__bool__" :method-wrapper,
- "__class__" :type,
- "__complex__" :builtin-function-or-method,
- "__contains__" :method-wrapper,
- ...
- "std" :builtin-function-or-method,
- "strides" :tuple,
- "sum" :builtin-function-or-method,
- "swapaxes" :builtin-function-or-method,
- "take" :builtin-function-or-method,
- "tobytes" :builtin-function-or-method,
- "tofile" :builtin-function-or-method,
- "tolist" :builtin-function-or-method,
- "tostring" :builtin-function-or-method,
- "trace" :builtin-function-or-method,
- "transpose" :builtin-function-or-method,
- "var" :builtin-function-or-method,
- "view" :builtin-function-or-method}
-```
-
-
-### att-type-map
-
-It can be extremely helpful to print out the attribute name->attribute type map:
-
-```clojure
-user> (att-type-map ones-ary)
-{"T" :ndarray,
- "__abs__" :method-wrapper,
- "__add__" :method-wrapper,
- "__and__" :method-wrapper,
- "__array__" :builtin-function-or-method,
- "__array_finalize__" :none-type,
- "__array_function__" :builtin-function-or-method,
- "__array_interface__" :dict,
+user> (dir ones-ary)
+["T"
+ "__abs__"
+ "__add__"
+ "__and__"
+ "__array__"
+ "__array_finalize__"
  ...
-  "real" :ndarray,
- "repeat" :builtin-function-or-method,
- "reshape" :builtin-function-or-method,
- "resize" :builtin-function-or-method,
- "round" :builtin-function-or-method,
- "searchsorted" :builtin-function-or-method,
- "setfield" :builtin-function-or-method,
- "setflags" :builtin-function-or-method,
- "shape" :tuple,
- "size" :int,
- "sort" :builtin-function-or-method,
  ...
-}
-```
+ "strides"
+ "sum"
+ "swapaxes"
+ "take"
+ "tobytes"
+ "tofile"
+ "tolist"
+ "tostring"
+ "trace"
+ "transpose"
+ "var"
+ "view"]
 
 ### DataFrame access full example
 
@@ -240,6 +197,7 @@ table.loc[row_date]
 
 ```clojure
 ; Clojure
+(require '[libpython-clj2.require :refer [require-python]])
 (require-python '[numpy :as np])
 (require-python '[pandas :as pan])
 
@@ -306,7 +264,7 @@ user> (py/$.. numpy random shuffle)
 <built-in method shuffle of numpy.random.mtrand.RandomState object at 0x7fa66410cca8>
 ```
 
-##### New sugar (fixme)
+##### Extra sugar 
 
 `libpython-clj` offers syntactic forms similar to those offered by
 Clojure for interacting with Python classes and objects.
@@ -338,9 +296,9 @@ To achieve a chain of method/attribute access, use the `py..` for.
 **Examples**
 
 ```clojure
-user=> (require '[libpython-clj.python :as py :refer [py. py.. py.-]])
+user=> (require '[libpython-clj2.python :as py :refer [py. py.. py.-]])
 nil
-user=> (require '[libpython-clj.require :refer [require-python]])
+user=> (require '[libpython-clj2.require :refer [require-python]])
 
 ... debug info ...
 
@@ -382,6 +340,7 @@ user=> (py.. requests (get "http://www.google.com") -content (decode "latin-1"))
 Speaking of numpy, you can move data between numpy and java easily.
 
 ```clojure
+(require '[tech.v3.tensor :refer [as-tensor]])
 user> (def tens-data (as-tensor ones-ary))
 #'user/tens-data
 user> (println tens-data)
@@ -391,7 +350,7 @@ user> (println tens-data)
 nil
 
 
-user> (require '[tech.v2.datatype :as dtype])
+user> (require '[tech.v3.datatype :as dtype])
 nil
 user> (def ignored (dtype/copy! (repeat 6 5) tens-data))
 #'user/ignored

From f231642d40bc2330c801262870e94ab4283bdbe2 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 13 Sep 2022 07:40:47 -0600
Subject: [PATCH 407/456] Fixes

---
 topics/Usage.md | 23 +++++++++++++----------
 1 file changed, 13 insertions(+), 10 deletions(-)

diff --git a/topics/Usage.md b/topics/Usage.md
index db1ecc1..2000fa3 100644
--- a/topics/Usage.md
+++ b/topics/Usage.md
@@ -264,7 +264,7 @@ user> (py/$.. numpy random shuffle)
 <built-in method shuffle of numpy.random.mtrand.RandomState object at 0x7fa66410cca8>
 ```
 
-##### Extra sugar 
+##### Extra sugar
 
 `libpython-clj` offers syntactic forms similar to those offered by
 Clojure for interacting with Python classes and objects.
@@ -340,23 +340,26 @@ user=> (py.. requests (get "http://www.google.com") -content (decode "latin-1"))
 Speaking of numpy, you can move data between numpy and java easily.
 
 ```clojure
-(require '[tech.v3.tensor :refer [as-tensor]])
-user> (def tens-data (as-tensor ones-ary))
+(require '[tech.v3.tensor :as dtt])
+;;includes the appropriate protocols and multimethod overloads
+(require '[libpython-clj2.python.np-array]
+;;python objects created now for numpy arrays will be different.  So you have to require
+;;np-array *before* you create your numpy data.
+user> (def ones-ary (py/py. np ones [2 3]))
+#'user/ones-ary
+user> (def tens-data (dtt/as-tensor ones-ary))
 #'user/tens-data
-user> (println tens-data)
-#tech.v2.tensor<float64>[2 3]
+user> tens-data
+#tech.v3.tensor<float64>[2 3]
 [[1.000 1.000 1.000]
  [1.000 1.000 1.000]]
-nil
 
 
 user> (require '[tech.v3.datatype :as dtype])
 nil
-user> (def ignored (dtype/copy! (repeat 6 5) tens-data))
+;;Only constant-time count items can be copied, so vectors and arrays and such.
+user> (def ignored (dtype/copy! (vec (repeat 6 5)) tens-data))
 #'user/ignored
-user> (.put main-globals "ones_ary" ones_ary)
-Syntax error compiling at (*cider-repl cnuernber/libpython-clj:localhost:39019(clj)*:191:7).
-Unable to resolve symbol: ones_ary in this context
 user> (.put main-globals "ones_ary" ones-ary)
 nil
 

From cf47c2bafe0b99ce847909d432d4c1c743492265 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 13 Sep 2022 07:45:31 -0600
Subject: [PATCH 408/456] Updating docs.

---
 docs/Usage.html                          | 138 +++++++++--------------
 docs/embedded.html                       |   2 +-
 docs/environments.html                   |   2 +-
 docs/index.html                          |   4 +-
 docs/libpython-clj2.codegen.html         |   2 +-
 docs/libpython-clj2.embedded.html        |   2 +-
 docs/libpython-clj2.java-api.html        |   2 +-
 docs/libpython-clj2.python.html          |   4 +-
 docs/libpython-clj2.python.np-array.html |   2 +-
 docs/libpython-clj2.require.html         |   2 +-
 docs/new-to-clojure.html                 |   2 +-
 docs/scopes-and-gc.html                  |   2 +-
 docs/slicing.html                        |   2 +-
 13 files changed, 69 insertions(+), 97 deletions(-)

diff --git a/docs/Usage.html b/docs/Usage.html
index b8e4c8b..32c3708 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
@@ -26,17 +26,18 @@ <h4>Ubuntu</h4>
 <h4>MacOSX</h4>
 <p>Python installation instructions <a href="https://docs.python-guide.org/starting/install3/osx/">here</a>.</p>
 <h3>Initialize python</h3>
-<pre><code class="language-clojure">user&gt;
+<pre><code class="language-clojure">user&gt; (require '[libpython-clj2.python
+                 :refer [as-python as-jvm
+                         -&gt;python -&gt;jvm
+                         get-attr call-attr call-attr-kw
+                         get-item initialize!
+                         run-simple-string
+                         add-module module-dict
+                         import-module
+                         python-type
+                         dir]
+                 :as py])
 
-user&gt; (require [libpython-clj2.python
-          :refer [as-python as-jvm
-                  -&gt;python -&gt;jvm
-                  get-attr call-attr call-attr-kw
-                  get-item initialize!
-                  run-simple-string
-                  add-module module-dict
-                  import-module
-                  python-type]])
 nil
 
 ; Mac and Linux
@@ -131,68 +132,34 @@ <h3>Execute Some Python</h3>
 user&gt; (vec (get-attr ones-ary "shape"))
 [2 3]
 
-user&gt; (att-type-map ones-ary)
-{"T" :ndarray,
- "__abs__" :method-wrapper,
- "__add__" :method-wrapper,
- "__and__" :method-wrapper,
- "__array__" :builtin-function-or-method,
- "__array_finalize__" :none-type,
- "__array_function__" :builtin-function-or-method,
- "__array_interface__" :dict,
- "__array_prepare__" :builtin-function-or-method,
- "__array_priority__" :float,
- "__array_struct__" :py-capsule,
- "__array_ufunc__" :builtin-function-or-method,
- "__array_wrap__" :builtin-function-or-method,
- "__bool__" :method-wrapper,
- "__class__" :type,
- "__complex__" :builtin-function-or-method,
- "__contains__" :method-wrapper,
+user&gt; (dir ones-ary)
+["T"
+ "__abs__"
+ "__add__"
+ "__and__"
+ "__array__"
+ "__array_finalize__"
  ...
- "std" :builtin-function-or-method,
- "strides" :tuple,
- "sum" :builtin-function-or-method,
- "swapaxes" :builtin-function-or-method,
- "take" :builtin-function-or-method,
- "tobytes" :builtin-function-or-method,
- "tofile" :builtin-function-or-method,
- "tolist" :builtin-function-or-method,
- "tostring" :builtin-function-or-method,
- "trace" :builtin-function-or-method,
- "transpose" :builtin-function-or-method,
- "var" :builtin-function-or-method,
- "view" :builtin-function-or-method}
-</code></pre>
-<h3>att-type-map</h3>
-<p>It can be extremely helpful to print out the attribute name-&gt;attribute type map:</p>
-<pre><code class="language-clojure">user&gt; (att-type-map ones-ary)
-{"T" :ndarray,
- "__abs__" :method-wrapper,
- "__add__" :method-wrapper,
- "__and__" :method-wrapper,
- "__array__" :builtin-function-or-method,
- "__array_finalize__" :none-type,
- "__array_function__" :builtin-function-or-method,
- "__array_interface__" :dict,
- ...
-  "real" :ndarray,
- "repeat" :builtin-function-or-method,
- "reshape" :builtin-function-or-method,
- "resize" :builtin-function-or-method,
- "round" :builtin-function-or-method,
- "searchsorted" :builtin-function-or-method,
- "setfield" :builtin-function-or-method,
- "setflags" :builtin-function-or-method,
- "shape" :tuple,
- "size" :int,
- "sort" :builtin-function-or-method,
  ...
-}
-</code></pre>
-<h3>DataFrame access full example</h3>
-<p>Here's how to create Pandas DataFrame and accessing its rows via <code>loc</code> in both Python and Clojure:</p>
-<pre><code class="language-python"># Python
+ "strides"
+ "sum"
+ "swapaxes"
+ "take"
+ "tobytes"
+ "tofile"
+ "tolist"
+ "tostring"
+ "trace"
+ "transpose"
+ "var"
+ "view"]
+
+### DataFrame access full example
+
+Here's how to create Pandas DataFrame and accessing its rows via `loc` in both Python and Clojure:
+
+```python
+# Python
 import numpy as np
 import pandas as pan
 
@@ -202,6 +169,7 @@ <h3>DataFrame access full example</h3>
 table.loc[row_date]
 </code></pre>
 <pre><code class="language-clojure">; Clojure
+(require '[libpython-clj2.require :refer [require-python]])
 (require-python '[numpy :as np])
 (require-python '[pandas :as pan])
 
@@ -255,7 +223,7 @@ <h4>Experimental Sugar</h4>
 user&gt; (py/$.. numpy random shuffle)
 &lt;built-in method shuffle of numpy.random.mtrand.RandomState object at 0x7fa66410cca8&gt;
 </code></pre>
-<h5>New sugar (fixme)</h5>
+<h5>Extra sugar</h5>
 <p><code>libpython-clj</code> offers syntactic forms similar to those offered by
 Clojure for interacting with Python classes and objects.</p>
 <p><strong>Class/object methods</strong>
@@ -276,9 +244,9 @@ <h5>New sugar (fixme)</h5>
 </code></pre>
 <p>(<strong>Note</strong>: requires Python <code>requests</code> module installled)</p>
 <p><strong>Examples</strong></p>
-<pre><code class="language-clojure">user=&gt; (require '[libpython-clj.python :as py :refer [py. py.. py.-]])
+<pre><code class="language-clojure">user=&gt; (require '[libpython-clj2.python :as py :refer [py. py.. py.-]])
 nil
-user=&gt; (require '[libpython-clj.require :refer [require-python]])
+user=&gt; (require '[libpython-clj2.require :refer [require-python]])
 
 ... debug info ...
 
@@ -314,22 +282,26 @@ <h5>New sugar (fixme)</h5>
 </code></pre>
 <h3>Numpy</h3>
 <p>Speaking of numpy, you can move data between numpy and java easily.</p>
-<pre><code class="language-clojure">user&gt; (def tens-data (as-tensor ones-ary))
+<pre><code class="language-clojure">(require '[tech.v3.tensor :as dtt])
+;;includes the appropriate protocols and multimethod overloads
+(require '[libpython-clj2.python.np-array]
+;;python objects created now for numpy arrays will be different.  So you have to require
+;;np-array *before* you create your numpy data.
+user&gt; (def ones-ary (py/py. np ones [2 3]))
+#'user/ones-ary
+user&gt; (def tens-data (dtt/as-tensor ones-ary))
 #'user/tens-data
-user&gt; (println tens-data)
-#tech.v2.tensor&lt;float64&gt;[2 3]
+user&gt; tens-data
+#tech.v3.tensor&lt;float64&gt;[2 3]
 [[1.000 1.000 1.000]
  [1.000 1.000 1.000]]
-nil
 
 
-user&gt; (require '[tech.v2.datatype :as dtype])
+user&gt; (require '[tech.v3.datatype :as dtype])
 nil
-user&gt; (def ignored (dtype/copy! (repeat 6 5) tens-data))
+;;Only constant-time count items can be copied, so vectors and arrays and such.
+user&gt; (def ignored (dtype/copy! (vec (repeat 6 5)) tens-data))
 #'user/ignored
-user&gt; (.put main-globals "ones_ary" ones_ary)
-Syntax error compiling at (*cider-repl cnuernber/libpython-clj:localhost:39019(clj)*:191:7).
-Unable to resolve symbol: ones_ary in this context
 user&gt; (.put main-globals "ones_ary" ones-ary)
 nil
 
diff --git a/docs/embedded.html b/docs/embedded.html
index e69bd7b..b2361f1 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index f49e805..db6809f 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index de5dc64..66a40ed 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.019-SNAPSHOT</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.018</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 14834c7..3e675b8 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 2f47f51..e8fea9d 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 89fdeb8..4715d86 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 117e6c9..af6cde1 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
@@ -246,7 +246,7 @@
 return 0;</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L366">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object.  Returns pyobj.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L208">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a> attributes.  Returns pyobj.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L215">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using  <strong>setitem</strong></p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L215">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Set an item on a python object using  <strong>setitem</strong></p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a>. Returns pyobj</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context.  All python objects allocated within this
 context will be released at the termination of this context.
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index aa66d0b..6c4c716 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 658ec92..f5f00ec 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 8fb56dd..8824144 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index a9aeddd..6698963 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index f093f57..dff495c 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019-SNAPSHOT</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>

From 996021e709044ba18f1c91a7ff44eaedca6a00a4 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 15 Sep 2022 14:55:56 -0600
Subject: [PATCH 409/456] Fixes #216

---
 src/libpython_clj2/python/io_redirect.clj | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/libpython_clj2/python/io_redirect.clj b/src/libpython_clj2/python/io_redirect.clj
index 5849275..203ed02 100644
--- a/src/libpython_clj2/python/io_redirect.clj
+++ b/src/libpython_clj2/python/io_redirect.clj
@@ -10,6 +10,8 @@
             [clojure.tools.logging :as log])
   (:import [java.io Writer]))
 
+(set! *warn-on-reflection* true)
+
 
 (defn self->writer
   ^Writer [self]
@@ -32,7 +34,9 @@
                 (py-ffi/py-none))
               {:arg-converter identity})
      "flush" (py-class/make-tuple-instance-fn
-              (constantly (py-ffi/py-none)))
+              (fn [self & args] (.flush (self->writer self)) (py-ffi/py-none))
+              {:arg-converter identity} ;;avoid paying anything for argument conversion
+              )
      "isatty" (py-class/make-tuple-instance-fn
                (constantly (py-ffi/py-false)))})))
 
@@ -53,3 +57,16 @@
   []
   (setup-std-writer #'*err* "stderr")
   (setup-std-writer #'*out* "stdout"))
+
+
+(comment
+  ;;Ensure flush works
+  (require '[libpython-clj2.python :as py])
+  (py/initialize!)
+  (def _)
+  (def _ (py/run-simple-string "import sys\nimport time"))
+  (py/run-simple-string "for i in range(10):
+\ttime.sleep(1)
+\tsys.stderr.write('#')
+\tsys.stdout.flush()")
+  )

From 5884e5dd1c2f56e0fd921f4608d7548fa8db7ea1 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 15 Sep 2022 15:26:07 -0600
Subject: [PATCH 410/456] Release 2.019

---
 CHANGELOG.md                             | 5 +++++
 deps.edn                                 | 8 ++++----
 docs/Usage.html                          | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 4 ++--
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.java-api.html        | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 15 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dd517dd..3a0ca25 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,9 @@
 # Time for a ChangeLog!
+## 2.019
+ * Upgrade to clojure 1.11 as development version.
+ * Upgrade dtype-next to get rid of 1.11 warnings (and for unary min,max).
+ * Upgrade jna to latest version for greater x-platform support.
+
 ## 2.017
  * Tested AOT and codegen of numpy namespace to ensure it is loadable and works as expected.
  * This fixed an issue with the codegen system.
diff --git a/deps.edn b/deps.edn
index f1d3c1a..d4b0445 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,7 +1,7 @@
 {:paths ["src"]
- :deps {org.clojure/clojure  {:mvn/version "1.10.2" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "9.015"}
-        net.java.dev.jna/jna {:mvn/version "5.10.0"}
+ :deps {org.clojure/clojure  {:mvn/version "1.11.1" :scope "provided"}
+        cnuernber/dtype-next {:mvn/version "9.032"}
+        net.java.dev.jna/jna {:mvn/version "5.12.1"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
  :aliases {:dev
@@ -55,7 +55,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.019-SNAPSHOT"
+                        :version "2.019"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 32c3708..8ee7c49 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/embedded.html b/docs/embedded.html
index b2361f1..15c6bb5 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index db6809f..1fe0928 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 66a40ed..382a1d0 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.018</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.019</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 3e675b8..f95235d 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index e8fea9d..fc8f183 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 4715d86..6463aab 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index af6cde1..ddbe894 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 6c4c716..5dd495f 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index f5f00ec..e96cbe3 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 8824144..31153ce 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 6698963..0863db7 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index dff495c..b5f541b 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.018</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>

From f070fd383aafa508469f3cbe5027b0a28eb898ed Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Oct 2022 10:27:46 -0600
Subject: [PATCH 411/456] Fixes #220

---
 CHANGELOG.md                         |  4 ++++
 src/libpython_clj2/python.clj        | 29 +++++++++++++++++++++++++++-
 src/libpython_clj2/python/ffi.clj    |  8 ++++++++
 test/libpython_clj2/classes_test.clj | 20 +++++++++++++++++++
 4 files changed, 60 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3a0ca25..3f5fd40 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,8 @@
 # Time for a ChangeLog!
+## 2.020
+ * Better support for running with `-Dlibpython_clj.manual_gil=true` - `with-manual-gil`.  
+   Addresses [issue 221](https://github.com/clj-python/libpython-clj/issues/221).
+
 ## 2.019
  * Upgrade to clojure 1.11 as development version.
  * Upgrade dtype-next to get rid of 1.11 warnings (and for unary min,max).
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 9409a09..5ebebf1 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -126,7 +126,7 @@ user> (py/py. np linspace 2 3 :num 10)
 
 (defmacro with-gil
   "Capture the gil for an extended amount of time.  This can greatly speed up
-  operations as the mutex is captured and held once as opposed to find grained
+  operations as the mutex is captured and held once as opposed to fine grained
   grabbing/releasing of the mutex."
   [& body]
   `(py-ffi/with-gil
@@ -146,6 +146,33 @@ user> (py/py. np linspace 2 3 :num 10)
      (pygc/with-stack-context
        ~@body)))
 
+
+(defmacro with-manual-gil
+  "When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
+  the python runtime with this locker.  This includes calls to require-python or any other
+  pathways.
+
+```clojure
+  (with-manual-gil
+    ...)
+```
+  "
+  [& body]
+  `(with-open [locker# (py-ffi/manual-gil-locker)]
+     ~@body))
+
+
+(defmacro with-manual-gil-stack-rc-context
+  "When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
+  the python runtime with this locker.  This includes calls to require-python or any other
+  pathways.  This macro furthermore defines a stack-based gc context to immediately release
+  objects when the stack frame exits."
+  [& body]
+  `(with-manual-gil
+     (pygc/with-stack-context
+       ~@body)))
+
+
 (declare ->jvm)
 
 (defn ^:no-doc in-py-ctx
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index 773d1f9..3111d2f 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -737,6 +737,14 @@ Each call must be matched with PyGILState_Release"}
     (PyGILState_Release gilstate)))
 
 
+(defn ^:no-doc manual-gil-locker
+  ^java.lang.AutoCloseable []
+  (let [gil-state (lock-gil)]
+     (reify java.lang.AutoCloseable
+       (close [this]
+         (unlock-gil gil-state)))))
+
+
 (defmacro with-gil
   "Grab the gil and use the main interpreter using reentrant acquire-gil pathway."
   [& body]
diff --git a/test/libpython_clj2/classes_test.clj b/test/libpython_clj2/classes_test.clj
index 4bc64ae..256fabd 100644
--- a/test/libpython_clj2/classes_test.clj
+++ b/test/libpython_clj2/classes_test.clj
@@ -48,3 +48,23 @@
     (is (= {"name" "ACME", "shares" 50, "price" 90}
            (edn/read-string (.toString new-instance))))
     (is (= 116.0 (py/call-attr-kw new-instance "kw_clj_fn" [1 2 3] {:a 20})))))
+
+
+(deftest new-kw-init-cls-test
+  ;;The crux of this is making instance functions to get the 'self' parameter
+  ;;passed in.
+  (let [cls-obj (py/create-class
+                 "Stock" nil
+                 {"__init__" (py/make-kw-instance-fn
+                              (fn [[self :as args] {:as kwargs}]
+                                (py/set-attr! self "kwargs" kwargs)
+                                ;;Because we did not use an arg-converter, all the
+                                ;;arguments above are raw jna Pointers - borrowed
+                                ;;references.
+                                ;;If you don't return nil from __init__ that is an
+                                ;;error.
+                                nil))})
+        new-instance (py/cfn cls-obj "ACME" 50 :a 1 :b 2)
+        dict (py/get-attr new-instance "kwargs")]
+    (is (= {"a" 1 "b" 2}
+           (py/->jvm dict)))))

From 3c8be2fb93f08b3532118392ded4823081aa0865 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 2 Oct 2022 10:29:39 -0600
Subject: [PATCH 412/456] Release 2.020

---
 deps.edn                                 |   2 +-
 docs/Usage.html                          |   2 +-
 docs/embedded.html                       |   2 +-
 docs/environments.html                   |   2 +-
 docs/index.html                          |   6 +-
 docs/libpython-clj2.codegen.html         |   2 +-
 docs/libpython-clj2.embedded.html        |   2 +-
 docs/libpython-clj2.java-api.html        |   2 +-
 docs/libpython-clj2.python.html          | 106 +++++++++++++----------
 docs/libpython-clj2.python.np-array.html |   2 +-
 docs/libpython-clj2.require.html         |   2 +-
 docs/new-to-clojure.html                 |   2 +-
 docs/scopes-and-gc.html                  |   2 +-
 docs/slicing.html                        |   2 +-
 14 files changed, 73 insertions(+), 63 deletions(-)

diff --git a/deps.edn b/deps.edn
index d4b0445..dd5d115 100644
--- a/deps.edn
+++ b/deps.edn
@@ -55,7 +55,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.019"
+                        :version "2.020"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 8ee7c49..e578c95 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/embedded.html b/docs/embedded.html
index 15c6bb5..887ecfb 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index 1fe0928..34088f2 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 382a1d0..d17b160 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.019</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.020</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
@@ -16,7 +16,7 @@
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--GILLocker">-GILLocker</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
-</div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+</div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li><li> <a href="libpython-clj2.python.html#var-with-manual-gil">with-manual-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context">with-manual-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index f95235d..7981cc6 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index fc8f183..f571f8b 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 6463aab..e60c544 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index ddbe894..1d6b825 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
@@ -23,34 +23,34 @@
 Keywords must be compile time constants.  So this won't work with 'apply'.  On the
 other hand, building the positional and kw argmaps happens at compile time as
 opposed to at runtime.  The attr name can be a symbol.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L551">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L578">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs.
 Keywords must be compile time constants.  So this won't work with 'apply'.  On the
 other hand, building the positional and kw argmaps happens at compile time as
 opposed to at runtime.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L562">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L266">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L360">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L348">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L354">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L254">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module.  This can create a module if it doesn't exist.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L168">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L589">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L293">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L375">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L381">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L281">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module.  This can create a module if it doesn't exist.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L195">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object.
 Arguments are passed in positionally.  Any keyword
 arguments are paired with the next arg, gathered, and passed into the
 system as *kwargs.</p>
 <p>Not having an argument after a keyword is an error.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L494">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L272">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L284">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it's items</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L278">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L260">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L191">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L197">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L331">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L521">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L299">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L311">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it's items</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L287">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L218">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L224">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L358">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object.
 Arguments are passed in positionally.  Any keyword
 arguments are paired with the next arg, gathered, and passed into the
 system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L483">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L510">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
 will be presented as instance methods.  If you want access to the
 'this' object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
@@ -77,7 +77,7 @@
 user&gt; (py/call-attr inst "addarg" 10)
 20
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L448">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs.  Useful when trying to match Python
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L475">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs.  Useful when trying to match Python
 idioms - this is definitely not idiomatic Clojure.</p>
 <p>Example:</p>
 <pre><code class="language-clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
@@ -89,15 +89,15 @@
 user&gt; c
 3
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L724">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L186">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L751">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L213">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python.
 Documentation is included.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L202">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using  <strong>getitem</strong></p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L228">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L222">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item.  Calls <strong>hasitem</strong>.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L241">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var.  Documentation is included.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L296">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module.  Module entries can be accessed via get-attr.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L158">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library.  If library path is not provided, then the system
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L332">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L229">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using  <strong>getitem</strong></p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L255">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L249">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item.  Calls <strong>hasitem</strong>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L268">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var.  Documentation is included.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L323">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module.  Module entries can be accessed via get-attr.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L185">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library.  If library path is not provided, then the system
 attempts to execute a simple python program and have python return system info.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or
 <code>:already-initialized</code> in which case we detected that python has already been
@@ -123,7 +123,7 @@
 </ul>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls.  Note that arguments
 are reversed as compared to <code>instance?</code></p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L319">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function.  This is called for you
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L346">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function.  This is called for you
 if you use <code>as-python</code> on an implementation of IFn.</p>
 <p>Options:</p>
 <ul>
@@ -136,7 +136,7 @@
 <li><code>:name</code> - Name of the python method.  This will appear in stack traces.</li>
 <li><code>:doc</code> - documentation for method.</li>
 </ul>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L399">view source</a></div></div><div class="public anchor" id="var-make-fastcallable"><h3>make-fastcallable</h3><div class="usage"><code>(make-fastcallable item)</code></div><div class="doc"><div class="markdown"><p>Wrap a python callable such that calling it in a tight loop with purely positional
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L426">view source</a></div></div><div class="public anchor" id="var-make-fastcallable"><h3>make-fastcallable</h3><div class="usage"><code>(make-fastcallable item)</code></div><div class="doc"><div class="markdown"><p>Wrap a python callable such that calling it in a tight loop with purely positional
 arguments is a bit (2x-3x) faster.</p>
 <p>Example:</p>
 <pre><code class="language-clojure">user&gt; (def test-fn (-&gt; (py/run-simple-string "def spread(bid,ask):
@@ -169,23 +169,23 @@
 "Elapsed time: 35.492965 msecs"
 nil
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L505">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the 'this'
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L532">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the 'this'
 object as it's first argument.  In addition, this function calls <code>make-callable</code>
 with a <code>arg-converter</code> defaulted to <code>as-jvm</code>.  See documentation for
 [[libpython-clj2.python.class/make-instance-fn.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L423">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments,
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L450">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments,
 the positional argument vector and a map of keyword arguments.  Results are marshalled
 back to python using <a href="libpython-clj2.python.fn-bridged-fn-arg--python">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also
 used when bridging an object into python.  See documentation for
 <a href="libpython-clj2.python.class-make-kw-instance-fn">libpython-clj2.python.class/make-kw-instance-fn</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L432">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L177">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as "builtins" or "builtins.list", load the module or
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L459">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as "builtins" or "builtins.list", load the module or
 the class object in the module.</p>
 <p>Options:</p>
 <ul>
 <li><code>:reload</code> - Reload the module.</li>
 </ul>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L699">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L726">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments
 to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
@@ -196,12 +196,12 @@
 (def kwargs {:cat "dog" :name "taco"})
 (py* d  update <a href="iterable">iterable</a> kwargs)
 d ;;=&gt; {"a": 1, "b": 2, "cat": "dog", "name": "taco"}</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L588">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L610">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L615">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L637">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
 is equivalent to Python's obj.method(arg1, arg2, ..., argN) syntax.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L579">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax.  (py.- obj attr) is equivalent to
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L606">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax.  (py.- obj attr) is equivalent to
 Python's obj.attr syntax.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L572">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L599">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python 'sys)
 (py.. sys -path (append "/home/user/bin"))</p>
 <p>is equivalent to Python's</p>
@@ -222,8 +222,8 @@
 <p>These forms exist for when you need to pass in a map of options
 in the same way you would use the f(*args, **kwargs) forms in
 Python.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L645">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L290">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L672">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L317">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of
 {:globals :locals}.
 This uses the global <strong>main</strong> dict under the covers so it matches the behavior
 of the cpython implementation with the exception of returning the various maps
@@ -244,11 +244,11 @@
 }
 Py_DECREF(v);
 return 0;</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L366">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object.  Returns pyobj.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L208">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a> attributes.  Returns pyobj.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L215">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Set an item on a python object using  <strong>setitem</strong></p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L234">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a>. Returns pyobj</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L247">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context.  All python objects allocated within this
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L393">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object.  Returns pyobj.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L235">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a> attributes.  Returns pyobj.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L242">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Set an item on a python object using  <strong>setitem</strong></p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L261">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a>. Returns pyobj</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L274">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context.  All python objects allocated within this
 context will be released at the termination of this context.
 !!This means that no python objects can escape from this context!!
 You must use copy semantics (-&gt;jvm) for anything escaping this context.
@@ -258,8 +258,8 @@
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L114">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the 'with' statement in python:
 (py/with <a href="item (py/call-attr testcode-module &quot;WithObjClass&quot; true fn-list)">item (py/call-attr testcode-module "WithObjClass" true fn-list)</a>
 (py/call-attr item "doit_err"))</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L543">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time.  This can greatly speed up
-operations as the mutex is captured and held once as opposed to find grained
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L570">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time.  This can greatly speed up
+operations as the mutex is captured and held once as opposed to fine grained
 grabbing/releasing of the mutex.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L127">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context.  The resource context is released
 before the gil is leading to much faster resource collection.  See documentation
@@ -268,4 +268,14 @@
 some undefined point in the future crash.  That being said, this is the recommended
 pathway to use in production contexts where you want defined behavior and timings
 related to use of python.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L136">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L136">view source</a></div></div><div class="public anchor" id="var-with-manual-gil"><h3>with-manual-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-manual-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
+the python runtime with this locker.  This includes calls to require-python or any other
+pathways.</p>
+<pre><code class="language-clojure">  (with-manual-gil
+    ...)
+</code></pre>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L150">view source</a></div></div><div class="public anchor" id="var-with-manual-gil-stack-rc-context"><h3>with-manual-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-manual-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
+the python runtime with this locker.  This includes calls to require-python or any other
+pathways.  This macro furthermore defines a stack-based gc context to immediately release
+objects when the stack frame exits.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L165">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 5dd495f..9738890 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index e96cbe3..2bebe56 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 31153ce..3ba4c2b 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 0863db7..d0e7973 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index b5f541b..249a16e 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.019</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>

From bfd5646a7f71f48b6906221e56b39c23b4bda2b3 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sat, 22 Oct 2022 09:07:01 -0400
Subject: [PATCH 413/456] ISSUE-224: Prevent NPE by substituting vector if
 `keys` evaluates to `nil` (#227)

* Prevent NPE by substituting vector if `keys` evaluates to `nil`

* fix whitespace issue on previous commit

* Add __iter__ test

* give credit where credit is due
---
 src/libpython_clj2/python/bridge_as_python.clj | 2 +-
 test/libpython_clj2/python_test.clj            | 7 ++++++-
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/libpython_clj2/python/bridge_as_python.clj b/src/libpython_clj2/python/bridge_as_python.clj
index 676e792..9754c08 100644
--- a/src/libpython_clj2/python/bridge_as_python.clj
+++ b/src/libpython_clj2/python/bridge_as_python.clj
@@ -122,7 +122,7 @@
           "__setitem__" (as-tuple-instance-fn #(.put (self->map %1) (py-base/as-jvm %2) %3))
           "__delitem__" (as-tuple-instance-fn #(.remove (self->map %1) (py-base/as-jvm %2)))
           "__hash__" (as-tuple-instance-fn #(.hashCode (self->map %1)))
-          "__iter__" (as-tuple-instance-fn #(.iterator ^Iterable (keys (self->map %1))))
+          "__iter__" (as-tuple-instance-fn #(.iterator ^Iterable (or (keys (self->map %1)) [])))
           "__len__" (as-tuple-instance-fn #(.size (self->map %1)))
           "__str__" (as-tuple-instance-fn #(.toString (self->map %1)))
           "clear" (as-tuple-instance-fn #(.clear (self->map %1)))
diff --git a/test/libpython_clj2/python_test.clj b/test/libpython_clj2/python_test.clj
index bc50c6d..7f1b270 100644
--- a/test/libpython_clj2/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -7,7 +7,8 @@
             [tech.v3.datatype.functional :as dfn]
             [tech.v3.datatype.ffi :as dt-ffi]
             [tech.v3.tensor :as dtt]
-            [clojure.test :refer :all])
+            [clojure.test :refer :all]
+            libpython-clj2.python.bridge-as-python)
   (:import [java.io StringWriter]
            [java.util Map List]
            [tech.v3.datatype.ffi Pointer]))
@@ -422,6 +423,10 @@ class Foo:
     (is (= [5 2]
            (py/->jvm (py/get-attr pp "shape"))))))
 
+(deftest iter-should-not-npe
+  ;; credit Carsten Behring
+  (is (true? (boolean (py. (libpython-clj2.python.bridge-as-python/map-as-python {}) __iter__)))))
+
 
 (comment
   (require '[libpython-clj.require :refer [require-python]])

From d5588a494a9b8ae97ecbc9fefb9094fb86fd986c Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sat, 5 Nov 2022 14:37:05 -0400
Subject: [PATCH 414/456] ISSUE-223: Allow `py/initialize!` settings to be read
 from a `python.edn` file (#226)

* Allow "py/initialize!" settings to be read from a `python.edn` file

* add documentation

* add missing paren, make flycheck happy
---
 CHANGELOG.md                  |  3 +++
 src/libpython_clj2/python.clj | 31 ++++++++++++++++++++++++++++---
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3f5fd40..6c5ec45 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
 # Time for a ChangeLog!
+## 2.021
+ * Add support for a `python.edn` file, see `libpython-clj2.python/initialize!` documentation
+
 ## 2.020
  * Better support for running with `-Dlibpython_clj.manual_gil=true` - `with-manual-gil`.  
    Addresses [issue 221](https://github.com/clj-python/libpython-clj/issues/221).
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 5ebebf1..8e82a54 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -34,7 +34,8 @@ user> (py/py. np linspace 2 3 :num 10)
             [libpython-clj2.python.windows :as win]
             [tech.v3.datatype.ffi :as dtype-ffi]
             [tech.v3.datatype.errors :as errors]
-            [clojure.tools.logging :as log])
+            [clojure.tools.logging :as log]
+            clojure.edn)
   (:import [java.util Map List]
            [clojure.lang IFn]))
 
@@ -47,6 +48,26 @@ user> (py/py. np linspace 2 3 :num 10)
     "Initialize the python library.  If library path is not provided, then the system
   attempts to execute a simple python program and have python return system info.
 
+  Note: all of the options passed to `initialize!` may now be provided in 
+  a root-level `python.edn` file.  Example:
+
+  ```
+  ;; python.edn
+  {:python-executable   \"/usr/bin/python3.7\"
+   :python-library-path \"/usr/lib/libpython3.7m.so\"
+   :python-home         \"/usr/lib/python3.7\"
+   :python-verbose      true}
+  ```
+  or, using a local virtual environment:
+  ```
+  ;; python.edn
+  {:python-executable   \"env/bin/python\"}
+  ```
+
+  The file MUST be named `python.edn` and be in the root of the classpath.
+  With a `python.edn` file in place, the `initialize!` function may be called
+  with no arguments and the options will be read from the file. If arguments are 
+  passed to `initialize!` then they will override the values in the file.
 
   Returns either `:ok` in which case the initialization completed successfully or
   `:already-initialized` in which case we detected that python has already been
@@ -72,8 +93,12 @@ user> (py/py. np linspace 2 3 :num 10)
              no-io-redirect?]
       :as options}]
   (if-not (and (py-ffi/library-loaded?)
-                 (= 1 (py-ffi/Py_IsInitialized)))
-    (let [info (py-info/detect-startup-info options)
+               (= 1 (py-ffi/Py_IsInitialized)))
+    (let [python-edn-opts (-> (try (slurp "python.edn")
+                                   (catch java.io.FileNotFoundException _ "{}"))
+                              clojure.edn/read-string)
+          options (merge python-edn-opts options)
+          info (py-info/detect-startup-info options)
           _ (log/infof "Startup info %s" info)
           _ (when-let [lib-path (:java-library-path-addendum
                                  options (:java-library-path-addendum info))]

From 84e6306fe8b0cc5843c806c47ffdbccc96d79965 Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Sat, 5 Nov 2022 19:37:23 +0100
Subject: [PATCH 415/456] Update embedded.md (#229)

Document usage of JDK_JAVA_OPTIONS to pass java args for embedded JVM.
---
 topics/embedded.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/topics/embedded.md b/topics/embedded.md
index 4a0c520..5de0e63 100644
--- a/topics/embedded.md
+++ b/topics/embedded.md
@@ -81,6 +81,11 @@ two important libraries for clojure loaded, nrepl and cider which allow a rich,
 interactive development experience so let's now connect to that port with our favorite
 Clojure editor - emacs of course ;-).
 
+If you want to specify arbitrary arguments for the JVM to be started by Python,
+you can use the environment variable `JDK_JAVA_OPTIONS` to do so. It will be picked up by 
+the JVM when starting.
+```
+```
 
 ## From the Clojure REPL
 

From dbd73313971a4de260d647a5ccc4553edd9dec03 Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Sun, 20 Nov 2022 23:57:14 +0100
Subject: [PATCH 416/456] document to use aliases to set JVM args (#232)

available since clojurebridge 0.0.8:

See here for background on this feature.
https://github.com/behrica/clojurebridge/issues/4
---
 topics/embedded.md | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/topics/embedded.md b/topics/embedded.md
index 5de0e63..1a32278 100644
--- a/topics/embedded.md
+++ b/topics/embedded.md
@@ -81,12 +81,36 @@ two important libraries for clojure loaded, nrepl and cider which allow a rich,
 interactive development experience so let's now connect to that port with our favorite
 Clojure editor - emacs of course ;-).
 
+### Passing JVM arguments 
+
 If you want to specify arbitrary arguments for the JVM to be started by Python,
 you can use the environment variable `JDK_JAVA_OPTIONS` to do so. It will be picked up by 
 the JVM when starting.
+
+Since clojurebridge 0.0.8, you can as well specify a list of aliases, which get resolved 
+from the `deps.edn` file. This allows as well to specify JVM arguments and JVM properties.
+
+Example: 
+
+Starting Clojure embedded from python via
+
+```python
+cljbridge.init_jvm(aliases=["jdk-17","fastcall"],start_repl=True)
 ```
+and a `deps.edn` with
+
+```clojure
+:aliases {
+
+           :fastcall
+           {:jvm-opts ["-Dlibpython_clj.manual_gil=true"]}
+           :jdk-17
+           {:jvm-opts ["--add-modules=jdk.incubator.foreign"
+                       "--enable-native-access=ALL-UNNAMED"]}}
 ```
 
+would add then the appropriate JVM options.
+
 ## From the Clojure REPL
 
 

From 311ec6ddc238913275ea4cad9aaaf0cd65587755 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 8 Dec 2022 14:53:53 -0700
Subject: [PATCH 417/456] Release 2.021 - first version with hamf-based dtype

---
 deps.edn                                 |   4 +-
 docs/Usage.html                          |   2 +-
 docs/embedded.html                       |  22 ++++-
 docs/environments.html                   |   2 +-
 docs/index.html                          |   4 +-
 docs/libpython-clj2.codegen.html         |   2 +-
 docs/libpython-clj2.embedded.html        |   2 +-
 docs/libpython-clj2.java-api.html        |   2 +-
 docs/libpython-clj2.python.html          | 120 +++++++++++++----------
 docs/libpython-clj2.python.np-array.html |   2 +-
 docs/libpython-clj2.require.html         |   2 +-
 docs/new-to-clojure.html                 |   2 +-
 docs/scopes-and-gc.html                  |   2 +-
 docs/slicing.html                        |   2 +-
 src/libpython_clj2/python/fn.clj         |   6 +-
 test/libpython_clj2/classes_test.clj     |   6 +-
 16 files changed, 111 insertions(+), 71 deletions(-)

diff --git a/deps.edn b/deps.edn
index dd5d115..5cb7681 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "9.032"}
+        cnuernber/dtype-next {:mvn/version "10.000-beta-2"}
         net.java.dev.jna/jna {:mvn/version "5.12.1"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 
@@ -55,7 +55,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.020"
+                        :version "2.021"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index e578c95..623e97e 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/embedded.html b/docs/embedded.html
index 887ecfb..2f669ee 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
@@ -62,6 +62,26 @@ <h2>From the Python REPL</h2>
 two important libraries for clojure loaded, nrepl and cider which allow a rich,
 interactive development experience so let's now connect to that port with our favorite
 Clojure editor - emacs of course ;-).</p>
+<h3>Passing JVM arguments</h3>
+<p>If you want to specify arbitrary arguments for the JVM to be started by Python,
+you can use the environment variable <code>JDK_JAVA_OPTIONS</code> to do so. It will be picked up by
+the JVM when starting.</p>
+<p>Since clojurebridge 0.0.8, you can as well specify a list of aliases, which get resolved
+from the <code>deps.edn</code> file. This allows as well to specify JVM arguments and JVM properties.</p>
+<p>Example:</p>
+<p>Starting Clojure embedded from python via</p>
+<pre><code class="language-python">cljbridge.init_jvm(aliases=["jdk-17","fastcall"],start_repl=True)
+</code></pre>
+<p>and a <code>deps.edn</code> with</p>
+<pre><code class="language-clojure">:aliases {
+
+           :fastcall
+           {:jvm-opts ["-Dlibpython_clj.manual_gil=true"]}
+           :jdk-17
+           {:jvm-opts ["--add-modules=jdk.incubator.foreign"
+                       "--enable-native-access=ALL-UNNAMED"]}}
+</code></pre>
+<p>would add then the appropriate JVM options.</p>
 <h2>From the Clojure REPL</h2>
 <p>From emacs, I run the command 'cider-connect' which allows me to specify a host
 and port to connect to.  Once connected, I get a minimal repl environment:</p>
diff --git a/docs/environments.html b/docs/environments.html
index 34088f2..a9ddffc 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index d17b160..5208ed6 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.020</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.021</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 7981cc6..785ed80 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index f571f8b..701cc28 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index e60c544..af1489b 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 1d6b825..33216c2 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
@@ -23,34 +23,34 @@
 Keywords must be compile time constants.  So this won't work with 'apply'.  On the
 other hand, building the positional and kw argmaps happens at compile time as
 opposed to at runtime.  The attr name can be a symbol.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L578">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L603">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs.
 Keywords must be compile time constants.  So this won't work with 'apply'.  On the
 other hand, building the positional and kw argmaps happens at compile time as
 opposed to at runtime.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L589">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L293">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L387">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L375">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L381">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L281">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module.  This can create a module if it doesn't exist.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L195">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L614">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L318">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L412">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L400">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L406">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L306">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module.  This can create a module if it doesn't exist.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L220">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object.
 Arguments are passed in positionally.  Any keyword
 arguments are paired with the next arg, gathered, and passed into the
 system as *kwargs.</p>
 <p>Not having an argument after a keyword is an error.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L521">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L299">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L311">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it's items</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L305">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L287">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L218">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L224">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L358">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L546">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L324">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L336">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it's items</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L330">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L312">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L243">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L249">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L383">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object.
 Arguments are passed in positionally.  Any keyword
 arguments are paired with the next arg, gathered, and passed into the
 system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L510">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L535">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
 will be presented as instance methods.  If you want access to the
 'this' object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
@@ -77,7 +77,7 @@
 user&gt; (py/call-attr inst "addarg" 10)
 20
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L475">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs.  Useful when trying to match Python
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L500">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs.  Useful when trying to match Python
 idioms - this is definitely not idiomatic Clojure.</p>
 <p>Example:</p>
 <pre><code class="language-clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
@@ -89,16 +89,32 @@
 user&gt; c
 3
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L751">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L213">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L776">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L238">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python.
 Documentation is included.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L332">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L229">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using  <strong>getitem</strong></p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L255">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L249">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item.  Calls <strong>hasitem</strong>.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L268">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var.  Documentation is included.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L323">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module.  Module entries can be accessed via get-attr.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L185">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library.  If library path is not provided, then the system
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L357">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L254">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using  <strong>getitem</strong></p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L280">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L274">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item.  Calls <strong>hasitem</strong>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L293">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var.  Documentation is included.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L348">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module.  Module entries can be accessed via get-attr.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L210">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library.  If library path is not provided, then the system
 attempts to execute a simple python program and have python return system info.</p>
+<p>Note: all of the options passed to <code>initialize!</code> may now be provided in
+a root-level <code>python.edn</code> file.  Example:</p>
+<pre><code>;; python.edn
+{:python-executable   "/usr/bin/python3.7"
+ :python-library-path "/usr/lib/libpython3.7m.so"
+ :python-home         "/usr/lib/python3.7"
+ :python-verbose      true}
+</code></pre>
+<p>or, using a local virtual environment:</p>
+<pre><code>;; python.edn
+{:python-executable   "env/bin/python"}
+</code></pre>
+<p>The file MUST be named <code>python.edn</code> and be in the root of the classpath.
+With a <code>python.edn</code> file in place, the <code>initialize!</code> function may be called
+with no arguments and the options will be read from the file. If arguments are
+passed to <code>initialize!</code> then they will override the values in the file.</p>
 <p>Returns either <code>:ok</code> in which case the initialization completed successfully or
 <code>:already-initialized</code> in which case we detected that python has already been
 initialized via <code>Py_IsInitialized</code> and we do nothing more.</p>
@@ -121,9 +137,9 @@
 </ul>
 </li>
 </ul>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L46">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls.  Note that arguments
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L47">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls.  Note that arguments
 are reversed as compared to <code>instance?</code></p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L346">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function.  This is called for you
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L371">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function.  This is called for you
 if you use <code>as-python</code> on an implementation of IFn.</p>
 <p>Options:</p>
 <ul>
@@ -136,7 +152,7 @@
 <li><code>:name</code> - Name of the python method.  This will appear in stack traces.</li>
 <li><code>:doc</code> - documentation for method.</li>
 </ul>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L426">view source</a></div></div><div class="public anchor" id="var-make-fastcallable"><h3>make-fastcallable</h3><div class="usage"><code>(make-fastcallable item)</code></div><div class="doc"><div class="markdown"><p>Wrap a python callable such that calling it in a tight loop with purely positional
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L451">view source</a></div></div><div class="public anchor" id="var-make-fastcallable"><h3>make-fastcallable</h3><div class="usage"><code>(make-fastcallable item)</code></div><div class="doc"><div class="markdown"><p>Wrap a python callable such that calling it in a tight loop with purely positional
 arguments is a bit (2x-3x) faster.</p>
 <p>Example:</p>
 <pre><code class="language-clojure">user&gt; (def test-fn (-&gt; (py/run-simple-string "def spread(bid,ask):
@@ -169,23 +185,23 @@
 "Elapsed time: 35.492965 msecs"
 nil
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L532">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the 'this'
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L557">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the 'this'
 object as it's first argument.  In addition, this function calls <code>make-callable</code>
 with a <code>arg-converter</code> defaulted to <code>as-jvm</code>.  See documentation for
 [[libpython-clj2.python.class/make-instance-fn.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L450">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments,
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L475">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments,
 the positional argument vector and a map of keyword arguments.  Results are marshalled
 back to python using <a href="libpython-clj2.python.fn-bridged-fn-arg--python">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also
 used when bridging an object into python.  See documentation for
 <a href="libpython-clj2.python.class-make-kw-instance-fn">libpython-clj2.python.class/make-kw-instance-fn</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L459">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L204">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as "builtins" or "builtins.list", load the module or
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L484">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L229">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as "builtins" or "builtins.list", load the module or
 the class object in the module.</p>
 <p>Options:</p>
 <ul>
 <li><code>:reload</code> - Reload the module.</li>
 </ul>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L726">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L751">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments
 to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
@@ -196,12 +212,12 @@
 (def kwargs {:cat "dog" :name "taco"})
 (py* d  update <a href="iterable">iterable</a> kwargs)
 d ;;=&gt; {"a": 1, "b": 2, "cat": "dog", "name": "taco"}</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L615">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L637">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L640">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L662">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
 is equivalent to Python's obj.method(arg1, arg2, ..., argN) syntax.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L606">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax.  (py.- obj attr) is equivalent to
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L631">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax.  (py.- obj attr) is equivalent to
 Python's obj.attr syntax.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L599">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L624">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python 'sys)
 (py.. sys -path (append "/home/user/bin"))</p>
 <p>is equivalent to Python's</p>
@@ -222,8 +238,8 @@
 <p>These forms exist for when you need to pass in a map of options
 in the same way you would use the f(*args, **kwargs) forms in
 Python.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L672">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L317">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L697">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L342">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of
 {:globals :locals}.
 This uses the global <strong>main</strong> dict under the covers so it matches the behavior
 of the cpython implementation with the exception of returning the various maps
@@ -244,38 +260,38 @@
 }
 Py_DECREF(v);
 return 0;</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L393">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object.  Returns pyobj.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L235">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a> attributes.  Returns pyobj.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L242">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Set an item on a python object using  <strong>setitem</strong></p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L261">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a>. Returns pyobj</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L274">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context.  All python objects allocated within this
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L418">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object.  Returns pyobj.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L260">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a> attributes.  Returns pyobj.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L267">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Set an item on a python object using  <strong>setitem</strong></p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L286">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a>. Returns pyobj</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L299">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context.  All python objects allocated within this
 context will be released at the termination of this context.
 !!This means that no python objects can escape from this context!!
 You must use copy semantics (-&gt;jvm) for anything escaping this context.
 Furthermore, if you are returning generic python objects you may need
 to call (into {}) or something like that just to ensure that absolutely
 everything is copied into the jvm.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L114">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the 'with' statement in python:
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L139">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the 'with' statement in python:
 (py/with <a href="item (py/call-attr testcode-module &quot;WithObjClass&quot; true fn-list)">item (py/call-attr testcode-module "WithObjClass" true fn-list)</a>
 (py/call-attr item "doit_err"))</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L570">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time.  This can greatly speed up
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L595">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time.  This can greatly speed up
 operations as the mutex is captured and held once as opposed to fine grained
 grabbing/releasing of the mutex.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L127">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context.  The resource context is released
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L152">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context.  The resource context is released
 before the gil is leading to much faster resource collection.  See documentation
 on <code>stack-resource-context</code> for multiple warnings; the most important one being
 that if a python object escapes this context your program will eventually, at
 some undefined point in the future crash.  That being said, this is the recommended
 pathway to use in production contexts where you want defined behavior and timings
 related to use of python.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L136">view source</a></div></div><div class="public anchor" id="var-with-manual-gil"><h3>with-manual-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-manual-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L161">view source</a></div></div><div class="public anchor" id="var-with-manual-gil"><h3>with-manual-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-manual-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
 the python runtime with this locker.  This includes calls to require-python or any other
 pathways.</p>
 <pre><code class="language-clojure">  (with-manual-gil
     ...)
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L150">view source</a></div></div><div class="public anchor" id="var-with-manual-gil-stack-rc-context"><h3>with-manual-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-manual-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-with-manual-gil-stack-rc-context"><h3>with-manual-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-manual-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
 the python runtime with this locker.  This includes calls to require-python or any other
 pathways.  This macro furthermore defines a stack-based gc context to immediately release
 objects when the stack frame exits.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L165">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L190">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 9738890..2296ee3 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 2bebe56..6a185b6 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 3ba4c2b..70e719d 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index d0e7973..8fe74a4 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index 249a16e..9098dd1 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.020</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>
diff --git a/src/libpython_clj2/python/fn.clj b/src/libpython_clj2/python/fn.clj
index 9b6cbe0..4f8206e 100644
--- a/src/libpython_clj2/python/fn.clj
+++ b/src/libpython_clj2/python/fn.clj
@@ -121,8 +121,10 @@
 (defn convert-kw-args
   [{:keys [arg-converter] :as options} tuple-args kw-args]
   [(raw-tuple-arg-converter arg-converter tuple-args nil)
-   (->> (py-proto/as-jvm kw-args options)
-        (into {}))])
+   (if kw-args
+     (->> (py-proto/as-jvm kw-args options)
+          (into {}))
+     {})])
 
 
 (defn make-tuple-fn
diff --git a/test/libpython_clj2/classes_test.clj b/test/libpython_clj2/classes_test.clj
index 256fabd..a043b64 100644
--- a/test/libpython_clj2/classes_test.clj
+++ b/test/libpython_clj2/classes_test.clj
@@ -38,7 +38,7 @@
                                  (let [self (first pos-args)
                                        price (double (py/py.- self price))]
                                    ;;keywords become strings!!
-                                   (apply + price (kw-args "a")
+                                   (apply + price (get kw-args "a" 5)
                                           (drop 1 pos-args)))))
                   "clsattr" 55})
         new-instance (cls-obj "ACME" 50 90)]
@@ -47,7 +47,9 @@
     (is (= 55 (py/py.- new-instance clsattr)))
     (is (= {"name" "ACME", "shares" 50, "price" 90}
            (edn/read-string (.toString new-instance))))
-    (is (= 116.0 (py/call-attr-kw new-instance "kw_clj_fn" [1 2 3] {:a 20})))))
+    (is (= 116.0 (py/call-attr-kw new-instance "kw_clj_fn" [1 2 3] {:a 20})))
+    (is (= 101.0 (py/call-attr-kw new-instance "kw_clj_fn" [1 2 3] nil)))
+    ))
 
 
 (deftest new-kw-init-cls-test

From 9298549ed9f141ba61ec80caf0350fefe4462162 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 15 Dec 2022 13:34:02 -0700
Subject: [PATCH 418/456] testing with latest dtype-next

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 5cb7681..a516019 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure  {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "10.000-beta-2"}
+        cnuernber/dtype-next {:mvn/version "10.000-beta-9-SNAPSHOT"}
         net.java.dev.jna/jna {:mvn/version "5.12.1"}
         org.clojure/data.json  {:mvn/version "1.0.0"}}
 

From 410aad544263ba65411fcb2f18617a8a2847c2f0 Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Tue, 27 Dec 2022 17:53:27 +0100
Subject: [PATCH 419/456] add 2 Init lifecycle hooks (#234)

* added 2 lifecycle methods before and after tnitialisation

* document the 2 hooks

* more idiomatic
---
 src/libpython_clj2/python.clj | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 8e82a54..16f1f32 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -42,8 +42,6 @@ user> (py/py. np linspace 2 3 :num 10)
 
 (set! *warn-on-reflection* true)
 
-
-
 (defn initialize!
     "Initialize the python library.  If library path is not provided, then the system
   attempts to execute a simple python program and have python return system info.
@@ -64,6 +62,24 @@ user> (py/py. np linspace 2 3 :num 10)
   {:python-executable   \"env/bin/python\"}
   ```
 
+  Additionaly the file can contain two keys which can can refer to custom hooks
+  to run code just before and just after python is initialised.
+  Typical use case for this is to setup / verify the python virtual enviornment
+  to be used.
+
+  ```
+  :pre-initialize-fn my-ns/my-venv-setup-fn!
+  :post-initialize-fn my-ns/my-venv-validate-fn!
+
+  ```
+
+  A :pre-initialize-fn could for example shell out and setup a python
+  virtual enviornment.
+
+  The :post-initialize-fn can use all functions from ns `libpython-clj2.python`
+  as libpython-clj is initialised alreday andc ould for example be used to validate
+  that later needed libraries can be loaded via calling `import-module`.
+
   The file MUST be named `python.edn` and be in the root of the classpath.
   With a `python.edn` file in place, the `initialize!` function may be called
   with no arguments and the options will be read from the file. If arguments are 
@@ -97,6 +113,7 @@ user> (py/py. np linspace 2 3 :num 10)
     (let [python-edn-opts (-> (try (slurp "python.edn")
                                    (catch java.io.FileNotFoundException _ "{}"))
                               clojure.edn/read-string)
+          _ (some-> python-edn-opts :pre-initialize-fn requiring-resolve (apply []))
           options (merge python-edn-opts options)
           info (py-info/detect-startup-info options)
           _ (log/infof "Startup info %s" info)
@@ -132,10 +149,10 @@ user> (py/py. np linspace 2 3 :num 10)
             (io-redirect/redirect-io!))
           (finally
             (py-ffi/unlock-gil gilstate))))
+      (some-> python-edn-opts :post-initialize-fn requiring-resolve (apply []))
       :ok)
     :already-initialized))
 
-
 (defmacro stack-resource-context
   "Create a stack-based resource context.  All python objects allocated within this
   context will be released at the termination of this context.

From 09276be622fac778c64b86752bc3b3e44025f441 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 6 Jan 2023 07:48:36 -0700
Subject: [PATCH 420/456] Release 2.022

---
 CHANGELOG.md                             |  4 ++++
 deps.edn                                 | 14 +++++++++-----
 docs/Usage.html                          |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  4 ++--
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        |  2 +-
 docs/libpython-clj2.python.html          |  2 +-
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 15 files changed, 27 insertions(+), 19 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6c5ec45..e1ec214 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,8 @@
 # Time for a ChangeLog!
+## 2.022
+ * Support for JDK-19.  Still uses JNA as the FFI provider but libpython-clj now works
+   out of the box when using JDK-19.
+ 
 ## 2.021
  * Add support for a `python.edn` file, see `libpython-clj2.python/initialize!` documentation
 
diff --git a/deps.edn b/deps.edn
index a516019..f7de6e6 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,8 +1,10 @@
 {:paths ["src"]
- :deps {org.clojure/clojure  {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next {:mvn/version "10.000-beta-9-SNAPSHOT"}
-        net.java.dev.jna/jna {:mvn/version "5.12.1"}
-        org.clojure/data.json  {:mvn/version "1.0.0"}}
+ :deps {org.clojure/clojure     {:mvn/version "1.11.1" :scope "provided"}
+        cnuernber/dtype-next    {:mvn/version "10.000-beta-20"}
+        net.java.dev.jna/jna    {:mvn/version "5.12.1"}
+        org.clojure/data.json   {:mvn/version "1.0.0"}
+        ;;Replace me with caffeine...
+        com.google.guava/guava  {:mvn/version "31.1-jre"}}
 
  :aliases {:dev
            {:extra-deps {criterium/criterium {:mvn/version"0.4.5"}
@@ -12,6 +14,8 @@
            :jdk-17
            {:jvm-opts ["--add-modules" "jdk.incubator.foreign"
                        "--enable-native-access=ALL-UNNAMED"]}
+           :jdk-19
+           {:jvm-opts ["--enable-native-access=ALL-UNNAMED"]}
            :codox
            {:extra-deps {codox-theme-rdash/codox-theme-rdash {:mvn/version "0.1.2"}
                          nrepl/nrepl {:mvn/version "0.8.3"}
@@ -55,7 +59,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.021"
+                        :version "2.022"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 623e97e..59909f4 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/embedded.html b/docs/embedded.html
index 2f669ee..b029e60 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index a9ddffc..55f4042 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 5208ed6..28f14b2 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.021</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.022</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 785ed80..5541d82 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 701cc28..3ba7ac7 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index af1489b..a5a0c82 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 33216c2..693dc95 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 2296ee3..3b9c31d 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 6a185b6..d96b57b 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 70e719d..5aa9c8b 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 8fe74a4..e9263e8 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index 9098dd1..969dfda 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.021</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>

From 83e378397ba5da9c1eea5b46236f7697e86176eb Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 6 Jan 2023 07:50:31 -0700
Subject: [PATCH 421/456] Release 2.023

---
 CHANGELOG.md                             |   3 +
 deps.edn                                 |   2 +-
 docs/Usage.html                          |   2 +-
 docs/embedded.html                       |   2 +-
 docs/environments.html                   |   2 +-
 docs/index.html                          |   4 +-
 docs/libpython-clj2.codegen.html         |   2 +-
 docs/libpython-clj2.embedded.html        |   2 +-
 docs/libpython-clj2.java-api.html        |   2 +-
 docs/libpython-clj2.python.html          | 117 +++++++++++++----------
 docs/libpython-clj2.python.np-array.html |   2 +-
 docs/libpython-clj2.require.html         |   2 +-
 docs/new-to-clojure.html                 |   2 +-
 docs/scopes-and-gc.html                  |   2 +-
 docs/slicing.html                        |   2 +-
 15 files changed, 82 insertions(+), 66 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e1ec214..d63b795 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
 # Time for a ChangeLog!
+## 2.023
+ * pre/post hooks for python initialization 
+   
 ## 2.022
  * Support for JDK-19.  Still uses JNA as the FFI provider but libpython-clj now works
    out of the box when using JDK-19.
diff --git a/deps.edn b/deps.edn
index f7de6e6..ddc1621 100644
--- a/deps.edn
+++ b/deps.edn
@@ -59,7 +59,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.022"
+                        :version "2.023"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 59909f4..582be7d 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/embedded.html b/docs/embedded.html
index b029e60..d66b909 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index 55f4042..dd269e1 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 28f14b2..793e7df 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.022</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.023</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 5541d82..cb39159 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 3ba7ac7..f7b82a9 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index a5a0c82..5901aea 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 693dc95..b297808 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
@@ -23,34 +23,34 @@
 Keywords must be compile time constants.  So this won't work with 'apply'.  On the
 other hand, building the positional and kw argmaps happens at compile time as
 opposed to at runtime.  The attr name can be a symbol.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L603">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L620">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs.
 Keywords must be compile time constants.  So this won't work with 'apply'.  On the
 other hand, building the positional and kw argmaps happens at compile time as
 opposed to at runtime.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L614">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L318">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L412">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L400">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L406">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L306">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module.  This can create a module if it doesn't exist.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L220">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L631">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L335">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L429">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L417">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L423">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L323">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module.  This can create a module if it doesn't exist.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L237">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object.
 Arguments are passed in positionally.  Any keyword
 arguments are paired with the next arg, gathered, and passed into the
 system as *kwargs.</p>
 <p>Not having an argument after a keyword is an error.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L546">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L324">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L336">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it's items</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L330">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L312">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L243">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L249">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L383">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L563">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L341">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L353">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it's items</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L347">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L329">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L260">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L266">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L400">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object.
 Arguments are passed in positionally.  Any keyword
 arguments are paired with the next arg, gathered, and passed into the
 system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L535">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L552">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
 will be presented as instance methods.  If you want access to the
 'this' object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
@@ -77,7 +77,7 @@
 user&gt; (py/call-attr inst "addarg" 10)
 20
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L500">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs.  Useful when trying to match Python
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L517">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs.  Useful when trying to match Python
 idioms - this is definitely not idiomatic Clojure.</p>
 <p>Example:</p>
 <pre><code class="language-clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
@@ -89,15 +89,15 @@
 user&gt; c
 3
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L776">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L238">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L793">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L255">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python.
 Documentation is included.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L357">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L254">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using  <strong>getitem</strong></p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L280">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L274">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item.  Calls <strong>hasitem</strong>.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L293">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var.  Documentation is included.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L348">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module.  Module entries can be accessed via get-attr.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L210">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library.  If library path is not provided, then the system
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L374">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L271">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using  <strong>getitem</strong></p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L297">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L291">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item.  Calls <strong>hasitem</strong>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L310">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var.  Documentation is included.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L365">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module.  Module entries can be accessed via get-attr.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L227">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library.  If library path is not provided, then the system
 attempts to execute a simple python program and have python return system info.</p>
 <p>Note: all of the options passed to <code>initialize!</code> may now be provided in
 a root-level <code>python.edn</code> file.  Example:</p>
@@ -111,6 +111,19 @@
 <pre><code>;; python.edn
 {:python-executable   "env/bin/python"}
 </code></pre>
+<p>Additionaly the file can contain two keys which can can refer to custom hooks
+to run code just before and just after python is initialised.
+Typical use case for this is to setup / verify the python virtual enviornment
+to be used.</p>
+<pre><code>:pre-initialize-fn my-ns/my-venv-setup-fn!
+:post-initialize-fn my-ns/my-venv-validate-fn!
+
+</code></pre>
+<p>A :pre-initialize-fn could for example shell out and setup a python
+virtual enviornment.</p>
+<p>The :post-initialize-fn can use all functions from ns <code>libpython-clj2.python</code>
+as libpython-clj is initialised alreday andc ould for example be used to validate
+that later needed libraries can be loaded via calling <code>import-module</code>.</p>
 <p>The file MUST be named <code>python.edn</code> and be in the root of the classpath.
 With a <code>python.edn</code> file in place, the <code>initialize!</code> function may be called
 with no arguments and the options will be read from the file. If arguments are
@@ -137,9 +150,9 @@
 </ul>
 </li>
 </ul>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L47">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls.  Note that arguments
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L45">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls.  Note that arguments
 are reversed as compared to <code>instance?</code></p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L371">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function.  This is called for you
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L388">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function.  This is called for you
 if you use <code>as-python</code> on an implementation of IFn.</p>
 <p>Options:</p>
 <ul>
@@ -152,7 +165,7 @@
 <li><code>:name</code> - Name of the python method.  This will appear in stack traces.</li>
 <li><code>:doc</code> - documentation for method.</li>
 </ul>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L451">view source</a></div></div><div class="public anchor" id="var-make-fastcallable"><h3>make-fastcallable</h3><div class="usage"><code>(make-fastcallable item)</code></div><div class="doc"><div class="markdown"><p>Wrap a python callable such that calling it in a tight loop with purely positional
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L468">view source</a></div></div><div class="public anchor" id="var-make-fastcallable"><h3>make-fastcallable</h3><div class="usage"><code>(make-fastcallable item)</code></div><div class="doc"><div class="markdown"><p>Wrap a python callable such that calling it in a tight loop with purely positional
 arguments is a bit (2x-3x) faster.</p>
 <p>Example:</p>
 <pre><code class="language-clojure">user&gt; (def test-fn (-&gt; (py/run-simple-string "def spread(bid,ask):
@@ -185,23 +198,23 @@
 "Elapsed time: 35.492965 msecs"
 nil
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L557">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the 'this'
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L574">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the 'this'
 object as it's first argument.  In addition, this function calls <code>make-callable</code>
 with a <code>arg-converter</code> defaulted to <code>as-jvm</code>.  See documentation for
 [[libpython-clj2.python.class/make-instance-fn.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L475">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments,
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L492">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments,
 the positional argument vector and a map of keyword arguments.  Results are marshalled
 back to python using <a href="libpython-clj2.python.fn-bridged-fn-arg--python">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also
 used when bridging an object into python.  See documentation for
 <a href="libpython-clj2.python.class-make-kw-instance-fn">libpython-clj2.python.class/make-kw-instance-fn</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L484">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L229">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as "builtins" or "builtins.list", load the module or
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L501">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L246">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as "builtins" or "builtins.list", load the module or
 the class object in the module.</p>
 <p>Options:</p>
 <ul>
 <li><code>:reload</code> - Reload the module.</li>
 </ul>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L751">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L768">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments
 to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
@@ -212,12 +225,12 @@
 (def kwargs {:cat "dog" :name "taco"})
 (py* d  update <a href="iterable">iterable</a> kwargs)
 d ;;=&gt; {"a": 1, "b": 2, "cat": "dog", "name": "taco"}</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L640">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L662">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L657">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L679">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
 is equivalent to Python's obj.method(arg1, arg2, ..., argN) syntax.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L631">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax.  (py.- obj attr) is equivalent to
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L648">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax.  (py.- obj attr) is equivalent to
 Python's obj.attr syntax.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L624">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L641">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python 'sys)
 (py.. sys -path (append "/home/user/bin"))</p>
 <p>is equivalent to Python's</p>
@@ -238,8 +251,8 @@
 <p>These forms exist for when you need to pass in a map of options
 in the same way you would use the f(*args, **kwargs) forms in
 Python.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L697">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L342">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L714">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L359">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of
 {:globals :locals}.
 This uses the global <strong>main</strong> dict under the covers so it matches the behavior
 of the cpython implementation with the exception of returning the various maps
@@ -260,38 +273,38 @@
 }
 Py_DECREF(v);
 return 0;</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L418">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object.  Returns pyobj.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L260">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a> attributes.  Returns pyobj.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L267">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Set an item on a python object using  <strong>setitem</strong></p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L286">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a>. Returns pyobj</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L299">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context.  All python objects allocated within this
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L435">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object.  Returns pyobj.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L277">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a> attributes.  Returns pyobj.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L284">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Set an item on a python object using  <strong>setitem</strong></p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L303">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a>. Returns pyobj</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L316">view source</a></div></div><div class="public anchor" id="var-stack-resource-context"><h3>stack-resource-context</h3><h4 class="type">macro</h4><div class="usage"><code>(stack-resource-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Create a stack-based resource context.  All python objects allocated within this
 context will be released at the termination of this context.
 !!This means that no python objects can escape from this context!!
 You must use copy semantics (-&gt;jvm) for anything escaping this context.
 Furthermore, if you are returning generic python objects you may need
 to call (into {}) or something like that just to ensure that absolutely
 everything is copied into the jvm.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L139">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the 'with' statement in python:
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L156">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the 'with' statement in python:
 (py/with <a href="item (py/call-attr testcode-module &quot;WithObjClass&quot; true fn-list)">item (py/call-attr testcode-module "WithObjClass" true fn-list)</a>
 (py/call-attr item "doit_err"))</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L595">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time.  This can greatly speed up
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L612">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time.  This can greatly speed up
 operations as the mutex is captured and held once as opposed to fine grained
 grabbing/releasing of the mutex.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L152">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context.  The resource context is released
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L169">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context.  The resource context is released
 before the gil is leading to much faster resource collection.  See documentation
 on <code>stack-resource-context</code> for multiple warnings; the most important one being
 that if a python object escapes this context your program will eventually, at
 some undefined point in the future crash.  That being said, this is the recommended
 pathway to use in production contexts where you want defined behavior and timings
 related to use of python.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L161">view source</a></div></div><div class="public anchor" id="var-with-manual-gil"><h3>with-manual-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-manual-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L178">view source</a></div></div><div class="public anchor" id="var-with-manual-gil"><h3>with-manual-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-manual-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
 the python runtime with this locker.  This includes calls to require-python or any other
 pathways.</p>
 <pre><code class="language-clojure">  (with-manual-gil
     ...)
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L175">view source</a></div></div><div class="public anchor" id="var-with-manual-gil-stack-rc-context"><h3>with-manual-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-manual-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L192">view source</a></div></div><div class="public anchor" id="var-with-manual-gil-stack-rc-context"><h3>with-manual-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-manual-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>When running with -Dlibpython_clj.manual_gil=true, you need to wrap all accesses to
 the python runtime with this locker.  This includes calls to require-python or any other
 pathways.  This macro furthermore defines a stack-based gc context to immediately release
 objects when the stack frame exits.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L190">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L207">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 3b9c31d..f273854 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index d96b57b..deece4f 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 5aa9c8b..0a966e8 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index e9263e8..1bf5295 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index 969dfda..8091a54 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.022</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>

From 73857422d12ce646c1167be0e84e807b5919c40c Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Thu, 26 Jan 2023 07:33:03 -0700
Subject: [PATCH 422/456] Release 2.024

---
 CHANGELOG.md                             | 12 ++++++++----
 deps.edn                                 |  4 ++--
 docs/Usage.html                          |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  4 ++--
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        |  2 +-
 docs/libpython-clj2.python.html          |  2 +-
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 scripts/deploy                           |  2 +-
 scripts/run-tests                        |  5 +++++
 src/libpython_clj2/python/fn.clj         |  9 ++++++---
 test/libpython_clj2/python_test.clj      |  7 +++++++
 19 files changed, 43 insertions(+), 24 deletions(-)
 create mode 100755 scripts/run-tests

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d63b795..02545d3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,16 +1,20 @@
 # Time for a ChangeLog!
+## 2.024
+ * large dtype-next/hamf upgrade.
+ * fix for call-attr (it was broken when using keywords).
+
 ## 2.023
- * pre/post hooks for python initialization 
-   
+ * pre/post hooks for python initialization
+
 ## 2.022
  * Support for JDK-19.  Still uses JNA as the FFI provider but libpython-clj now works
    out of the box when using JDK-19.
- 
+
 ## 2.021
  * Add support for a `python.edn` file, see `libpython-clj2.python/initialize!` documentation
 
 ## 2.020
- * Better support for running with `-Dlibpython_clj.manual_gil=true` - `with-manual-gil`.  
+ * Better support for running with `-Dlibpython_clj.manual_gil=true` - `with-manual-gil`.
    Addresses [issue 221](https://github.com/clj-python/libpython-clj/issues/221).
 
 ## 2.019
diff --git a/deps.edn b/deps.edn
index ddc1621..1fced82 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure     {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next    {:mvn/version "10.000-beta-20"}
+        cnuernber/dtype-next    {:mvn/version "10.000-beta-32"}
         net.java.dev.jna/jna    {:mvn/version "5.12.1"}
         org.clojure/data.json   {:mvn/version "1.0.0"}
         ;;Replace me with caffeine...
@@ -59,7 +59,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.023"
+                        :version "2.024"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index 582be7d..e34264e 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/embedded.html b/docs/embedded.html
index d66b909..0bd528c 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index dd269e1..055fc16 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 793e7df..356fd8b 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.023</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.024</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index cb39159..744cc27 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index f7b82a9..cf26a99 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 5901aea..5ca82c9 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index b297808..f8d3340 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index f273854..3d72c15 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index deece4f..5426f02 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 0a966e8..dc244a3 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 1bf5295..1ad5597 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index 8091a54..54cc64d 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.023</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>
diff --git a/scripts/deploy b/scripts/deploy
index 0d2b368..8fb7e00 100755
--- a/scripts/deploy
+++ b/scripts/deploy
@@ -4,7 +4,7 @@
 set -e
 
 rm -rf classes
-clj -M:test
+scripts/run-tests
 clj -X:codox
 clj -X:depstar
 clj -X:deploy
diff --git a/scripts/run-tests b/scripts/run-tests
new file mode 100755
index 0000000..bc038dc
--- /dev/null
+++ b/scripts/run-tests
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+set -e
+
+clj -M:test
\ No newline at end of file
diff --git a/src/libpython_clj2/python/fn.clj b/src/libpython_clj2/python/fn.clj
index 4f8206e..07fddd1 100644
--- a/src/libpython_clj2/python/fn.clj
+++ b/src/libpython_clj2/python/fn.clj
@@ -224,14 +224,17 @@
   map of keyword args."
   [item att-name arglist kw-map arg-converter]
   (py-ffi/with-gil
-    (if (string? att-name)
-      (py-ffi/with-decref [attval (py-ffi/PyObject_GetAttrString item att-name)]
+    (if (or (string? att-name) (keyword? att-name))
+      (py-ffi/with-decref [attval (py-ffi/PyObject_GetAttrString
+                                   item (if (keyword? att-name)
+                                          (name att-name)
+                                          att-name))]
         (when-not attval (py-ffi/check-error-throw))
         (->> (call-py-fn attval arglist kw-map arg-converter)
              (py-proto/marshal-return item)))
       (py-ffi/with-decref
         [att-name (py-ffi/untracked->python att-name py-base/->python)
-         att-val (py-ffi/untracked->python att-name py-base/->python)]
+         att-val (py-ffi/PyObject_GetAttr item att-name)]
         (when (or (nil? att-name) (nil? att-val))
           (py-ffi/check-error-throw))
         (->> (call-py-fn att-val arglist kw-map arg-converter)
diff --git a/test/libpython_clj2/python_test.clj b/test/libpython_clj2/python_test.clj
index 7f1b270..e693169 100644
--- a/test/libpython_clj2/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -428,6 +428,13 @@ class Foo:
   (is (true? (boolean (py. (libpython-clj2.python.bridge-as-python/map-as-python {}) __iter__)))))
 
 
+(deftest call-attr-test
+  (let [np (py/import-module "numpy")
+        random (py/get-attr np "random")
+        data (py/call-attr random :randn 8 6)]
+    (is (= [8 6] (dtype/shape (py/call-attr random :randn 8 6))))))
+
+
 (comment
   (require '[libpython-clj.require :refer [require-python]])
 

From a35d737d5cb8b8066de655fcff2edc022f00aec5 Mon Sep 17 00:00:00 2001
From: The Alchemist <kap4020@gmail.com>
Date: Tue, 7 Feb 2023 10:50:28 -0500
Subject: [PATCH 423/456] minor grammar fix in README (#237)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 791036c..4374188 100644
--- a/README.md
+++ b/README.md
@@ -151,7 +151,7 @@ languages.
 #### Environments
 
 
-One very complimentary aspect of Python with respect to Clojure is it's integration
+One very complimentary aspect of Python with respect to Clojure is its integration
 with cutting edge native libraries.  Our support isn't perfect so some understanding
 of the mechanism is important to diagnose errors and issues.
 

From 953e42f8131133535baa4ea60b46e37b8c56b425 Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Tue, 28 Feb 2023 22:59:51 +0100
Subject: [PATCH 424/456] Clarify potential issue with dynamic python library
 (#236)

* Clarify that about dynamic python library

and that it cannot be found in all cases, and what to do in such situation.

* Improved wording

using GTP-3
---
 README.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/README.md b/README.md
index 4374188..15bd490 100644
--- a/README.md
+++ b/README.md
@@ -160,6 +160,13 @@ configuration as json.  We parse the json and use the output to attempt to find
 the `libpython3.Xm.so` shared library so for example if we are loading python
 3.6 we look for `libpython3.6m.so` on Linux or `libpython3.6m.dylib` on the Mac.
 
+If we are unable to find a dynamic library such as `libpythonx.y.so` or `libpythonx.z.dylib`, 
+it may be because Python is statically linked and the library is not present at all. 
+This is dependent on the operating system and installation, and it is not always possible to detect it. 
+In this case, we will receive an error message saying "Failed to find a valid python library!". 
+To fix this, you may need to install additional OS packages or manually set the precise library location during `py/initialize!`.
+
+
 This pathway has allowed us support Conda albeit with some work.  For examples
 using Conda, check out the facial rec repository a)bove or look into how we
 [build](scripts/build-conda-docker)

From 181a4f5563371cab6ca9fe24a3c9fb9ff107bc8b Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 12 Mar 2023 06:09:34 -0600
Subject: [PATCH 425/456] Adding back attr-type-map

---
 src/libpython_clj2/python.clj | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 16f1f32..2a14ccf 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -46,7 +46,7 @@ user> (py/py. np linspace 2 3 :num 10)
     "Initialize the python library.  If library path is not provided, then the system
   attempts to execute a simple python program and have python return system info.
 
-  Note: all of the options passed to `initialize!` may now be provided in 
+  Note: all of the options passed to `initialize!` may now be provided in
   a root-level `python.edn` file.  Example:
 
   ```
@@ -82,7 +82,7 @@ user> (py/py. np linspace 2 3 :num 10)
 
   The file MUST be named `python.edn` and be in the root of the classpath.
   With a `python.edn` file in place, the `initialize!` function may be called
-  with no arguments and the options will be read from the file. If arguments are 
+  with no arguments and the options will be read from the file. If arguments are
   passed to `initialize!` then they will override the values in the file.
 
   Returns either `:ok` in which case the initialization completed successfully or
@@ -359,7 +359,17 @@ user> (py/py. np linspace 2 3 :num 10)
 (defn python-type
   "Get the type (as a keyword) of a python object"
   [v]
-  (py-ffi/with-gil (py-proto/python-type v)))
+  (if v
+    (py-ffi/with-gil (py-proto/python-type v))
+    :py-none))
+
+
+(defn attr-type-map
+  "Return a map of attr name to python-type of the attribute"
+  [pyobj]
+  (py-ffi/with-gil
+    (into (sorted-map) (map #(vector % (python-type (get-attr pyobj %))))
+          (dir pyobj))))
 
 
 (defmacro import-as

From b1aa2ef9c9cd325c71e0fe39ab5b6a5cddb3d052 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 29 Mar 2023 13:45:03 -0600
Subject: [PATCH 426/456] docfix

---
 deps.edn                                 |  1 +
 docs/Usage.html                          |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  6 ++-
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        |  2 +-
 docs/libpython-clj2.python.html          | 61 ++++++++++++------------
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 src/libpython_clj2/python.clj            |  4 +-
 src/libpython_clj2/python/class.clj      | 28 +++++------
 16 files changed, 62 insertions(+), 60 deletions(-)

diff --git a/deps.edn b/deps.edn
index 1fced82..3a227ef 100644
--- a/deps.edn
+++ b/deps.edn
@@ -40,6 +40,7 @@
                         :doc-paths ["topics"]
                         :source-uri "https://github.com/clj-python/libpython-clj/blob/master/{filepath}#L{line}"
                         :namespaces [libpython-clj2.python
+                                     libpython-clj2.python.class
                                      libpython-clj2.codegen
                                      libpython-clj2.python.np-array
                                      libpython-clj2.require
diff --git a/docs/Usage.html b/docs/Usage.html
index e34264e..f7917ba 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/embedded.html b/docs/embedded.html
index 0bd528c..26444b8 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index 055fc16..65434e8 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 356fd8b..16ce104 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
@@ -16,7 +16,9 @@
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.java-api.html#var--arrayToJVM">-arrayToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--call">-call</a> </li><li> <a href="libpython-clj2.java-api.html#var--callKw">-callKw</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyData">-copyData</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToJVM">-copyToJVM</a> </li><li> <a href="libpython-clj2.java-api.html#var--copyToPy">-copyToPy</a> </li><li> <a href="libpython-clj2.java-api.html#var--createArray">-createArray</a> </li><li> <a href="libpython-clj2.java-api.html#var--getAttr">-getAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--getGlobal">-getGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--getItem">-getItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--GILLocker">-GILLocker</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasAttr">-hasAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--hasItem">-hasItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--importModule">-importModule</a> </li><li> <a href="libpython-clj2.java-api.html#var--initialize">-initialize</a> </li><li> <a href="libpython-clj2.java-api.html#var--initializeEmbedded">-initializeEmbedded</a> </li><li> <a href="libpython-clj2.java-api.html#var--lockGIL">-lockGIL</a> </li><li> <a href="libpython-clj2.java-api.html#var--makeFastcallable">-makeFastcallable</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsFile">-runStringAsFile</a> </li><li> <a href="libpython-clj2.java-api.html#var--runStringAsInput">-runStringAsInput</a> </li><li> <a href="libpython-clj2.java-api.html#var--setAttr">-setAttr</a> </li><li> <a href="libpython-clj2.java-api.html#var--setGlobal">-setGlobal</a> </li><li> <a href="libpython-clj2.java-api.html#var--setItem">-setItem</a> </li><li> <a href="libpython-clj2.java-api.html#var--unlockGIL">-unlockGIL</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.html">libpython-clj2.python</a></h3><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
-</div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li><li> <a href="libpython-clj2.python.html#var-with-manual-gil">with-manual-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context">with-manual-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+</div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.html#var-.24a">$a</a> </li><li> <a href="libpython-clj2.python.html#var-.24c">$c</a> </li><li> <a href="libpython-clj2.python.html#var--.3Ejvm">-&gt;jvm</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-dict">-&gt;py-dict</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-list">-&gt;py-list</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epy-tuple">-&gt;py-tuple</a> </li><li> <a href="libpython-clj2.python.html#var--.3Epython">-&gt;python</a> </li><li> <a href="libpython-clj2.python.html#var-add-module">add-module</a> </li><li> <a href="libpython-clj2.python.html#var-afn">afn</a> </li><li> <a href="libpython-clj2.python.html#var-as-jvm">as-jvm</a> </li><li> <a href="libpython-clj2.python.html#var-as-list">as-list</a> </li><li> <a href="libpython-clj2.python.html#var-as-map">as-map</a> </li><li> <a href="libpython-clj2.python.html#var-as-python">as-python</a> </li><li> <a href="libpython-clj2.python.html#var-attr-type-map">attr-type-map</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr">call-attr</a> </li><li> <a href="libpython-clj2.python.html#var-call-attr-kw">call-attr-kw</a> </li><li> <a href="libpython-clj2.python.html#var-callable.3F">callable?</a> </li><li> <a href="libpython-clj2.python.html#var-cfn">cfn</a> </li><li> <a href="libpython-clj2.python.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.html#var-def-unpack">def-unpack</a> </li><li> <a href="libpython-clj2.python.html#var-dir">dir</a> </li><li> <a href="libpython-clj2.python.html#var-from-import">from-import</a> </li><li> <a href="libpython-clj2.python.html#var-get-attr">get-attr</a> </li><li> <a href="libpython-clj2.python.html#var-get-item">get-item</a> </li><li> <a href="libpython-clj2.python.html#var-has-attr.3F">has-attr?</a> </li><li> <a href="libpython-clj2.python.html#var-has-item.3F">has-item?</a> </li><li> <a href="libpython-clj2.python.html#var-import-as">import-as</a> </li><li> <a href="libpython-clj2.python.html#var-import-module">import-module</a> </li><li> <a href="libpython-clj2.python.html#var-initialize.21">initialize!</a> </li><li> <a href="libpython-clj2.python.html#var-is-instance.3F">is-instance?</a> </li><li> <a href="libpython-clj2.python.html#var-make-callable">make-callable</a> </li><li> <a href="libpython-clj2.python.html#var-make-fastcallable">make-fastcallable</a> </li><li> <a href="libpython-clj2.python.html#var-make-instance-fn">make-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.html#var-module-dict">module-dict</a> </li><li> <a href="libpython-clj2.python.html#var-path-.3Epy-obj">path-&gt;py-obj</a> </li><li> <a href="libpython-clj2.python.html#var-py*">py*</a> </li><li> <a href="libpython-clj2.python.html#var-py**">py**</a> </li><li> <a href="libpython-clj2.python.html#var-py.">py.</a> </li><li> <a href="libpython-clj2.python.html#var-py.-">py.-</a> </li><li> <a href="libpython-clj2.python.html#var-py..">py..</a> </li><li> <a href="libpython-clj2.python.html#var-python-type">python-type</a> </li><li> <a href="libpython-clj2.python.html#var-run-simple-string">run-simple-string</a> </li><li> <a href="libpython-clj2.python.html#var-set-attr.21">set-attr!</a> </li><li> <a href="libpython-clj2.python.html#var-set-attrs.21">set-attrs!</a> </li><li> <a href="libpython-clj2.python.html#var-set-item.21">set-item!</a> </li><li> <a href="libpython-clj2.python.html#var-set-items.21">set-items!</a> </li><li> <a href="libpython-clj2.python.html#var-stack-resource-context">stack-resource-context</a> </li><li> <a href="libpython-clj2.python.html#var-with">with</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil">with-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-gil-stack-rc-context">with-gil-stack-rc-context</a> </li><li> <a href="libpython-clj2.python.html#var-with-manual-gil">with-manual-gil</a> </li><li> <a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context">with-manual-gil-stack-rc-context</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.class.html">libpython-clj2.python.class</a></h3><div class="doc"><div class="markdown"><p>Namespace to help create a new python class from Clojure.  Used as a core
+implementation technique for bridging JVM objects into python.</p>
+</div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.python.class.html#var-create-class">create-class</a> </li><li> <a href="libpython-clj2.python.class.html#var-make-kw-instance-fn">make-kw-instance-fn</a> </li><li> <a href="libpython-clj2.python.class.html#var-make-tuple-instance-fn">make-tuple-instance-fn</a> </li><li> <a href="libpython-clj2.python.class.html#var-py-fn-.3Einstance-fn">py-fn-&gt;instance-fn</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.python.np-array.html">libpython-clj2.python.np-array</a></h3><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index 744cc27..bbda58e 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index cf26a99..91fb183 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 5ca82c9..6990956 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index f8d3340..574e88c 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-attr-type-map"><div class="inner"><span>attr-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
@@ -23,34 +23,35 @@
 Keywords must be compile time constants.  So this won't work with 'apply'.  On the
 other hand, building the positional and kw argmaps happens at compile time as
 opposed to at runtime.  The attr name can be a symbol.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L620">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L630">view source</a></div></div><div class="public anchor" id="var-.24c"><h3>$c</h3><h4 class="type">macro</h4><div class="usage"><code>($c item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object using automatic detection of the python kwargs.
 Keywords must be compile time constants.  So this won't work with 'apply'.  On the
 other hand, building the positional and kw argmaps happens at compile time as
 opposed to at runtime.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L631">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L641">view source</a></div></div><div class="public anchor" id="var--.3Ejvm"><h3>-&gt;jvm</h3><div class="usage"><code>(-&gt;jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L335">view source</a></div></div><div class="public anchor" id="var--.3Epy-dict"><h3>-&gt;py-dict</h3><div class="usage"><code>(-&gt;py-dict v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python dict</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L429">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L417">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L423">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L439">view source</a></div></div><div class="public anchor" id="var--.3Epy-list"><h3>-&gt;py-list</h3><div class="usage"><code>(-&gt;py-list v)</code></div><div class="doc"><div class="markdown"><p>Copy the data into a python list</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L427">view source</a></div></div><div class="public anchor" id="var--.3Epy-tuple"><h3>-&gt;py-tuple</h3><div class="usage"><code>(-&gt;py-tuple v)</code></div><div class="doc"><div class="markdown"><p>Copy v into a python tuple</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L433">view source</a></div></div><div class="public anchor" id="var--.3Epython"><h3>-&gt;python</h3><div class="usage"><code>(-&gt;python v)</code></div><div class="doc"><div class="markdown"><p>Copy a jvm value into a python object</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L323">view source</a></div></div><div class="public anchor" id="var-add-module"><h3>add-module</h3><div class="usage"><code>(add-module modname)</code></div><div class="doc"><div class="markdown"><p>Add a python module.  This can create a module if it doesn't exist.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L237">view source</a></div></div><div class="public anchor" id="var-afn"><h3>afn</h3><div class="usage"><code>(afn item attr &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute of an object.
 Arguments are passed in positionally.  Any keyword
 arguments are paired with the next arg, gathered, and passed into the
 system as *kwargs.</p>
 <p>Not having an argument after a keyword is an error.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L563">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L573">view source</a></div></div><div class="public anchor" id="var-as-jvm"><h3>as-jvm</h3><div class="usage"><code>(as-jvm v &amp; [opts])</code></div><div class="doc"><div class="markdown"><p>Copy a python value into java datastructures</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L341">view source</a></div></div><div class="public anchor" id="var-as-list"><h3>as-list</h3><div class="usage"><code>(as-list pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a list</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L353">view source</a></div></div><div class="public anchor" id="var-as-map"><h3>as-map</h3><div class="usage"><code>(as-map pobj)</code></div><div class="doc"><div class="markdown"><p>Make a python object appear as a map of it's items</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L347">view source</a></div></div><div class="public anchor" id="var-as-python"><h3>as-python</h3><div class="usage"><code>(as-python v)</code></div><div class="doc"><div class="markdown"><p>Bridge a jvm value into a python object</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L329">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L329">view source</a></div></div><div class="public anchor" id="var-attr-type-map"><h3>attr-type-map</h3><div class="usage"><code>(attr-type-map pyobj)</code></div><div class="doc"><div class="markdown"><p>Return a map of attr name to python-type of the attribute</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L367">view source</a></div></div><div class="public anchor" id="var-call-attr"><h3>call-attr</h3><div class="usage"><code>(call-attr pyobj attname &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an attribute on a python object using only positional arguments</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L260">view source</a></div></div><div class="public anchor" id="var-call-attr-kw"><h3>call-attr-kw</h3><div class="usage"><code>(call-attr-kw pyobj attname args kw-list)</code></div><div class="doc"><div class="markdown"><p>Call an attribute passing in both positional and keyword arguments.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L266">view source</a></div></div><div class="public anchor" id="var-callable.3F"><h3>callable?</h3><div class="usage"><code>(callable? pyobj)</code></div><div class="doc"><div class="markdown"><p>Return true if python object is callable.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L400">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L410">view source</a></div></div><div class="public anchor" id="var-cfn"><h3>cfn</h3><div class="usage"><code>(cfn item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Call an object.
 Arguments are passed in positionally.  Any keyword
 arguments are paired with the next arg, gathered, and passed into the
 system as *kwargs.</p>
 <p>Not having an argument after a keyword argument is an error.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L552">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L562">view source</a></div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
 will be presented as instance methods.  If you want access to the
 'this' object then you must use <code>make-instance-fn</code>.</p>
 <p>Example:</p>
@@ -77,7 +78,7 @@
 user&gt; (py/call-attr inst "addarg" 10)
 20
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L517">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs.  Useful when trying to match Python
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L527">view source</a></div></div><div class="public anchor" id="var-def-unpack"><h3>def-unpack</h3><h4 class="type">macro</h4><div class="usage"><code>(def-unpack symbols input)</code></div><div class="doc"><div class="markdown"><p>Unpack a set of symbols into a set of defs.  Useful when trying to match Python
 idioms - this is definitely not idiomatic Clojure.</p>
 <p>Example:</p>
 <pre><code class="language-clojure">user&gt; (py/def-unpack [a b c] (py/-&gt;py-tuple [1 2 3]))
@@ -89,14 +90,14 @@
 user&gt; c
 3
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L793">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L255">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python.
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L803">view source</a></div></div><div class="public anchor" id="var-dir"><h3>dir</h3><div class="usage"><code>(dir pyobj)</code></div><div class="doc"><div class="markdown"></div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L255">view source</a></div></div><div class="public anchor" id="var-from-import"><h3>from-import</h3><h4 class="type">macro</h4><div class="usage"><code>(from-import module-path item &amp; args)</code></div><div class="doc"><div class="markdown"><p>Support for the from a import b,c style of importing modules and symbols in python.
 Documentation is included.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L374">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L384">view source</a></div></div><div class="public anchor" id="var-get-attr"><h3>get-attr</h3><div class="usage"><code>(get-attr pyobj attname)</code></div><div class="doc"><div class="markdown"><p>Get an attribute from a python object</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L271">view source</a></div></div><div class="public anchor" id="var-get-item"><h3>get-item</h3><div class="usage"><code>(get-item pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Get an item from a python object using  <strong>getitem</strong></p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L297">view source</a></div></div><div class="public anchor" id="var-has-attr.3F"><h3>has-attr?</h3><div class="usage"><code>(has-attr? pyobj att-name)</code></div><div class="doc"><div class="markdown"><p>Return true if this python object has this attribute.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L291">view source</a></div></div><div class="public anchor" id="var-has-item.3F"><h3>has-item?</h3><div class="usage"><code>(has-item? pyobj item-name)</code></div><div class="doc"><div class="markdown"><p>Return true if the python object has an item.  Calls <strong>hasitem</strong>.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L310">view source</a></div></div><div class="public anchor" id="var-import-as"><h3>import-as</h3><h4 class="type">macro</h4><div class="usage"><code>(import-as module-path varname)</code></div><div class="doc"><div class="markdown"><p>Import a module and assign it to a var.  Documentation is included.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L365">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module.  Module entries can be accessed via get-attr.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L375">view source</a></div></div><div class="public anchor" id="var-import-module"><h3>import-module</h3><div class="usage"><code>(import-module modname)</code></div><div class="doc"><div class="markdown"><p>Import a python module.  Module entries can be accessed via get-attr.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L227">view source</a></div></div><div class="public anchor" id="var-initialize.21"><h3>initialize!</h3><div class="usage"><code>(initialize! &amp; {:keys [windows-anaconda-activate-bat library-path no-io-redirect?], :as options})</code></div><div class="doc"><div class="markdown"><p>Initialize the python library.  If library path is not provided, then the system
 attempts to execute a simple python program and have python return system info.</p>
 <p>Note: all of the options passed to <code>initialize!</code> may now be provided in
@@ -152,7 +153,7 @@
 </ul>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L45">view source</a></div></div><div class="public anchor" id="var-is-instance.3F"><h3>is-instance?</h3><div class="usage"><code>(is-instance? py-inst py-cls)</code></div><div class="doc"><div class="markdown"><p>Return true if inst is an instance of cls.  Note that arguments
 are reversed as compared to <code>instance?</code></p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L388">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function.  This is called for you
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L398">view source</a></div></div><div class="public anchor" id="var-make-callable"><h3>make-callable</h3><div class="usage"><code>(make-callable ifn options)</code><code>(make-callable ifn)</code></div><div class="doc"><div class="markdown"><p>Make a python callable object from a clojure function.  This is called for you
 if you use <code>as-python</code> on an implementation of IFn.</p>
 <p>Options:</p>
 <ul>
@@ -165,7 +166,7 @@
 <li><code>:name</code> - Name of the python method.  This will appear in stack traces.</li>
 <li><code>:doc</code> - documentation for method.</li>
 </ul>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L468">view source</a></div></div><div class="public anchor" id="var-make-fastcallable"><h3>make-fastcallable</h3><div class="usage"><code>(make-fastcallable item)</code></div><div class="doc"><div class="markdown"><p>Wrap a python callable such that calling it in a tight loop with purely positional
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L478">view source</a></div></div><div class="public anchor" id="var-make-fastcallable"><h3>make-fastcallable</h3><div class="usage"><code>(make-fastcallable item)</code></div><div class="doc"><div class="markdown"><p>Wrap a python callable such that calling it in a tight loop with purely positional
 arguments is a bit (2x-3x) faster.</p>
 <p>Example:</p>
 <pre><code class="language-clojure">user&gt; (def test-fn (-&gt; (py/run-simple-string "def spread(bid,ask):
@@ -198,23 +199,23 @@
 "Elapsed time: 35.492965 msecs"
 nil
 </code></pre>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L574">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the 'this'
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L584">view source</a></div></div><div class="public anchor" id="var-make-instance-fn"><h3>make-instance-fn</h3><div class="usage"><code>(make-instance-fn ifn options)</code><code>(make-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an callable instance function - a function which will be passed the 'this'
 object as it's first argument.  In addition, this function calls <code>make-callable</code>
 with a <code>arg-converter</code> defaulted to <code>as-jvm</code>.  See documentation for
-[[libpython-clj2.python.class/make-instance-fn.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L492">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments,
+<a href="libpython-clj2.python.html#var-make-callable">make-callable</a> and <a href="libpython-clj2.python.class.html#var-make-tuple-instance-fn">libpython-clj2.python.class/make-tuple-instance-fn</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L502">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn ifn options)</code><code>(make-kw-instance-fn ifn)</code></div><div class="doc"><div class="markdown"><p>Make an kw callable instance function - function by default is passed 2 arguments,
 the positional argument vector and a map of keyword arguments.  Results are marshalled
 back to python using <a href="libpython-clj2.python.fn-bridged-fn-arg--python">libpython-clj2.python.fn/bridged-fn-arg-&gt;python</a> which is also
-used when bridging an object into python.  See documentation for
-<a href="libpython-clj2.python.class-make-kw-instance-fn">libpython-clj2.python.class/make-kw-instance-fn</a>.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L501">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p>
+used when bridging an object into python.  See documentation for <a href="libpython-clj2.python.html#var-make-callable">make-callable</a>
+<a href="libpython-clj2.python.class.html#var-make-kw-instance-fn">libpython-clj2.python.class/make-kw-instance-fn</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L511">view source</a></div></div><div class="public anchor" id="var-module-dict"><h3>module-dict</h3><div class="usage"><code>(module-dict mod)</code></div><div class="doc"><div class="markdown"><p>Get the module dictionary.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L246">view source</a></div></div><div class="public anchor" id="var-path-.3Epy-obj"><h3>path-&gt;py-obj</h3><div class="usage"><code>(path-&gt;py-obj item-path &amp; {:keys [reload?]})</code></div><div class="doc"><div class="markdown"><p>Given a string such as "builtins" or "builtins.list", load the module or
 the class object in the module.</p>
 <p>Options:</p>
 <ul>
 <li><code>:reload</code> - Reload the module.</li>
 </ul>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L768">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L778">view source</a></div></div><div class="public anchor" id="var-py*"><h3>py*</h3><h4 class="type">macro</h4><div class="usage"><code>(py* x method args)</code><code>(py* x method args kwargs)</code></div><div class="doc"><div class="markdown"><p>Special syntax for passing along *args and **kwargs style arguments
 to methods.</p>
 <p>Usage:</p>
 <p>(py* obj method args kwargs)</p>
@@ -225,12 +226,12 @@
 (def kwargs {:cat "dog" :name "taco"})
 (py* d  update <a href="iterable">iterable</a> kwargs)
 d ;;=&gt; {"a": 1, "b": 2, "cat": "dog", "name": "taco"}</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L657">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L679">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L667">view source</a></div></div><div class="public anchor" id="var-py**"><h3>py**</h3><h4 class="type">macro</h4><div class="usage"><code>(py** x method kwargs)</code><code>(py** x method arg &amp; args)</code></div><div class="doc"><div class="markdown"><p>Like py*, but it is assumed that the LAST argument is kwargs.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L689">view source</a></div></div><div class="public anchor" id="var-py."><h3>py.</h3><h4 class="type">macro</h4><div class="usage"><code>(py. x method-name &amp; args)</code></div><div class="doc"><div class="markdown"><p>Class/object method syntax.  (py. obj method arg1 arg2 ... argN)
 is equivalent to Python's obj.method(arg1, arg2, ..., argN) syntax.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L648">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax.  (py.- obj attr) is equivalent to
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L658">view source</a></div></div><div class="public anchor" id="var-py.-"><h3>py.-</h3><h4 class="type">macro</h4><div class="usage"><code>(py.- x arg)</code></div><div class="doc"><div class="markdown"><p>Class/object getter syntax.  (py.- obj attr) is equivalent to
 Python's obj.attr syntax.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L641">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L651">view source</a></div></div><div class="public anchor" id="var-py.."><h3>py..</h3><h4 class="type">macro</h4><div class="usage"><code>(py.. x &amp; args)</code></div><div class="doc"><div class="markdown"><p>Extended accessor notation, similar to the <code>..</code> macro in Clojure.</p>
 <p>(require-python 'sys)
 (py.. sys -path (append "/home/user/bin"))</p>
 <p>is equivalent to Python's</p>
@@ -251,7 +252,7 @@
 <p>These forms exist for when you need to pass in a map of options
 in the same way you would use the f(*args, **kwargs) forms in
 Python.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L714">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L724">view source</a></div></div><div class="public anchor" id="var-python-type"><h3>python-type</h3><div class="usage"><code>(python-type v)</code></div><div class="doc"><div class="markdown"><p>Get the type (as a keyword) of a python object</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L359">view source</a></div></div><div class="public anchor" id="var-run-simple-string"><h3>run-simple-string</h3><div class="usage"><code>(run-simple-string program &amp; {:keys [globals locals]})</code></div><div class="doc"><div class="markdown"><p>Run a string expression returning a map of
 {:globals :locals}.
 This uses the global <strong>main</strong> dict under the covers so it matches the behavior
@@ -273,7 +274,7 @@
 }
 Py_DECREF(v);
 return 0;</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L435">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object.  Returns pyobj.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L445">view source</a></div></div><div class="public anchor" id="var-set-attr.21"><h3>set-attr!</h3><div class="usage"><code>(set-attr! pyobj attname attval)</code></div><div class="doc"><div class="markdown"><p>Set an attribute on a python object.  Returns pyobj.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L277">view source</a></div></div><div class="public anchor" id="var-set-attrs.21"><h3>set-attrs!</h3><div class="usage"><code>(set-attrs! pyobj att-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a> attributes.  Returns pyobj.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L284">view source</a></div></div><div class="public anchor" id="var-set-item.21"><h3>set-item!</h3><div class="usage"><code>(set-item! pyobj item-name item-val)</code></div><div class="doc"><div class="markdown"><p>Set an item on a python object using  <strong>setitem</strong></p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L303">view source</a></div></div><div class="public anchor" id="var-set-items.21"><h3>set-items!</h3><div class="usage"><code>(set-items! pyobj item-seq)</code></div><div class="doc"><div class="markdown"><p>Set a sequence of <a href="name value">name value</a>. Returns pyobj</p>
@@ -287,7 +288,7 @@
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L156">view source</a></div></div><div class="public anchor" id="var-with"><h3>with</h3><h4 class="type">macro</h4><div class="usage"><code>(with bind-vec &amp; body)</code></div><div class="doc"><div class="markdown"><p>Support for the 'with' statement in python:
 (py/with <a href="item (py/call-attr testcode-module &quot;WithObjClass&quot; true fn-list)">item (py/call-attr testcode-module "WithObjClass" true fn-list)</a>
 (py/call-attr item "doit_err"))</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L612">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time.  This can greatly speed up
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L622">view source</a></div></div><div class="public anchor" id="var-with-gil"><h3>with-gil</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil for an extended amount of time.  This can greatly speed up
 operations as the mutex is captured and held once as opposed to fine grained
 grabbing/releasing of the mutex.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python.clj#L169">view source</a></div></div><div class="public anchor" id="var-with-gil-stack-rc-context"><h3>with-gil-stack-rc-context</h3><h4 class="type">macro</h4><div class="usage"><code>(with-gil-stack-rc-context &amp; body)</code></div><div class="doc"><div class="markdown"><p>Capture the gil, open a resource context.  The resource context is released
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 3d72c15..8aeee37 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 5426f02..d39ac02 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index dc244a3..0ab76f2 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 1ad5597..34f2ded 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index 54cc64d..5427df7 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -52px;"><span class="top" style="height: 61px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 2a14ccf..661f285 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -503,7 +503,7 @@ Options:
   "Make an callable instance function - a function which will be passed the 'this'
   object as it's first argument.  In addition, this function calls `make-callable`
   with a `arg-converter` defaulted to `as-jvm`.  See documentation for
-  [[libpython-clj2.python.class/make-instance-fn."
+  [[make-callable]] and [[libpython-clj2.python.class/make-tuple-instance-fn]]."
   ([ifn options] (py-class/make-tuple-instance-fn ifn options))
   ([ifn] (make-instance-fn ifn nil)))
 
@@ -512,7 +512,7 @@ Options:
   "Make an kw callable instance function - function by default is passed 2 arguments,
   the positional argument vector and a map of keyword arguments.  Results are marshalled
   back to python using [[libpython-clj2.python.fn/bridged-fn-arg->python]] which is also
-  used when bridging an object into python.  See documentation for
+  used when bridging an object into python.  See documentation for [[make-callable]]
   [[libpython-clj2.python.class/make-kw-instance-fn]]."
   ([ifn options] (py-class/make-kw-instance-fn ifn options))
   ([ifn] (make-kw-instance-fn ifn nil)))
diff --git a/src/libpython_clj2/python/class.clj b/src/libpython_clj2/python/class.clj
index 5cc6587..971f8ff 100644
--- a/src/libpython_clj2/python/class.clj
+++ b/src/libpython_clj2/python/class.clj
@@ -27,7 +27,8 @@
   as that can add confusion and unnecessary overhead.  Self will be the first argument.
   Callers can change this behavior by setting the 'arg-converter' option as in
   'make-tuple-fn'.
-  Options are the same as make-tuple-fn."
+
+  See options to [[libpython-clj2.python/make-callable]]."
   ([clj-fn & [{:keys [arg-converter]
                :or {arg-converter py-base/as-jvm}
                :as options}]]
@@ -45,16 +46,13 @@
   pass as-jvm bridged python object ptr args and kw dict args to the clojure function without
   marshalling.  Self will be the first argument of the arg vector.
 
-
+  See options to [[libpython-clj2.python/make-callable]].
 
   Options:
 
-  * `:kw-arg-converter` - passed two arguments, the positional arguments as a python ptr
-  and the keyword arguments as a python pointer.  The clj-fn is 'applied' to the result
-  of `:arg-converter` which has the same default as [[make-tuple-fn]].
-
-  * `:result-converter` - defaults to the same argument conversion rules of bridged
-     objects."
+  * `:arg-converter` - gets one argument and must convert into jvm space - defaults to as-jvm.
+  * `:result-converter` - gets one argument and must convert to python space.
+     Has reasonable default."
   ([clj-fn & [{:keys [arg-converter
                       result-converter]
                :or {arg-converter py-base/as-jvm}
@@ -84,7 +82,7 @@
           (py-base/as-jvm)))))
 
 
-(def wrapped-jvm-destructor*
+(def ^:private wrapped-jvm-destructor*
   (jvm-handle/py-global-delay
    (make-tuple-instance-fn
     (fn [self]
@@ -94,28 +92,28 @@
         nil)))))
 
 
-(defn wrapped-jvm-destructor
+(defn ^:no-doc wrapped-jvm-destructor
   []
   @wrapped-jvm-destructor*)
 
 
-(def wrapped-jvm-constructor*
+(def ^:private wrapped-jvm-constructor*
   (jvm-handle/py-global-delay
    (make-tuple-instance-fn jvm-handle/py-self-set-jvm-handle!)))
 
 
-(defn wrapped-jvm-constructor
+(defn ^:no-doc wrapped-jvm-constructor
   []
   @wrapped-jvm-constructor*)
 
 
-(def abc-callable-type*
+(def ^:no-doc abc-callable-type*
   (jvm-handle/py-global-delay
    (py-ffi/with-decref [mod (py-ffi/PyImport_ImportModule "collections.abc")]
      (py-proto/get-attr mod "Callable"))))
 
 
-(def wrapped-fn-class*
+(def ^:no-doc wrapped-fn-class*
   (jvm-handle/py-global-delay
      (create-class
       "LibPythonCLJWrappedFn" [@abc-callable-type*]
@@ -133,7 +131,7 @@
                      (.toString (jvm-handle/py-self->jvm-obj self)))))})))
 
 
-(defn wrap-ifn
+(defn ^:no-doc wrap-ifn
   [ifn]
   (errors/when-not-errorf
    (instance? IFn ifn)

From f146cbd9389dc2c9931316123b969c0d83b5deb7 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 29 Mar 2023 13:46:52 -0600
Subject: [PATCH 427/456] Updating class docs

---
 docs/libpython-clj2.python.class.html | 34 +++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 docs/libpython-clj2.python.class.html

diff --git a/docs/libpython-clj2.python.class.html b/docs/libpython-clj2.python.class.html
new file mode 100644
index 0000000..f28aecf
--- /dev/null
+++ b/docs/libpython-clj2.python.class.html
@@ -0,0 +1,34 @@
+<!DOCTYPE html PUBLIC ""
+    "">
+<html><head><meta charset="UTF-8" /><title>libpython-clj2.python.class documentation</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch current"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.class.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-py-fn-.3Einstance-fn"><div class="inner"><span>py-fn-&gt;instance-fn</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.class</h1><div class="doc"><div class="markdown"><p>Namespace to help create a new python class from Clojure.  Used as a core
+implementation technique for bridging JVM objects into python.</p>
+</div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
+will be presented as instance methods.
+Things in the cls hashmap had better be either atoms or already converted
+python objects.  You may get surprised otherwise; you have been warned.
+See the classes-test file in test/libpython-clj</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/class.clj#L70">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn clj-fn &amp; [{:keys [arg-converter result-converter], :or {arg-converter py-base/as-jvm}, :as options}])</code></div><div class="doc"><div class="markdown"><p>Make an instance function - a function which will be passed the 'this' object as
+it's first argument.  In this case the default behavior is to
+pass as-jvm bridged python object ptr args and kw dict args to the clojure function without
+marshalling.  Self will be the first argument of the arg vector.</p>
+<p>See options to <a href="libpython-clj2.python.html#var-make-callable">libpython-clj2.python/make-callable</a>.</p>
+<p>Options:</p>
+<ul>
+<li><code>:arg-converter</code> - gets one argument and must convert into jvm space - defaults to as-jvm.</li>
+<li><code>:result-converter</code> - gets one argument and must convert to python space.
+Has reasonable default.</li>
+</ul>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/class.clj#L43">view source</a></div></div><div class="public anchor" id="var-make-tuple-instance-fn"><h3>make-tuple-instance-fn</h3><div class="usage"><code>(make-tuple-instance-fn clj-fn &amp; [{:keys [arg-converter], :or {arg-converter py-base/as-jvm}, :as options}])</code></div><div class="doc"><div class="markdown"><p>Make an instance function - a function which will be passed the 'this' object as
+it's first argument.  In this case the default behavior is to
+pass raw python object ptr args to the clojure function without marshalling
+as that can add confusion and unnecessary overhead.  Self will be the first argument.
+Callers can change this behavior by setting the 'arg-converter' option as in
+'make-tuple-fn'.</p>
+<p>See options to <a href="libpython-clj2.python.html#var-make-callable">libpython-clj2.python/make-callable</a>.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/class.clj#L23">view source</a></div></div><div class="public anchor" id="var-py-fn-.3Einstance-fn"><h3>py-fn-&gt;instance-fn</h3><div class="usage"><code>(py-fn-&gt;instance-fn py-fn)</code></div><div class="doc"><div class="markdown"><p>Given a python callable, return an instance function meant to be used
+in class definitions.</p>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/class.clj#L13">view source</a></div></div></div></body></html>
\ No newline at end of file

From 2a4347789c00ee74151b8fb635fa961810454c93 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 14 Apr 2023 13:17:59 -0600
Subject: [PATCH 428/456] Updating to latest dtype-next and testing.

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 3a227ef..c1815a1 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure     {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next    {:mvn/version "10.000-beta-32"}
+        cnuernber/dtype-next    {:mvn/version "10.000-beta-46"}
         net.java.dev.jna/jna    {:mvn/version "5.12.1"}
         org.clojure/data.json   {:mvn/version "1.0.0"}
         ;;Replace me with caffeine...

From fee7f411a0c360aa9b444d96054e083b7a33cc93 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sat, 22 Apr 2023 08:14:35 -0600
Subject: [PATCH 429/456] update to latest dtype-next

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index c1815a1..4c6a83d 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure     {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next    {:mvn/version "10.000-beta-46"}
+        cnuernber/dtype-next    {:mvn/version "10.000-beta-48"}
         net.java.dev.jna/jna    {:mvn/version "5.12.1"}
         org.clojure/data.json   {:mvn/version "1.0.0"}
         ;;Replace me with caffeine...

From 9c9e013da1a6d86a4915411af8fd1999dd3625ce Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 28 Apr 2023 10:06:49 -0600
Subject: [PATCH 430/456] Upgrade dtype-next to fix subtle ham-fisted issue.

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index 4c6a83d..c8f2afd 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure     {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next    {:mvn/version "10.000-beta-48"}
+        cnuernber/dtype-next    {:mvn/version "10.000-beta-49"}
         net.java.dev.jna/jna    {:mvn/version "5.12.1"}
         org.clojure/data.json   {:mvn/version "1.0.0"}
         ;;Replace me with caffeine...

From 56673740767f3274335519177d54fe692b055691 Mon Sep 17 00:00:00 2001
From: ikappaki <ikappaki@users.noreply.github.com>
Date: Tue, 11 Jul 2023 20:41:18 +0100
Subject: [PATCH 431/456] Fix to correctly locate python DLL on MS-Windows

Also
- Add ci test matrix across different archs, java and python versions.
- Fix a test issue with name reference in the python collections lib.
---
 .github/workflows/test.yml          | 52 +++++++++++++++++++++++++++++
 .gitignore                          |  3 +-
 CHANGELOG.md                        |  4 +++
 src/libpython_clj2/python/info.clj  |  8 ++++-
 test/libpython_clj2/python_test.clj |  2 +-
 5 files changed, 66 insertions(+), 3 deletions(-)
 create mode 100644 .github/workflows/test.yml

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..d79b392
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,52 @@
+name: test
+
+on:
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - '**/README.md'
+      - '**/CHANGELOG.md'
+  pull_request:
+
+jobs:
+  unit-test:
+    runs-on: ${{matrix.os}}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, ubuntu-latest, windows-latest]
+        jdk: [8, 17, 19]
+        python-version: ["3.11"]
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up JDK ${{ matrix.jdk }}
+        uses: actions/setup-java@v1
+        with:
+          java-version: ${{ matrix.jdk }}
+
+      - name: Install Clojure
+        uses: DeLaGuardo/setup-clojure@11.0
+        with:
+          cli: 1.11.1.1347
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install numpy
+
+      - name: Run tests (jdk<17)
+        if: ${{ matrix.jdk < 17 }}
+        run: |
+          clojure -M:test
+      - name: Run tests (jdk>=17)
+        if: ${{ matrix.jdk >= 17 }}
+        run: |
+          clojure -M:jdk-${{matrix.jdk}}:test
diff --git a/.gitignore b/.gitignore
index 6bd4f64..476e9bb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,4 +20,5 @@ a.out
 *.iml
 .lsp
 .clj-kondo
-pregen-ffi-test
\ No newline at end of file
+pregen-ffi-test
+*~
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 02545d3..8ff520c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,8 @@
 # Time for a ChangeLog!
+## Unreleased
+ * Fix issue with locating python dll on MS-Windows
+   [#246](https://github.com/clj-python/libpython-clj/issues/246).
+
 ## 2.024
  * large dtype-next/hamf upgrade.
  * fix for call-attr (it was broken when using keywords).
diff --git a/src/libpython_clj2/python/info.clj b/src/libpython_clj2/python/info.clj
index 5667f0b..170be78 100644
--- a/src/libpython_clj2/python/info.clj
+++ b/src/libpython_clj2/python/info.clj
@@ -96,6 +96,7 @@ print(json.dumps(
                                   "Failed to find value python executable.  Tried %s"
                                   default-python-executables)))))
         python-home (find-python-home system-info options)
+        platform (:platform system-info)
         java-lib-path (java-library-path-addendum python-home)
         [ver-maj ver-med _ver-min] (:version system-info)
         lib-version                (format "%s.%s" ver-maj ver-med)
@@ -105,7 +106,12 @@ print(json.dumps(
         libnames                   (concat [libname]
                                            ;;Make sure we try without the 'm' suffix
                                            (when lib-version
-                                             [(str "python" lib-version)]))]
+                                             [(str "python" lib-version)])
+                                           ;; The official python dll
+                                           ;; does not have a dot in
+                                           ;; its name.
+                                           (when (= platform "win32")
+                                             [(str "python" ver-maj ver-med)]))]
     (merge
      system-info
      {:python-home                python-home
diff --git a/test/libpython_clj2/python_test.clj b/test/libpython_clj2/python_test.clj
index e693169..6f46a39 100644
--- a/test/libpython_clj2/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -365,7 +365,7 @@ class Foo:
         bridged-dict (py/as-python {"a" 1 "b" 2})
         bridged-iter (py/as-python (repeat 5 1))
         bridged-list (py/as-python (vec (range 10)))
-        pycol (py/import-module "collections")
+        pycol (py/import-module "collections.abc")
         mapping-type (py/get-attr pycol "Mapping")
         iter-type (py/get-attr pycol "Iterable")
         sequence-type (py/get-attr pycol "Sequence")]

From 5b241fe1c712b94d975e61df864aa3778caf80ec Mon Sep 17 00:00:00 2001
From: ikappaki <ikappaki@users.noreply.github.com>
Date: Thu, 13 Jul 2023 21:26:45 +0100
Subject: [PATCH 432/456] Extend ci coverage to ms-win/macos, fix ns issue in
 test for py>3.10

---
 .github/workflows/test.yml          | 52 +++++++++++++++++++++++++++++
 test/libpython_clj2/python_test.clj |  2 +-
 2 files changed, 53 insertions(+), 1 deletion(-)
 create mode 100644 .github/workflows/test.yml

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..06bbc99
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,52 @@
+name: test
+
+on:
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - '**/README.md'
+      - '**/CHANGELOG.md'
+  pull_request:
+
+jobs:
+  unit-test:
+    runs-on: ${{matrix.os}}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [macos-latest, ubuntu-latest, windows-latest]
+        jdk: [8, 17, 19]
+        python-version: ["3.9", "3.11"]
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up JDK ${{ matrix.jdk }}
+        uses: actions/setup-java@v1
+        with:
+          java-version: ${{ matrix.jdk }}
+
+      - name: Install Clojure
+        uses: DeLaGuardo/setup-clojure@11.0
+        with:
+          cli: 1.11.1.1347
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install numpy
+
+      - name: Run tests (jdk<17)
+        if: ${{ matrix.jdk < 17 }}
+        run: |
+          clojure -M:test
+      - name: Run tests (jdk>=17)
+        if: ${{ matrix.jdk >= 17 }}
+        run: |
+          clojure -M:jdk-${{matrix.jdk}}:test
diff --git a/test/libpython_clj2/python_test.clj b/test/libpython_clj2/python_test.clj
index e693169..6f46a39 100644
--- a/test/libpython_clj2/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -365,7 +365,7 @@ class Foo:
         bridged-dict (py/as-python {"a" 1 "b" 2})
         bridged-iter (py/as-python (repeat 5 1))
         bridged-list (py/as-python (vec (range 10)))
-        pycol (py/import-module "collections")
+        pycol (py/import-module "collections.abc")
         mapping-type (py/get-attr pycol "Mapping")
         iter-type (py/get-attr pycol "Iterable")
         sequence-type (py/get-attr pycol "Sequence")]

From bb39bdf177b546158bcb150aa762257785611600 Mon Sep 17 00:00:00 2001
From: ikappaki <ikappaki@users.noreply.github.com>
Date: Thu, 13 Jul 2023 21:38:29 +0100
Subject: [PATCH 433/456] revert test suite fix/CI suggestion/.gitignore as
 suggested

To be considered to go to seperate GH issues/PRs instead
---
 .github/workflows/test.yml          | 52 -----------------------------
 .gitignore                          |  3 +-
 test/libpython_clj2/python_test.clj |  2 +-
 3 files changed, 2 insertions(+), 55 deletions(-)
 delete mode 100644 .github/workflows/test.yml

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
deleted file mode 100644
index d79b392..0000000
--- a/.github/workflows/test.yml
+++ /dev/null
@@ -1,52 +0,0 @@
-name: test
-
-on:
-  push:
-    branches:
-      - master
-    paths-ignore:
-      - '**/README.md'
-      - '**/CHANGELOG.md'
-  pull_request:
-
-jobs:
-  unit-test:
-    runs-on: ${{matrix.os}}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [macos-latest, ubuntu-latest, windows-latest]
-        jdk: [8, 17, 19]
-        python-version: ["3.11"]
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Set up JDK ${{ matrix.jdk }}
-        uses: actions/setup-java@v1
-        with:
-          java-version: ${{ matrix.jdk }}
-
-      - name: Install Clojure
-        uses: DeLaGuardo/setup-clojure@11.0
-        with:
-          cli: 1.11.1.1347
-
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install numpy
-
-      - name: Run tests (jdk<17)
-        if: ${{ matrix.jdk < 17 }}
-        run: |
-          clojure -M:test
-      - name: Run tests (jdk>=17)
-        if: ${{ matrix.jdk >= 17 }}
-        run: |
-          clojure -M:jdk-${{matrix.jdk}}:test
diff --git a/.gitignore b/.gitignore
index 476e9bb..6bd4f64 100644
--- a/.gitignore
+++ b/.gitignore
@@ -20,5 +20,4 @@ a.out
 *.iml
 .lsp
 .clj-kondo
-pregen-ffi-test
-*~
+pregen-ffi-test
\ No newline at end of file
diff --git a/test/libpython_clj2/python_test.clj b/test/libpython_clj2/python_test.clj
index 6f46a39..e693169 100644
--- a/test/libpython_clj2/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -365,7 +365,7 @@ class Foo:
         bridged-dict (py/as-python {"a" 1 "b" 2})
         bridged-iter (py/as-python (repeat 5 1))
         bridged-list (py/as-python (vec (range 10)))
-        pycol (py/import-module "collections.abc")
+        pycol (py/import-module "collections")
         mapping-type (py/get-attr pycol "Mapping")
         iter-type (py/get-attr pycol "Iterable")
         sequence-type (py/get-attr pycol "Sequence")]

From 626aa327632aa64241d8dce4357dda8e81564083 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Fri, 4 Aug 2023 12:55:57 -0600
Subject: [PATCH 434/456] Update to v10.000 dtype-next

---
 deps.edn                              | 2 +-
 test/libpython_clj2/java_api_test.clj | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/deps.edn b/deps.edn
index c8f2afd..3e4b9a7 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure     {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next    {:mvn/version "10.000-beta-49"}
+        cnuernber/dtype-next    {:mvn/version "10.000"}
         net.java.dev.jna/jna    {:mvn/version "5.12.1"}
         org.clojure/data.json   {:mvn/version "1.0.0"}
         ;;Replace me with caffeine...
diff --git a/test/libpython_clj2/java_api_test.clj b/test/libpython_clj2/java_api_test.clj
index 3c2ddb4..e7c014d 100644
--- a/test/libpython_clj2/java_api_test.clj
+++ b/test/libpython_clj2/java_api_test.clj
@@ -2,7 +2,6 @@
   (:require [libpython-clj2.java-api :as japi]
             [libpython-clj2.python.ffi :as py-ffi]
             [libpython-clj2.python :as py]
-            [tech.v3.datatype.jvm-map :as jvm-map]
             [clojure.test :refer [deftest is]]))
 
 

From 8ceda146c3e7f9077189cc6efe8091a25335ff6a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 5 Sep 2023 08:37:04 -0600
Subject: [PATCH 435/456] moving away from nio buffer string pathways

---
 deps.edn                          | 2 +-
 src/libpython_clj2/python/ffi.clj | 7 +------
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/deps.edn b/deps.edn
index 3e4b9a7..46e656e 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure     {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next    {:mvn/version "10.000"}
+        cnuernber/dtype-next    {:mvn/version "10.009-SNAPSHOT"}
         net.java.dev.jna/jna    {:mvn/version "5.12.1"}
         org.clojure/data.json   {:mvn/version "1.0.0"}
         ;;Replace me with caffeine...
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index 3111d2f..f3bc07e 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -16,7 +16,6 @@
             [tech.v3.datatype.struct :as dt-struct]
             [tech.v3.datatype.errors :as errors]
             [tech.v3.datatype.native-buffer :as native-buffer]
-            [tech.v3.datatype.nio-buffer :as nio-buffer]
             [tech.v3.datatype.protocols :as dt-proto]
             [tech.v3.resource :as resource]
             [libpython-clj2.python.gc :as pygc]
@@ -793,11 +792,7 @@ Each call must be matched with PyGILState_Release"}
                                          (size-obj 0)
                                          nil)]
     (native-buffer/free size-obj)
-    (-> (.decode StandardCharsets/UTF_8
-                 ;;avoid resource chaining for performance
-                 ^java.nio.ByteBuffer (nio-buffer/native-buf->nio-buf
-                                       nbuf {:resource-type nil}))
-        (.toString))))
+    (native-buffer/native-buffer->string nbuf)))
 
 (defn pytype-name
   ^String [type-pyobj]

From e5568fa71fbc999355278f431885598cbe5a70d4 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 5 Sep 2023 09:56:16 -0600
Subject: [PATCH 436/456] Ugprading to valid version of dtype-next

---
 deps.edn | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/deps.edn b/deps.edn
index 46e656e..f011bea 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure     {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next    {:mvn/version "10.009-SNAPSHOT"}
+        cnuernber/dtype-next    {:mvn/version "10.009"}
         net.java.dev.jna/jna    {:mvn/version "5.12.1"}
         org.clojure/data.json   {:mvn/version "1.0.0"}
         ;;Replace me with caffeine...
@@ -60,7 +60,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.024"
+                        :version "2.025-SNAPSHOT"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]

From ad4f08c9ff8707af90d7363fc71e3c5196889d27 Mon Sep 17 00:00:00 2001
From: Mark Dawson <markgdawson@gmail.com>
Date: Tue, 5 Sep 2023 17:03:13 +0100
Subject: [PATCH 437/456] Handle conversion of generic-alias and union-type
 types in ->jvm (#251)

Co-authored-by: Mark Dawson <mark.dawson@polecat.com>
---
 src/libpython_clj2/python/copy.clj          | 61 ++++++++++++---------
 test/libpython_clj2/require_python_test.clj |  9 +++
 2 files changed, 43 insertions(+), 27 deletions(-)

diff --git a/src/libpython_clj2/python/copy.clj b/src/libpython_clj2/python/copy.clj
index c8a0599..a1a95ae 100644
--- a/src/libpython_clj2/python/copy.clj
+++ b/src/libpython_clj2/python/copy.clj
@@ -172,36 +172,43 @@
           stop (py-base/->jvm (py-proto/get-attr pyobj "stop"))]
       (range start stop step))))
 
+(def mapping-exceptions
+  "These types pass PyMapping_Check but cannot be treated as a collection."
+  ;; See github issue#250
+  #{:generic-alias
+    :union-type})
 
 (defmethod py-proto/pyobject->jvm :default
   [pyobj & [options]]
-  (cond
-    (= :none-type (py-ffi/pyobject-type-kwd pyobj))
-    nil
-    ;;Things could implement mapping and sequence logically so mapping
-    ;;takes precedence
-    (= 1 (py-ffi/PyMapping_Check pyobj))
-    (do
-      (if-let [map-items (py-ffi/PyMapping_Items pyobj)]
-        (try
-          (python->jvm-copy-hashmap pyobj map-items)
-          (finally
-            (py-ffi/Py_DecRef map-items)))
-        (do
-          ;;Ignore error.  The mapping check isn't thorough enough to work for all
-          ;;python objects.
-          (py-ffi/PyErr_Clear)
-          (python->jvm-copy-persistent-vector pyobj))))
-    ;;Sequences become persistent vectors
-    (= 1 (py-ffi/PySequence_Check pyobj))
-    (python->jvm-copy-persistent-vector pyobj)
-    :else
-    {:type (py-ffi/pyobject-type-kwd pyobj)
-     ;;Create a new GC root as the old reference is released.
-     :value (let [new-obj (py-ffi/track-pyobject
-                           (Pointer. (.address (dt-ffi/->pointer pyobj))))]
-              (py-ffi/Py_IncRef new-obj)
-              new-obj)}))
+  (let [python-type-keyword (py-ffi/pyobject-type-kwd pyobj)]
+    (cond
+      (= :none-type python-type-keyword)
+      nil
+      ;;Things could implement mapping and sequence logically so mapping
+      ;;takes precedence
+      (and (= 1 (py-ffi/PyMapping_Check pyobj))
+           (not (mapping-exceptions python-type-keyword)))
+      (do
+        (if-let [map-items (py-ffi/PyMapping_Items pyobj)]
+          (try
+            (python->jvm-copy-hashmap pyobj map-items)
+            (finally
+              (py-ffi/Py_DecRef map-items)))
+          (do
+            ;;Ignore error.  The mapping check isn't thorough enough to work for all
+            ;;python objects.
+            (py-ffi/PyErr_Clear)
+            (python->jvm-copy-persistent-vector pyobj))))
+      ;;Sequences become persistent vectors
+      (= 1 (py-ffi/PySequence_Check pyobj))
+      (python->jvm-copy-persistent-vector pyobj)
+      :else
+      {:type python-type-keyword
+       ;;Create a new GC root as the old reference is released.
+       :value (let [new-obj (py-ffi/track-pyobject
+                             (Pointer. (.address (dt-ffi/->pointer pyobj))))]
+                (py-ffi/Py_IncRef new-obj)
+                new-obj)})))
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
diff --git a/test/libpython_clj2/require_python_test.clj b/test/libpython_clj2/require_python_test.clj
index 89954b3..be91411 100644
--- a/test/libpython_clj2/require_python_test.clj
+++ b/test/libpython_clj2/require_python_test.clj
@@ -146,3 +146,12 @@
           "Methods have line numbers")
       (is (string? file)
           "Methods have file paths"))))
+
+(deftest convert-types
+  (let [typing-module (py/import-module "typing")]
+    (testing "convert generic alias type to JVM"
+      (-> (py/py. typing-module GenericAlias list str)
+          py/->jvm
+          :type
+          (= :generic-alias)
+          is))))

From 3bea77a13f461c9b178783b4ce0084cf0d9028ae Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 5 Sep 2023 10:08:43 -0600
Subject: [PATCH 438/456] Release 2.025

---
 CHANGELOG.md                             | 4 +++-
 deps.edn                                 | 2 +-
 docs/Usage.html                          | 2 +-
 docs/embedded.html                       | 2 +-
 docs/environments.html                   | 2 +-
 docs/index.html                          | 4 ++--
 docs/libpython-clj2.codegen.html         | 2 +-
 docs/libpython-clj2.embedded.html        | 2 +-
 docs/libpython-clj2.java-api.html        | 2 +-
 docs/libpython-clj2.python.class.html    | 2 +-
 docs/libpython-clj2.python.html          | 2 +-
 docs/libpython-clj2.python.np-array.html | 2 +-
 docs/libpython-clj2.require.html         | 2 +-
 docs/new-to-clojure.html                 | 2 +-
 docs/scopes-and-gc.html                  | 2 +-
 docs/slicing.html                        | 2 +-
 16 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8ff520c..19ffa91 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,7 @@
 # Time for a ChangeLog!
-## Unreleased
+## 2.025
+ * [Stop using nio-buffer conversion for ->string](https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/ffi.clj#L795)
+ * [PR - Handle conversion of more types in ->jvm](https://github.com/clj-python/libpython-clj/pull/251)
  * Fix issue with locating python dll on MS-Windows
    [#246](https://github.com/clj-python/libpython-clj/issues/246).
 
diff --git a/deps.edn b/deps.edn
index f011bea..1b21ba8 100644
--- a/deps.edn
+++ b/deps.edn
@@ -60,7 +60,7 @@
             :exec-fn hf.depstar/jar
             :exec-args {:group-id "clj-python"
                         :artifact-id "libpython-clj"
-                        :version "2.025-SNAPSHOT"
+                        :version "2.025"
                         :sync-pom true
                         :aot true
                         :compile-ns [libpython-clj2.java-api]
diff --git a/docs/Usage.html b/docs/Usage.html
index f7917ba..ea00e21 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/embedded.html b/docs/embedded.html
index 26444b8..f80a215 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index 65434e8..5c230ba 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index 16ce104..f29da03 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.024</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.025</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index bbda58e..f861560 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 91fb183..49c5eaa 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 6990956..196951f 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.class.html b/docs/libpython-clj2.python.class.html
index f28aecf..169011e 100644
--- a/docs/libpython-clj2.python.class.html
+++ b/docs/libpython-clj2.python.class.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch current"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.class.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-py-fn-.3Einstance-fn"><div class="inner"><span>py-fn-&gt;instance-fn</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.class</h1><div class="doc"><div class="markdown"><p>Namespace to help create a new python class from Clojure.  Used as a core
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch current"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.class.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-py-fn-.3Einstance-fn"><div class="inner"><span>py-fn-&gt;instance-fn</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.class</h1><div class="doc"><div class="markdown"><p>Namespace to help create a new python class from Clojure.  Used as a core
 implementation technique for bridging JVM objects into python.</p>
 </div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
 will be presented as instance methods.
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index 574e88c..de578f2 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-attr-type-map"><div class="inner"><span>attr-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-attr-type-map"><div class="inner"><span>attr-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index 8aeee37..a9b8b4b 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index d39ac02..0d0d272 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index 0ab76f2..fe20328 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index 34f2ded..ae5c681 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index 5427df7..b3226d4 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.024</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>

From 8e34710c3ee390e7900ff6a8cb30d774de365d81 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Tue, 5 Sep 2023 15:29:26 -0600
Subject: [PATCH 439/456] Optimization for very large strings coming from
 python.

---
 CHANGELOG.md | 3 +++
 deps.edn     | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 19ffa91..b33d73f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,7 @@
 # Time for a ChangeLog!
+## 2.026 - UNRELEASED
+ * Faster string conversion from c->jvm for large strings.
+
 ## 2.025
  * [Stop using nio-buffer conversion for ->string](https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/ffi.clj#L795)
  * [PR - Handle conversion of more types in ->jvm](https://github.com/clj-python/libpython-clj/pull/251)
diff --git a/deps.edn b/deps.edn
index 1b21ba8..c35da23 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure     {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next    {:mvn/version "10.009"}
+        cnuernber/dtype-next    {:mvn/version "10.010"}
         net.java.dev.jna/jna    {:mvn/version "5.12.1"}
         org.clojure/data.json   {:mvn/version "1.0.0"}
         ;;Replace me with caffeine...

From 67b83cce6f41f240d0cc0fa0b12c29c4a3c1ffb8 Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Wed, 4 Oct 2023 01:08:41 +0200
Subject: [PATCH 440/456] fixed spelling (#252)

---
 src/libpython_clj2/python.clj | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 661f285..98ab73b 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -77,7 +77,7 @@ user> (py/py. np linspace 2 3 :num 10)
   virtual enviornment.
 
   The :post-initialize-fn can use all functions from ns `libpython-clj2.python`
-  as libpython-clj is initialised alreday andc ould for example be used to validate
+  as libpython-clj is initialised alreday and could for example be used to validate
   that later needed libraries can be loaded via calling `import-module`.
 
   The file MUST be named `python.edn` and be in the root of the classpath.

From b25f3669095ca71008fe0d73455b1213d73fe001 Mon Sep 17 00:00:00 2001
From: "J.J. Tolton" <jjtolton@gmail.com>
Date: Sun, 15 Oct 2023 15:45:51 -0400
Subject: [PATCH 441/456] make require-python optionally user path informed
 (#254)

Co-authored-by: James J. Tolton <jay@toltontechnology.ai>
---
 src/libpython_clj2/metadata.clj |   7 +++
 src/libpython_clj2/require.clj  | 107 +++++++++++++++++++++++++++++---
 2 files changed, 104 insertions(+), 10 deletions(-)

diff --git a/src/libpython_clj2/metadata.clj b/src/libpython_clj2/metadata.clj
index 4ee76b4..36b190e 100644
--- a/src/libpython_clj2/metadata.clj
+++ b/src/libpython_clj2/metadata.clj
@@ -41,6 +41,7 @@
              (get-attr % "__doc__")
              (catch Exception e
                "")))
+(def os (import-module "os"))
 (def get-pydoc doc)
 (def vars (get-attr builtins "vars"))
 (def pyclass? (get-attr inspect "isclass"))
@@ -227,6 +228,12 @@
   (or (string? att-val)
       (number? att-val)))
 
+(defn py-chdir [path]
+  (py/$a os "chdir" path))
+
+(defn py-getcwd []
+  (py/$a os "getcwd"))
+
 (defn datafy-module-or-class [item]
   (with-gil
     (->> (if (or (pyclass? item)
diff --git a/src/libpython_clj2/require.clj b/src/libpython_clj2/require.clj
index 08fe66d..70481a6 100644
--- a/src/libpython_clj2/require.clj
+++ b/src/libpython_clj2/require.clj
@@ -6,7 +6,8 @@
             [libpython-clj2.metadata :as pymeta]
             [clojure.datafy :refer [datafy nav]]
             [clojure.tools.logging :as log]
-            [clojure.core.protocols :as clj-proto]))
+            [clojure.core.protocols :as clj-proto])
+  (:import (java.io File)))
 
 
 (defn- parse-flags
@@ -19,7 +20,7 @@
   ;; First attempt is to filter keywords and make sure any keywords are
   ;; in supported-flags
   (let [total-flags (set (concat supported-flags [:as :refer :exclude
-                                                  :* :all :bind-ns]))]
+                                                  :* :all :bind-ns :path]))]
     (when-let [missing-flags (->> reqs
                                   (filter #(and (not (total-flags %))
                                                 (keyword? %)))
@@ -100,13 +101,20 @@
         no-arglists?        (:no-arglists flags)
         bind-ns?            (:bind-ns flags)
         alias-name          (:as etc)
+        path                (:path etc)
         exclude             (into #{} (:exclude etc))
-
         refer-data          (cond
                               (= :all (:refer etc)) #{:all}
                               (= :* (:refer etc))   #{:*}
                               :else                 (into #{} (:refer etc)))
-        pyobj               (py/path->py-obj (str module-name) :reload? reload?)
+        pyobj               (if path
+                              (let [cwd (pymeta/py-getcwd)]
+                                (try
+                                  (pymeta/py-chdir path)
+                                  (py/path->py-obj (str module-name) :reload? reload?)
+                                  (finally
+                                    (pymeta/py-chdir cwd))))
+                              (py/path->py-obj (str module-name) :reload? reload?))
         existing-py-ns?     (find-ns module-name)]
     (create-ns module-name)
 
@@ -170,6 +178,7 @@
          (into [(req-transform prefix base)] reqs))))))
 
 
+
 (defn require-python
   "## Basic usage ##
 
@@ -219,9 +228,64 @@
    ## Setting up classpath for custom modules ##
 
    Note: you may need to setup your PYTHONPATH correctly.
-   One technique to do this is, if your foo.py lives at
-   /path/to/foodir/foo.py:
-
+   **WARNING**: This is very handy for local REPL development,
+            ..: if you are going to AOT classes,
+            ..: refer to the documentation on codegen
+            ..: or your AOT compilation will fail.
+   If your foo.py lives at /path/to/foodir/foo.py, the easiest
+   way to do it is:
+
+   (require-python :from \"/path/to/foodir\"
+                   'foo) ;; or
+   (require-python \"/path/to/foodir\"
+                   'foo) ;; or
+   (require-python {:from \"/path/to/foodir\"}
+                   'foo)
+
+   as you prefer.
+
+   Additionally, if you want to keep the namespacing as you have 
+   it in Python, you may prefer to use a relative import 
+   starting from a location of your choosing. If your 
+   os.getcwd() => /some/path/foo,
+   and your directory structure looks something like:
+
+   /some $ tree
+   .
+   └── path
+       ├── baz
+       │   └── quux.py
+       └── foo
+           └── bar.py
+
+   
+   (require-python :from \"path\"
+                   '[baz.quux :as quux]
+                   :from \"path/foo\"
+                   'bar)
+   
+   is perfectly acceptable. It probably makes the most 
+   sense to keep you style consistent, but you can mix
+   and match as you see fit between <path>, :from <path>, 
+   and {:from <path>}.  <path> can either be a file or a
+   directory.  If it is a file, the Python path will be
+   set to the directory containing that file.
+
+   You may also stack several require-pythons under one path:
+
+   (require-python {:from \"dir-a\"}
+                   'a
+                   'b
+                   'c
+                   {:from \"dir-b\"}
+                   'e.f
+                   'g
+                   {:from \"dir-c}
+                   'hi.there)
+
+   Other options more in keeping with traditional PYTHONPATH
+   management include:
+   
    (require-python 'sys)
    (py/call-attr (py/get-attr sys \"path\")
                  \"append\"
@@ -275,9 +339,32 @@
        (throw (Exception. "Invalid argument: %s" req))))
    :ok)
   ([req & reqs]
-   (require-python req)
-   (when (not-empty reqs)
-     (apply require-python reqs))
+   (cond (and (map? req)
+              (contains? req :from)
+              (seq reqs))
+         (apply require-python (:from req) reqs)
+         (and (keyword? req)
+              (= :from req)
+              (string? (first reqs)))
+         (apply require-python (first reqs) (rest reqs))
+         (and (string? req)
+              (.isFile (File. req)))
+         (let [file (File. req)
+               cwd (pymeta/py-getcwd)]
+           (apply require-python (str (.getParent file)) reqs))
+         (and (string? req)
+              (.isDirectory (File. req)))
+         (let [cwd (pymeta/py-getcwd)]
+           (try
+             (pymeta/py-chdir req)
+             (apply require-python reqs)
+             (finally
+               (pymeta/py-chdir cwd))))
+         :else
+         (do
+           (require-python req)
+           (when (not-empty reqs)
+             (apply require-python reqs))))
    :ok))
 
 

From 073a887e9ddb0f74a48aa34b91b013a67ec71401 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 5 Nov 2023 08:19:39 -0700
Subject: [PATCH 442/456] Recording how to call super.init().

---
 docs/libpython-clj2.python.class.html |  7 +++-
 docs/libpython-clj2.python.html       |  2 +-
 docs/libpython-clj2.require.html      | 53 +++++++++++++++++++++++++--
 src/libpython_clj2/python/class.clj   | 11 +++++-
 4 files changed, 66 insertions(+), 7 deletions(-)

diff --git a/docs/libpython-clj2.python.class.html b/docs/libpython-clj2.python.class.html
index 169011e..06ef653 100644
--- a/docs/libpython-clj2.python.class.html
+++ b/docs/libpython-clj2.python.class.html
@@ -10,7 +10,12 @@
 will be presented as instance methods.
 Things in the cls hashmap had better be either atoms or already converted
 python objects.  You may get surprised otherwise; you have been warned.
-See the classes-test file in test/libpython-clj</p>
+See the classes-test file in test/libpython-clj.</p>
+<p>Calling <code>super.init()</code> may be done in a non-obvious way:</p>
+<pre><code class="language-clojure">(py. (py/get-item (py.. self -__class__ -__mro__) 1) __init__ self)
+</code></pre>
+<p>More feedback/research in this area is needed to integrated deeper into
+the python class hierarchies.</p>
 </div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/class.clj#L70">view source</a></div></div><div class="public anchor" id="var-make-kw-instance-fn"><h3>make-kw-instance-fn</h3><div class="usage"><code>(make-kw-instance-fn clj-fn &amp; [{:keys [arg-converter result-converter], :or {arg-converter py-base/as-jvm}, :as options}])</code></div><div class="doc"><div class="markdown"><p>Make an instance function - a function which will be passed the 'this' object as
 it's first argument.  In this case the default behavior is to
 pass as-jvm bridged python object ptr args and kw dict args to the clojure function without
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index de578f2..bf266e7 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -123,7 +123,7 @@
 <p>A :pre-initialize-fn could for example shell out and setup a python
 virtual enviornment.</p>
 <p>The :post-initialize-fn can use all functions from ns <code>libpython-clj2.python</code>
-as libpython-clj is initialised alreday andc ould for example be used to validate
+as libpython-clj is initialised alreday and could for example be used to validate
 that later needed libraries can be loaded via calling <code>import-module</code>.</p>
 <p>The file MUST be named <code>python.edn</code> and be in the root of the classpath.
 With a <code>python.edn</code> file in place, the <code>initialize!</code> function may be called
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 0d0d272..17fb8e3 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -8,7 +8,7 @@
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L284">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2>Basic usage</h2>
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L371">view source</a></div></div><div class="public anchor" id="var-require-python"><h3>require-python</h3><div class="usage"><code>(require-python req)</code><code>(require-python req &amp; reqs)</code></div><div class="doc"><div class="markdown"><h2>Basic usage</h2>
 <p>(require-python 'math)
 (math/sin 1.0) ;;=&gt; 0.8414709848078965</p>
 <p>(require-python '<a href="math :as maaaath">math :as maaaath</a>)</p>
@@ -40,8 +40,53 @@ <h2>Use with custom modules</h2>
 ..: the behavior mimics importlib.reload</p>
 <h2>Setting up classpath for custom modules</h2>
 <p>Note: you may need to setup your PYTHONPATH correctly.
-One technique to do this is, if your foo.py lives at
-/path/to/foodir/foo.py:</p>
+<strong>WARNING</strong>: This is very handy for local REPL development,
+..: if you are going to AOT classes,
+..: refer to the documentation on codegen
+..: or your AOT compilation will fail.
+If your foo.py lives at /path/to/foodir/foo.py, the easiest
+way to do it is:</p>
+<p>(require-python :from "/path/to/foodir"
+'foo) ;; or
+(require-python "/path/to/foodir"
+'foo) ;; or
+(require-python {:from "/path/to/foodir"}
+'foo)</p>
+<p>as you prefer.</p>
+<p>Additionally, if you want to keep the namespacing as you have
+it in Python, you may prefer to use a relative import
+starting from a location of your choosing. If your
+os.getcwd() =&gt; /some/path/foo,
+and your directory structure looks something like:</p>
+<p>/some $ tree
+.
+└── path
+├── baz
+│   └── quux.py
+└── foo
+└── bar.py</p>
+<p>(require-python :from "path"
+'<a href="baz.quux :as quux">baz.quux :as quux</a>
+:from "path/foo"
+'bar)</p>
+<p>is perfectly acceptable. It probably makes the most
+sense to keep you style consistent, but you can mix
+and match as you see fit between <path>, :from <path>,
+and {:from <path>}.  <path> can either be a file or a
+directory.  If it is a file, the Python path will be
+set to the directory containing that file.</path></path></path></path></p>
+<p>You may also stack several require-pythons under one path:</p>
+<p>(require-python {:from "dir-a"}
+'a
+'b
+'c
+{:from "dir-b"}
+'e.f
+'g
+{:from "dir-c}
+'hi.there)</p>
+<p>Other options more in keeping with traditional PYTHONPATH
+management include:</p>
 <p>(require-python 'sys)
 (py/call-attr (py/get-attr sys "path")
 "append"
@@ -68,4 +113,4 @@ <h2>For library developers</h2>
 those things designated by the module under the <strong>all</strong> attribute,
 you can do</p>
 <p>(require-python '<a href="operators :refer :*">operators :refer :*</a>)</p>
-</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L173">view source</a></div></div></div></body></html>
\ No newline at end of file
+</div></div><div class="src-link"><a href="https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/require.clj#L182">view source</a></div></div></div></body></html>
\ No newline at end of file
diff --git a/src/libpython_clj2/python/class.clj b/src/libpython_clj2/python/class.clj
index 971f8ff..26bad87 100644
--- a/src/libpython_clj2/python/class.clj
+++ b/src/libpython_clj2/python/class.clj
@@ -72,7 +72,16 @@
   will be presented as instance methods.
   Things in the cls hashmap had better be either atoms or already converted
   python objects.  You may get surprised otherwise; you have been warned.
-  See the classes-test file in test/libpython-clj"
+  See the classes-test file in test/libpython-clj.
+
+
+  Calling `super.init()` may be done in a non-obvious way:
+
+```clojure
+(py. (py/get-item (py.. self -__class__ -__mro__) 1) __init__ self)
+```
+  More feedback/research in this area is needed to integrated deeper into
+  the python class hierarchies."
   [name bases cls-hashmap]
   (py-ffi/with-gil
     (py-ffi/with-decref

From c3cc82ffc82425577caeb845b63ca67c8bf6ed9f Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Wed, 28 Feb 2024 16:23:28 -0700
Subject: [PATCH 443/456] Ensuring latest dtype-next works with libpython-clj

---
 deps.edn | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/deps.edn b/deps.edn
index c35da23..77a6c5f 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure     {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next    {:mvn/version "10.010"}
+        cnuernber/dtype-next    {:mvn/version "10.111"}
         net.java.dev.jna/jna    {:mvn/version "5.12.1"}
         org.clojure/data.json   {:mvn/version "1.0.0"}
         ;;Replace me with caffeine...

From fbe42a184c3fe36613fc7413c3183f04438cfb7a Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Thu, 23 May 2024 17:46:29 +0200
Subject: [PATCH 444/456] mention devcontainer template (#261)

---
 README.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/README.md b/README.md
index 15bd490..659a133 100644
--- a/README.md
+++ b/README.md
@@ -172,6 +172,13 @@ using Conda, check out the facial rec repository a)bove or look into how we
 [build](scripts/build-conda-docker)
 our test [docker containers](dockerfiles/CondaDockerfile).
 
+#### devcontainer 
+The scicloj community is maintaining a `devcontainer` [template](https://github.com/scicloj/devcontainer-templates/tree/main/src/scicloj) on which `libpython-clj` is know to work
+out of the box.
+
+This can be used as a starting point for projects using `libpython-clj` or as reference for debuging issues.
+
+
 ## Community
 
 We like to talk about libpython-clj on [Zulip](https://clojurians.zulipchat.com/#streams/215609/libpython-clj-dev) as the conversations are persistent and searchable.

From aaabb68bcaff5368c56b86e5edb7639646b41fbe Mon Sep 17 00:00:00 2001
From: guto <joaoaugustolanjoni@gmail.com>
Date: Sat, 14 Sep 2024 11:17:34 -0300
Subject: [PATCH 445/456] docs: update README.md with deps.edn aliases (#264)

- update steps to install and deploy to clojars with Clojure CLI
commands instead of Leiningen (as before)
---
 README.md | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 659a133..53bb94b 100644
--- a/README.md
+++ b/README.md
@@ -217,16 +217,21 @@ we have an [introductory document](topics/new-to-clojure.md).
 To install jar to local .m2 :
 
 ```bash
-$ lein install
+$ clj -X:depstar
 ```
 
-### Deploy to clojars
+After building and process `pom.xml` file you can run:
 
 ```bash
-$ lein deploy clojars
+$ clj -X:install
 ```
-This command will sign jar before deploy, using your gpg key. (see dev/src/build.clj for signing options)
 
+### Deploy to clojars
+
+```bash
+$ clj -X:deploy
+```
+> This command will sign jar before deploy, using your gpg key.
 
 
 ## License

From 6ad28733488cf6ff74071909372e7823104d9f90 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 8 Dec 2024 10:13:49 -0700
Subject: [PATCH 446/456] Fixes
 https://github.com/techascent/tech.ml.dataset/issues/437

---
 CHANGELOG.md                                |  1 +
 deps.edn                                    |  2 +-
 src/libpython_clj2/python.clj               |  2 +-
 src/libpython_clj2/python/base.clj          |  4 ++--
 src/libpython_clj2/python/bridge_as_jvm.clj |  4 ++--
 src/libpython_clj2/python/ffi.clj           | 10 ++++++++++
 6 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b33d73f..0070847 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,5 @@
 # Time for a ChangeLog!
+
 ## 2.026 - UNRELEASED
  * Faster string conversion from c->jvm for large strings.
 
diff --git a/deps.edn b/deps.edn
index 77a6c5f..cf2dd4f 100644
--- a/deps.edn
+++ b/deps.edn
@@ -1,6 +1,6 @@
 {:paths ["src"]
  :deps {org.clojure/clojure     {:mvn/version "1.11.1" :scope "provided"}
-        cnuernber/dtype-next    {:mvn/version "10.111"}
+        cnuernber/dtype-next    {:mvn/version "10.124"}
         net.java.dev.jna/jna    {:mvn/version "5.12.1"}
         org.clojure/data.json   {:mvn/version "1.0.0"}
         ;;Replace me with caffeine...
diff --git a/src/libpython_clj2/python.clj b/src/libpython_clj2/python.clj
index 98ab73b..1ec9027 100644
--- a/src/libpython_clj2/python.clj
+++ b/src/libpython_clj2/python.clj
@@ -413,7 +413,7 @@ user> (py/py. np linspace 2 3 :num 10)
   (cond
     (instance? IFn pyobj)
     true
-    (dtype-ffi/convertible-to-pointer? pyobj)
+    (py-ffi/convertible-to-pointer? pyobj)
     (py-ffi/with-gil
       (let [retval (long (py-ffi/PyCallable_Check pyobj))]
         (case retval
diff --git a/src/libpython_clj2/python/base.clj b/src/libpython_clj2/python/base.clj
index e7e6282..d3f4bfd 100644
--- a/src/libpython_clj2/python/base.clj
+++ b/src/libpython_clj2/python/base.clj
@@ -80,13 +80,13 @@
 (extend-type Object
   py-proto/PCopyToJVM
   (->jvm [item options]
-    (if (dt-ffi/convertible-to-pointer? item)
+    (if (py-ffi/convertible-to-pointer? item)
       (py-proto/pyobject->jvm item options)
       ;;item is already a jvm object
       item))
   py-proto/PBridgeToJVM
   (as-jvm [item options]
-    (if (dt-ffi/convertible-to-pointer? item)
+    (if (py-ffi/convertible-to-pointer? item)
       (py-proto/pyobject-as-jvm item options)
       item))
   py-proto/PPyCallable
diff --git a/src/libpython_clj2/python/bridge_as_jvm.clj b/src/libpython_clj2/python/bridge_as_jvm.clj
index 84eb351..b23853b 100644
--- a/src/libpython_clj2/python/bridge_as_jvm.clj
+++ b/src/libpython_clj2/python/bridge_as_jvm.clj
@@ -179,7 +179,7 @@
          (get-attr [item# item-name#]
            (with-gil
              (-> (py-proto/get-attr @pyobj*# item-name#)
-                 py-base/as-jvm)))
+                 (py-base/as-jvm))))
          (set-attr! [item# item-name# item-value#]
            (with-gil
              (py-ffi/with-decref [item-value# (py-ffi/untracked->python
@@ -225,7 +225,7 @@
                  (py-base/->jvm (py-fn/call-attr @pyobj*# "__str__" nil))))))
          (equals [this# other#]
            (boolean
-            (when (dt-ffi/convertible-to-pointer? other#)
+            (when (py-ffi/convertible-to-pointer? other#)
               (py-base/equals? @pyobj*# other#))))
          (hashCode [this#]
            (.hashCode ^Object (py-base/hash-code this#)))
diff --git a/src/libpython_clj2/python/ffi.clj b/src/libpython_clj2/python/ffi.clj
index f3bc07e..4d170f2 100644
--- a/src/libpython_clj2/python/ffi.clj
+++ b/src/libpython_clj2/python/ffi.clj
@@ -323,6 +323,16 @@ Each call must be matched with PyGILState_Release"}
            :pyobject [{:name :ob_refcnt :datatype (ffi-size-t/size-t-type)}
                       {:name :ob_type :datatype (ffi-size-t/size-t-type)}])))
 
+
+(defn convertible-to-pointer?
+  "Older definition - excludes Long objects which were made convertible-to-pointer
+  in later versions of dtype-next."
+  [d]
+  (boolean 
+   (when-not (instance? Long d)
+     (dt-ffi/convertible-to-pointer? d))))
+
+
 (defn pytype-offset
   ^long []
   (first (dt-struct/offset-of @pyobject-struct-type* :ob_type)))

From 7f572215a96ac6fb14b5928ee6258b889cdee375 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Sun, 8 Dec 2024 10:28:01 -0700
Subject: [PATCH 447/456] Release 2.026

---
 CHANGELOG.md                             |  3 ++-
 deps.edn                                 | 18 ++++++------------
 docs/Usage.html                          |  2 +-
 docs/embedded.html                       |  2 +-
 docs/environments.html                   |  2 +-
 docs/index.html                          |  4 ++--
 docs/libpython-clj2.codegen.html         |  2 +-
 docs/libpython-clj2.embedded.html        |  2 +-
 docs/libpython-clj2.java-api.html        |  2 +-
 docs/libpython-clj2.python.class.html    |  2 +-
 docs/libpython-clj2.python.html          |  2 +-
 docs/libpython-clj2.python.np-array.html |  2 +-
 docs/libpython-clj2.require.html         |  2 +-
 docs/new-to-clojure.html                 |  2 +-
 docs/scopes-and-gc.html                  |  2 +-
 docs/slicing.html                        |  2 +-
 scripts/deploy                           |  4 +++-
 17 files changed, 26 insertions(+), 29 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0070847..8b611fc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,8 @@
 # Time for a ChangeLog!
 
-## 2.026 - UNRELEASED
+## 2.026
  * Faster string conversion from c->jvm for large strings.
+ * Fix for https://github.com/techascent/tech.ml.dataset/issues/437
 
 ## 2.025
  * [Stop using nio-buffer conversion for ->string](https://github.com/clj-python/libpython-clj/blob/master/src/libpython_clj2/python/ffi.clj#L795)
diff --git a/deps.edn b/deps.edn
index cf2dd4f..5aefc5f 100644
--- a/deps.edn
+++ b/deps.edn
@@ -24,6 +24,9 @@
             :exec-fn codox.main/-main
             :exec-args {:arg-paths [[:aliases :depstar :exec-args]]
                         :name "libpython-clj"
+                        :group-id "clj-python"
+                        :artifact-id "libpython-clj"
+                        :version "2.026"
                         :description "Python bindings for Clojure"
                         :metadata {:doc/format :markdown}
                         :google-analytics "G-LN7PG6FJ2D"
@@ -53,18 +56,9 @@
                          ch.qos.logback/logback-classic {:mvn/version "1.1.3"}}
             :extra-paths ["test"]
             :main-opts ["-m" "cognitect.test-runner"]}
-           :depstar
-           {: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.025"
-                        :sync-pom true
-                        :aot true
-                        :compile-ns [libpython-clj2.java-api]
-                        :jar "target/libpython-clj.jar"}}
+           :build
+           {:deps {io.github.clojure/tools.build {:mvn/version "0.10.5"}}
+            :ns-default build}
            :deploy
            {:replace-deps {slipset/deps-deploy {:mvn/version "0.1.5"}}
             :exec-fn deps-deploy.deps-deploy/deploy
diff --git a/docs/Usage.html b/docs/Usage.html
index ea00e21..22416ef 100644
--- a/docs/Usage.html
+++ b/docs/Usage.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1  current"><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>LibPython-CLJ Usage</h1>
 <p>Python objects are essentially two dictionaries, one for 'attributes' and one for
 'items'.  When you use python and use the '.' operator, you are referencing attributes.
 If you use the '[]' operator, then you are referencing items.  Attributes are built in,
diff --git a/docs/embedded.html b/docs/embedded.html
index f80a215..8f91472 100644
--- a/docs/embedded.html
+++ b/docs/embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1  current"><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Embedding Clojure In Python</h1>
 <p>The initial development push for <code>libpython-clj</code> was simply to embed Python in
 Clojure allowing Clojure developers to use Python modules simply transparently.
 This approach relied on <code>libpython-clj</code> being able to find the Python shared library
diff --git a/docs/environments.html b/docs/environments.html
index 5c230ba..83e3bfa 100644
--- a/docs/environments.html
+++ b/docs/environments.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1  current"><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Python Environments</h1>
 <h2>pyenv</h2>
 <p>pyenv requires that you build the shared library.  This is a separate configuration option than a lot of pyenv users have used before.</p>
 <ul>
diff --git a/docs/index.html b/docs/index.html
index f29da03..e7c44a0 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -1,10 +1,10 @@
 <!DOCTYPE html PUBLIC ""
     "">
-<html><head><meta charset="UTF-8" /><title>libpython-clj 2.025</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
+<html><head><meta charset="UTF-8" /><title>libpython-clj 2.026</title><script async="true" src="https://www.googletagmanager.com/gtag/js?id=G-LN7PG6FJ2D"></script><script>window.dataLayer = window.dataLayer || [];
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 current"><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="namespace-index" id="content"><h1><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></h1><div class="doc"><p>Python bindings for Clojure.</p></div><h2>Topics</h2><ul class="topics"><li><a href="Usage.html">LibPython-CLJ Usage</a></li><li><a href="embedded.html">Embedding Clojure In Python</a></li><li><a href="environments.html">Python Environments</a></li><li><a href="new-to-clojure.html">So Many Parenthesis!</a></li><li><a href="scopes-and-gc.html">Scopes And Garbage Collection</a></li><li><a href="slicing.html">Slicing And Slices</a></li></ul><h2>Namespaces</h2><div class="namespace"><h3><a href="libpython-clj2.codegen.html">libpython-clj2.codegen</a></h3><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="index"><p>Public variables and functions:</p><ul><li> <a href="libpython-clj2.codegen.html#var-write-namespace.21">write-namespace!</a> </li></ul></div></div><div class="namespace"><h3><a href="libpython-clj2.embedded.html">libpython-clj2.embedded</a></h3><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
diff --git a/docs/libpython-clj2.codegen.html b/docs/libpython-clj2.codegen.html
index f861560..ca2b050 100644
--- a/docs/libpython-clj2.codegen.html
+++ b/docs/libpython-clj2.codegen.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch current"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.codegen.html#var-write-namespace.21"><div class="inner"><span>write-namespace!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.codegen</h1><div class="doc"><div class="markdown"><p>Generate a namespace on disk for a python module or instances</p>
 </div></div><div class="public anchor" id="var-write-namespace.21"><h3>write-namespace!</h3><div class="usage"><code>(write-namespace! 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}})</code><code>(write-namespace! py-mod-or-cls)</code></div><div class="doc"><div class="markdown"><p>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.</p>
diff --git a/docs/libpython-clj2.embedded.html b/docs/libpython-clj2.embedded.html
index 49c5eaa..51470f0 100644
--- a/docs/libpython-clj2.embedded.html
+++ b/docs/libpython-clj2.embedded.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.embedded.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-start-repl.21"><div class="inner"><span>start-repl!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.embedded.html#var-stop-repl.21"><div class="inner"><span>stop-repl!</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.embedded</h1><div class="doc"><div class="markdown"><p>Tools for embedding clojure into a python host process.
 See jbridge.py for python details.  This namespace relies on
 the classpath having nrepl and cider-nrepl on it.  For example:</p>
 <pre><code class="language-console">clojure -SPath '{:deps {nrepl/nrepl {:mvn/version "0.8.3"} cider/cider-nrepl {:mvn/version "0.25.5"}}}' ...
diff --git a/docs/libpython-clj2.java-api.html b/docs/libpython-clj2.java-api.html
index 196951f..78c03e7 100644
--- a/docs/libpython-clj2.java-api.html
+++ b/docs/libpython-clj2.java-api.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch current"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.java-api.html#var--arrayToJVM"><div class="inner"><span>-arrayToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--call"><div class="inner"><span>-call</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--callKw"><div class="inner"><span>-callKw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyData"><div class="inner"><span>-copyData</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToJVM"><div class="inner"><span>-copyToJVM</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--copyToPy"><div class="inner"><span>-copyToPy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--createArray"><div class="inner"><span>-createArray</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getAttr"><div class="inner"><span>-getAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getGlobal"><div class="inner"><span>-getGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--getItem"><div class="inner"><span>-getItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--GILLocker"><div class="inner"><span>-GILLocker</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasAttr"><div class="inner"><span>-hasAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--hasItem"><div class="inner"><span>-hasItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--importModule"><div class="inner"><span>-importModule</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initialize"><div class="inner"><span>-initialize</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--initializeEmbedded"><div class="inner"><span>-initializeEmbedded</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--lockGIL"><div class="inner"><span>-lockGIL</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--makeFastcallable"><div class="inner"><span>-makeFastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsFile"><div class="inner"><span>-runStringAsFile</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--runStringAsInput"><div class="inner"><span>-runStringAsInput</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setAttr"><div class="inner"><span>-setAttr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setGlobal"><div class="inner"><span>-setGlobal</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--setItem"><div class="inner"><span>-setItem</span></div></a></li><li class="depth-1"><a href="libpython-clj2.java-api.html#var--unlockGIL"><div class="inner"><span>-unlockGIL</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.java-api</h1><div class="doc"><div class="markdown"><p>A java api is exposed for libpython-clj2.  The methods below are statically callable
 without the leading '-'.  Note that returned python objects implement the respective
 java interfaces so a python dict will implement java.util.Map, etc.  There is some
 startup time as Clojure dynamically compiles the source code but this binding should
diff --git a/docs/libpython-clj2.python.class.html b/docs/libpython-clj2.python.class.html
index 06ef653..00484ca 100644
--- a/docs/libpython-clj2.python.class.html
+++ b/docs/libpython-clj2.python.class.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch current"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.class.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-py-fn-.3Einstance-fn"><div class="inner"><span>py-fn-&gt;instance-fn</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.class</h1><div class="doc"><div class="markdown"><p>Namespace to help create a new python class from Clojure.  Used as a core
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch current"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.class.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-make-tuple-instance-fn"><div class="inner"><span>make-tuple-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.class.html#var-py-fn-.3Einstance-fn"><div class="inner"><span>py-fn-&gt;instance-fn</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.class</h1><div class="doc"><div class="markdown"><p>Namespace to help create a new python class from Clojure.  Used as a core
 implementation technique for bridging JVM objects into python.</p>
 </div></div><div class="public anchor" id="var-create-class"><h3>create-class</h3><div class="usage"><code>(create-class name bases cls-hashmap)</code></div><div class="doc"><div class="markdown"><p>Create a new class object.  Any callable values in the cls-hashmap
 will be presented as instance methods.
diff --git a/docs/libpython-clj2.python.html b/docs/libpython-clj2.python.html
index bf266e7..ea79875 100644
--- a/docs/libpython-clj2.python.html
+++ b/docs/libpython-clj2.python.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-attr-type-map"><div class="inner"><span>attr-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.html#var-.24a"><div class="inner"><span>$a</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-.24c"><div class="inner"><span>$c</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Ejvm"><div class="inner"><span>-&gt;jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-dict"><div class="inner"><span>-&gt;py-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-list"><div class="inner"><span>-&gt;py-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epy-tuple"><div class="inner"><span>-&gt;py-tuple</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var--.3Epython"><div class="inner"><span>-&gt;python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-add-module"><div class="inner"><span>add-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-afn"><div class="inner"><span>afn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-jvm"><div class="inner"><span>as-jvm</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-list"><div class="inner"><span>as-list</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-map"><div class="inner"><span>as-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-as-python"><div class="inner"><span>as-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-attr-type-map"><div class="inner"><span>attr-type-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr"><div class="inner"><span>call-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-call-attr-kw"><div class="inner"><span>call-attr-kw</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-callable.3F"><div class="inner"><span>callable?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-cfn"><div class="inner"><span>cfn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-create-class"><div class="inner"><span>create-class</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-def-unpack"><div class="inner"><span>def-unpack</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-dir"><div class="inner"><span>dir</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-from-import"><div class="inner"><span>from-import</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-attr"><div class="inner"><span>get-attr</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-get-item"><div class="inner"><span>get-item</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-attr.3F"><div class="inner"><span>has-attr?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-has-item.3F"><div class="inner"><span>has-item?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-as"><div class="inner"><span>import-as</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-import-module"><div class="inner"><span>import-module</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-initialize.21"><div class="inner"><span>initialize!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-is-instance.3F"><div class="inner"><span>is-instance?</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-callable"><div class="inner"><span>make-callable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-fastcallable"><div class="inner"><span>make-fastcallable</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-instance-fn"><div class="inner"><span>make-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-make-kw-instance-fn"><div class="inner"><span>make-kw-instance-fn</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-module-dict"><div class="inner"><span>module-dict</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-path-.3Epy-obj"><div class="inner"><span>path-&gt;py-obj</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py*"><div class="inner"><span>py*</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py**"><div class="inner"><span>py**</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py."><div class="inner"><span>py.</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.-"><div class="inner"><span>py.-</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-py.."><div class="inner"><span>py..</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-python-type"><div class="inner"><span>python-type</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-run-simple-string"><div class="inner"><span>run-simple-string</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attr.21"><div class="inner"><span>set-attr!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-attrs.21"><div class="inner"><span>set-attrs!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-item.21"><div class="inner"><span>set-item!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-set-items.21"><div class="inner"><span>set-items!</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-stack-resource-context"><div class="inner"><span>stack-resource-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with"><div class="inner"><span>with</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil"><div class="inner"><span>with-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-gil-stack-rc-context"><div class="inner"><span>with-gil-stack-rc-context</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil"><div class="inner"><span>with-manual-gil</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.html#var-with-manual-gil-stack-rc-context"><div class="inner"><span>with-manual-gil-stack-rc-context</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python</h1><div class="doc"><div class="markdown"><p>Python bindings for Clojure.  This library dynamically finds the installed
 python, loads the shared library and allows Clojure users to use Python modules
 as if they were Clojure namespaces.</p>
 <p>Example:</p>
diff --git a/docs/libpython-clj2.python.np-array.html b/docs/libpython-clj2.python.np-array.html
index a9b8b4b..5bd4b54 100644
--- a/docs/libpython-clj2.python.np-array.html
+++ b/docs/libpython-clj2.python.np-array.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3 current"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-datatype-.3Eptr-type-name"><div class="inner"><span>datatype-&gt;ptr-type-name</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-descriptor-.3Enumpy"><div class="inner"><span>descriptor-&gt;numpy</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-dtype-.3Epy-dtype-map"><div class="inner"><span>dtype-&gt;py-dtype-map</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-numpy-.3Edesc"><div class="inner"><span>numpy-&gt;desc</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-obj-dtype-.3Edtype"><div class="inner"><span>obj-dtype-&gt;dtype</span></div></a></li><li class="depth-1"><a href="libpython-clj2.python.np-array.html#var-py-dtype-.3Edtype-map"><div class="inner"><span>py-dtype-&gt;dtype-map</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.python.np-array</h1><div class="doc"><div class="markdown"><p>Bindings for deeper intergration of numpy into the tech.v3.datatype system.  This
 allows seamless usage of numpy arrays in datatype and tensor functionality such as
 enabling the tech.v3.tensor/ensure-tensor call to work with numpy arrays -- using
 zero copying when possible.</p>
diff --git a/docs/libpython-clj2.require.html b/docs/libpython-clj2.require.html
index 17fb8e3..0424838 100644
--- a/docs/libpython-clj2.require.html
+++ b/docs/libpython-clj2.require.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2 current"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="sidebar secondary"><h3><a href="#top"><span class="inner">Public Vars</span></a></h3><ul><li class="depth-1"><a href="libpython-clj2.require.html#var-import-python"><div class="inner"><span>import-python</span></div></a></li><li class="depth-1"><a href="libpython-clj2.require.html#var-require-python"><div class="inner"><span>require-python</span></div></a></li></ul></div><div class="namespace-docs" id="content"><h1 class="anchor" id="top">libpython-clj2.require</h1><div class="doc"><div class="markdown"><p>Namespace implementing requiring python modules as Clojure namespaces.  This works via
 scanning the module for metadata and dynamically building the Clojure namespace.</p>
 </div></div><div class="public anchor" id="var-import-python"><h3>import-python</h3><div class="usage"><code>(import-python)</code></div><div class="doc"><div class="markdown"><p>Loads python, python.list, python.dict, python.set, python.tuple,
 and python.frozenset.</p>
diff --git a/docs/new-to-clojure.html b/docs/new-to-clojure.html
index fe20328..1d1525f 100644
--- a/docs/new-to-clojure.html
+++ b/docs/new-to-clojure.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1  current"><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>So Many Parenthesis!</h1>
 <h2>About Clojure</h2>
 <p>LISP stands for List Processing and it was originally designed by John McCarthy
 around 1958.  It was the first language with a garbage collector making it the first
diff --git a/docs/scopes-and-gc.html b/docs/scopes-and-gc.html
index ae5c681..11da3f8 100644
--- a/docs/scopes-and-gc.html
+++ b/docs/scopes-and-gc.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1  current"><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1 "><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Scopes And Garbage Collection</h1>
 <p>libpython-clj now supports stack-based scoping rules so you can guarantee all python
 objects created during a section of code will be released by a certain point.</p>
 <p>Using the stack-based scoping looks like:</p>
diff --git a/docs/slicing.html b/docs/slicing.html
index b3226d4..32aa0c9 100644
--- a/docs/slicing.html
+++ b/docs/slicing.html
@@ -4,7 +4,7 @@
   function gtag(){dataLayer.push(arguments);}
   gtag('js', new Date());
 
-  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.025</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
+  gtag('config', 'G-LN7PG6FJ2D');</script><link rel="stylesheet" type="text/css" href="css/default.css" /><link rel="stylesheet" type="text/css" href="highlight/solarized-light.css" /><script type="text/javascript" src="highlight/highlight.min.js"></script><script type="text/javascript" src="js/jquery.min.js"></script><script type="text/javascript" src="js/page_effects.js"></script><script>hljs.initHighlightingOnLoad();</script></head><body><div id="header"><h2>Generated by <a href="https://github.com/weavejester/codox">Codox</a> with <a href="https://github.com/xsc/codox-theme-rdash">RDash UI</a> theme</h2><h1><a href="index.html"><span class="project-title"><span class="project-name">libpython-clj</span> <span class="project-version">2.026</span></span></a></h1></div><div class="sidebar primary"><h3 class="no-link"><span class="inner">Project</span></h3><ul class="index-link"><li class="depth-1 "><a href="index.html"><div class="inner">Index</div></a></li></ul><h3 class="no-link"><span class="inner">Topics</span></h3><ul><li class="depth-1 "><a href="Usage.html"><div class="inner"><span>LibPython-CLJ Usage</span></div></a></li><li class="depth-1 "><a href="embedded.html"><div class="inner"><span>Embedding Clojure In Python</span></div></a></li><li class="depth-1 "><a href="environments.html"><div class="inner"><span>Python Environments</span></div></a></li><li class="depth-1 "><a href="new-to-clojure.html"><div class="inner"><span>So Many Parenthesis!</span></div></a></li><li class="depth-1 "><a href="scopes-and-gc.html"><div class="inner"><span>Scopes And Garbage Collection</span></div></a></li><li class="depth-1  current"><a href="slicing.html"><div class="inner"><span>Slicing And Slices</span></div></a></li></ul><h3 class="no-link"><span class="inner">Namespaces</span></h3><ul><li class="depth-1"><div class="no-link"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>libpython-clj2</span></div></div></li><li class="depth-2 branch"><a href="libpython-clj2.codegen.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>codegen</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.embedded.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>embedded</span></div></a></li><li class="depth-2 branch"><a href="libpython-clj2.java-api.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>java-api</span></div></a></li><li class="depth-2"><a href="libpython-clj2.python.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>python</span></div></a></li><li class="depth-3 branch"><a href="libpython-clj2.python.class.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>class</span></div></a></li><li class="depth-3"><a href="libpython-clj2.python.np-array.html"><div class="inner"><span class="tree"><span class="top"></span><span class="bottom"></span></span><span>np-array</span></div></a></li><li class="depth-2"><a href="libpython-clj2.require.html"><div class="inner"><span class="tree" style="top: -83px;"><span class="top" style="height: 92px;"></span><span class="bottom"></span></span><span>require</span></div></a></li></ul></div><div class="document" id="content"><div class="doc"><div class="markdown"><h1>Slicing And Slices</h1>
 <p>The way Python implements slicing is via overloading the <code>get-item</code> function call.
 This is the call the Python interpreter makes under the covers whenever you use the
 square bracket <code>[]</code> syntax.</p>
diff --git a/scripts/deploy b/scripts/deploy
index 8fb7e00..6b42b77 100755
--- a/scripts/deploy
+++ b/scripts/deploy
@@ -6,5 +6,7 @@ set -e
 rm -rf classes
 scripts/run-tests
 clj -X:codox
-clj -X:depstar
+rm -rf pom.xml
+clj -T:build jar
+cp target/classes/META-INF/maven/clj-python/libpython-clj/pom.xml .
 clj -X:deploy

From 27078c9224651ac2a73188d51c214c2b9570ddf8 Mon Sep 17 00:00:00 2001
From: Naoya Yamashita <conao3@gmail.com>
Date: Tue, 20 Jan 2026 00:04:20 +0900
Subject: [PATCH 448/456] specify ubuntu version (#278)

---
 dockerfiles/CondaDockerfile | 3 ++-
 dockerfiles/Py38Dockerfile  | 3 ++-
 dockerfiles/Py39Dockerfile  | 4 +++-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/dockerfiles/CondaDockerfile b/dockerfiles/CondaDockerfile
index fdba41d..4cc756f 100644
--- a/dockerfiles/CondaDockerfile
+++ b/dockerfiles/CondaDockerfile
@@ -1,10 +1,11 @@
 # We will use Ubuntu for our image
-FROM ubuntu:latest
+FROM ubuntu:22.04
 
 # Updating Ubuntu packages
 
 ARG CLOJURE_TOOLS_VERSION=1.10.1.507
 
+ENV DEBIAN_FRONTEND=noninteractive
 
 RUN apt-get -qq update && apt-get -qq -y install curl wget bzip2 openjdk-8-jdk-headless \
     && curl -sSL https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -o /tmp/miniconda.sh \
diff --git a/dockerfiles/Py38Dockerfile b/dockerfiles/Py38Dockerfile
index 41ec6a5..0d3fd8c 100644
--- a/dockerfiles/Py38Dockerfile
+++ b/dockerfiles/Py38Dockerfile
@@ -1,10 +1,11 @@
 # We will use Ubuntu for our image
-FROM ubuntu:latest
+FROM ubuntu:22.04
 
 # Updating Ubuntu packages
 
 ARG CLOJURE_TOOLS_VERSION=1.10.1.507
 
+ENV DEBIAN_FRONTEND=noninteractive
 
 RUN apt-get -qq update && apt-get -qq -y install curl wget bzip2 openjdk-8-jdk-headless python3.8 libpython3.8 python3-pip \
     && curl -o install-clojure https://download.clojure.org/install/linux-install-${CLOJURE_TOOLS_VERSION}.sh \
diff --git a/dockerfiles/Py39Dockerfile b/dockerfiles/Py39Dockerfile
index f071037..bf2675f 100644
--- a/dockerfiles/Py39Dockerfile
+++ b/dockerfiles/Py39Dockerfile
@@ -1,10 +1,12 @@
 # We will use Ubuntu for our image
-FROM ubuntu:latest
+FROM ubuntu:22.04
 
 # Updating Ubuntu packages
 
 ARG CLOJURE_TOOLS_VERSION=1.10.1.507
 
+ENV DEBIAN_FRONTEND=noninteractive
+
 RUN apt-get -qq update \
     && apt install -y software-properties-common \
     && add-apt-repository -y ppa:deadsnakes/ppa

From 4e355c1b1b95e98167926a8b41cbf175b64667ee Mon Sep 17 00:00:00 2001
From: Naoya Yamashita <conao3@gmail.com>
Date: Tue, 20 Jan 2026 00:08:37 +0900
Subject: [PATCH 449/456] allow nil ns-prefix in codegen/write-namespace!
 (#279)

* allow blank ns-prefix

* add codegen_test
---
 src/libpython_clj2/codegen.clj       |  4 ++-
 test/libpython_clj2/codegen_test.clj | 37 ++++++++++++++++++++++++++++
 2 files changed, 40 insertions(+), 1 deletion(-)
 create mode 100644 test/libpython_clj2/codegen_test.clj

diff --git a/src/libpython_clj2/codegen.clj b/src/libpython_clj2/codegen.clj
index af4b4cf..31e81b5 100644
--- a/src/libpython_clj2/codegen.clj
+++ b/src/libpython_clj2/codegen.clj
@@ -151,7 +151,9 @@ user> (doto (python/list)
                         exclude default-exclude}}]
    (let [metadata-fn (requiring-resolve
                       'libpython-clj2.metadata/datafy-module-or-class)
-         ns-symbol (or ns-symbol (symbol (str ns-prefix "." py-mod-or-cls)))]
+         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)
diff --git a/test/libpython_clj2/codegen_test.clj b/test/libpython_clj2/codegen_test.clj
new file mode 100644
index 0000000..2a2700c
--- /dev/null
+++ b/test/libpython_clj2/codegen_test.clj
@@ -0,0 +1,37 @@
+(ns libpython-clj2.codegen-test
+  (:require [clojure.test :refer [deftest is testing]]
+            [clojure.string :as s]
+            [clojure.java.io :as io]
+            [libpython-clj2.codegen :as codegen]))
+
+(defn- ns-symbol-for
+  [py-mod-or-cls ns-prefix]
+  (symbol (str (when-not (s/blank? ns-prefix)
+                 (str ns-prefix "."))
+               py-mod-or-cls)))
+
+(deftest ns-prefix-nil-test
+  (testing "ns-prefix nil should not produce leading dot"
+    (is (= 'numpy (ns-symbol-for "numpy" nil)))
+    (is (= 'builtins (ns-symbol-for "builtins" nil))))
+
+  (testing "ns-prefix empty string should not produce leading dot"
+    (is (= 'numpy (ns-symbol-for "numpy" "")))
+    (is (= 'builtins (ns-symbol-for "builtins" ""))))
+
+  (testing "ns-prefix with value should produce prefixed namespace"
+    (is (= 'python.numpy (ns-symbol-for "numpy" "python")))
+    (is (= 'my.prefix.builtins (ns-symbol-for "builtins" "my.prefix")))))
+
+(deftest write-namespace-nil-prefix-test
+  (testing "write-namespace! with nil ns-prefix"
+    (let [tmp-dir (str (System/getProperty "java.io.tmpdir") "/libpython-clj-test-" (System/currentTimeMillis))]
+      (try
+        (codegen/write-namespace! "builtins" {:output-dir tmp-dir
+                                              :ns-prefix nil})
+        (is (.exists (io/file tmp-dir "builtins.clj")))
+        (let [content (slurp (io/file tmp-dir "builtins.clj"))]
+          (is (re-find #"\(ns builtins" content)))
+        (finally
+          (doseq [f (reverse (file-seq (io/file tmp-dir)))]
+            (.delete f)))))))

From 51ea5893379b659768c2dcf5936e5380a8200ece Mon Sep 17 00:00:00 2001
From: Lidor <lidorcg@gmail.com>
Date: Mon, 19 Jan 2026 17:09:04 +0200
Subject: [PATCH 450/456] test: add context manager tests for __enter__
 behavior (#274)

fix: update 'with' macro to bind return value of __enter__ correctly
---
 src/libpython_clj2/python/with.clj  | 19 +++++++-------
 test/libpython_clj2/python_test.clj | 11 +++++---
 testcode/__init__.py                | 39 +++++++++++++++++++++--------
 3 files changed, 47 insertions(+), 22 deletions(-)

diff --git a/src/libpython_clj2/python/with.clj b/src/libpython_clj2/python/with.clj
index 6b45dce..5478833 100644
--- a/src/libpython_clj2/python/with.clj
+++ b/src/libpython_clj2/python/with.clj
@@ -49,15 +49,16 @@
   [bind-vec & body]
   (when-not (= 2 (count bind-vec))
     (throw (Exception. "Bind vector must have 2 items")))
-  (let [varname (first bind-vec)]
+  (let [varname (first bind-vec)
+        mgr (gensym "mgr")]
     `(py-ffi/with-gil
-       (let [~@bind-vec]
+       (let [~mgr ~(second bind-vec)]
          (with-bindings
            {#'py-ffi/*python-error-handler* python-pyerr-fetch-error-handler}
-           (py-fn/call-attr ~varname "__enter__" nil)
-           (try
-             (let [retval# (do ~@body)]
-               (py-fn/call-attr ~varname "__exit__" [nil nil nil])
-               retval#)
-             (catch Throwable e#
-               (with-exit-error-handler ~varname e#))))))))
+           (let [~varname (py-fn/call-attr ~mgr "__enter__" nil)]
+             (try
+               (let [retval# (do ~@body)]
+                 (py-fn/call-attr ~mgr "__exit__" [nil nil nil])
+                 retval#)
+               (catch Throwable e#
+                 (with-exit-error-handler ~mgr e#)))))))))
diff --git a/test/libpython_clj2/python_test.clj b/test/libpython_clj2/python_test.clj
index 6f46a39..71d99c5 100644
--- a/test/libpython_clj2/python_test.clj
+++ b/test/libpython_clj2/python_test.clj
@@ -192,6 +192,13 @@
       (is (= ["enter" "exit: None"]
              (py/->jvm fn-list))))))
 
+(deftest with-enter-returns-different-object
+  (testing "py/with should bind the return value of __enter__, not the context manager"
+    (let [testcode (py/import-module "testcode")]
+      (py/with [f (py/call-attr testcode "FileWrapper" "test content")]
+               ;; f should be the StringIO object returned by __enter__, not FileWrapper
+               (is (= "test content" (py/call-attr f "read")))))))
+
 (deftest arrow-as-fns-with-nil
   (is (= nil (py/->jvm nil)))
   (is (= nil (py/as-jvm nil))))
@@ -449,6 +456,4 @@ class Foo:
 
   (let [data (doto (pd/DataFrame {:index [1 2] :value [2 3] :variable [1 1]})
                (py. melt :id_vars "index"))]
-    ((py.- px line) :data_frame data :x "index" :y "value" :color "variable"))
-
-  )
+    ((py.- px line) :data_frame data :x "index" :y "value" :color "variable")))
diff --git a/testcode/__init__.py b/testcode/__init__.py
index d2fa00b..52727dd 100644
--- a/testcode/__init__.py
+++ b/testcode/__init__.py
@@ -2,17 +2,38 @@ class WithObjClass:
     def __init__(self, suppress, fn_list):
         self.suppress = suppress
         self.fn_list = fn_list
+
     def __enter__(self):
         self.fn_list.append("enter")
+        return self  # Return self so methods can be called on the bound variable
+
     def doit_noerr(self):
         return 1
+
     def doit_err(self):
         raise Exception("Spam", "Eggs")
+
     def __exit__(self, ex_type, ex_val, ex_traceback):
         self.fn_list.append("exit: " + str(ex_val))
         return self.suppress
 
 
+class FileWrapper:
+    """Context manager where __enter__ returns a different object"""
+
+    def __init__(self, content):
+        self.content = content
+
+    def __enter__(self):
+        # Return a different object with the content
+        import io
+
+        return io.StringIO(self.content)
+
+    def __exit__(self, *args):
+        return False
+
+
 def for_iter(arg):
     retval = []
     for item in arg:
@@ -24,15 +45,13 @@ def calling_custom_clojure_fn(arg):
     return arg.clojure_fn()
 
 
-
-def complex_fn(a, b, c: str=5, *args, d=10, **kwargs):
-    return {"a" : a,
-            "b" : b,
-            "c" : c,
-            "args" : args,            
-            "d": d,
-            "kwargs": kwargs}
+def complex_fn(a, b, c: str = 5, *args, d=10, **kwargs):
+    return {"a": a, "b": b, "c": c, "args": args, "d": d, "kwargs": kwargs}
 
 
-complex_fn_testcases = {"complex_fn(1, 2, c=10, d=10, e=10)":complex_fn(1, 2, c=10, d=10, e=10),
-                        "complex_fn(1, 2, 10, 11, 12, d=10, e=10)":complex_fn(1, 2, 10, 11, 12, d=10, e=10)}
+complex_fn_testcases = {
+    "complex_fn(1, 2, c=10, d=10, e=10)": complex_fn(1, 2, c=10, d=10, e=10),
+    "complex_fn(1, 2, 10, 11, 12, d=10, e=10)": complex_fn(
+        1, 2, 10, 11, 12, d=10, e=10
+    ),
+}

From f8e33993daa24f6f9f2ddff1e889fb6cbf087c16 Mon Sep 17 00:00:00 2001
From: Carsten Behring <carsten.behring@gmail.com>
Date: Mon, 19 Jan 2026 16:12:06 +0100
Subject: [PATCH 451/456] Expand Python versions in CI workflow (#276)

* Expand Python versions in CI workflow

* Update JDK and Python versions in workflow
---
 .github/workflows/test.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 06bbc99..8b27a67 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -16,8 +16,8 @@ jobs:
       fail-fast: false
       matrix:
         os: [macos-latest, ubuntu-latest, windows-latest]
-        jdk: [8, 17, 19]
-        python-version: ["3.9", "3.11"]
+        jdk: [8, 17, 19, 21, 25]
+        python-version: ["3.9", "3.11","3.12","3.13","3.14"]
 
     steps:
       - uses: actions/checkout@v3

From 239659007543c58f9f727353fb88e9d21461d76a Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 19 Jan 2026 08:23:49 -0700
Subject: [PATCH 452/456] Trying latest setup-python script

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 8b27a67..b1fa9ba 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -33,7 +33,7 @@ jobs:
           cli: 1.11.1.1347
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v6
         with:
           python-version: ${{ matrix.python-version }}
 

From 089780f441d296c3ef89bb0c5dfd22cf53965ded Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 19 Jan 2026 08:30:37 -0700
Subject: [PATCH 453/456] build golf

---
 .github/workflows/test.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index b1fa9ba..0a07503 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -40,7 +40,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install numpy
+          pip install numpy --no-cache-dir
 
       - name: Run tests (jdk<17)
         if: ${{ matrix.jdk < 17 }}

From c7abe1a35b4ab508980b839ac227814a12843347 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 19 Jan 2026 08:46:15 -0700
Subject: [PATCH 454/456] Drop testing support for older JDKS to limit possible
 issues

---
 .github/workflows/test.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 0a07503..aa23e60 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -16,14 +16,14 @@ jobs:
       fail-fast: false
       matrix:
         os: [macos-latest, ubuntu-latest, windows-latest]
-        jdk: [8, 17, 19, 21, 25]
+        jdk: [19, 21, 25]
         python-version: ["3.9", "3.11","3.12","3.13","3.14"]
 
     steps:
       - uses: actions/checkout@v3
 
       - name: Set up JDK ${{ matrix.jdk }}
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v4
         with:
           java-version: ${{ matrix.jdk }}
 

From 83e51dc9661d56ded8151b4ef53d1950d8907696 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 19 Jan 2026 08:52:04 -0700
Subject: [PATCH 455/456] print out architecture information from java's
 perspective and from python's perspective on startup.

---
 src/libpython_clj2/python/info.clj | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/libpython_clj2/python/info.clj b/src/libpython_clj2/python/info.clj
index 170be78..986b815 100644
--- a/src/libpython_clj2/python/info.clj
+++ b/src/libpython_clj2/python/info.clj
@@ -37,7 +37,7 @@
   (list python-major python-minor python-micro)"
   [executable]
   (let [{:keys [out err exit]}
-        (sh/sh executable "-c" "import sys, json;
+        (sh/sh executable "-c" "import sys, platform, json;
 print(json.dumps(
 {'platform':          sys.platform,
   'prefix':           sys.prefix,
@@ -45,6 +45,7 @@ print(json.dumps(
   'executable':       sys.executable,
   'base-exec-prefix': sys.base_exec_prefix,
   'exec-prefix':      sys.exec_prefix,
+  'platform-arch':    platform.machine(),
   'version':          list(sys.version_info)[:3]}))")]
     (when (= 0 exit)
       (json/read-str out :key-fn keyword))))
@@ -117,6 +118,7 @@ print(json.dumps(
      {:python-home                python-home
       :lib-version                lib-version
       :libname                    libname
-      :libnames                   libnames}
+      :libnames                   libnames
+      :java-os-arch               (System/getProperty "os.arch")}
      (when java-lib-path
        {:java-library-path-addendum java-lib-path}))))

From 97dff5cdf75ccd5f01efe3e4a51f42006620c270 Mon Sep 17 00:00:00 2001
From: Chris Nuernberger <chris@techascent.com>
Date: Mon, 19 Jan 2026 09:21:54 -0700
Subject: [PATCH 456/456] adding jdk distribution

---
 .github/workflows/test.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index aa23e60..cd8466d 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -26,6 +26,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           java-version: ${{ matrix.jdk }}
+          distribution: temurin
 
       - name: Install Clojure
         uses: DeLaGuardo/setup-clojure@11.0